常用类（续）

1、字符串的其他方法

1、字符串长度length()

int length()

// 判断长度
 @Test
 public void test1(){
String str = "阁下比我的两位故友阁下稍有逊色";
​
  System.out.println(str.length()); // 15
  }

2、判断字符串是否是空的

boolean isEmpty()

  // 字符串不为空
@Test
public void test2(){
 String str = "阁下比我的两位故友阁下稍有逊色";
​
 boolean b = str.isEmpty();
 System.out.println(b); // false
 }
// 字符串为空
 @Test
 public void test3(){
   String str = "";
  boolean b = str.isEmpty();
  System.out.println(b); // ture
 }

3、比较两个字符串是否相等

boolean equals(Object obj)

/*
严格区分大小写
*/
@Test
public void test4(){
 String str1="abcd";
 String str2="ABCD" ;
 System.out.println(str1.equals(str2)); // false
 System.out.println(str1==str2); // false
 String str3="abcd";
 String str4="abcd" ;
 System.out.println(str3.equals(str4)); // ture
 System.out.println(str3==str4); // ture
 }

boolean equalsIgnoreCase(String obj)

/*
不区分大小写
*/
@Test
 public void test5(){
  String str1="abcd";
  String str2="ABCD" ;
  System.out.println(str1.equalsIgnoreCase(str2)); // ture
  System.out.println(str1==str2); // false
  String str3="abcd";
  String str4="abcd" ;
  System.out.println(str3.equalsIgnoreCase(str4)); // ture
  System.out.println(str3==str4); // ture
 }

4、比较两个字符串的大小

int compareTo(String str)

int compareToIgnoreCase(String str)

 @Test
 public void test6(){
  String str1="abcd";
  String str2="ABCD" ;
  // 区分大小写
  System.out.println(str1.compareTo(str2)); // 32
  // 不区分大小写
  System.out.println(str1.compareToIgnoreCase(str2));// 0
  }

5、字符串拼接

String concat(String str)

 @Test
 public void test7() {
  String str1 = "abcd";
  String str2 = "ABCD";
  String str = str1.concat(str2);
  System.out.println(str); //abcdABCD
 }

6、把字符串存储到常量池

String intern()

@Test
public void test8(){
  String s1 = new String("hello");// "hello"是一个字符串对象，然后又new了一个字符串对象
                                         //"hello"已经在常量池中，new的不在常量池
  String s2 = s1.intern(); //把new处理的"hello"放到常量池中，但是先检查了一下，常量池中已经有一个"hello"，新的这个没有放进去
                           //intern()得到的字符串地址是 原来"hello"的字符串地址，不是新new那个
 System.out.println(s1==s2); //false
 /*
  JDK8：false
  JDK6：false
  */
​
 }
 @Test
 public void test9(){
  String s1 = "he".concat("llo");//拼接的结果是新new"hello"
  String s2 = s1.intern();//把拼接的结果放入常量池
  //先检查了一下，常量池中没有"hello"，Java8版本，
  // 就会把新new这个hello的地址值直接放到常量池
  System.out.println(s1 == s2);
        /*
        JDK8：true
        JDK6：false    JDK6版本的常量池在方法区中，和堆中字符串一定不会共享的，
         */
 }

7、字符串转大小写

（1）String toLowerCase()：将字符串中大写字母转为小写

（2）String toUpperCase()：将字符串中小写字母转为大写

 @Test
 public void test10(){
  System.out.println("A".toLowerCase()); // a
  System.out.println("a".toUpperCase()); // A
​
  }

8、判断字符串是否以xx开头或结尾

（1）boolean startsWith(xx)：是否以xx开头

（2）boolean endsWith(xx)：是否以xx结尾

@Test
public void test11(){
  String name = "张三";
 System.out.println(name.startsWith("张")); // ture
 System.out.println(name.startsWith("三")); // false
 System.out.println(name.endsWith("张"));  // false
 System.out.println(name.endsWith("三"));  // ture
 }
