黑马程序员----String类

——- android培训、java培训、期待与您交流！ ———-

一、String类:

        字符串是一个特殊的对象，字符串是常量，一旦初始化就不可以被改变（被final关键字修饰）。

        初始化方式：
                String str="abc";//str是一个类类型变量，“abc”是一个对象。
                String str1=new String("abc");

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

        这两种初始化方式有什么区别？

                String类复写了Object类中的equals方法，定义了自己独特内容，该方法用于判断字符串内容是否相同。

        str和str1有什么区别？
                str在内存中有一个对象，str1在内存中有两个对象。

        方法区：方法，静态和常量池，常量池中有数组，存放a，b，c这样的字符。

        如果字符串相同，当定义其他引用的时候，会指向用一个已经存在的对象，而不再单独开辟空间，节省内存。

        String类是用于描述字符串事物，它提供可多个方法对字符串进行操作。

        String类中的方法：
            获取：
           1.字符串中包含字符数，即：获取字符串的长度；    
                int length();

2.根据位置获取该位置上的某个字符。返回值类型为char；
    char charAt(int index)
3.根据字符获取该字符在字符串中的位置。
    int indexOf(int ch)：返回的是ch在字符串中第一次出现的位置。
    int indexOf(int ch，int fromIndex):从指定位置开始，获取ch在字符串中的位置。
    int indexOf(String str)    ：返回的是str在字符串中第一次出现的位置。
    int indexOf(String str，int fromIndex)：从指定位置开始，获取str在字符串中的位置。    
    int lastIndexOf(int ch):反向索引。

判断:
1.字符串中是否包含某一个子串；
    boolean  contains(str);
    特殊之处：indexOf(str):可以索引str第一次出现的位置（如果返回-1，则表示该str不在字符串中存在），也可以用于对指定字符串判断是否包含。如果字符串对象.indexOf("aa")!=-1,则包含，而且该方法既可以判断又可以获取出现的位置。
2.字符串中是否有内容；
    boolean isEmpty();原理就是判断长度是否为0 ，//1.6版本以下不能用。
3.字符串是否是以指定内容开头
    boolean startWith(str);
4.字符串是否是以指定内容结尾
    boolean endWith(str);
5.字符串的内容是否相同：
    boolean equals(str);复写了Object类中的equals方法。
6.内容是否相同并忽略大小写：
    boolean  equalsIgnoreCase(str);

转换：
1.将字符数组转换成字符串；
    构造函数：String(char[] value);
    构造函数：String(char[] value,int offset,int count);//将字符数组中的一部分转换长字符串；
    
    静态方法：static String copyValueOf(char[]);
    静态方法：static String copyVlaueOf(char[] data,int offset,int count);
    静态方法：static String valueOF(char[]);
    
2.将字符串转换成字符数组；//重要：不需要参数，因为这个对象就是字符串，里面用的 是this。
    char[] toCharArray();
3.将字节数组转换成字符串；
    String(byte[] value);
    String(byte[] value,int offset,int count);//将字节数组中的一部分转换成字符串；
4.将字符串转换成字节数组；
    byte[] getBytes();//字符串和字符数组在转换过程中是可以指定编码表的。
5.将基本数据类型转换成字符串：
    static String valueOf(int);
    static String valueOf(double);
    ......
    3+"":String.valueOf(3);//返回的也是字符串3.

替换：
1.替换字符串中的指定字符；
    String replace(oldchar,newchar);
2.替换字符串；
    String replace("oldstring","newstring");
3.将字符串按照指定的规则进行替换：（包含正则表达式）
    String replaceAll(String regex,String replacement);

切割：
按指定分隔符将一个字符串分割成多个字符串，
    String[] split(regex);
    
子串：
获取字符串中的一部分。
    String substring(int beginIndex);
    String substring(int beginIndex,int endIndex);
    
转换：将字符串转换成大写或者小写
    String toUpperCase();//转换成大写；

    String tolowerCase();//转换成小写；

    不区分大小写比较的原理：全部转换成大写或者小写，再用equals去比较。

