Java基础---String类和基本数据类型包装类

第一讲     String类

一、概述

        String是字符串的类类型,用于描述字符串事物。字符串是一个特殊的对象。特殊之处就在于:

Stings= new String();和String s1=””;两种写法都是在创建对象,使用起来一样。

二、特点

字符串最大的特点就是:一旦被初始化就不可以被改变。

例:

String s1=“abc”;

String s2 = new String(“abc”);

String s3=“abc”;

比较的结果:

s1==s2   ( false )

s1.equals(s2) ( true )

//String类复写了Object类中的equals方法,该方法用于判断字符串是否相同。

s1==s3   ( true )

//因为“abc”这个字符串对象已经在内存中存在,作为字符串这种特殊的对象,这种在常量池中存在的数据。s3进行初始化时,发现abc已经在内存中存在,就不会再独立开辟空间,因为再开辟空间就比较浪费空间。因此为了节约内存,在字符串对象当中只要字符串相同,那么s1和s3就指向同一个对象。

s1和s2淘宝开店教程的区别:

s1在内存中有一个对象。

s2在内存中有两个对象。

三、常见操作方法

1、获取

1.1字符串中包含的字符数,也就是字符串的长度

int   length()://获取长度。

1.2根据位置获取位置上的某个字符

char  charAt(int  index)://当访问到字符串中不存在的角标时,会发生字符串角标越界的错误。

1.3根据字符获取该字符存在字符串的位置

int  indexOf(int ch)://返回的是ch在字符串中第一次出现的位置。//传入的是字符对应的ASCII码。//如果没有找到,返回-1。

int  indexOf(int ch,int fromIndex)://从fromIndex指定位置开始,获取ch在字符串中出现的位置。

int  indexOf(String str)://返回的是str在字符串中第一次出现的位置。

int  indexOf(String str,int fromIndex)://从fromIndex指定位置开始,获取str在字符串中出现的位置。

int  lastIndexOf()://反向索引

2、判断

2.1字符串中是否包含某一个子串

booleancontains(str);

//特殊之处:indexOf(str)可以索引str第一次出现的位置,如果返回-1表示该str不在字符串中存在。所以,也可以用于对指定判断是否包含。如:if(str.indexOf(“aa”)!=-1)而且该方法既可以判断,又可以获取出现的位置。如果只为判断,用contains。

2.2字符串中是否有内容

booleanifEmpty();//原理就是判断长度是否为0。

2.3字符串是否是以指定内容开头

booleanstartsWith(str);

2.4字符串是否是以指定内容结尾

booleanendsWith(str);

2.5判断字符串内容是否相同,复写了Object类中的equals方法

booleanequals(str);

2.6判断内容是否相同,并忽略大小写。

booleanequalsIgnoreCase();

3、转换

3.1将字符数组转成字符串

构造函数:String (char[]);

String(char[],offset,count);//将字符数组中的一部分转成字符串。

静态方法:

static String copyValueOf(char[]);

staticString copyValueOf(char[] data,int offset ,int count );

static String valueOf(char[]);

3.2将字符串转成字符数组

char[]toCharArray();

3.3将字节数组转成字符串

String (byte[]);

String(byte[],offset,count);//将字节数组中的一部分转成字符串。count表示个数。

3.4将字符串转成字节数组

byte[]getBytes();

3.5将基本数据类型转成字符串

StringvalueOf(int);

StringvalueOf(double);

特殊:字符串和字节数组在转换过程中,是可以指定编码表的。

4、替换

Stringreplace(oldchar,newchar);//返回的是一个新字符串。如果要替换的字符不存在,返回的还是原字符串。

5、切割

String[] split(regex);//涉及到正则表达式的点,不能作为切割字符串的regex。

6、子串,获取字符串中的一部分

String substring(begin);//从指定位置开始到结尾。如果角标不存在,会出现字符串角标越界异常。

Stringsubstring(begin,end);//包含头,不包含尾。

7、转换,去除空格,比较

7.1将字符串转成大写或小写

StringtoUpperCase();

String toLowerCase();

7.2将字符串两端的多个空格去除

String trim();

7.3对两个字符串进行自然顺序的比较

intcompareTo(String);

实例练习:

1、

