特点

1、字符串都是对象。
2、一旦初始化就不可以被更改。因为是常量。

//指的是"abc"不可以更改，s只是指向"abc"的对象
String s = "abc";
s = "def";

3、因为 String 对象是不可变的，所以可以共享。

        //多个引用指向同一个字符串
        //两个"itcast"是同一个对象，所以s1和s2指向同一个对象
        String s1 = "itcast";
        String s2 = "itcast";
        System.out.println(s1==s2);

      //两个内容相同，创建方式不同的字符串
      String s3 = "abc";
      String s4 = new String("abc");
        //s3和s4有什么不同呢？
        /*
         * s3创建，在内存中只有一个对象。"abc"
         * 
         * s4创建，在内存中有两个对象。"abc" s4
         */
        
        System.out.println(s3==s4);//false
//      因为String复写了equals方法，
//      建立字符串自己的判断相同的依据。通过字符串对象中的内容来判断的。
        System.out.println(s3.equals(s4));//true,

4、通过String类的构造函数可以知道，将字节数组或者字符转成字符串。

字符串查找

        /*
         * "abcde"
         * 
         * 1，字符串是一个对象，那么它的方法必然时围绕操作这个对象的数据而定义的。
         * 2，字符串中部分功能
         *  2.1 有多少个字符?
         *      int length()
         * 
         *  2.2 字符的位置。
         *      int indexOf(ch,fromIndex);
         * 
         *  2.3 获取指定位置上的字符。
         *      char charAt(int)
         * 
         *  2.4 获取部分字符串。
         *      String substring(int start,int end);
         *  
         * 
         * 
         */
        String str = "abada";
//      System.out.println("length="+str.length());
        int len = str.length();
        System.out.println("len="+len);
        
        //------a字母出现的位置------
        int index = str.indexOf('a');//获取的是a字符第一次出现的位置。
        System.out.println("index="+index);
        //------第二个a字母出现的位置------
        
        int index1 = str.indexOf('a',index+1);
        System.out.println("index1="+index1);
        //------第三个a字母出现的位置------
        int index2 = str.indexOf('a',index1+1);
        System.out.println("index2="+index2);
        
        str = "sdfghjkl;wertyuiop[sdfghjkla;";
        int index3 = str.lastIndexOf('m');//如果要找的字符不存在，-1
        System.out.println("index3="+index3);
        
        //----------获取指定位置上字符。---------------
        str = "itcast";
        char ch = str.charAt(3);//不存在角标会发生StringIndexOutOfBoundsException
        System.out.println("ch="+ch);
        
        //------------获取部分字符串----------------------
        String s = str.substring(2, 4);//包含头，不包含尾。
        System.out.println("s="+s);

    /*
         * String方法查找练习。
         * 1，字符串是否以指定字符串开头。结尾同理。
         *      boolean startsWith(string)
         *      boolean endsWith(string)
         * 
         * 2，字符串中是否包含另一个字符串。
         *      boolean contains(string);
         *      int indexOf(string)//如果返回-1，表示不存在。
         * 
         * 3，字符串中另一个字符串出现的位置。
         *      int indexOf(string)
         * 4，将字符串中指定的字符串替换成另一个字符串。
         *      String replace(oldstring , newstring)
         * 
         * 5，字符串如何比较大小?
         * 
         * 6，将字符串转成一个字符数组。或者字节数组。
         *      toCharArray()
         *      getBytes()
         * 7，将字母字符串转成大写的字母字符串。
         *      toUpperCase()
         *      toLowerCase();
         * 8，将字符串按照指定的方式分解成多个字符串, "lisi,wangwu,zhaoliu"获取三个姓名。
         *      String[] split(string);
         * 
         */
        
        //1
        String str = "StringDemo.java";
        boolean b1 = str.startsWith("Demo");//false
        //2
        boolean b2 = str.contains("Demo");//CharSequence x = "Demo";//true
        //4
        String s = str.replace("haha", "Test");//没有被替换内容时，结果是原串儿。
        System.out.println("s="+s);
        //6
        char[] chs = str.toCharArray();
        byte[] bytes = str.getBytes();
        //7
        String upperString = str.toUpperCase();
        
        //8
        str = "lisi,wangwu,zhaoliu";
        String[] names = str.split(",");
        for (int i = 0; i < names.length; i++) {
            System.out.println(names[i]);
        }
        
        //5,字符串如何比较大小?
        int result = "ab".compareTo("ab");//只要想让对象具备比较大小的功能只需实现Comparable接口。
        System.out.println("result:"+result);

