Java字符串总结

1.String:字符串对象是不可变的，只能够指向新的字符串的地址。使用同一个常量创建的字符串变量是相等的，因为他们会指向常量池中的同一个常量。String的equals()方法时复写过的，所以会比较引用变量的实际值，如果相等返回true。PS:如下是一个构造String的少用的例子：String(char[] value,int offset,int count)取字符数组value的下标从offset—>count的字符来初始化String对象。示例String对象的比较：

        String s1 = "abc";
        String s2 = "abc";
        String s3 = new String("abc");
        String s4 = s3;
        System.out.println(s1 == s2);
        System.out.println(s1 == s3);
        System.out.println(s1.equals(s3));
        System.out.println(s4 == s3);

.
2.String类的方法：char charAt(int num)——>返回字符串的第num个字符。(从0开始算起) int indexOf(int ch)——>获取字符ch第一次出现的位置。String substring(int beginIndex,int endIndex)——>返回从beginIndex开始到endIndex之前的字符串，计数是从0开始的。String split(String regex)——>按照给定的规则切割字符串，返回切割后的字符串数组。切割示例：

        String s1 = "a.b.c.d.e";
        String[] s = s1.split("[\\.]");
        for (int i = 0; i < s.length; i++) {
            System.out.println(s[i]);
        }

.
3.示例：将字符串变为字符数组，将字符串变成字节数组，字符串中字母大小写转换，内容置换，代码示例：

    public static void main(String[] args) {
        String s = "caizhanqi";
        // 字符串转换为字符数组
        char[] charArr = s.toCharArray();
        for (int i = 0; i < charArr.length; i++) {
            System.out.print(charArr[i] + "\t");
        }
        System.out.println();
        // 字符串转换为字节数组
        byte[] bArr = s.getBytes();
        for (int i = 0; i < bArr.length; i++) {
            System.out.print(bArr[i] + "\t");
        }
        System.out.println();
        // 将字符串中的字母转换为大写
        System.out.println(s.toUpperCase());
        s = "ABCDERF";
        // 将字符串中的字母转换为小写
        System.out.println(s.toLowerCase());
        s = "caizhanqicaizhanqi";
        // 内容置换
        System.out.println(s.replace('a', '*'));
        System.out.println(s.replace("cai", "55"));
        System.out.println(s);
        System.out.println(
                "所有这些操作对于原来的字符串是没有影响的");
    }

.
4.字符串转换：String.valueOf(num);去除字符串前后的空格，字符连接，两个字符串内容相等判断，字符串中是否包含指定字符串，字符串是否以指定的字符串开头/结尾，代码示例：

    public static void main(String[] args) {
        //去除字符串前后的空格
        String s = "      ";
        System.out.println(s.trim().length());
        System.out.println("去除前后空格会去除前后两部分连着的空格");
        //字符连接
        System.out.println(s.concat("ssssssssss"));
        //两个字符内容判断是否相等
        System.out.println("abvder".equalsIgnoreCase("ABVDER"));
        //字符串中是否包含指定字符串
        System.out.println("abcderf".contains("abc"));
        //字符串是否以指定字符串开头/结尾
        System.out.println("abcdefd".startsWith("abc"));
        System.out.println("abcderf".endsWith("rf"));
    }

.
5.字符串的比较：int compareTo(String str)。如果相等返回0；如果不相等，按照字典序，str小于引用值返回一个小于0的值，大于则返回一个大于0的值。返回值一般是两个字符串最后比较的那一对字符的ASCII差值。

        String s1 = "abcdefgh";
        System.out.println(s1.compareTo("abcdefgh"));
        System.out.println(s1.compareTo("abcdefg"));
        System.out.println(s1.compareTo("abcdefghy"));

.
6.如果调用Object.intern()时，object所指向的值已经存在于常量池中，则直接返回常量池中的该值，否则将该值放入常量池中，然后返回地址给引用。只有用常量池中的值创建的对象，或者使用了intern()方法创建的对象，才可能是引用相等的。

        String sss = new String("abc");
        String s = sss.intern();
        String ss = s.intern();
        System.out.println(sss == s);

.
7.对字符串数组按照字典序排序：代码如下：从小到大字典序冒泡排序

        public static void main(String[] args) {
        // 从小到大
        String[] str = new String[] { 
        "abc", "des", "avc", "abcd",
         "abcdd","abcs", "a" };
        for (int i = 0; i < str.length - 1; i++) {
            for (int j = str.length - 1; j > i; j--) {
                if (str[j].compareTo(str[j - 1]) < 0) {
                    String s = str[j - 1];
                    str[j - 1] = str[j];
                    str[j] = s;
                }
            }
        }
        for (int i = 0; i < str.length; i++) {
            System.out.print(str[i]+"\t");
        }
    }

