10-java API与常见算法：字符串API、可变字符序列、正则表达式

目录

10.5 字符串

10.5.1 字符串的特点

10.5.2 构造字符串对象

1、使用构造方法

2、使用静态方法

3、使用""+

10.5.3 字符串的对象的个数

10.5.4 字符串对象的内存分析

10.5.5 字符串拼接问题

1、拼接结果的存储和比较问题

2、拼接效率问题

3、两种拼接

10.5.6 字符串对象的比较

10.5.7 空字符的比较

10.5.8 字符串的常用方法

1、系列1：常用方法

2、系列2：查找

3、系列3：字符串截取

4、系列4：和字符相关

5、系列5：编码与解码

6、系列6：开头与结尾

7、系列7：正则匹配

8、系列8：替换

9、系列9：拆分

10.6 可变字符序列

10.6.1 String与可变字符序列的区别

10.6.2 StringBuilder、StringBuffer的API

10.6.3 效率测试

10.7 正则表达式

常见的正则表达式示例

---

10.5 字符串

 

10.5.1 字符串的特点

1、字符串String类型本身是final声明的，意味着我们不能继承String。

2、字符串的对象也是不可变对象，意味着一旦进行修改，就会产生新对象

我们修改了字符串后，如果想要获得新的内容，必须重新接收。

如果程序中涉及到大量的字符串的修改操作，那么此时的时空消耗比较高。可能需要考虑使用StringBuilder或StringBuffer的可变字符序列。

3、String对象内部是用字符数组进行保存的

JDK1.9之前有一个char[] value数组，JDK1.9之后byte[]数组

"abc" 等效于 char[] data={ 'a' , 'b' , 'c' }。

例如： 
String str = "abc";
​
相当于： 

char data[] = {'a', 'b', 'c'};     
String str = new String(data);
// String底层是靠字符数组实现的。

4、String类中这个char[] values数组也是final修饰的，意味着这个数组不可变，然后它是private修饰，外部不能直接操作它，String类型提供的所有的方法都是用新对象来表示修改后内容的，所以保证了String对象的不可变。

5、就因为字符串对象设计为不可变，那么所以字符串有常量池来保存很多常量对象

常量池在方法区。

如果细致的划分：

（1）JDK1.6及其之前：方法区

（2）JDK1.7：堆

（3）JDK1.8：元空间

String s1 = "abc";
String s2 = "abc";
System.out.println(s1 == s2);
// 内存中只有一个"abc"对象被创建，同时被s1和s2共享。

10.5.2 构造字符串对象

1、使用构造方法

• public String() ：初始化新创建的 String对象，以使其表示空字符序列。

• String(String original)： 初始化一个新创建的 String 对象，使其表示一个与参数相同的字符序列；换句话说，新创建的字符串是该参数字符串的副本。

• public String(char[] value) ：通过当前参数中的字符数组来构造新的String。

• public String(char[] value,int offset, int count) ：通过字符数组的一部分来构造新的String。

• public String(byte[] bytes) ：通过使用平台的默认字符集解码当前参数中的字节数组来构造新的String。

• public String(byte[] bytes,String charsetName) ：通过使用指定的字符集解码当前参数中的字节数组来构造新的String。

构造举例，代码如下：

//字符串常量对象
String str = "hello";
​
// 无参构造
String str1 = new String（）；
​
//创建"hello"字符串常量的副本
String str2 = new String("hello");
​
//通过字符数组构造
char chars[] = {'a', 'b', 'c','d','e'};     
String str3 = new String(chars);
String str4 = new String(chars,0,3);
​
// 通过字节数组构造
byte bytes[] = {97, 98, 99 };     
String str5 = new String(bytes);
String str6 = new String(bytes,"GBK");

2、使用静态方法

• static String copyValueOf(char[] data)： 返回指定数组中表示该字符序列的 String

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

• static String valueOf(char[] data) ： 返回指定数组中表示该字符序列的 String

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

• static String valueOf(xx value)：xx支持各种数据类型，返回各种数据类型的value参数的字符串表示形式。

    public static void main(String[] args) {
        char[] data = {'h','e','l','l','o','j','a','v','a'};
        String s1 = String.copyValueOf(data);
        String s2 = String.copyValueOf(data,0,5);
        int num = 123456;
        String s3 = String.valueOf(num);
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
    }

3、使用""+

任意数据类型与"字符串"进行拼接，结果都是字符串

    public static void main(String[] args) {
        int num = 123456;
        String s = num + "";
        System.out.println(s);
        
        Student stu = new Student();
        String s2 = stu + "";//自动调用对象的toString()，然后与""进行拼接
        System.out.println(s2);
    }