[java] view plaincopy

  1. /*
  2. 需求:获取一个字符串在另一个字符串中出现的次数
  3. 思路:1、定义一计数器
  4. 2、获得字符串第一次在另个字符中出现的位置
  5. 3、从第一次出现的位置后剩余的字符串中继续获取字符串出现的次数,每出现一次,计数器就加一次
  6. 3、当获取不到时候,计数停止
  7. */
  8. class  CountTest
  9. {
  10. public static void main(String[] args)
  11. {
  12. String s="Hllello Worlld!";
  13. sop("s="+s);
  14. sop("count="+count(s,"ll"));
  15. }
  16. public static int count(String s,String key)
  17. {
  18. int count=0;//定义计数器
  19. int index=0;//定义获取角标变量
  20. while((index=s.indexOf(key,index))!=-1)//如果包含,则继续
  21. {
  22. index=index+key.length();//从找到的子串位置后一位开始获取
  23. count++;
  24. }
  25. return count;
  26. }
  27. private static  void sop(Object obj)
  28. {
  29. System.out.println(obj);
  30. }
  31. }

结果:

2、

[java] view plaincopy

  1. /*
  2. 需求:将一个字符串反转
  3. 思路:1、将字符串转换为字符数组
  4. 2、将数组反转
  5. 3、将字符数组转换为字符串
  6. */
  7. class ReverseTest
  8. {
  9. public static void sop(Object obj)
  10. {
  11. System.out.println(obj);
  12. }
  13. public static void main(String[] args)
  14. {
  15. String s="abca dv daf";
  16. sop(s);
  17. //      ReverseString r=new ReverseString();
  18. sop(new ReverseString().reverseString(s));
  19. }
  20. }
  21. class ReverseString
  22. {
  23. public static String  reverseString(String s,int start,int end)
  24. {
  25. //将字符串变为字符数组
  26. char[] ch=s.toCharArray();
  27. //将数组进行反转
  28. charReverse(ch,start,end);
  29. //将字符数组变为字符串
  30. return new String().valueOf(ch);
  31. }
  32. //反转整个字符串
  33. public static String reverseString(String s)
  34. {
  35. return reverseString(s,0,s.length());
  36. }
  37. //反转指定字符数组位置
  38. private static void charReverse(char[] ch,int start,int end)
  39. {
  40. for (int x=start,y=end-1; x<y;x++,y--)
  41. {
  42. swap(ch,x,y);
  43. }
  44. }
  45. //交换相应数组元素
  46. private static  void swap(char[] ch, int start,int end)
  47. {
  48. char temp=ch[start];
  49. ch[start]=ch[end];
  50. ch[end]=temp;
  51. }
  52. }

结果:

3、

[java] view plaincopy

  1. /*
  2. 需求:获取两个字符串中最大相同子串
  3. 思路:1、将短的一个字符串与长的进行比较,如果没有,则将短串的字串按长度递减的方式获取
  4. 2、将每次获取的子串,去长串中判断是否包含,包含即找到。
  5. */
  6. class  MaxSubstring
  7. {
  8. public static void main(String[] args)
  9. {
  10. String s1="HelloafsfWorldcgagb!";
  11. String s2="fWorldafdffsfsfsfsfdc";
  12. sop(getMaxSubstring(s1,s2));
  13. }
  14. public static String getMaxSubstring(String s1,String s2)
  15. {
  16. String max,min;
  17. max=(s1.length()>s2.length())?s1:s2;//判断出大字符串
  18. min=(max==s1)?s2:s1;//判断出小字符串
  19. for (int x=0;x<min.length() ;x++ )//外循环,控制在最短字串长度内
  20. {
  21. for (int y=0,z=min.length()-x;z<min.length()+1; y++,z++)//依次递减短字符串子串
  22. {
  23. String temp=min.substring(y,z);//获取短字符串子串
  24. if(max.contains(temp))//如果长串包含,则表示找到
  25. return temp;
  26. }
  27. }
  28. return "没有相同的字符串";
  29. }
  30. //打印输出
  31. public static void sop(Object obj)
  32. {
  33. System.out.println(obj);
  34. }
  35. }

结果:

4、