.
8. 输出一个字符串在另一个字符串中出现的次数：

        public static void main(String[] args) {
        String s = "abc abc abc jfd;gjfds abc abc";
        int count = 0;
        while (s.indexOf("abc") != -1) {
            System.out.println(s+"------------");
            count++;
            int beginIndex = s.indexOf("abc");
            int endIndex = s.indexOf("abc")+3;
            System.out.println(beginIndex+"---"+endIndex);
            s = s.substring(endIndex,s.length());
        }
        System.out.println(count);
    }

.
9. 取两个字符串中的最大公约子串：代码示例：

        public static void main(String[] args) {
        String s = "fdslfdslgfdjbngfd1111111abcderfgfmdl";
        String ss = "silvfsdnabc1111111dkom";
        String str = null;
        boolean flag = false;
        for (int i = ss.length(); i > 0; i--) {
            for (int j = 0, k = i + j; k <= ss.length(); j++, k++) {
                str = ss.substring(j, k);
                if (s.contains(str)) {
                    flag = true;
                    break;
                }
            }
            if (flag) {
                System.out.println(str);
                break;
            }
        }
    }

.
10.模拟trim()。

        // 模拟trim()
        String s = "        h j      ";
        char[] str = s.toCharArray();
        while(str[0] == 32 || str[str.length-1] == 32){
            if(str[0] == 32)
                s = s.substring(1, s.length());
            if(str[str.length-1] == 32)
                s = s.substring(0,s.length()-1);
            str = s.toCharArray();
        }
        System.out.println("---"+s+"---"+s.length());

.
11.StringBuffer:字符缓冲区，长度可变，可存储不同类型数据，最终转成字符串调用。代码详解使用方法：

        StringBuffer s = new StringBuffer();
        //添加
        s.append(555).append("skdnfds");
        System.out.println(s);
        //插入
        s.insert(1, 12345);
        System.out.println(s);
        s.insert(1, "222", 0, 3);
        System.out.println(s);
        //删除
        s.delete(0, 5);
        System.out.println(s);
        s.deleteCharAt(0);
        System.out.println(s);
        //查找
        System.out.println(s.charAt(1));
        System.out.println(s.indexOf("34"));
        System.out.println(s.indexOf("s"));
        System.out.println(s.lastIndexOf("s"));
        //修改
        System.out.println(s.replace(0, 5, "a"));
        s.setCharAt(0, 'b');
        System.out.println(s);
        //反转字符串
        System.out.println(s.reverse()+"----"+s);
        //设置字符串长度
        s.setLength(50);
        System.out.println(s.length()+"-------"+s+"---");

.
12.如果StringBuffer的setLength()方法，设置值大于已有长度，用空格补齐，小于已有长度，裁剪掉多余部分。StringBuffer默认数组长度是16，超过之后会新建一个数组。
13.StringBuilder与StringBuffer功能一样，不同的部分：StringBuffer是线程同步的，通常用于多线程，StringBuilder是线程不同步的，通常用于单线程，它的出现提高了程序效率，故StringBuilder用于多个线程是不安全的，如果需要多线程的同步，可使用StringBuffer。示例：

        int[] num = {1,2,3,4,5};
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (int i = 0; i < num.length; i++) {
            if(i!=num.length-1)
                sb.append(num[i]+",");
            else
                sb.append(num[i]+"]");
        }
        System.out.println(sb);

.
14.基本数据类型转为应用类型：代码示例：

        // 基本类型变量转换为引用变量
        Integer num1 = Integer.parseInt("52");
        System.out.println(num1 + 1);
        num1 = Integer.valueOf("555");
        System.out.println(num1);
        // 十进制转化为二进制，八进制，十六进制
        System.out.println(Integer.toBinaryString(num1));
        System.out.println(Integer.toOctalString(num1));
        System.out.println(Integer.toHexString(num1));
        // 转换16为20进制的字符串
        System.out.println(Integer.toString(16, 20));
        // 其他进制到十进制,第二个参数为当前进制，最后转换为十进制
        System.out.println(Integer.parseInt("110", 2));
        System.out.println(Integer.parseInt("110", 8));
        System.out.println(Integer.parseInt("110", 10));

.
15.对一个字符串中的数值进行从小到大的排序：示例：

        //给定字符串
        String str = "1 2 3 8 4 2 5 6";
        //切割为字符数组
        String[] strArr = str.split(" ");
        //赋值给int数组
        int[] numArr = new int[strArr.length];
        for (int i = 0; i < numArr.length; i++) {
            numArr[i] = Integer.parseInt(strArr[i]);
        }
        //排序
        Arrays.sort(numArr);
        //int数组转换为字符数组
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < numArr.length; i++) {
            sb.append(numArr[i]+"\t");
        }
        //输出
        str = sb.toString();
        System.out.println(str);