10.5.3 字符串的对象的个数

1、字符串常量对象

String str1 = "hello";//1个，在常量池中

2、字符串的普通对象和常量对象一起

String str3 = new String("hello");
//str3首先指向堆中的一个字符串对象，然后堆中字符串的value数组指向常量池中常量对象的value数组

3、面试题

String str1 = "hello";
String str2 = new String("hello");
​
//上面的代码一共有几个字符串对象。
//2个

10.5.4 字符串对象的内存分析

String s;
​
String s = null;
​
String s = "";
String s = new String();
String s = new String("");
​
String s = "abc";
String s = new String("abc");
​
char[] arr = {'a','b'};
String s = new String(arr);
​
​
char[] arr = {'a','b','c','d','e'};
String s = new String(arr,0,3);

10.5.5 字符串拼接问题

1、拼接结果的存储和比较问题

原则：

（1）常量+常量：结果是常量池

（2）常量与变量 或 变量与变量：结果是堆

（3）拼接后调用intern方法：结果在常量池

    public void test06(){
        String s1 = "hello";
        String s2 = "world";
        String s3 = "helloworld";
        
        String s4 = (s1 + "world").intern();//把拼接的结果放到常量池中
        String s5 = (s1 + s2).intern();
        
        System.out.println(s3 == s4);//true
        System.out.println(s3 == s5);//true
    }
    
    
    public void test05(){
        final String s1 = "hello";
        final String s2 = "world";
        String s3 = "helloworld";
        
        String s4 = s1 + "world";//s4字符串内容也helloworld，s1是常量，"world"常量，常量+ 常量 结果在常量池中
        String s5 = s1 + s2;//s5字符串内容也helloworld，s1和s2都是常量，常量+ 常量 结果在常量池中
        String s6 = "hello" + "world";//常量+ 常量 结果在常量池中，因为编译期间就可以确定结果
        
        System.out.println(s3 == s4);//true
        System.out.println(s3 == s5);//true
        System.out.println(s3 == s6);//true
    }
    
    
    public void test04(){
        String s1 = "hello";
        String s2 = "world";
        String s3 = "helloworld";
        
        String s4 = s1 + "world";//s4字符串内容也helloworld，s1是变量，"world"常量，变量 + 常量的结果在堆中
        String s5 = s1 + s2;//s5字符串内容也helloworld，s1和s2都是变量，变量 + 变量的结果在堆中
        String s6 = "hello" + "world";//常量+ 常量 结果在常量池中，因为编译期间就可以确定结果
        
        System.out.println(s3 == s4);//false
        System.out.println(s3 == s5);//false
        System.out.println(s3 == s6);//true
    }

2、拼接效率问题

public class TestString {
    public static void main(String[] args) {
        String str = "0";
        for (int i = 0; i <= 5; i++) {
            str += i;  
        }
        System.out.println(str);
    }
}

3、两种拼接

public class TestString {
    public static void main(String[] args) {
        String str = "hello";
        String str2 = "world";
        String str3 ="helloworld";
        
        String str4 = "hello".concat("world");
        String str5 = "hello"+"world";
        
        System.out.println(str3 == str4);//false
        System.out.println(str3 == str5);//true
    }
}

concat方法拼接，哪怕是两个常量对象拼接，结果也是在堆。

10.5.6 字符串对象的比较

1、==：比较是对象的地址

只有两个字符串变量都是指向字符串的常量对象时，才会返回true

String str1 = "hello";
String str2 = "hello";
System.out.println(str1 == str2);//true
    
String str3 = new String("hello");
String str4 = new String("hello");
System.out.println(str1 == str4); //false
System.out.println(str3 == str4); //false

2、equals：比较是对象的内容，因为String类型重写equals，区分大小写

只要两个字符串的字符内容相同，就会返回true

String str1 = "hello";
String str2 = "hello";
System.out.println(str1.equals(str2));//true
    
String str3 = new String("hello");
String str4 = new String("hello");
System.out.println(str1.equals(str3));//true
System.out.println(str3.equals(str4));//true

3、equalsIgnoreCase：比较的是对象的内容，不区分大小写

String str1 = new String("hello");
String str2 = new String("HELLO");
System.out.println(str1.equalsIgnoreCase(strs)); //true

4、compareTo：String类型重写了Comparable接口的抽象方法，自然排序，按照字符的Unicode编码值进行比较大小的，严格区分大小写