[java] view plaincopy

  1. /*
  2. 需求:对一个字符串中的字符进行自然排序
  3. 思路:1、将字符串转换为字符数组。
  4. 2、对字符数组进行选择、冒泡排序
  5. 3、将排好序的字符数组转换为字符串
  6. */
  7. class  RaturalSortString
  8. {
  9. public static void main(String[] args)
  10. {
  11. String s="vcz1bdaA+cs";
  12. sop(s);//打印原字符串
  13. sop(raturalSortString(s));//打印排序后的字符串
  14. sop(getLowerCaseString(raturalSortString(s)));//打印排序后的小写字母部分
  15. }
  16. //取出有序字符串中的小写字母部分
  17. public static String getLowerCaseString(String s)
  18. {
  19. int[] arr=lowerCaseIndex(s);
  20. return s.substring(arr[0],arr[1]);
  21. }
  22. //对字符串中的小写字母进行自然排序的方法
  23. public static String raturalSortString(String s)
  24. {
  25. //将字符串转换为字符数组
  26. char[] arr = s.toCharArray();
  27. //将字符数组进行排序
  28. selectSortArray(arr);
  29. //将排序好的字符数组转换为字符串返回
  30. return new String(arr);
  31. }
  32. //对数组进行选择排序
  33. private static void selectSortArray(char[] arr)
  34. {
  35. for (int x=0; x<arr.length-1; x++)
  36. {
  37. for (int y=x+1;y<arr.length ; y++)
  38. {
  39. if(arr[x]>arr[y])
  40. swap(arr,x,y);
  41. }
  42. }
  43. }
  44. //交换数组两元素
  45. private static void swap(char[] arr ,int x,int y )
  46. {
  47. arr[x]=(char)(arr[x]^arr[y]);
  48. arr[y]=(char)(arr[x]^arr[y]);
  49. arr[x]=(char)(arr[x]^arr[y]);
  50. }
  51. //判断小写字母部分在有序字符串中的位置,并将第一个的位置和最后一个的位置存在一个数组中,返回数组
  52. private static int[] lowerCaseIndex(String s)
  53. {
  54. //将字符串转换为字符数组
  55. char[] arr = s.toCharArray();
  56. int x=0;
  57. for(;arr[x]<‘a‘;x++);
  58. int y=arr.length-1;
  59. for(;arr[y]>‘z‘;y--);
  60. int[] a = {x,y+1};
  61. return a;
  62. }
  63. //打印
  64. private static void sop(Object obj)
  65. {
  66. System.out.println(obj);
  67. }
  68. }

结果:

第二讲     StringBuffer

一、概述

StringBuffer是一个容器,字符串的组成原理就是通过该类实现的。StringBuffer可以对字符串内容进行增删改查等操作,很多方法和String相同。

二、特点

1、而且长度是可变化的。(数组是固定的)

2、可以直接操作多个数据类型。(数组只能操作一个)

3、最终会通过toString方法变成字符串。

三、常见操作

1、存储

StringBuffer append():将指定数据作为参数添加到已有数据的结尾处。

StringBuffer insert(intoffset ,数据):可以将数据插入到指定offset位置。

2、删除

StringBufferedelete(start,end):删除缓冲区中的数据,包含start,不包含end。

StringBuffer deleteCharAt(index):删除指定位置的字符。

清空缓冲区:对象.delete(0,对象.length());

3、获取

char charAt(int index);

int indexOf(String str);

int lastIndexOf(String str);

int length();

String substring(int start,int end);

4、修改

StringBuffer replace(int start,int end,String str);

void setCharAt(int index,char ch);

5、反转

StringBuffer reverse();

6、将缓冲区中指定数据存储到指定字符数组中

voidgetChars(int srcBegin, int srcEnd,char[] dst,int dstBegin)

在JDK1.5版本之后出现了StringBuilder。

StringBuffer是线程同步的。有锁。效率低伤感的句子

StringBuilder是线程不同步的。无锁。效率高

以后开发,建议使用StringBuilder。如遇多线程,使用StringBuffer或自己加锁。

升级三因素:

1、提高效率

2、简化书写

3、提高安全性。

第三讲     基本数据类型包装类

将基本数据类型封装成对象的好处,在于可以在对象中定义更多的功能方法操作该数据。基本数据类型对象包装类的最常见作用,就是用于基本数据类型和字符串类型之间做转换。下面我们来了解包装类的写法形式和常用方法。

一、基本数据类型对象包装类。

byte               Byte

short              Short

int                  Integer

long               Long

boolean          Boolean

float               Float

double           Double

char               Character

 

二、基本数据类型转成字符串

基本数据类型+" "

基本数据类型.toString(基本数据类型值);

如:Integer.toString(34);//将34整数变成"34"。

三、字符串转成基本数据类型。

xxx a=Xxx.parseXxx(string);//必须传入对应类型的字符串。

如   inta=Integer.parseInt("123");//静态

