JAVA String

         String类是用来描述字符串，他提供了若干方法来操作字符串：

public class StringDemo {
    public static void main(String[] args) {
        String str1 = "abccbade";

        /**
         * 字符串中的获取
         */
        // 获取字符串的长度
        System.out.println("str1的长度是： " + str1.length());
        // 获取字符串中某个位置的字符
        System.out.println("str1第2个位置的字符： " + str1.charAt(2));
        // 获取某个字符在字符串中第一次出现的位置,如果没有这个字符，返回-1
        System.out.println("字符c在str1中第一次出现的位置： " + str1.indexOf('c'));
        // 从某个位置开始，获取某个字符在字符串中第一次出现的位置,如果没有这个字符，返回-1
        System.out.println("从第2位开始，字符c在str1中第一次出现的位置： " + str1.indexOf('b', 2));
        // 反向根据字符，获取位置，（从右往左）如果不存在，返回-1
        System.out.println(str1.lastIndexOf('b'));
        System.out.println(str1.lastIndexOf('b', 2));

        /**
         * 字符串中的判断
         */
        System.out.println("该字符串是以a字符串开头的吗？： " + str1.startsWith("a"));
        System.out.println("该字符串是以a字符串结尾的吗？： " + str1.endsWith("a"));
        System.out.println("该字符串是空的吗？： " + str1.isEmpty());
        System.out.println("该字符串包含字符串abc吗？： " + str1.contains("abc"));
        System.out.println("该字符串是否和abcd内容相同" + str1.equals("abcd"));
        System.out.println("该字符串是否和aBCcbAde内容相同"
                + str1.equalsIgnoreCase("aBCcbAde"));

        /**
         * 字符串的转换
         */
        // 将字符数组转换成字符串
        char[] charArray = { 'a', 'b', 'c', 'd', 'e', 'f' };
        System.out.println(new String(charArray));
        System.out.println(new String(charArray, 3, 3));
        System.out.println(String.copyValueOf(charArray));// 该方法为静态方法
        // 将字符串转换成字符数组
        System.out.println(str1.toCharArray());

        /**
         * 字符串的其他方法
         */
        // 切割字符串
        String str2 = "abc2def2ghi";
        String[] strArray = str2.split("2");
        for (int i = 0; i < strArray.length; i++) {
            System.out.println(strArray[i]);
        }

        // 大小写转换以及去掉首尾空格
        String str3 = "   Hello World   ";
        System.out.println(str3.toUpperCase());
        System.out.println(str3.toLowerCase());
        System.out.println(str3.trim());
        // 字符串截取
        System.out.println(str3.trim().substring(2));
        System.out.println(str3.trim().substring(2, 10));
        //字符串比较
        String str4 = "abcdef";
        String str5 = "abbdgf";
        System.out.println(str4.compareTo(str5));
    }
}

　　练习：

题目一：实现trim方法的功能

思路：先判断给定字符串是否是以空格开头，如果是，从第二位截取剩余字符串，循环，得到开头没有空格的字符串，再判断是否以空格结尾，如果是，则从第0为开始，到第length-1位结束截取字符串，循环去掉尾部的空格

public class StringDemo {
    public static void main(String[] args) {
        String str = "   abcdef   ";
        StringDemo sd = new StringDemo();
        System.out.println(sd.trimDemo(str));
    }

    public String trimDemo(String str) {
        while (str.startsWith(" ")) {
            str = str.substring(1);
        }
        while (str.endsWith(" ")) {
            str = str.substring(0, str.length() - 1);
        }
        return str;
    }
}

题目二：翻转一个字符串

思路：先把字符串转换成一个字符数组，再新建一个空的同样长度的字符数组，依次将源字符数组翻转过来添加到新数组中，让新数组转化成字符串返回

public class StringDemo {
    public static void main(String[] args) {
        String str = "   abcdef   ";
        StringDemo sd = new StringDemo();
        System.out.println(sd.turnString("abcdef"));
    }

    public String turnString(String str) {

        char[] charArray = str.toCharArray();

        char[] newCharArray = new char[charArray.length];

        for (int i = 0; i < charArray.length; i++) {
            newCharArray[(charArray.length - i - 1)] = charArray[i];
        }

        return new String(newCharArray);
    }
}

题目三：判断一个字符串在另外一个字符串中出现的次数

思路：那么设置一个count变量用来存放出现的次数，再设置一个flag变量来存放字符串出现的位置，使用indexOf方法来判断是否存在，如果返回的不是-1，那么count+1，indexOf可以获取到出现的位置，那么从出现的（位置+字符串的长度）开始截取子字符串开始继续判断

public class StringDemo {
    public static void main(String[] args) {
        String str1 = "huhuiikshuiadkhuihuinfvkasdhuikfhhui";
        String str2 = "hui";
        StringDemo sd = new StringDemo();
        System.out.println(sd.subStringCount(str1, str2));
    }

