Java学习日记（八）String类、StringBuffer类、基本数据类型对象包装类

一、String类

       ·String类是一个特殊的对象，是对字符串事物的描述，专门用于操作字符串

              Stringstr=”abc”;//str是一个类类型变量，”abc”是一个对象

       ·字符串一旦初始化就不可以该改变

       ·String str1=”abc”;与String str2=new String(“abc”);有什么区别？

              str1在内存中有一个对象，str2在内存中有两个对象

String类的常用方法：

◆获取：

       1.int length()——字符串中的包含的字符数，字符串的长度

       2.char charAt(int index)——根据位置获取位置上某个字符

       3.int indexOf(int ch)——返回的是ch在字符串中第一次出现的位置

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

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

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

          int lastIndexOf(int ch)——返回指定字符在此字符串中最后一次出现处的位置

示例：

class StringDemo {

       public static void main(String[] args) {

              Strings1="abcdefgabcdefg";

              //返回字符串的长度

              System.out.println(s1.length());                //结果：14

              //返回脚标为4的字符

              System.out.println(s1.charAt(4));                //结果：e

              //获取第一次出现的d的脚标

              System.out.println(s1.indexOf("d"));           //结果：3

              //获取从脚标为4的元素开始第一次d的脚标

              System.out.println(s1.indexOf("d",4));        //结果：10

              //获取Unicode值为99在s1中出现的第一次位置

              System.out.println(s1.indexOf(100));          //结果：3

              //从脚本为6的元素开始获取Unicode值为99在s1中出现的第一次位置

              System.out.println(s1.indexOf(100,6));              //结果：10

              //获取Unicode值为103最后一次出现的位置

              System.out.println(s1.lastIndexOf(103));     //结果：13

       }

}

◆判断：

       1.boolean contains(str)——字符串中是否包含某一个子串

       2.boolean isEmpty()——字符中是否有内容

       3.boolean startsWith(str)——字符串是否是以指定内容开头

       4.boolean endsWith(str)——字符串是否是以指定内容结尾

       5.boolean equals(str)——判断字符串内容是否相同（复写了Object类中的equals方法）

       6.boolean equalsIgnoreCase()——判断内容是否相同，并忽略大小写

示例：

class StringDemo {

       publics tatic void main(String[] args) {

              String s1 = "abcdefgabcdefg";

              String s2="efgab";

              String s3="";

              String s4="abc";

              String s5="efgab";

              String s6="eFGaB";

              //判断s1中是否包含指定内容

              System.out.println(s1.contains(s2));                   //结果：true

              System.out.println(s1.contains("geavge"));          //结果：false

              //判断字符中是否有内容

              System.out.println(s1.isEmpty());                      //结果：false

              System.out.println(s3.isEmpty());                      //结果：true

              //判断字符串是否是以指定内容开头

              System.out.println(s1.startsWith(s2));                 //结果：false

              System.out.println(s1.startsWith(s4));                 //结果：true

              //判断字符串内容是否相同

              System.out.println(s2.equals(s5));                      //结果：true

              System.out.println(s2.equals(s4));                      //结果：false

              //判断内容是否相同，并忽略大小写

              System.out.println(s2.equalsIgnoreCase(s5));      //结果：true

              System.out.println(s2.equalsIgnoreCase(s6));      //结果：true

       }

}

◆类型转换：

       1.将字符数组转换为字符串

              构造函数String(char[] arr)

                             String(char[] arr,int offset,int count)——从offset位置开始取count个转成数组

              静态方法：static StringcopyValueOf(char[] arr)

                                  static String copyValueOf(char[] data, intoffset, int count)

                                  static String valueOf(char[])

       2.将字符串转成字符数组——char[] toCharArray()

       3.将字节数组转成字符串——String(byte[] bytes)

                                                   String(byte[] bytes,int offset,int count)——将字节数组中的一部分转成字符串

       4.将字符串转成字节数组——byte[] getBytes()

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

              static Stirng vlaueOf(int a)——返回int参数的字符串表示形式

              static String valueOf(double a)——返回double参数的字符串表示形式