booleanb=Boolean.parseBoolean("true");

Integeri=new Integer("123");

intnum=i.intValue();//跟上面的静态方式的结果一样,但这种属于对象调用方式。

注意:

在使用时,Integer  x = null;上面的代码就会出现NullPointerException。

四、十进制转成其他进制。

toBinaryString();

toHexString();

toOctalString();

五、其他进制转成十进制。

parseInt(String,radix);

如:int a= Intager.parseInt("3c",16);

JDK1.5版本以后出现的新特性。

Integer x=new Integer(4);

等效于:Integer x=4;//自动装箱。

还可以直接进行运算:x=x+2;//x进行自动拆箱。变成了int类型。和2进行加法运算。再将和进行装箱赋给x。x的拆箱动作等效:x.intValue()。

六、示例

Integer x=128;

Integer y=128;

x==y   (false)

Integer m=127;

Integer n=127;

m==n ( true)

原因:

因为m和n指向了同一个Integer对象。因为当数值在byte范围内,对于新特性,如果该数组已经存在,则不会再开辟新的空间。

七、小练习

[java] view plaincopy

  1. /*
  2. "12 0 99 -7 30 4 100 13 -6"
  3. 要求对字符串中的数值进行排序。生成一个数值从小到大新字符串。
  4. "-7 -6 0 4 12 13 30 99 100"
  5. 思路:1、将字符串切割为字符串数组
  6. 2、将字符串数组转换为整数类型数组
  7. 3、对整数类型数组进行冒泡排序
  8. 4、将排序后的整数类型数组转换为字符串
  9. */
  10. class  StringSort
  11. {
  12. public static void main(String[] args)
  13. {
  14. String s="12 0 99 -7 30 4 100 13 -6";
  15. sop(s);
  16. sop(stringSort(s));
  17. }
  18. public static String stringSort(String s)
  19. {
  20. //将字符串切割成字符串数组
  21. String[] str=s.split(" ");
  22. //将字符串数组转换为整数类型数组
  23. int[] arr=stringToInt(str);
  24. // 对整数类型数组进行冒泡排序
  25. bubbleSort(arr);
  26. //将排序后的整数类型数组转换为字符串
  27. return intToString(arr).toString();
  28. }
  29. // 将字符串数组转换为整数类型数组方法
  30. private static int[] stringToInt(String[] str)
  31. {
  32. int[] arr=new int[str.length];
  33. for(int x=0;x<str.length;x++)
  34. {
  35. arr[x]=Integer.parseInt(str[x]);
  36. //          sop(arr[x]);
  37. }
  38. //  sop(arr);
  39. return arr;
  40. }
  41. //对数组进行冒泡排序
  42. private static void bubbleSort(int[] arr)
  43. {
  44. for (int x=0;x<arr.length ;x++ )
  45. {
  46. for (int y=0;y<arr.length-x-1; y++)
  47. {
  48. if(arr[y]>arr[y+1])
  49. swap(arr,y,y+1);
  50. }
  51. }
  52. //  sop(arr);
  53. }
  54. //交换数组中的两元素
  55. private static void swap(int[] arr,int x,int y)
  56. {
  57. arr[x]=arr[x]^arr[y];
  58. arr[y]=arr[x]^arr[y];
  59. arr[x]=arr[x]^arr[y];
  60. //      int temp=arr[x];
  61. //      arr[x]=arr[y];
  62. //      arr[y]=temp;
  63. }
  64. //将整数类型数组存放到一个StringBuiler容器中
  65. private static StringBuilder intToString(int[] arr)
  66. {
  67. StringBuilder sb=new StringBuilder();
  68. for (int x=0;x<arr.length-1; x++)
  69. {
  70. sb.append(arr[x]+" ");
  71. }
  72. sb.append(arr[arr.length-1]+"");
  73. return sb;
  74. }
  75. //打印字符串
  76. private static void sop(Object obj)
  77. {
  78. System.out.println(obj);
  79. }
  80. //遍历数组
  81. private static void sop(int[] arr)
  82. {
  83. for (int x=0; x<arr.length;x++ )
  84. {
  85. System.out.print(arr[x]+"\t");
  86. }
  87. System.out.println();
  88. }
  89. }

结果:

时间: 01-13

Java基础---String类和基本数据类型包装类的相关文章

黑马程序员-java基础-String类