    public int subStringCount(String str1, String str2) {

        int count = 0;    //用来存放出现次数 
        int flag = 0;    //用来存放出现位置

        while (str1.indexOf(str2) != -1) { //如果返回值不为-1，说明是存在的
            count += 1;  //出现次数+1
                        flag = str1.indexOf(str2);   //获取到存放的位置            
            str1 = str1.substring(flag + str2.length());  //从存放位置+字符串长度  处开始截取子字符串

        }

        return count;
    }
}

题目四：给定两个字符串，获取两个字符串的最大公共子字符串

思路：假设str1为主，str2为附，得到所有str2的子字符串存到一个list中去，然后循环判断str1中是否存在这些子字符串，将存在的放到新的list中去，再判断新list中最长的字符串是多长，然后再将这个长度的字符串拿出来，这就是公共最长字符串

public class StringDemo {
    public static void main(String[] args) {
        String str1 = "abcdefghijklmnopqrst";
        String str2 = "cd34cde5691mno26";
        StringDemo sd = new StringDemo();
        sd.getMaxString(str1, str2);
    }

    public void getMaxString(String str1, String str2) {

        List<String> subString = new ArrayList<String>(); // 用来存放str2的所有子字符串
        List<String> str1ContainsStr2 = new ArrayList<String>();

        for (int end = str2.length(); end > 0; end--) { // 用来设置去str2子字符串的subString方法起点位置
            for (int start = 0; start < end; start++) { // 用来设置去str2子字符串的subString方法终点位置
                subString.add(str2.substring(start, end));    //将str2的子字符串添加到list中
            }
        }

        int tmp = 0;    //设置一个临时变量来存放长度
        for (String string : subString) {
            if (str1.contains(string)) {    //如果str1中存在str2的子字符串，说明是公共字符串
                str1ContainsStr2.add(string);    //那么添加到公共字符串list中
                if (string.length() > tmp) {    //获取到最大长度的公共字符串的长度
                    tmp = string.length();
                }
            }
        }
        for (String string : str1ContainsStr2) {    //找到公共字符串中最长的字符串
            if (string.length() == tmp) {
                System.out.println(string);
            }
        }
    }
}

题目：翻转一个字符串

思路：将一个字符串转化成一个字符数组，再让这个字符数组翻转存储到一个新的字符数组中，将这个新的字符数组转成字符串

public class StringDemo {
    public static void main(String[] args) {
        String str = "123456789";
        StringDemo sd = new StringDemo();
        System.out.println(sd.overturn(str));
    }

    public String overturn(String str) {
        char[] charArray = str.toCharArray();
        char[] newCharArray = new char[charArray.length];
        int tmp = 0;
        for (int i = charArray.length - 1; i >= 0; i--) {
            newCharArray[tmp] = charArray[i];
            tmp++;
        }

        return new String(newCharArray);
    }
}

StringBuffer和StringBuilder

         可以将StringBuffer看成是一个可以存放字符串的容器，和String不同的是，这个容器可以改变长度，并且容器内可以存放多种类型数据，并且最终可以通过toString方法转化为String类型

         StringBuffer的增删查改

public class StringBufferDemo {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        StringBuffer sb2 = new StringBuffer();
        sb2.append("xyz");
        /**
         * StringBuffer的增
         */
        sb.append("123");
        System.out.println(sb); // 输出结果为123
        sb.append(true);
        System.out.println(sb); // 输出结果为123true
        sb.append(123).append(sb2);
        System.out.println(sb); // 输出结果为123true123xyz
        sb.insert(1, "mmm");
        System.out.println(sb);// 输出结果为1mmm23true123xyz

        /**
         * StringBuffer的删
         */
        sb.deleteCharAt(4);
        System.out.println(sb); // 输出结果为1mmm3true123xyz
        sb.delete(1, 4);
        System.out.println(sb); // 输出结果为13true123xyz(含头不含尾)

        /**
         * StringBuffer的查
         */
        System.out.println(sb.length()); // 输出结果为12
        System.out.println(sb.charAt(10)); // 输出结果为y
        System.out.println(sb.indexOf("true")); // 输出结果为2
        System.out.println(sb.indexOf("1", 2));// 输出结果为6
        System.out.println(sb.substring(2, 4));// 输出结果为tr(含头不含尾)

        /**
         * StringBuffer的改
         */
        sb.setCharAt(0, '2');
        System.out.println(sb); // 输出结果为23true123xyz
        System.out.println(sb.reverse());// 输出结果为zyx321eurt32
        System.out.println(sb.replace(1, 2, "hello"));// 输出结果为zhellox321eurt32(含头不含尾)
    }
}

　　StringBuilder和StringBuffer的区别在于StringBuffer是不同步的，所以多线程下不安全，但是如果是单线程情况下，StringBuilder比StringBuffer速度要快