String/StringBuilder/StringBuffer/字符串方法详解

String方法

1.说明：String s=“a”； 这么初始化的字符串值是放在字符串常量池中的
String a=new String(“a”)； 这么初始化的字符串值是放在堆中的；
String 是final修饰的最终类，是线程不安全的

        String str="123456789123456789+AAA+bbb+啊啊啊";

        //寻找指定子字符串第一次出现的位置
        System.out.println(str.indexOf("789"));
        //从指定开始下标开始寻找指定子字符串第一次出现的位置
        System.out.println(str.indexOf("789",7));
        //寻找指定字符第一次出现的位置
        System.out.println(str.indexOf('8'));
        //从指定开始下标开始寻找指定字符第一次出现的位置
        System.out.println(str.indexOf('8',8));

        //寻找指定子字符串最后出现的位置
        System.out.println(str.lastIndexOf("456"));
        //从0到指定结束下标范围内找到子字符串最后出现的开始下标，注意如果刚好最后一个字符对上了子字符串的第一个字符，则会变成结束下标+子字符串.length()去匹配
        System.out.println(str.lastIndexOf("45",12));
        //寻找指定字符最后出现的位置
        System.out.println(str.lastIndexOf('8'));
        //从0到指定结束下标范围内找到字符最后出现的开始下标
        System.out.println(str.lastIndexOf('8',7));

        //指定开始下标截取字符串，包前不包后，可以理解为开始下标从0开始，结束下标从1开始
        System.out.println(str.substring(9));
        //指定开始结束下标截取字符串，包前不包后，可以理解为开始下标从0开始，结束下标从1开始，结束下标本来也是从0开始，但是因为不包后，所以真是显示的是 N-1 下标
        System.out.println(str.substring(0,9));

        //根据字符条件寻找替换内容
        System.out.println(str.replace('1','a'));
        //根据子字符串条件寻找替换内容
        System.out.println(str.replace("1","a"));
        //根据正则表达式条件寻找替换内容，一般用 | 隔开表示多个条件
        System.out.println(str.replaceAll("1|2","a"));
        //根据子字符串条件寻找替换第一次出现的内容
        System.out.println(str.replaceFirst("123","a"));

        //根据子字符串分割字符串成数组，要注意如果子字符串匹配的内容全部会清除了
        //另外如果子字符串刚好匹配到开头或者有多个子字符串相邻会导致空串出现
        //如果刚好匹配到最后则不会
        //有些特殊分割符要加上 \\
        //可以使用正则表达式，一般都是用 | 隔开表示多个条件都可以分割，看情况使用
        String s=",123,456,,,789,";
        String[] strings=s.split(",|1");
        //这个是指定分割次数，这里注意如果刚好匹配到最后则可能出现空格
        String[] strings1= s.split(",",3);

        //把字符串中的大写字母转成小写的,默认使用当前jvm的语言环境
        System.out.println(str.toLowerCase());
        //把字符串中的大写字母转成小写的,选择使用哪个国家的语言环境
        System.out.println(str.toLowerCase(Locale.ITALY));
        //把字符串中的小写字母转成大写的,默认使用当前jvm的语言环境
        System.out.println(str.toUpperCase());
        //把字符串中的小写字母转成大写的,选择使用哪个国家的语言环境
        System.out.println(str.toUpperCase(Locale.ITALY));

        //如果比较的子字符串和字符串从第一个字符开始比一直一样，未出现任何不一致的字符则比较字符串长度
        //如果比较的子字符串和字符串比较时有不同，则取第一个字符的ascll的差值
        System.out.println(str.compareTo("1ttt"));
        System.out.println(str.compareToIgnoreCase("123456789123456789+AAA+bbb+洪志能AAAAAAA"));

        //返回指定下标对应字符的ascll码的值
        System.out.println(str.codePointAt(0));
        //返回指定下标前一个字符的ascll码的值
        System.out.println(str.codePointBefore(2));

        //获取指定开始下标到结束下标的截取字符串长度
        System.out.println(str.codePointCount(1,str.length()));
        //这个和上面的区别是第二个参数是长度，不是结束下标，就是 开始下标+N
        System.out.println(str.offsetByCodePoints(0,str.length()));

        //判断子字符串是否存在
        System.out.println(str.contains("123"));
        //获取对象的内存地址hash码
        System.out.println(str.hashCode());
        //判断是否为 "",不能是null
        System.out.println(str.isEmpty());
        //equals() 方法只能比较两个相同类型的对象是否相等，比如String就只能和String比较
        StringBuilder sa=new StringBuilder("123456789123456789+AAA+bbb+啊啊");
        System.out.println(str.equals("123456789123456789+AAA+BBB+啊啊"));
        //contentEquals() 方法比较的是实现了CharSequence接口的对象值，比如String和StringBuilder都实现了，所以可以比较值，会等于true
        System.out.println(str.contentEquals(sa));
        //忽略大小写的比较，只认字，equals() 方法的宽松版
        System.out.println(str.equalsIgnoreCase("123456789123456789+AAA+bbb+啊啊"));
        //比较字符串开始下标到结束的内容和子字符串开始下标到结束下标的内容是否相等
        System.out.println(str.regionMatches(0,str,1,str.length()));
        System.out.println(str.regionMatches(false,0,str,0,str.length()));

        //从左到右和子字符串比较是否相等，一般用来校验前缀名，比如网址/ip
        System.out.println(str.startsWith("123456789123456789+AAA+bbb+啊啊"));
        //指定开始下标位置，从左到右和子字符串比较是否相等，一般用来校验前缀名，比如网址/ip
        System.out.println(str.startsWith("123456",1));
        //从右到左和子字符串比较是否相等，一般用来校验后缀名，比如图片
        System.out.println(str.endsWith(".jpg"));

        //把字符串转成当前系统默认编码格式byte字节数组
        byte[] bytesA=str.getBytes();
        //把字符串转成指定编码格式byte字节数组
        byte[] bytesB=str.getBytes("GBK");
        //把字符串转成指定编码格式byte字节数组
        byte[] bytesC=str.getBytes(Charset.forName("GBK"));
        //String的构造方法,使用当前系统默认编码格式读取byte字节数组成字符串
        String stringA=new String(bytesA);
        //String的构造方法,使用指定编码格式读取byte字节数组成字符串
        String stringB=new String(bytesA,"GBK");
        //使用工具类自动识别字节数组的编码类型
        String stringC=new String(bytesA, CharsetDetectUtil.detect(bytesA));

        //指定开始和结束下标，把字符串转成字符数组，从数组指定位置开始存储
        //第1-2参数是开始结束下标，3是字符数组，4是数组开始存储下标
        char[] chars=new char[str.length()];
        str.getChars(1,str.length(),chars,1);
        //把字符串转成char[] 字符数组
        System.out.println(str.toCharArray());

        //比较问题
        String s1 = "abc";
        String s2 = "a";
        String s3 = "bc";
        String s4 = "abc";
        String s6=new String("abc");
        String s7=new String("abc");
        //两个直接赋值的 == 比较为 true
        System.out.println(s1 == s4);
        //一个直接赋值的和一个new的 == 比较为 false
        System.out.println(s1==s6);
        //一个直接赋值的和多个直接拼接的字符串 == 比较为 true
        System.out.println(s1=="a"+"bc");
        //一个直接赋值的和多个带引用拼接的字符串 == 比较为 false
        System.out.println(s1==s2+"bc");
        //两个new的 == 比较为 false
        System.out.println(s6==s7);
        //任意组合 .equals 比较为 true
        System.out.println(s1.equals(s6));

        //去掉字符串前后所有空格
        System.out.println(str.trim());
        //指定下标获取char字符
        System.out.println(str.charAt(0));
        //判断是否符合指定正则表达式规则
        System.out.println(str.matches("123456789123456789\\+AAA\\+bbb\\+啊啊啊"));
        //在尾部添加新内容
        System.out.println(str.concat("AAA"));
        //把堆中的数据放入字符串常量池
        System.out.println(str.intern());
        //根据开始结束下标截取字符串
        System.out.println(str.subSequence(0,10).toString());