示例：

class StringDemo {

       public static void main(String[] args) {

              //将字符数组转换成字符串（构造函数）

              String s1 = new String(new char[] { 'a', 'b', 'c', 'd', 'e', 'f', 'g' });

              System.out.println(s1);                                     // 结果：abcdefg

              String s2 = new String(new char[] { 'a', 'b', 'c', 'd', 'e', 'f', 'g','h','i', 'j', 'k', 'l', 'm', 'n' }, 4, 9);

              System.out.println(s2);                                     // 结果：efghijklm

              //将字符数组转换成字符串（静态方法）

              Strings3 = String.copyValueOf(new char[] { 'a', 'b', 'c', 'd', 'e','f','g' });

              System.out.println(s3);                                     // 结果：abcdefg

              Strings4 = String.copyValueOf(new char[] { 'a', 'b', 'c', 'd', 'e','f','g', 'h', 'i', 'j', 'k', 'l', 'm', 'n' }, 4, 9);

              System.out.println(s4);                                     // 结果：efghijklm

              //将字符串转成字符数组

              char[] ch = s1.toCharArray();                                   //结果：[a,b,c,d,e,f,g]

              System.out.print("[");

              for(int x = 0; x < ch.length; x++) {

                     if(x != ch.length - 1)

                            System.out.print(ch[x]+ ",");

                     else

                            System.out.println(ch[x]+ "]");

              }

              //将字节数组转成字符串

              String s5 = new String(new byte[] { 'a', 'b', 'c', 'd', 'e', 'f' });

              System.out.println(s5);                                     // 结果：abcdef

              //将字符串转成字节数组

              byte[] bytes = s5.getBytes();                              //结果：[97,98,99,100,101,102]

              System.out.print("[");

              for(int  x = 0; x < bytes.length; x++) {

                     if(x != bytes.length - 1)

                            System.out.print(bytes[x]+ ",");

                     else

                            System.out.println(bytes[x]+ "]");

              }

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

              System.out.println(String.valueOf(100));            // 结果：100

              System.out.println(String.valueOf((char)100));  // 结果：d

              System.out.println(String.valueOf(true));           //结果：true

       }

}

◆替换

       String replace(char old,char new)

示例：

class StringDemo {

       public static void main(String[] args) {

              String s1 = "afadfefsdfefefe";

              System.out.println(s1.replace('e','f'));                 //结果：afadfffsdffffff

       }

}

◆切割

       String[] split(String regex)——用正则表达式将字符串分割成数组

示例：

class StringDemo {

       public static void main(String[] args) {

              String s = "a3fd5f8de6rerer6yrt";

              //将s以数字分开

              String[] temp = s.split("[0-9]");                  //结果：[a,fd,f,de,rerer,yrt]

              System.out.print("[");

              for(int  x = 0; x < temp.length; x++) {

                     if(x != temp.length - 1)

                            System.out.print(temp[x]+ ",");

                     else

                            System.out.println(temp[x]+ "]");

              }

       }

}

◆子串

       1.Stringsubstring(int begin)——返回从begin到结尾

       2.Stringsubstring(int begin,int end)——返回从begin到end-1（包含头，不包含尾）

示例：

class StringDemo {

       public static void main(String[] args) {

              Strings1 = "abcdefg";

              //从第2个开始截到最后

              System.out.println(s1.substring(2));                   //结果：cdefg

              //从第2个开始截到第4个

              System.out.println(s1.substring(2,5));                 //结果：cde

       }

}

◆转换、取出空格、比较

       1.String toUpperCase()——将字符串转成大写

         String toLowerCase()——将字符串转成小写

       2.String trim()——将字符串两端的多个空格去除

       3.int compareTo(string s)——对两个字符串进行自然顺序的比较