String str1 = "hello";
String str2 = "world";
str1.compareTo(str2) //小于0的值

5、compareToIgnoreCase：不区分大小写，其他按照字符的Unicode编码值进行比较大小

String str1 = new String("hello");
String str2 = new String("HELLO");
str1.compareToIgnoreCase(str2)  //等于0

10.5.7 空字符的比较

1、哪些是空字符串

String str1 = "";
String str2 = new String();
String str3 = new String("");

空字符串：长度为0

2、如何判断某个字符串是否是空字符串

if("".equals(str))
​
if(str!=null  && str.isEmpty())
​
if(str!=null && str.equals(""))
​
if(str!=null && str.length()==0)

10.5.8 字符串的常用方法

1、系列1：常用方法

（1）boolean isEmpty()：字符串是否为空

（2）int length()：返回字符串的长度

（3）String concat(xx)：拼接，等价于+

（4）boolean equals(Object obj)：比较字符串是否相等，区分大小写

（5）boolean equalsIgnoreCase(Object obj)：比较字符串是否相等，不区分大小写

（6）int compareTo(String other)：比较字符串大小，区分大小写，按照Unicode编码值比较大小

（7）int compareToIgnoreCase(String other)：比较字符串大小，不区分大小写

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

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

（10）String trim()：去掉字符串前后空白符

（11）public String intern()：结果在常量池中共享

2、系列2：查找

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

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

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

    public void test01(){
        String str = "好谷就业力成长于河南，专注于河南，口碑于河南，拥有自主知识产权的三大实训支持系统（技术系统/能力系统/职业战略），立志为青年学子提供技术与能力并重的职业技能综合发展平台，助力河南学子创造中国互联网未来";
        System.out.println("是否包含河南：" + str.contains("河南"));
        System.out.println("河南出现的第一次下标：" + str.indexOf("河南"));
        System.out.println("河南出现的最后一次下标：" + str.lastIndexOf("河南"));
    }

3、系列3：字符串截取

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

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

 public void test01(){
        String str = "helloworldjavahaogu";
        String sub1 = str.substring(5);
        String sub2 = str.substring(5,10);
        System.out.println(sub1);
        System.out.println(sub2);
    }
​
    
    public void test02(){
        String fileName = "快速学习Java的秘诀.dat";
        //截取文件名
        System.out.println("文件名：" + fileName.substring(0,fileName.lastIndexOf(".")));
        //截取后缀名
        System.out.println("后缀名：" + fileName.substring(fileName.lastIndexOf(".")));
    }

4、系列4：和字符相关

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

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

（18）String(char[] value)：返回指定数组中表示该字符序列的 String。

（19）String(char[] value, int offset, int count)：返回指定数组中表示该字符序列的 String。

（20）static String copyValueOf(char[] data)： 返回指定数组中表示该字符序列的 String

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

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

（23）static String valueOf(char[] data) ：返回指定数组中表示该字符序列的 String

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

5、系列5：编码与解码

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

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

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

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

​
import org.junit.Test;
​
public class StringMethod5 {
    
    public void test01()throws Exception{
        byte[] data = {(byte)0B11100101, (byte)0B10110000, (byte)0B10011010, (byte)0B11000111, (byte)0B10101011,(byte)0B01110110};
        System.out.println(new String(data,"ISO8859-1"));
        System.out.println(new String(data,"GBK"));
        System.out.println(new String(data,"UTF-8"));
    }
​
    
    public void test02() throws Exception {
        String str = "中国";
        System.out.println(str.getBytes("ISO8859-1").length);// 2
        // ISO8859-1把所有的字符都当做一个byte处理，处理不了多个字节
        System.out.println(str.getBytes("GBK").length);// 4 每一个中文都是对应2个字节
        System.out.println(str.getBytes("UTF-8").length);// 6 常规的中文都是3个字节
​
        /*
         * 不乱码：（1）保证编码与解码的字符集名称一样（2）不缺字节
         */
        System.out.println(new String(str.getBytes("ISO8859-1"), "ISO8859-1"));// 乱码
        System.out.println(new String(str.getBytes("GBK"), "GBK"));// 中国
        System.out.println(new String(str.getBytes("UTF-8"), "UTF-8"));// 中国
    }
}

6、系列6：开头与结尾

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

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

  
    public void test2(){
        String name = "张三";
        System.out.println(name.startsWith("张"));
    }
    
    
    public void test(){
        String file = "Hello.txt";
        if(file.endsWith(".java")){
            System.out.println("Java源文件");
        }else if(file.endsWith(".class")){
            System.out.println("Java字节码文件");
        }else{
            System.out.println("其他文件");
        }
    }