去除空格：将字符串两端的多余空格去除

    String trim();

比较：对两个字符串进行自然顺序的比较
    int compareTo(string);    

    如果参数字符串等于此字符串，则返回值是0

    如果此字符串按字典顺序小于字符串参数，则返回一个小于0 的值；

    如果如果此字符串按字典顺序大于字符串参数，则返回一个大于0 的值。

public class StringDemo_0{public static void sop(Object obj){System.out.println(obj);}//方法演示：//获取：public static void method_get(){String str="abcdeamnjkuf";//获取长度：sop(str.length());//根据索引获取字符：sop(str.charAt(4));//sop(str.charAt(40));//当访问到字符串中不存在的角标时，会发生角标越界异常。//根据字符获取索引：sop(str.indexOf('a',3));//sop(str.indexOf('m',3));//如果没有找到，没有角标返回-1；//反向索引一个字符出现的位置：sop(str.lastIndexOf("n"));}//判断：public static void method_is(){String str="ArrayDemo.java";//判断文件名称是否是以Array开头：sop(str.startsWith("Array"));//判断文件名称是不是.java的文件：sop(str.endsWith(".java"));//判断文件名称是否包含Demo：sop(str.contains("Demo"));}//转换：public static void method_trans(){char[] arr={'a','b','c','d','e','f'};String s=new String(arr);String s1=new String(arr,1,3);//3是个数，从角标为1的位置开始的三个字符；//打印数组：sop("s="+s);sop("s1="+s1);String s0="qwertyuiop";char[] chs=s0.toCharArray();for(int x=0;x<chs.length;x++){sop("chs="+chs[x]);}}//替换：public static void method_replace(){String s="Hello java";//替换字符：String s1=s.replace('a', 'n');//String s1=s.replace('q', 'n');//如果要替换的字符不存在，则返回的是原来的字符串。sop("s="+s);sop("s1="+s1);//替换字符串：String s2=s.replace("java","world");sop("s2="+s2);}//切割：public static void method_split(){String s="qwertyuiop,asdfghjkl,zxcvbnm";String[] s1=s.split(",");for(int x=0;x<s1.length;x++){sop(x+":"+s1[x]);}}//获取子串：public static void method_substring(){String s="asdfghjklzxcvbnm";sop(s.substring(2));//获取从角标为2的字符开始到结尾的子串；s.substring(2,s.length);sop(s.substring(2,4));//获取从角标2到角标4之间的子串；（包括角标2不包括角标4的字符）.//如果角标不存在，会出现角标越界的异常；}//转换、去除空格、比较：public static void method_caseTrimCompare(){String s="    Hello Java    ";String s1="Hello World";sop(s.toUpperCase());sop(s.toLowerCase());sop(s.trim());sop(s.compareTo(s1));//-40?比较的是该位上的ASCII码值得大小，返回ASCII码值之差；}//主函数：public static void main(String[] args){String str0="abc";//常用方式;String str1=new String("abc");System.out.println(str0==str1);//false;System.out.println(str0.equals(str1));//true;str0="kk";//abc对象并没有变，只是str指向了kk这个对象。String str2="abc";System.out.println(str0==str1);//false;System.out.println(str0==str2);//false;//abc对象已经在内存中存在了.//--------------------------------------------------------------------------method_get();method_is();method_trans();method_replace();method_split();method_substring();method_caseTrimCompare();}}

二、基本数据类型包装类

        数据类型        对应的对象(引用数据类型)
        byte                Byte
        short              Short
        int                   Integer
        long               Long
        boolean        Boolean
        float               Float
        double          Double
        char              Character

        最常见的作用就是用于基本数据类型和字符串类型之间做转换。
                1.基本数据类型转成字符串；
                    基本数据类型+"";
                    基本数据类型.toString(基本数据类型值)；
                    如：Integer.toString(34);//将34整数转换成字符串"34";
    
