【13】String类_获取，判断，转换，替换，切割...

6.1 Sting类

 

String类适用于描述字符串事物。

那么它就提供了多个方法对字符串进行操作。

 

常见的操作有哪些？

"abcd"

 

6.1.1.获取。

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

                   intlength():获取长度。

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

                   charcharAt(int index):

         1.3 根据字符获取该字符在字符串中位置。

                   intindexOf(int ch):返回的是ch在字符串中第一次出现的位置。

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

 

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

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

 

                   intlastIndexOf(int ch) ：

 

                  

6.1.2.判断。

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

                   booleancontains(str):

                   特殊之处：indexOf(str):可以索引str第一次出现位置，如果返回-1.表示该str不在字符串中存在。

                    所以，也可以用于对指定判断是否包含。

                   if(str.indexOf("aa")!=-1)

 

                   而且该方法即可以判断，有可以获取出现的位置。

 

         2.2 字符中是否有内容。

                   booleanisEmpty(): 原理就是判断长度是否为0.

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

                   booleanstartsWith(str);

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

                   booleanendsWith(str);

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

                   booleanequals(str);

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

                   booleanequalsIgnoreCase();

        

6.1.3.转换。

         3.1 将字符数组转成字符串。

                   构造函数：String(char[])

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

 

                   静态方法：

                                     staticString copyValueOf(char[]);

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

 

                                     staticString valueOf(char[]):

 

                  

         3.2 将字符串转成字符数组。**

                   char[]toCharArray():

 

         3.3 将字节数组转成字符串。

                            String(byte[])

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

 

         3.4 将字符串转成字节数组。

                            byte[]  getBytes():

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

                   staticString valueOf(int)

                   staticString valueOf(double)

 

                   //3+"";//String.valueOf(3);

 

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

 

6.1.4.替换

         Stringreplace(oldchar,newchar);

 

6.1.5.切割

         String[]split(regex);

 

6.1.6.子串。获取字符串中的一部分

         Stringsubstring(begin);

         Stringsubstring(begin,end);

 

6.1.7.转换，去除空格，比较

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

                    String toUpperCase();

                    String toLowerCase();

 

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

                   Stringtrim();

 

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

                   intcompareTo(string);

 

练习一：String类常见操作

 