1.概述 String 类适用于描述字符串事务.提供了多种对字符串进行操作的方法. > 字符串的最大的特点:一旦被初始化就不能被改变. 2.常见的操作方法: 2.1 获取: 1 public class StringText1 { 2 public static void main(String srgs[]) 3 { 4 // str 是一个类类型变量,"abc"是一个对象. 5 String str = "hello java!" ; 6 // str 和

黑马程序员——Java基础---String类

--Java培训.Android培训.iOS培训.UI培训.PHP培训.期待与您交流! -- Scanner的概述和方法介绍 1.Scanner类的构造方法 Scanner(InputStream source) 2. 一般方法 hasNextXxx() 判断是否还有下一个输入项,其中Xxx可以是Int,Double等.如果需要判断是否包含下一个字符串,则可以省略Xxx package com.geekds.scanner; import java.util.Scanner; public cl

深入Java基础(一)——基本数据类型及其包装类

作为一名程序员,我觉得会多门语言的前提,必须把一门语言熟练掌握,才能触类旁通,因此,也就出现了这次的Java基础与深入之旅啦!欢迎大家关注这一系列. 这一系列打算慢慢地去接触源码,并且列出相关的题目,对于完全的初学者的话,我到时候会搜一套我认为比较好的培训机构的视频以及给些社区资料和相关博客咯.让我们一起开始思考,深入学习Java吧. 这篇文章就数据类型咯-文章结构:1. 基本数据类型的系统描述:2.数据类型的包装类理解(含源码解析):3.数据类型转换.装包拆包等一些小坑. 一.基本数据类型的系

java基础学习——1、基本数据类型

一.四大基本数据类型: 1.逻辑性boolean: boolean类型的数据只允许取值true or false,不可以用0或非0代替. 2.字符型char: 字符常量用单引号括起来的单个字符,例如: 1 char weChar = 'a'; 2 char weChar = '我': 3.整数型(byte.short.int.long) 十进制整数,如:12,-314,0: 八进制整数,要求以0开头,如:012: 十六进制整数,要求以0x或0X开头,如:0x12. Java语言的整型常量默认为i

黑马程序员----java基础--String字符串

------Java培训.Android培训.iOS培训..Net培训.期待与您交流! ------- 一.String类概述 java中用String类进行描述对字符串进行了对象的封装.这样的好处是可以对字符串这种常见数据进行方便的操作.对象封装后,可以定义N多属性和行为. String类是final的,也就是说它没有子类. 二.String字符串的特点 1.字符串一旦被初始化就不可以被改变.并且存放在方法区中的常量池中. 1 class StringDemo{ 2 public static

黑马程序员_Java基础String类

- - - - - android培训.java培训.期待与您交流! - - - - - - - String是一个对象 String不属于8种基本数据类型(byte, char, short, int, float, long, double, boolean),String是对象,所以其默认值是null. String是一种特殊的对象,有其它对象没有的一些特性,通过JDK发现: public final class String implements java.io.Serializable

Java中String类的特殊性

java中特殊的String类型 Java中String是一个特殊的包装类数据有两种创建形式: String s = "abc"; String s = new String("abc"); 第一种先在栈中创建一个对String类的对象引用变量s,然后去查找"abc"是否被保存在字符串常量池中,如果没有则在栈中创建三个char型的值'a'.'b'.'c',然后在堆中创建一个String对象object,它的值是刚才在栈中创建的三个char型值组成

深入分析Java的String类的方法与特点

字符串是任何编程语言都必须支持的变量类型,有些编程语言是直接提供了原生的变量类型,有些编程语言则使用语法特性以 SDK 的形式提供支持.在Java编程平台中,对字符串的支持使用了后者的形式,就是通过在 JDK中提供一个名为String的类,对应字符串这个变量类型. 源码分析 既然JDK中的String类对应了字符串变量类型,为了熟练地掌握Java中字符串相关的技能,我们必须深入地分析和研究一下这个类.编码界有一句名言叫做 "源码面前,了无秘密",因此,我们第一步就是来看看String类

java笔记--String类对象解析与运用

1.String中的equals和==的区别 String是对象而非基本数据类型,不能使用"=="来判断两个字符串是否相当, 判断两个字符串内容是否相同用equals(); 判断两个字符串内存地址是否相同用"==" 2.startsWith(String str): 判断字符串是否以str为前缀 3.endsWith(String str): 判断字符串是否以str为后缀 4.String 字符串的比较: 1).compareTo()和compareToIgnore