字符串

String类

String类的特点：字符串对象一旦被初始化就不会被改变。所以它可以被共享。
String s=”abc”;//这种方式定义的字符串对象存储在字符串常量池中。池中没有对象就建立对象，池中有对象就直接使用这个对象。
String s1=new String(“abc”);//这种定义字符串对象的方式其实是在堆中建立了两个对象，先创建了一个String对象，这个对象接收了”abc”这个对象。
因此，s==s1的结果是false，他们不是一个对象，地址值不同。
而s.equals(s1)的结果会是true。这是因为虽然equals方法的源码本来也是比较地址值，但是由于String类是Object的子类，它将equals方法进行了复写，它建立了字符串自身特点来比较字符串是否相同的依据，即比较字符串的内容。

String类的构造函数

常用的构造函数：
String();
String(byte[] bytes);
String(byte[] bytes,int offset,int length);
String(char[] value);
String(char[] value,int offset,int count);
下面通过一段代码来演示这些构造方法：

public class StringConstructorDemo {
    public static void main(String[] args) {
        stringConstructorDemo();
    }

    private static void stringConstructorDemo() {

        String s=new String();//等效于String s="";不等效于String s=null;因为null是一个变量，而不是一个对象

        byte[] arr={65,66,67,68};
        String s0=new String(arr);
        System.out.println("s0="+s0);//输出为：s0=ABCD  将字节数组变成了字符串

        String s1=new String(arr,1,2);
        System.out.println("s1="+s1);//输出为：s1=BC

        char[] arr2={'h','a','p','p','y'};
        String s2=new String(arr2);
        System.out.println("s2="+s2);//输出为：s2=happy

        String s3=new String(arr2,1,3);
        System.out.println("s3="+s3);//输出为：s2=app
    }
}

String类的常用功能

1.获取
1.1获取字符串中字符的个数（长度）
int length();
1.2根据位置获取字符
char charAt(int index)
1.3根据字符获取在字符串中第一次出现出的索引
int indexOf(int ch)//参数可以是字符的ASCII码
int indexOf(int ch,int fromIndex)//从指定位置开始索引需要索引的字符
int indexOf(String str);
int indexOf(String str,int fromIndex);
根据字符获取在字符串中最后一次出现出的索引
int indexOf(int ch)//参数可以是字符的ASCII码
int lastIndexOf(int ch,int fromIndex)
int lastIndexOf(String str);
int lastIndexOf(String str,int fromIndex);
1.4获取字符串中的一部分字符串，也叫子串
String substring(int beginIndex,int endIndex);//子串从beginIndex处开始，直到enIndex-1结束。
String substring(int beginIndex);
下面用代码来对以上功能进行演示：

public class StringMethodDemo {
    public static void main(String[] args) {
        stringMethodDemo_1();
    }
    private static void stringMethodDemo_1() {
        String s="abcdae";
        System.out.println("length="+s.length());
        System.out.println("char:"+s.charAt(2));
        System.out.println("index:"+s.indexOf('a'));
        System.out.println("lastIndex:"+s.lastIndexOf('a'));
        System.out.println("substring:"+s.substring(2,4));// cd
        //System.out.println("char:"+s.charAt(20));// java.lang.StringIndexOutOfBoundsException: String index out of range: 20
        System.out.println("index:"+s.indexOf('k'));//输出-1，根据-1来判断该字符或字符串是否存在
//输出结果如下：
//              length=6
//              char:c
//              index:0
//              lastIndex:4
//              index:-1
    }
}

2.转换
2.1将字符串变成字符串数组（字符串的切割）
String[] split(String regex); 涉及到正则表达式
2.2 将字符串变成字符数组
char[] toCharArray();
2.3 将字符串变成字节数组
byte[] getBytes();
2.4将字符串中的字母转成大小写
String toUpperCase():大写
String toLowerCase():小写
2.5将字符串中的内容进行替换
String replace(char oldchar,char newchar)
String repalce(String s1,String s2)
2.6将字符串两端的空格去除
String trim();
2.7将字符串进行连接
String concat(string);
2.8将基本数据类型转换成字符串
String valueOf(int ch)等
下面用代码进行演示：