class StringMethodDemo{          public static void method_7()         {                   String s = "    Hello Java     ";                   sop(s.toLowerCase());                   sop(s.toUpperCase());                   sop(s.trim());                    String s1 = "a1c";                   String s2 = "aaa";                    sop(s1.compareTo(s2));         }         public static void method_sub()         {                   String s = "abcdef";                    sop(s.substring(2));//从指定位置开始到结尾。如果角标不存在，会出现字符串角标越界异常。                   sop(s.substring(2,4));//包含头，不包含尾。s.substring(0,s.length());         }          public static void  method_split()         {                   String s = "zhagnsa,lisi,wangwu";                    String[] arr  = s.split(",");                    for(intx = 0; x<arr.length; x++)                   {                            sop(arr[x]);                   }         }          public static void method_replace()         {                   String s = "hello java";                    //String s1 = s.replace('q','n');//如果要替换的字符不存在，返回的还是原串。                     String s1 = s.replace("java","world");                   sop("s="+s);                   sop("s1="+s1);         }          public static void method_trans()         {                   char[] arr = {'a','b','c','d','e','f'};                    String s= new String(arr,1,3);                    sop("s="+s);                    String s1 = "zxcvbnm";                    char[] chs = s1.toCharArray();                    for(intx=0; x<chs.length; x++)                   {                            sop("ch="+chs[x]);                   }         }         public static void method_is()         {                   String str = "ArrayDemo.java";                                     //判断文件名称是否是Array单词开头。                   sop(str.startsWith("Array"));                   //判断文件名称是否是.java的文件。                   sop(str.endsWith(".java"));                   //判断文件中是否包含Demo                   sop(str.contains(".java"));          }           public static void method_get()         {                   String str = "abcdeakpf";                    //长度                  sop(str.length());                    //根据索引获取字符。                   sop(str.charAt(4));//当访问到字符串中不存在的角标时会发生StringIndexOutOfBoundsException。                    //根据字符获取索引                   sop(str.indexOf('m',3));//如果没有找到，返回-1.                                     //反向索引一个字符出现位置。                   sop(str.lastIndexOf("a"));                           }         public static void main(String[] args)         {                   method_7();//               method_trans();//               method_is();//               method_get();                   /*                   String s1 = "abc";                   String s2 = new String("abc");                    String s3 = "abc";                   System.out.println(s1==s2);                   System.out.println(s1==s3);                    */         }          public static void sop(Object obj)         {                   System.out.println(obj);         }}

 

练习二：灵活运用String的常见操作

/*1，模拟一个trim方法，去除字符串两端的空格。         思路：         1，判断字符串第一个位置是否是空格，如果是继续向下判断，直到不是空格为止。                   结尾处判断空格也是如此。         2，当开始和结尾都判断到不是空格时，就是要获取的字符串。   2，将一个字符串进行反转。将字符串中指定部分进行反转，"abcdefg";abfedcg         思路：         1，曾经学习过对数组的元素进行反转。         2，将字符串变成数组，对数组反转。         3，将反转后的数组变成字符串。         4，只要将或反转的部分的开始和结束位置作为参数传递即可。  */ class StringTest{          public static void sop(String str)         {                   System.out.println(str);         }         public static void main(String[] args)         {                   String s = "      ab cd      ";                    sop("("+s+")");//               s= myTrim(s);//               sop("("+s+")");                    sop("("+reverseString(s)+")");                           }           //将字符串反转。         /*         思路：         1，将字符串变成数组。         2，对数组反转。         3，将数组变成字符串。         */          public static String reverseString(String s,int start,int end)         {                   //字符串变数组。                   char[] chs = s.toCharArray();                    //反转数组。                   reverse(chs,start,end);                    //将数组变成字符串。                   return new String(chs);         }         public static String reverseString(String s)         {                   return reverseString(s,0,s.length());                           }          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;         }          //去除字符串两端空格。         public static String myTrim(String str)         {                   int start = 0,end = str.length()-1;                    while(start<=end&& str.charAt(start)==' ')                            start++;                    while(start<=end&& str.charAt(end)==' ')                            end--;                    return str.substring(start,end+1);         }}

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

 

/*3，获取一个字符串在另一个字符串中出现的次数。         "abkkcdkkefkkskk"          思路：         1，定义个计数器。         2，获取kk第一次出现的位置。         3，从第一次出现位置后剩余的字符串中继续获取kk出现的位置。                   每获取一次就计数一次。         4，当获取不到时，计数完成。*/ class StringTest2{                /*         方法一         */          public static int getSubCount(String str,String key)         {                   int count = 0;                   int index = 0;                    while((index=str.indexOf(key))!=-1)                   {                            sop("str="+str);                            str= str.substring(index+key.length());                             count++;                    }                   return count;         }          /*         方法二         */         public static int getSubCount_2(String str,String key)         {                   int count = 0;                   int index = 0;                    while((index=str.indexOf(key,index))!=-1)                   {                            sop("index="+index);                            index= index + key.length();                             count++;                   }                   return count;         }          public static void main(String[] args)         {                   String str = "kkabkkcdkkefkks";                    ///sop("count====="+str.split("kk").length);split()不建议使用。                    sop("count="+getSubCount_2(str,"kk"));         }          public static void sop(String str)         {                   System.out.println(str);         }}

 

练习四：获取两个字符串中最大相同子串。

 

/*4.获取两个字符串中最大相同子串。第一个动作：将短的那个串进行长度一次递减的子串打印。         "abcwerthelloyuiodef"         "cvhellobnm"         思路：                   1，将短的那个子串按照长度递减的方式获取到。                   2，将每获取到的子串去长串中判断是否包含，                            如果包含，已经找到！。*/class StringTest3{         public static String getMaxSubString(String s1,String s2)         {                     String max = "",min = "";                    max= (s1.length()>s2.length())?s1: s2;                    min= (max==s1)?s2: s1;                  //               sop("max="+max+"...min="+min);                   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);                                                                         sop(temp);                                     if(max.contains(temp))//if(s1.indexOf(temp)!=-1)                                               return temp;                            }                   }                   return "";         }           public static void main(String[] args)         {                   String s1 = "ab";                   String s2 = "cvhellobnm";                   sop(getMaxSubString(s2,s1));         }          public static void sop(String str)         {                   System.out.println(str);         }}

 

6.1.8  StringBuffer是字符串缓冲区

 

StringBuffer是一个容器。

特点：

1，长度是可变化的。

2，可以字节操作多个数据类型。

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

 

C create U update R read D delete

 

1，存储。

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

         StringBufferinsert(index,数据):可以将数据插入到指定index位置。

 

2，删除。

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

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

        

3，获取。

         charcharAt(int index)

         intindexOf(String str)

         intlastIndexOf(String str)

         intlength()

         Stringsubstring(int start, int end)

 

4，修改。

         StringBufferreplace(start,end,string);

         voidsetCharAt(int index, char ch) ;

 

 

5，反转。

         StringBufferreverse();

 

6，

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

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

 

        

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

 

StringBuffer是线程同步。

StringBuilder是线程不同步。

 

以后开发，建议使用StringBuilder

 

升级三个因素：

1，提高效率。

2，简化书写。

3，提高安全性。

 

练习五：StringBuffer操作的练习

class Demo{} class StringBufferDemo{         public static void main(String[] args)         {                   //method_update();                    StringBuilder sb = new StringBuilder("abcdef");                           char[] chs = new char[6];                    sb.getChars(1,4,chs,1);//将                    for(int x=0; x<chs.length; x++)                   {                            sop("chs["+x+"]="+chs[x]+";");                   }                    draw(3,6);                   draw(8,9); //               StringBuilder sb1 = new StringBuilder();//               sb1.append(newDemo()).append(new Demo());//               sop("sb1="+sb1);         }         public static void method_update()         {                   StringBuffer sb  = newStringBuffer("abcde"); //               sb.replace(1,4,"java");                   sb.setCharAt(2,'k');                    sop(sb.toString());                 }         public static void method_del()         {                   StringBuffer sb  = newStringBuffer("abcde");                 //               sb.delete(1,3);                   //清空缓冲区。                   //sb.delete(0,sb.length());                    //sb.delete(2,3);                   sb.deleteCharAt(2);                    sop(sb.toString());         }          public static void method_add()         {                   StringBuffer sb = new StringBuffer();                    //sb.append("abc").append(true).append(34);//               StringBuffer sb1 = sb.append(34);//               sop("sb==sb1:"+(sb==sb1));                    sb.insert(1,"qq");                   sop(sb.toString());//abctrue34                   //sop(sb1.toString());                            }                  public static void sop(String str)         {                   System.out.println(str);         }                 public static void draw(int row,int col)         {                   StringBuilder sb = new StringBuilder();                   for(int x=0; x<row; x++)                   {                            for(int y=0; y<col; y++)                            {                                     sb.append("*");                            }                            sb.append("\r\n");                   }                    sop(sb.toString());         } }

 

6.1.9基本数据类型对象包装类。

 

byte Byte

short         short

int              Integer

long          Long

boolean   Boolean

float           Float

double      Double

char          Character

 

 

 

基本数据类型对象包装类的最常见作用，

就是用于基本数据类型和字符串类型之间做转换

 

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

 

         基本数据类型+""

 

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

 

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

 

 

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

 

         xxxa = Xxx.parseXxx(String);

 

         inta = Integer.parseInt("123");

 

         doubleb = Double.parseDouble("12.23");

 

         booleanb = Boolean.parseBoolean("true");

 

         Integeri = new Integer("123");

 

         intnum = i.intValue();

 

十进制转成其他进制。

         toBinaryString();

         toHexString();

         toOctalString();

 

 

其他进制转成十进制。

         parseInt(string,radix);

 

练习六：基本数据类型操作

class IntegerDemo{         public static void sop(String str)         {                   System.out.println(str);         }                 public static void main(String[] args)         {                   //整数类型的最大值。                   //判断数据是否超出最大值                   //sop("intmax :"+Integer.MAX_VALUE); //               将一个字符串转成整数。                    int num = Integer.parseInt("123");//必须传入数字格式的字符串。                   //long x = Long.parseLong("123"); //               sop("num="+(num+4)); //               sop(Integer.toBinaryString(-6));//               sop(Integer.toHexString(60));                    int x = Integer.parseInt("3c",16);                    sop("x="+x);           }}

 

6.1.10JDK1.5版本以后出现的新特性，基本数据类型自动装箱、拆箱

 

练习六：基本数据类型的自动拆箱，装箱

class IntegerDemo1{         public static void main(String[] args)         {                  //               Integer x = new Integer(4);                    Integer x = 4;//自动装箱。//new Integer(4)                    x= x + 2;//x+2:x 进行自动拆箱。变成成了int类型。和2进行加法运算。                                               //再将和进行装箱赋给x。                   //x的拆箱过程    x.intValue()                      Integer m = 128;                   Integer n = 128;                    sop("m==n:"+(m==n));                    Integer a = 127;                   Integer b = 127;                    sop("a==b:"+(a==b));//结果为true。因为a和b指向了同一个Integer对象。                                                        //因为当数值在byte范围内容，对于新特性，如果该数值已经存在，则不会在开辟新的空间。         }          public static void method()         {                   Integer x = new Integer("123");                    Integer y = new Integer(123);                     sop("x==y:"+(x==y));                   sop("x.equals(y):"+x.equals(y));         }          public static void sop(String str)         {                   System.out.println(str);         }        }