                2.字符串转成基本数据类型。
        静态方法：
                基本数据类型xxx a=Xxx.parseXxx("字符串");
                如：    int num=Integer.parseInt("123");
                          boolean xx=Boolean.parseBoolean("true");
        非静态方法：对象调用方式        
                Integer i=new Integer("34");
                int num=i.intValue();
    
        特殊的：character没有这种方法，它本身就是字符.
        
        进制转换：
               1.十进制转换成其他进制：
                    toBinaryString();//2
                    toHexString();//8
                    toOctalString();//16
    
               2.其他进制转换成十进制;
                    parseInt(String,index);
    
        JDK1.5版本出现的新特性：
               1.拆箱、装箱。
                int:只能是整数
                Integer比int多了一个值：null;
                要对Integer进行判断，不为空则运算；为空时要小心空指针异常；

                2.当数值在byte范围内时，对于新特性，如果数值已经存在，不会再开辟新的空间；

public class StringDemo_1 {public static void sop(String str){System.out.println(str);}//主函数：public static void main(String[] args){//整数类型的最大值：sop("int max="+Integer.MAX_VALUE);//将一个字符串转成整数：int num=Integer.parseInt("123");//long num1=Long.parseLong("a123456");//数字格式异常，必须传入数字格式的字符串；sop("num="+(num+4));//sop("num1="+(num1+4));//十进制转换成其他进制：sop(Integer.toBinaryString(6));sop(Integer.toBinaryString(-6));sop(Integer.toHexString(60));//其他进制转十进制：int x=Integer.parseInt("110", 2);sop("x="+x);int x1=Integer.parseInt("3c", 16);sop("x="+x1);//--------------------------------------------------------------------------//新特性：Integer m=new Integer(4);Integer n=4;//自动装箱，封装为对象：相当于new Integer(4);n=n/*操作是：n.intValue();*/+2;//n+2:n进行自动拆箱，变成int类型与2相加，再把相加的值装箱赋给n;//Integer n=null;//n=n+2;//做运算时会出现空指针异常；n不能调用intValue();Integer s=128;Integer t=128;sop("s==t:"+(s==t));//false;s和t指向两个不同的对象；Integer a=127;Integer b=127;sop("a==b:"+(a==b));//true;因为a和b指向了同一个对象;//当数值在byte范围内时，对于新特性，如果数值已经存在，不会再开辟新的空间；}public static void method_Integer(){Integer m=new Integer("346");Integer n=new Integer(346);//问题：sop("m==n:"+(m==n));//两个对象；sop("m.equals(n):"+(m.equals(n)));//equals复写了Object类中的equals方法，比较的是数值是否相同。}}

三、StringBuffer类:

        字符串缓冲区

        特点：
            1.StringBuffer是一个容器；很多方法和String相同。
            2.StringBuffer是可变长度的，可以操作多个数据类型。
            3.最终会通过toString方法变成字符串。

        StrinBuffer可以对字符串进行增删改查：C:create;U:update;R:read;D:delete.