示例：

class StringDemo {

       public static void main(String[] args) {

              String s1 = "    abcdefgAB  CDEFG   ";

              //将字符串转成大写

              System.out.println(s1.toUpperCase());//结果：____ABCDEFGAB__CDEFG____(_代表空格)

              //将字符串转成小写

              System.out.println(s1.toLowerCase());//结果：____abcdefgab__cdefg____(_代表空格)

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

              System.out.println(s1.trim());//结果：abcdefgAB__CDEFG

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

              String s2 = "agbfd";

              String s3 = "abd";

              String s4 = "bde";

              String s5 = "bde";

              System.out.println(s2.compareTo(s3));//结果：5意味着s2>s3

              System.out.println(s3.compareTo(s4));//结果：-1意味着s3<s4

              System.out.println(s4.compareTo(s5));//结果：0意味着s4=s5

       }

}

练习一：（获取一个字符串在另一个字符串中出现的次数）

思路：

1.定义一个计数器；

2.获取某个字符串第一次出现的位置；

3.从第一次出现位置后剩余的字符串中继续获取kk出现的位置；

4.当获取不到时，计数完成。

代码实现：

class StringCount {

       public static void main(String[] args) {

              String s = "aabbddfeaadfeddaaeedfeaa";

              int  x = getSubCount_1(s, "aa");

              System.out.println(x);

              int  y = getSubCount_2(s, "aa");

              System.out.println(y);

       }

       public  static int getSubCount_1(String s, String key) {

              int  count = 0;

              int  index = 0;

              while((index = s.indexOf(key)) != -1) {

                     System.out.println("s="+ s);

                     s= s.substring(index + key.length());

                     count++;

              }

              return  count;

       }

       public  static int getSubCount_2(String s, String key) {

              int  count = 0;

              int  index = 0;

              while((index = s.indexOf(key, index)) != -1) {

                     System.out.println("index="+ index);

                     index= index + key.length();

                     count++;

              }

              return   count;

       }

}

运行结果：

s=aabbddfeaadfeddaaeedfeaa

s=bbddfeaadfeddaaeedfeaa

s=dfeddaaeedfeaa

s=eedfeaa

4

index=0

index=8

index=15

index=22

4

练习二：（获取两个字符串中最大相同子串）

思路：

1.将短的那个字符串按照长度递减的方式获取到；

2.将每次取得的子串去判断长的字符串中是否包含，如果包含，已经找到。

代码实现：

class MaxSubStringDemo {

       public  static void main(String[] args) {

              String  s = "aabbddfeaadfeddaaeedfeaa";

              //dfeddaaee

              String  s2="dfeddaaeefdagagadgaga";

              System.out.println(getMaxSubString(s,s2));

       }

       public  static String getMaxSubString(String s1, String s2) {

              String  max = "", min = "";

              max= (s1.length() > s2.length()) ? s1 : s2;

              min= (max == s1) ? s2 : s1;

              for(int x = 0; x < min.length(); x++) {

                     for(int y = 0, z = min.length() - x; z != min.length() + 1; y++, z++) {

                            String  temp = min.substring(y, z);

                            //System.out.println(temp);

                            if(max.contains(temp))

                                   return  temp;

                     }

              }

              return "";

       }

}

运行结果：dfeddaaee

练习三：（对字符串中字符进行自然顺序排序）

思路：

1.字符串变成字符数组

2.对数组排序

3.将排序后的数组变成字符串

代码实现：

class StringDemo {

       public  static void main(String[] args) {

              String  s="gheiuhgagvihgkgvhdu";

              char[]  ch=s.toCharArray();

              Arrays.sort(ch);

              System.out.println(newString(ch));

       }

}

运行结果：adeggggghhhhiikuuvv

练习四：（模拟一个trim方法，去除字符串两端的空格）

思路：

1.判断字符串第一个位置是否为空格，如果是继续向下判断，直到不是空格为止，结尾处判断空格也是一样的；