@Test
 public void test12() {
  String file = "Hello.txt";
  if (file.endsWith(".java")) {
   System.out.println("java源文件");
  } else if (file.endsWith(".clsss")) {
   System.out.println("java字节码文件");
  } else {
   System.out.println("其他文件");
  }
 }
​
输出结果：其他文件

9、去掉字符串前后空白符

（1）String trim():去掉字符串前后空白符

 @Test
    public void test13() {
        System.out.println("[" + "    hello world     ".trim() + "]");
    }
​
输出结果：[hello world]
    @Test
public void test14(){
 // 将用户输入的单词转为小写，如果用户没有输入单词，重新输入
    Scanner scanner = new Scanner(System.in);
    String s;
    while(true){
        System.out.println("请输入单词：");
        s = scanner.nextLine();
        if(s.trim().length()!=0){
            s=s.toLowerCase();
            break;
        }
    }
    System.out.println("你输入的单词是："+ s);
    scanner.close();
}

10、在该字符串内搜索查找

（1）boolean contains(xx)：是否包含xx

@Test
public void test15(){
 String str = "abcdefg";
    boolean c = str.contains("c");
    System.out.println(c); // ture
 }

（2）int indexOf(xx)：从前往后找当前字符串中xx，即如果有返回第一次出现的下标，要是没有返回-1

  @Test
    public void test16() {
        String str = "HelloWorld";
        int s = str.indexOf("l");
        System.out.println(s); // 2
    }

（3）int lastIndexOf(xx)：从后往前找当前字符串中xx，即如果有返回最后一次出现的下标，要是没有返回-1

 @Test
    public void test17() {
        String str = "HelloWord";
        int s = str.lastIndexOf("l");
        System.out.println(s); // 3
    }

11、截取字符串

（1）String substring(int beginIndex):返回一个新的字符串，它是此字符串的从beginIndex开始截取到最后的一个字符串。

@Test
public void test18() {
    String str = "java,HelloWorld,liu";
    String s = str.substring(5);
    String s2 = str.substring(7);
    System.out.println(s);
    System.out.println(s2);
}
输出结果：HelloWorld,liu
        lloWorld,liu

（2）String substring(int beginIndex, int endIndex) ：返回一个新字符串，它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。

@Test
public void test19() {
    String str = "java,HelloWorld,liu";
    String s = str.substring(5,7);
    String s2 = str.substring(7,16);
    System.out.println(s);
    System.out.println(s2);
}
输出结果：He
        lloWorld,

12、获取char和char[]

（1）char charAt(index)：返回[index]位置的字符

@Test
public void test23(){
        String str = "阁下虽然很强，但是比起我那两位敌友阁下还是稍显逊色 ";
    char c = str.charAt(20);
    System.out.println(c); //是

（2）char[] toCharArray()： 将此字符串转换为一个新的字符数组返回

 @Test
    public void test24() {
        String str = "阁下虽然很强，但是比起我那两位敌友阁下还是稍显逊色 ";
        char[] c = str.toCharArray();
        System.out.println(c); // 阁下虽然很强，但是比起我那两位敌友阁下还是稍显逊色
        System.out.println(Arrays.toString(c)); //[阁, 下, 虽, 然, 很, 强, ，, 但, 是, 比, 起, 我, 那, 两, 位, 敌, 友, 阁, 下, 还, 是, 稍, 显, 逊, 色,  ]
    }
}

将字符数组转为String对象，可以使用之前介绍过的构造器和静态方法valueOf或copyValueOf等

• String(char[] value)：返回指定数组中表示该字符序列的 String。
• String(char[] value, int offset, int count)：返回指定数组中表示该字符序列的 String。
• static String copyValueOf(char[] data)： 返回指定数组中表示该字符序列的 String
• static String copyValueOf(char[] data, int offset, int count)：返回指定数组中表示该字符序列的 String
• static String valueOf(char[] data, int offset, int count) ： 返回指定数组中表示该字符序列的 String
• static String valueOf(char[] data) ：返回指定数组中表示该字符序列的 String