StringBuilder / StringBuffer

1.说明：StringBuilder 是非线程安全的类，没有加悲观锁或段锁一类的东西，非最终类
StringBuffer是线程安全的，每个方法都加了悲观锁

        StringBuffer buffer=new StringBuffer("123456");

        //支持任何基本数据类型
        buffer.append(789);
        //支持字符数组
        buffer.append(chars);
        //支持字符数组，可以指定数组的取值范围(开始结束下标)
        buffer.append(chars,0,3);
        //根据ascll值添加一个对应的字符在尾部
        buffer.appendCodePoint(49);

        //支持任何类型
        buffer.insert(buffer.length(),"c8888");
        //支持字符数组
        buffer.insert(buffer.length(),chars);
        //支持字符数组，可以指定数组的取值范围(开始结束下标)
        buffer.insert(buffer.length(),chars,0,3);

        StringBuffer stringBuffer=new StringBuffer("123456789");
        //把字符串进行倒着排序
        System.out.println(stringBuffer.reverse());
        //获取当前StringBuffer容量大小，初始化默认是 构造方法的值.Length()+16
        //如果是append或intern 方法则只要 .length的大小没有超过 .length()+16 则不会再扩容，如果超过则会扩容一次 (.length()+16+1)*2 后面则根据内容大小扩容
        System.out.println(stringBuffer.capacity());
        //根据开始和结束下标删除字符串内容
        System.out.println(stringBuffer.delete(0,1));
        //根据指定下标删除字符
        System.out.println(stringBuffer.deleteCharAt(0));
        //设置StringBuffer的最小初始化容量，如果 .length()+16 小于设置的最小容量初始化则会扩容一次 (.length()+16)*2
        //如果值够了但是容量还没达到最小要求则继续扩容至设置的最小值，如果值不够则根据值大小继续扩容
        stringBuffer.ensureCapacity(26);
        //往指定下标前面插入一个字符
        stringBuffer.setCharAt(0,'a');
        //设置字符串长度，相当于控制了显示的长度
        stringBuffer.setLength(0);
        //自动调整StringBuffer的容量，去掉一些没值的内存空间
        stringBuffer.trimToSize();