2.当开始和结尾都判断到不是空格时，就是要获取的字符串

代码实现：

class StringDemo {

       public  static void main(String[] args) {

              String  s="   dfa  fdsaf  ";

              System.out.println(s);

              System.out.println(myTrim(s));//结果：dfa  fdsa

       }

       public  static String myTrim(String s){

              int  start=0,end=s.length()-1;

              while(start<=end&&s.charAt(start)==' ')

                     start++;

              while(start<=end&&s.charAt(end)==' ')

                     end--;

              return  s.substring(start, end);

       }

}

练习五：（将一个字符串进行反转，将字符串中指定部分进行反转）

思路：

1.将字符串变成数组，对数组反转

2.将反转后的数组变成字符串

3.只要将要反转的部分的开始和结束位置作为参数传递即可

代码实现：

class StringDemo {

       public  static void main(String[] args) {

              String  s = "adfdsafdedae";

              System.out.println(s);

              System.out.println(reverseString(s,0, s.length()-3));

       }

       public  static String reverseString(String s, int start, int end) {

              char[]  chs = s.toCharArray();

              reverse(chs,start, end);

              return  new String(chs);

       }

       private  static void reverse(char[] arr, int x, int y) {

              for(int start = x, end = y - 1; start < end; start++, end--) {

                     swap(arr,start, end);

              }

       }

       private  static void swap(char[] arr, int x, int y) {

              char temp = arr[x];

              arr[x] = arr[y];

              arr[y] =temp;

       }

}

运行结果：

adfdsafdedae

edfasdfdadae

二、StringBuffer

1.特点：

       ·StringBuffer是字符串缓冲区

       ·字符串的组成原理就是通过该类实现的

       ·StringBuffer可以对字符串内容进行增删

       ·StringBuffer是一个容器

       ·很多方法与String相同

       ·StringBuffer是可变长度的

       ·最终会通过toString方法变成字符串

2. StringBuffer类的常用方法：

◆存储

       StringBufferappend()——将指定数据作为参数添加到已有数据结尾处

       StringBufferinsert(int index,data)——可以将data插入到指定index位置

示例：

class StringBufferDemo {

       public  static void main(String[] args) {

              StringBuffer  sb1=new StringBuffer("abcdefg");

              //在sb1结尾处添加数据add

              sb1.append("add");

              System.out.println(sb1);                             //结果：abcdefgadd

              //从sb1的第三个脚本开始插入insert

              sb1.insert(3,"insert");

              System.out.println(sb1);                             //结果：abcinsertdefgadd

       }

}

◆删除

       StringBuffer delete(intstart,int end)——删除缓冲区中的数据，包含start，不包含end

       StringBufferdeleteCharAt(index)——删除指定位置的字符

示例：

class StringBufferDemo {

       public  static void main(String[] args) {

              StringBuffer  sb1 = new StringBuffer("abcdefghijklmn");

              //删除脚标为5的元素

              sb1.deleteCharAt(5);

              System.out.println(sb1);                      // 结果：abcdeghijklmn

              //删除脚标从2到4的元素

              sb1.delete(2,5);

              System.out.println(sb1);                      // 结果：abghijklmn

       }

}

◆获取

       char  charAt(int index)

       int  indexOf(String str)

       int  lastIndexOf(String str)

       int  length()

       String  substring(int start, int end)

这几个功能与String用法相同，不再举例说明

◆修改

       String  Bufferreplace(start,end,string)

       void  setCharAt(int index, char ch)

示例：

class StringBufferDemo {

       public  static void main(String[] args) {

              StringBuffer  sb = new StringBuffer("abcdefghijk");

              //将脚本从1到8的数据换成abc

              sb.replace(1,9, "abc");

              System.out.println(sb);                // 结果：aabcjk

              //将脚标为0的数据替换成r

              sb.setCharAt(0,'r');

              System.out.println(sb);                // 结果：rabcjk

       }

}