public class StringMethodDemo {
    public static void main(String[] args) {
        stringMethodDemo_2();
    }
    private static void stringMethodDemo_2() {
        String s="lili,mike,miemie";
        String[] arr=s.split(",");
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
//      lili
//      mike
//      miemie

        char[] chs=s.toCharArray();
        for(int i=0;i<chs.length;i++){
            System.out.println(chs[i]);//lili,mike,miemie
        }

        s="abc喵";
        byte[] bytes=s.getBytes();
        for(int i=0;i<bytes.length;i++){
            System.out.println(bytes[i]);
        }
        //97
        //98
        //99
        //-33
        //-9
        //GB2312：中文的编码表，有六七千汉字，中文和二进制的对应关系,一个汉字两个字节，这两个字节最高位都是1，所以打印的是负数
        System.out.println("ABcd".toUpperCase());//ABCD
        System.out.println("java".replace('a','o'));//jovo
        System.out.println("happy".replace('r', 'e'));//happy

        String s1="java";
        String s2=s1.replace('q', 'e');
        System.out.println(s1==s2);//ture

        System.out.println("-"+"    ab  c    ".trim()+"-");//-ab  c-
        System.out.println("abc"+"mm");//abcmm
        System.out.println("abc".concat("mm"));abcmm

        System.out.println(String.valueOf(4)+1);//41
        System.out.println(""+4+1);//41
    }
}

3.判断
3.1 两个字符串的内容是否相同
boolean equals(Object obj);
boolean equalsIgnoreCase(string str);忽略大小写比较内容
3.2 字符串当中是否包含指定字符串？
boolean contains(string str);
3.3 字符串是否已指定字符串开头，是否以指定字符串结尾
boolean startsWith(string);
boolean endsWith(string);

public class StringMethodDemo {
    public static void main(String[] args) {
        stringMethodDemo_3();
    }
    private static void stringMethodDemo_3() {
        String s="abc";
        System.out.println(s.equals("ABC"));
        System.out.println(s.equalsIgnoreCase("ABC"));
        System.out.println(s.equals("ABC".toLowerCase()));

        System.out.println(s.contains("ab"));
        System.out.println(s.contains("ac"));
        System.out.println(s.indexOf("ac"));

        String str="ArrayDemo.java";
        System.out.println(str.startsWith("Array"));
        System.out.println(str.endsWith(".java"));
        System.out.println(str.contains("Demo"));
    }
}
//false
//true
//true
//true
//false
//-1
//true
//true
//true

4.比较
compareTo()

public class StringMethodDemo {
    public static void main(String[] args) {
        stringMethodDemo_4();
    }
    private static void stringMethodDemo_4() {
        System.out.println("a".compareTo("A"));//32
        System.out.println("aBC".compareTo("aQD"));//-15
    }
}

5.intern()方法

public class StringObjectDemo {
    public static void main(String[] args) {    
        //intern():对字符串池进行操作
        String s1=new String("abc");
        String s2=s1.intern();//String s2="abc";
        System.out.println(s1==s2);
    }
}

String类的练习

1.给定一个字符串数组。安装字典书序进行从小到大的排序。
{“nba”,”abc”,”cba”,”zz”,”qq”,”haha”}
思路：1，排序，用冒泡或者选择排序。
2，数组元素是字符串，字符串的比较方法为compareTo().
代码如下：