        StringBuffer中方法：

1.存储：
    StringBuffer append();//将指定的数据作为参数，添加到已有数据的结尾处；
    StringBuffer insert(index,数据);//可以将数据插入到指定index位置；
2.删除：
    StringBuffer delete(int start,int end);//删除缓冲区中的数据；包含头不包含尾；
    StringBuffer deleteCharAt(index);//删除指定位置的字符；
3.获取：
    char charAt(int index);
    int indexOf(String str);
    int lastIndexOf(String str);
    int length();
    String substring(int start.int end);
4.修改：
    StringBuffer replace(start,end,string);//替换字符串；
    void setCharAt(int index,char ch);//替换一个字符；
5.反转：
    StringBuffer reverse();
6.将缓冲区中的指定数据存储到指定字符的数组中；（包含头不包含尾）
    void getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin );

public class StringBuffer_0{public static void sop(String str){System.out.println(str);}//添加：public static void method_add(){StringBuffer sb=new StringBuffer();//空字符StringBuffer sb1=sb.append(34);sb.append("abc").append(true).append(34);//方法调用链；sop(sb1.toString());//34;sop("sb==sb1:"+(sb==sb1));//true;sb.insert(2, "b");sop(sb.toString());//34;}//删除：public static void method_delete(){StringBuffer sb=new StringBuffer("abcdefghigklmn");sb.delete(2, 5);sb.deleteCharAt(8);//sb.delete(2, 3);sop(sb.toString());//清空缓冲区：//sb=new StringBuffer();sb.delete(0, sb.length());}//修改：public static void method_Update(){StringBuffer sb=new StringBuffer("abcdefghigklmn");sb.replace(1, 3, "java");sop(sb.toString());sb.setCharAt(0, 'y');//替换一个字符；sop(sb.toString());}//6.将缓冲区中的指定数据存储到指定字符的数组中；（包含头不包含尾）public static void method_GetChars(){StringBuffer sb=new StringBuffer("abcdefghigklmn");char[] chs=new char[4];sb.getChars(1, 4, chs, 1);for(int x=0;x<chs.length;x++){sop("chs["+x+"]="+chs[x]+";");}}//主函数：public static void main(String[] args){method_add();method_delete();method_Update();method_GetChars();}}

四、StringBuilder类:

在JDK1.5版本之后出现了StringBuilder.
一个可变的字符序列，此类提供一个与StringBuilder兼容的API，但不保证同步。该类被设计用作StringBuffer的简易替换，用在字符串缓冲区被单个线程使用的时候。
如果可能，简易优先采用该类，因为大多数实现中它比StringBuffer要快。

与StringBuilder的不同之处在于：
    StringBuffer是线程同步的，安全。
    StringBuilder线程不同步。

将StringBuilder的实例用于多线程是安全的，如果需要同步，则建议使用StringBuffer。单线程用StringBuilder.

java的升级围绕3个部分：
    1.提高效率；
    2.简化书写；
    3.提高安全性。

StringBuilder是提高了StringBuffer的效率，以后开发，建议使用StringBuilder.
修改程序将StringBuffer改成StringBuilder即可。方法不变，只涉及到有没有锁的问题。

public class StringBuilder_0 {public static void sop(String str){System.out.println(str);}//添加：public static void method_add(){StringBuilder sb=new StringBuilder();//空字符StringBuilder sb1=sb.append(34);sb.append("abc").append(true).append(34);//方法调用链；sop(sb1.toString());//34;sop("sb==sb1:"+(sb==sb1));//true;sb.insert(2, "b");sop(sb.toString());//34;}//删除：public static void method_delete(){StringBuilder sb=new StringBuilder("abcdefghigklmn");sb.delete(2, 5);sb.deleteCharAt(8);//sb.delete(2, 3);sop(sb.toString());//清空缓冲区：//sb=new StringBuilder();sb.delete(0, sb.length());}//修改：public static void method_Update(){StringBuilder sb=new StringBuilder("abcdefghigklmn");sb.replace(1, 3, "java");sop(sb.toString());sb.setCharAt(0, 'y');//替换一个字符；sop(sb.toString());}//将缓冲区中的指定数据存储到指定字符的数组中；（包含头不包含尾）public static void method_GetChars(){StringBuilder sb=new StringBuilder("abcdefghigklmn");char[] chs=new char[4];sb.getChars(1, 4, chs, 1);for(int x=0;x<chs.length;x++){sop("chs["+x+"]="+chs[x]+";");}}//主函数：public static void main(String[] args){method_add();method_delete();method_Update();method_GetChars();}}

五、练习

1.模拟一个trim方法，去除字符串来两端的空格
    思路：
    1.判断字符串的第一个位置是否是空格，如果是继续向下判断，直到不是空格为止；结尾处判断也是如此。
    2.当开始和结尾都判断不是空格时，获取字符串。

2.将一个字符串进行反转。将字符串中指定的部分进行反转，“abcdefg”--"abfedcg".
    思路：
    1.曾经学习过对数组的元素进行反转；
    2.将字符串变成数组，对数组进行反转；
    3.将反转后的数组变成字符串；
    4.只要将反转的部分的开始和结束位置作为参数传递即可。
    
3.获取一个字符串在另一个字符串中出现的次数，“abkkcdkkekfkkskk”
    思路：
    1.定义一个计数器；
    2.获取kk第一次出现的位置；
    3.从第一次出现的位置后剩余的字符串中继续获取kk出席那的位置，每获取一次就计数一次；
    4.当获取不到时，计数完成。

4.获取两个字符串中最大相同子串，第一个动作：将短的那个串进行长度依次递减的子串打印，“abcwerthelloyuiodef”，“cvhellobnm”.
    思路:
    1.将短的那个子串按照长度依次递减的方式获取到；
    2.将每个获取到的子串去长的那个字符串中判断是否包含，如果包含就找到。

public class StringPractece_0 {//打印：public static void sop(String str){System.out.println(str);}public static void print(){System.out.println();}//反转换位：private static void reverse(char[] chs){for(int start=0,end=chs.length-1;start<end;start++,end--)//从头到尾；{swap(chs,start,end);}}private static void reverse(char[] chs,int x,int y){for(int start=x,end=y-1;start<end;start++,end--)//定义一个区间；{swap(chs,start,end);}}private static void swap(char[] chs,int x,int y){char temp=chs[x];chs[x]=chs[y];chs[y]=temp;}//练习1：去除字符串两端的空格：public static String method_Trim(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);//包含头不包含尾，end要加1；}//练习2：字符串中指定的部分进行反转：public static String method_ReverseString(String str){//第一步：字符串变数组：char[] chs=str.toCharArray();//第二步：反转数组：reverse(chs);//第三步：将数组变成字符串：return new String(chs);}public static String method_ReverseString(String str,int start,int end){char[] chs=str.toCharArray();reverse(chs,start,end);return new String(chs,0,str.length());//返回从头至尾的字符串；}//练习3：获取一个字符串在另一个字符串中出现的次数public static int method_GetTimes(String str,String key){/*//方式一：int count=0;int index=0;while((index=str.indexOf(key))!=-1){System.out.println("str="+str);str=str.substring(index+key.length());//原来的串发生改变了；count++;}return count;*///方式二：不打印子串;int count=0;int index=0;while((index=str.indexOf(key,index))!=-1)//从指定位置index开始查；{sop("index="+index);index=index+key.length();count++;}return count;}//练习4：获取两个字符串中最大相同子串public static String method_GetMaxString(String str1,String str2){String max="",min="";max=(str1.length()>str2.length())?str1:str2;min=(max==str1)?str2:str1;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(str1.indexOf(temp)!=-1){return temp;}}}return "";}//主函数：public static void main(String[] args){//练习1：去除字符串两端的空格：String s0="    ab cd  efg      ";sop("原字符串：s0="+s0);sop("去除字符串两端的空格：s="+method_Trim(s0));print();//练习2：//1.将整个字符串进行反转：String s1=" abc defg  ";sop("原字符串：s1="+s1);sop("反转后的字符串：s="+method_ReverseString(s1));//2.字符串中指定的部分进行反转：sop("部分反转后的字符串：s="+method_ReverseString(s1,3,9));//函数重载；print();//练习3：获取一个字符串在另一个字符串中出现的次数：String s2="abkkcdkkekfkkskk";sop("原字符串：s2="+s2);sop("kk出现的次数：count="+method_GetTimes(s2,"kk"));sop("count="+s2.split("kk").length);//这个方法也可以。但是如果字符串开头有kk，用这种方法就少一个，不建议使用。print();//练习4：获取两个字符串中最大相同子串String s3="abcwerthelloyuiodef";String s4="cvhellobnm";sop("原字符串：s3="+s3);sop("最大相同子串：s="+method_GetMaxString(s3,s4));}}