7、系列7：正则匹配

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

    
    public void test1(){
        //简单判断是否全部是数字，这个数字可以是1~n位
        String str = "12a345";
        //正则不是Java的语法，它是独立与Java的规则
        //在正则中\是表示转义，
        //同时在Java中\也是转义
        boolean flag = str.matches("\\d+");
        System.out.println(flag);
    }
    
    
    public void test2(){
        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);
    }
​
    public void test03(){
        //密码要求：必须有大写字母，小写字母，数字组成，6位
        System.out.println("Cly892".matches("^(?=.*[A-Z])(?=.*[a-z])(?=.*[0-9])[A-Za-z0-9]{6}$"));//true
        System.out.println("1A2c45".matches("^(?=.*[A-Z])(?=.*[a-z])(?=.*[0-9])[A-Za-z0-9]{6}$"));//true
        System.out.println("Clyyyy".matches("^(?=.*[A-Z])(?=.*[0-9])[A-Za-z0-9]{6}$"));//false
    }

8、系列8：替换

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

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

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

   public void test4(){
        String str = "hello244world.java;887";
        //把其中的非字母去掉
        str = str.replaceAll("[^a-zA-Z]", "");
        System.out.println(str);
    }

9、系列9：拆分

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

    public void test4(){
        String str = "张三.23|李四.24|王五.25";
        //|在正则中是有特殊意义，我这里要把它当做普通的|
        String[] all = str.split("\\|");
        //转成一个一个学生对象
        Student[] students = new Student[all.length];
        for (int i = 0; i < students.length; i++) {
            //.在正则中是特殊意义，我这里想要表示普通的.
            String[] strings = all[i].split("\\.");//张三,  23
            String name = strings[0];
            int age = Integer.parseInt(strings[1]);
            students[i] = new Student(name,age);
        }
        
        for (int i = 0; i < students.length; i++) {
            System.out.println(students[i]);
        }
        
    }
    
    
    public void test3(){
        String str = "1Hello2World3java4haogu5";
        str = str.replaceAll("^\\d|\\d$", "");
        String[] all = str.split("\\d");
        for (int i = 0; i < all.length; i++) {
            System.out.println(all[i]);
        }
    }
    
    
    public void test2(){
        String str = "1Hello2World3java4haogu";
        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]);
        }
    }
    
    
    
    public void test1(){
        String str = "Hello World java haogu";
        String[] all = str.split(" ");
        for (int i = 0; i < all.length; i++) {
            System.out.println(all[i]);
        }
    }

10.6 可变字符序列

10.6.1 String与可变字符序列的区别

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

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

StringBuilder：线程不安全的

10.6.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)之间字符

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

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

（5）StringBuffer reverse()：反转

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

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

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

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

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

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

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

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

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

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

10.6.3 效率测试

​

import org.junit.Test;
​
public class TestTime {
​
    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字节
    }
​
    
    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
    }
​
    
    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
    }
}
​

10.7 正则表达式

常见的正则表达式示例

• 验证用户名和密码，要求第一个字必须为字母，一共6~16位字母数字下划线组成：（^[a-zA-Z]\w{5,15}$）

• 验证电话号码：xxx/xxxx-xxxxxxx/xxxxxxxx：（^(\d{3,4}-)\d{7,8}$）

• 验证手机号码：( ^(13[0-9]|14[5|7]|15[0|1|2|3|5|6|7|8|9]|18[0|1|2|3|5|6|7|8|9])\d{8}$ )

• 验证身份证号： (^\d{15}$)|(^\d{18}$)|(^\d{17}(\d|X|x)$)

• 验证Email地址：(^\w+([-+.]\w+)@\w+([-.]\w+).\w+([-.]\w+)*$)

• 只能输入由数字和26个英文字母组成的字符串：(^[A-Za-z0-9]+$)

• 整数或者小数：(^[0-9]+(.[0-9]+){0,1}$)

• 中文字符的正则表达式：([\u4e00-\u9fa5])

• 金额校验(非零开头的最多带两位小数的数字)：(^([1-9][0-9]*)+(.[0-9]{1,2})?$)

• IPV4地址：(((\d{1,2})|(1\d{1,2})|(2[0-4]\d)|(25[0-5]))\.){3}((\d{1,2})|(1\d{1,2})|(2[0-4]\d)|(25[0-5]))