◆反转

       String  Bufferreverse()

示例：

class StringBufferDemo {

       public  static void main(String[] args) {

              StringBuffer  sb = new StringBuffer("abcdefghijk");

              System.out.println(sb);

              System.out.println(sb.reverse());

       }

}

运行结果：

abcdefghijk

kjihgfedcba

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

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

示例：

class StringBufferDemo {

       public  static void main(String[] args) {

              StringBuffer  sb = new StringBuffer("abcdefghijk");

              char[]  ch = new char[] { 'q', 'w', 'e', 'r', 't', 'y', 'u' };

              //将sb中脚标从2到3的元素替换到ch中，ch从脚标为2开始替换，如果替换额长度超过了char数组的话，报出异常

              sb.getChars(2,4, ch, 2);

              System.out.print("[");

              for(int  x = 0; x < ch.length; x++) {

                     if(x != ch.length - 1)

                            System.out.print(ch[x]+ ",");

                     else

                            System.out.println(ch[x]+ "]");

              }

       }

}

运行结果：

[q,w,c,d,t,y,u]

总结：

StringBuffer类特有的方法：

StringBuffer append(int x);

StringBuffer delete(int start,int end);

StringBuffer insert(int index,String str);

StringBuffer reverse();

JDK1.5出现一个StringBuilder，区别是StringBuffer是同步的，StringBuilder是非同步的。

建议在以后开发中使用StringBuilder。

 

三、基本数据类型对象包装类

       byte        Byte

       short       Short

       int          Integer

       long        Long

       boolean   Boolean

       float        Float

       double     Double

       char        Character

       ·将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能来操作数据

       ·常用的操作：用于基本数据类型与字符串之间的转换

◆基本数据类型转换成字符串：

       1.基本数据类型+””;

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

比如：Integer.toStirng(45);//将45整数转成字符串”34”

◆字符串转成基本数据类型

       Typea=Type.parseType(String);

       int a=Integer.parseInt(“123”);

       double b=Double.parseDouble(“123”);

       boolean  b=Boolean.parseBoolean(“true”) ;

      

       Integer  i = new Integer("123");

       intnum = i.intValue();

      

◆十进制转成其他进制

       String toBinaryString()——转成二进制

       String toHexString()——转成十六进制

       String toOctalString()——转成八进制

 

◆其他进制转成十进制

       int parseInt(String,radix)

例如：

parseInt("0",10) 返回 0

parseInt("1100110",2) 返回 102

parseInt("-FF",16) 返回 -255

基本数据类型对象包装类新特性：

JDK1.5以后，简化了定义方式

       Integer x=new Integer(4);//可以直接写成

       Integer x=4;//自动装箱

       x=x+5;//自动拆箱，通过intValue方法

示例：

IntegerDemo {

       public static void main(String[] args) {

              Integer x = new Integer(4);

              Integer z = new Integer(4);

              System.out.println(x== z);// 结果：false——这是两个对象

              System.out.println(x.equals(z));//结果：true——值相等

              System.out.println(x);//结果：4

              Integer y = 4;

              System.out.println(y);//结果：4

              System.out.println(x== y);// 结果：flase

              System.out.println(x.equals(y));//结果：true

              //x = x.intValue() + 2;

              x= x + 2;// 进行自动拆箱，变成int类型，再和2进行加法运算，再将结果进行装箱赋给x

              System.out.println(x);//结果：6

              y= y + 2;

              System.out.println(y);//结果：6

              Integer a = 12;

              Integer b = 12;

              System.out.println(a== b);// 结果为true。因为a和b指向了同一个Integer对象

              Integer m = 128;

              Integer n = 128;

              System.out.println(m== n);// 结果为false。因为当数值在byte范围内容，对于新特性，如果该数值已经存在，则不会在开辟新的空间。

       }

}

需要注意：在使用时，Integer x=null;上面的代码就会出现NullPointException