public class StringTest_1{
    public static void main(String[] args) {
        String[] arr = { "nba", "abc", "cba", "zz", "qq", "haha" };
        printArray(arr);
        sortString(arr);
        printArray(arr);
    }
    public static void printArray(String[] arr)(){
        System.out.print("{");
        for(int i=0;i<arr.length;i++)
            {
                if(i!=arr.length-1)
                    System.out.print(arr[i]+",");
                else
                    System.out.print(arr[i]+"}");
            }
    }
    public static void sortString(String[] arr){
        for(int i=0;i<arr.length-1;i++){
            for(int j=i+1;j<arr.length;j++){
                if(arr[i].compareTo(arr[j])>0)
                    swap(arr,i,j);
            }
        }
    }
    private static void swap(arr,i,j){
        int temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }
}

2.一个子串在整串中出现的次数
例如：求”nba”在”nbaerbatynbauinbaopnba”内出现的次数。
思路：
1、先判断子串是否存在，如果存在，获取它所在的位置；
2、求一个子串在整串中第一次出现的位置用函数：int indexOf(String str)
3、找到子串在整串的第一次出现位置后，可以将第一次找到的位置加上子串长度后的位置作为新的整串开始位置，循环以上过程，继续用indexOf函数查找，找不到会返回-1，用计数器计数。
代码如下：

public class StringTest_2{
    public static void main(String[] args){
        String str="nbaernbatynbauinbaopnba";
        String key="nba"; 
        //int count=testKeyStringCount_1(str,key);
        int count=testKeyStringCount_2(str,key);
        System.out.println("count="+count);
    }
    public static int testKeyStringCount_1(String str,String key){
        int count=0;
        int index=0;
        while((index=str.indexOf(key))!=-1){
            str=str.substring(index+key.length());
            count++;
        }
        return count;
    }
    public static int testKeyStringCount_2(String str,String key){
        int count=0;
        int index=0;
        while((index=str.indexOf(key))!=-1){
            index=index+key.length();
            count++;
        }
        return count;
    }
}

3.两个字符串中最大相同的子串。
例如：找出”chedagkahgalss”和”afgakahgaa”的最大相同子串。
思路：
1、先看短的字符串是否存在于长的字符串中，存在的话则短的字符串就是最大相同子串；
2、如果不是，就将短的字符串长度依次地递减一，看所得的子串是否存在于长的字符串中，存在的话这个字符串就是最大相同子串。
3、判断存在的函数是contains();
4、字符串长度依次减一获得子串可以通过下标的变化来获得。用双层循环，外层控制长度递减，内层获得递减后长度的子字符串始末下标。
5，要判断哪个字符串是长的字符串,哪个是短的字符串。
代码如下：

public class StringTest_3{
    public static void main(String[] args){
        String s1="chedagkahgalss";
        String s2="afgakahgaa";
        String s=getMaxSubstring(s1,s2);
        System.out.println("s="+s);
    }
    public static String getMaxSubstring(String s1, String s2) { 
        //解决了哪个字符串长哪个字符串短的问题
        String max=null,min=null;
        max=(s1.length()>s2.length())?s1:s2;
        min=max.equals(s1)?s2:s1;
        //双层循环
        for(int i=0;i<min.length();i++)//第一层控制子串的长度
        {
            for(int a=0,b=min.length-i;b!=min.length+1;a++,b++){//第二层控制子串的头尾下标
                String sub=min.substring(a,b);//取子串  包括a角标，不包括b角标  
                if(max.contains(sub))
                    return sub
            }
        }
        return null;
    }
}

4.模拟一个trim功能一致的方法。
思路：
1，一个变量作为从头开始判断字符串空格的角标，不断++
一个变量作为从尾开始判断字符串空格的角标，不断–
2，判断到不是空格为止，取头尾之间的字符串即可。
代码如下：

public class StringTest_4 {
    public static void main(String[] args) {
        String s="    ab  c    ";
        System.out.println("-"+s+"-");
        s=myTrim(s);
        System.out.println("-"+s+"-");
    }
    public static String myTrim(String s){
        int start=0;
        int end=s.length-1;
        while(start<end&&s.charAt(start)==' ')
            start++;
        while(start<end&&s.charAt(end)==' ')
            end--;
        return s.substring(start, end+1);
    }
}