字符串数组排序

import java.util.Arrays;

public class StringTest2_1 {
    /**
     * @param args
     */
    public static void main(String[] args) {
        /*
         * 案例一：字符串数组
         * ["abc","nba","cctv","itcast"]
         * 要求从小到大排序。
         * 
         */
        String[] strs = {"abc","nba","cctv","itcast"};
        printArray(strs);
        sortString(strs);
        printArray(strs);
    }

    /**
     * 字符串数组
     * 思路：
     * 1，曾经玩过int[]排序，选择，冒泡。
     * 2，字符串排序同理。
     * 3，for嵌套循环。
     * 4，循环中进行元素的大小比较，满足条件位置置换。
     * @param strs
     */
    public static void sortString(String[] strs) {
        
        for (int i = 0; i < strs.length -1 ; i++) {
            for (int j = i + 1; j < strs.length; j++) {
                if(strs[i].compareTo(strs[j])>0){//对象比较用方法。compareTo。
                    swap(strs,i,j);
                }
            }
        }
//      Arrays.sort(strs);
        
    }
    /*
     * 数组元素位置置换。
     */
    private static void swap(String[] strs, int i, int j) {
        String temp = strs[i];
        strs[i] = strs[j];
        strs[j] = temp;
        
    }
    /*
     * 打印字符串数组。
     */
    private static void printArray(String[] strs) {
        for (int i = 0; i < strs.length; i++) {
            System.out.print(strs[i]+" ");
        }
        System.out.println();
    }
}

字符串出现的次数

public class StringTest2_2 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        
        /*
         * 
         * 案例二：
         * "witcasteritcasttyuiitcastodfghjitcast"有几个itcast
         * 
         * 思路：
         * 1，无非就是在一个字符串中查找另一个字符串。indexOf。
         * 2，查找到第一次出现的指定字符串后，如何查找第二个呢？
         * 3，无需在从头开始，只要从第一次出现的位置+要找的字符串的长度的位置开始向后查找下一个第一次出现的位置即可。
         * 4，当返回的位置是-1时，查找结束。
         */
        String str = "witcasteritcasttyuiitcastodfghjitcast";
        String key = "itcast";
        
        int count = getKeyCount(str,key);
        System.out.println("count="+count);
        /*
        int x = str.indexOf(key,0);//从头开始找。
        System.out.println("x="+x);
        
        int y = str.indexOf(key,x+key.length());//从指定起始位开始找。
        System.out.println("y="+y);
        
        int z = str.indexOf(key,y+key.length());//从指定起始位开始找。
        System.out.println("z="+z);
        
        int a = str.indexOf(key,z+key.length());//从指定起始位开始找。
        System.out.println("a="+a);
        
        int b = str.indexOf(key,a+key.length());//从指定起始位开始找。
        System.out.println("b="+b);
        */
    }

    /**
     * 获取key在str中出现次数。
     * @param str
     * @param key
     * @return
     */
    public static int getKeyCount(String str, String key) {
        
        //1,定义变量。记录每一次找到的key的位置。
        int index = 0;
        //2,定义变量，记录出现的次数。
        int count = 0;
        
        //3,定义循环。只要索引到的位置不是-1，继续查找。
        while((index = str.indexOf(key,index))!=-1){
            
            //每循环一次，就要明确下一次查找的起始位置。
            index = index + key.length();
            
            //每查找一次，count自增。
            count++;
        }
        return count;
    }
}

按照长度递减获取字符串

public class StringTest2_3 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        /*
         * 
         * 
         * 案例三： "itcast_sh"要求，将该字符串按照长度由长到短打印出来。 itcast_sh itcast_s tcast_sh
         */

        String str = "itcast";
        printStringByLength(str);

    }

    public static void printStringByLength(String str) {

        // 1，通过分析，发现是for嵌套循环。
        for (int i = 0; i < str.length(); i++) {

            for (int start = 0, end = str.length() - i; end <= str.length(); start++, end++) {

                //根据start，end截取字符串。
                String temp = str.substring(start, end);
                System.out.println(temp);
            }

        }
    }
}