@Test
    public void test20(){
        //将字符串中的字符按照大小顺序排列
        String str = "helloworldjavaatguigu";
        char[] array = str.toCharArray();
        Arrays.sort(array);
        str = new String(array);
        System.out.println(str);//aaadegghijllloortuuvw
    }
​
    @Test
    public void test21(){
        //将首字母转为大写
        String str = "jack";
        str = Character.toUpperCase(str.charAt(0))+str.substring(1);
        System.out.println(str); // Jack
    }
​

13、字符串编码解码

（1）byte[] getBytes()：编码，把字符串变为字节数组，按照平台默认的字符编码方式进行编码

byte[] getBytes(字符编码方式)：按照指定的编码方式进行编码

（2）new String(byte[] ) 或 new String(byte[], int, int)：解码，按照平台默认的字符编码进行解码

new String(byte[]，字符编码方式 ) 或 new String(byte[], int, int，字符编码方式)：解码，按照指定的编码方式进行解码

==（编码方式见附录10.7.1）==

@Test
public void test22() throws UnsupportedEncodingException {
  String str = "中国";
    System.out.println(str.getBytes("ISO8859-1").length); // 2

14、判断字符串是否满足xx规则的方法（判断是否满足设置好的正则表达式）

（1）boolean matches(正则表达式)：判断当前字符串是否匹配某个正则表达式。==（正则表达式详细见附录）==

  @Test
    public void test25(){
        //简单判断是否全部是数字，这个数字可以是1~n位
        String str = "12a345";
​
        //正则不是Java的语法，它是独立与Java的规则
        //在正则中\是表示转义，
        //同时在Java中\也是转义
        boolean flag = str.matches("\d+");
        System.out.println(flag); // false
    }
​
    @Test
    public void test26(){
        String str = "123456789";
​
        //判断它是否全部由数字组成，并且第1位不能是0，长度为9位
        //第一位不能是0，那么数字[1-9]
        //接下来8位的数字，那么[0-9]{8}+
        boolean flag = str.matches("[1-9][0-9]{8}+");
        System.out.println(flag);
    }

15、字符串内容的替换

（1）String replace(xx,xx)：不支持正则

（2）String replaceFirst(正则，value)：替换第一个匹配部分

（3）String replaceAll(正则， value)：替换所有匹配部分

@Test
public void test27(){
    String str = "hello244world.java;887";
​
    String s1 = str.replace("244","");
    System.out.println("s1 = " + s1);
​
    String s2 = str.replaceFirst("\d+","");
    System.out.println("s2 = " + s2);
​
​
    //把其中的非字母去掉
    String s3 = str.replaceAll("[^a-zA-Z]", "");
    System.out.println("s3 = " + s3);
}

16、字符串拆分

（1）String[] split(正则)：按照某种规则进行拆分

@Test
public void test28(){
    String str = "Hello World java liu ";
    String[] s = str.split(" ");
    for (int i = 0; i < s.length; i++) {
        System.out.println(s[i]);
​
    }
​
 }
输出结果：
Hello
World
java
liu    
​
@Test
public void test29(){
    String str = "1Hello2World3java4liu";
    str = str.replaceFirst("\d", "");
    System.out.println(str);
​
    String[] all = str.split("\d");
    for (int i = 0; i < all.length; i++) {
        System.out.println(all[i]);
​
    }
    str = str.replaceAll("\d+"," ");
    System.out.println(str);
}
输出结果：
Hello2World3java4liu
Hello
World
java
liu
Hello World java liu
​

2 可变字符序列

1、 String与可变字符序列的区别

因为String对象是不可变对象，虽然可以共享常量对象，但是对于频繁字符串的修改和拼接操作，效率极低。因此，JDK又在java.lang包提供了可变字符序列StringBuilder和StringBuffer类型。

StringBuffer：老的，线程安全的（因为它的方法有synchronized修饰）

StringBuilder：线程不安全的

2、StringBuilder、StringBuffer的API

常用的API，StringBuilder、StringBuffer的API是完全一致的

（1）StringBuffer append(xx)：拼接，追加

（2）StringBuffer insert(int index, xx)：在[index]位置插入xx

（3）StringBuffer delete(int start, int end)：删除[start,end)之间字符

（3）StringBuffer deleteCharAt(int index)：删除[index]位置字符

（5）void setCharAt(int index, xx)：替换[index]位置字符

（6）StringBuffer reverse()：反转

（7）void setLength(int newLength) ：设置当前字符序列长度为newLength

（8）StringBuffer replace(int start, int end, String str)：替换[start,end)范围的字符序列为str

（9）int indexOf(String str)：在当前字符序列中查询str的第一次出现下标

int indexOf(String str, int fromIndex)：在当前字符序列[fromIndex,最后]中查询str的第一次出现下标

（10）int lastIndexOf(String str)：在当前字符序列中查询str的最后一次出现下标

int lastIndexOf(String str, int fromIndex)：在当前字符序列[fromIndex,最后]中查询str的最后一次出现下标

（11）String substring(int start)：截取当前字符序列[start,最后]

String substring(int start, int end)：截取当前字符序列[start,end)

（12）String toString()：返回此序列中数据的字符串表示形式

（13）void trimToSize()：尝试减少用于字符序列的存储空间。如果缓冲区大于保存当前字符序列所需的存储空间，则将重新调整其大小，以便更好地利用存储空间。

    @Test
    public void test6(){
        StringBuilder s = new StringBuilder("helloworld");
        s.setLength(30);
        System.out.println(s);
    }
    @Test
    public void test5(){
        StringBuilder s = new StringBuilder("helloworld");
        s.setCharAt(2, 'a');
        System.out.println(s);
    }
    
    
    @Test
    public void test4(){
        StringBuilder s = new StringBuilder("helloworld");
        s.reverse();
        System.out.println(s);
    }
    
    @Test
    public void test3(){
        StringBuilder s = new StringBuilder("helloworld");
        s.delete(1, 3);
        s.deleteCharAt(4);
        System.out.println(s);
    }
    
    
    @Test
    public void test2(){
        StringBuilder s = new StringBuilder("helloworld");
        s.insert(5, "java");
        s.insert(5, "chailinyan");
        System.out.println(s);
    }
    
    @Test
    public void test1(){
        StringBuilder s = new StringBuilder();
        s.append("hello").append(true).append('a').append(12).append("atguigu");
        System.out.println(s);
        System.out.println(s.length());
    }

3、 效率测试

package com.atguigu.stringbuffer;
​
import org.junit.Test;
​
public class TestTime {
​
    @Test
    public void testString(){
        long start = System.currentTimeMillis();
        String s = new String("0");
        for(int i=1;i<=10000;i++){
            s += i;
        }
        long end = System.currentTimeMillis();
        System.out.println("String拼接+用时："+(end-start));//367
​
        long memory = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();
        System.out.println("String拼接+memory占用内存: " + memory);//473081920字节
    }
​
    @Test
    public void testStringBuilder(){
        long start = System.currentTimeMillis();
        StringBuilder s = new StringBuilder("0");
        for(int i=1;i<=10000;i++){
            s.append(i);
        }
        long end = System.currentTimeMillis();
        System.out.println("StringBuilder拼接+用时："+(end-start));//5
        long memory = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();
        System.out.println("StringBuilder拼接+memory占用内存: " + memory);//13435032
    }
​
    @Test
    public void testStringBuffer(){
        long start = System.currentTimeMillis();
        StringBuffer s = new StringBuffer("0");
        for(int i=1;i<=10000;i++){
            s.append(i);
        }
        long end = System.currentTimeMillis();
        System.out.println("StringBuffer拼接+用时："+(end-start));//5
        long memory = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();
        System.out.println("StringBuffer拼接+memory占用内存: " + memory);//13435032
    }
}