java第十二课——字符串

知行&

已于 2022-09-12 10:44:48 修改

阅读量272

点赞数 2

分类专栏： Java语法文章标签：学习 java 开发语言

于 2022-04-17 17:36:02 首次发布

本文链接：https://blog.csdn.net/baijaiyu/article/details/124186478

版权

Java语法专栏收录该内容

15 篇文章 9 订阅

订阅专栏

2. boolean equals(Object anObject) 方法：按照字典序比较

3.int compareTo(String s) 方法: 按照字典序进行比较。

4.int compareToIgnoreCase(String str) 方法

三：StringBuilder和StringBuffer

一：常用方法

1.1字符串构造

我仅介绍最常用的三种构造方法。


public class TestDemo {
    public static void main(String[] args) {
        // 1.使用常量串构造
        String s1 = "helloworld";
        System.out.println(s1);
        // 2.直接newString对象
        String s2 = new String("helloworld");
        System.out.println(s2);
        // 3.使用字符数组进行构造
        char[] array = {'h','e','l','l','o','w','o','r','l','d'};
        String s3 = new String(array);
        System.out.println(s3);
    }
}

运行结果如下：

1.2String对象的比较

1. ==比较是否引用同一个对象

注意：对于内置类型，==比较的是变量中的值；对于引用类型==比较的是引用中的地址。

public class TestDemo {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 10;
// 对于基本类型变量，==比较两个变量中存储的值是否相同
        System.out.println(a == b); // false
        System.out.println(a == c); // true
// 对于引用类型变量，==比较两个引用变量引用的是否为同一个对象
        String s1 = new String("hello");
        String s2 = new String("hello");
        String s3 = new String("world");
        String s4 = s1;
        System.out.println(s1 == s2); // false
        System.out.println(s2 == s3); // false
        System.out.println(s1 == s4); // true
    }
}

运行结果如下：

2. boolean equals(Object anObject) 方法：按照字典序比较

字典序（dictionary order），又称字母序（alphabetical order），原意是表示英文单词在字典中的先后顺序，在计算机领域中扩展成两个任意字符串的大小关系。

字典序：字符大小的顺序。String类重写了父类Object中equals方法。

public class TestDemo {
    public static void main(String[] args) {
        String s1 = new String("hello");
        String s2 = new String("hello");
        String s3 = new String("world");
        // s1、s2、s3引用的是三个不同对象，因此==比较结果全部为false
        System.out.println(s1 == s2); // false
        System.out.println(s1 == s3); // false
        // equals比较：String对象中的逐个字符
// 虽然s1与s2引用的不是同一个对象，但是两个对象中放置的内容相同，因此输出true
// s1与s3引用的不是同一个对象，而且两个对象中内容也不同，因此输出false
        System.out.println(s1.equals(s2)); // true
        System.out.println(s1.equals(s3)); // false
    }
}

运行结果如下：

总结：S1.equals(S2)，就是比较字符串S1与S2的内容是否相同，返回值为boolean类型。

3.int compareTo(String s) 方法: 按照字典序进行比较。

public class TestDemo {
    public static void main(String[] args) {
        String s1 = new String("abc");
        String s2 = new String("ac");
        String s3 = new String("abc");
        String s4 = new String("abcdefg");
        System.out.println(s1.compareTo(s2)); // 第1个字符完全相同，输出长度差值-1
        System.out.println(s1.compareTo(s3)); // 相同输出 0
        System.out.println(s1.compareTo(s4)); // 前4个字符完全相同，输出长度差值-4
    }
}

运行结果如下：

总结：S1.compareTo(S2)，就是比较字符串S1与S2的内容是否相同，返回值为int类型，返回值等于0，说明S1和S2内容相同；输出负数，说明S1字典序小于S2；输出正数，说明S1字典序大于S2。

4.int compareToIgnoreCase(String str) 方法

与compareTo方式相同，但是忽略大小写比较。

public class TestDemo {
    public static void main(String[] args) {
        String s1 = new String("abc");
        String s2 = new String("ac");
        String s3 = new String("ABc");
        String s4 = new String("abcdef");
        System.out.println(s1.compareToIgnoreCase(s2)); // 不同输出字符差值-1
        System.out.println(s1.compareToIgnoreCase(s3)); // 相同输出 0
        System.out.println(s1.compareToIgnoreCase(s4)); // 前k个字符完全相同，输出长度差值 -3
    }
}

运行结果如下：

1.3字符串查找

String提供的常用查找方法有：

public class TestDemo {
    public static void main(String[] args) {
        String s = "aaabbbcccaaabbbccc";
        System.out.println(s.charAt(3)); 
    }
}

运行结果如下：

1.4转化

1. 数值和字符串转化

public class TestDemo {
    public static void main(String[] args) {
        // 数字转字符串
        String s1 = String.valueOf(1234);
        String s2 = String.valueOf(12.34);
        String s3 = String.valueOf(true);
        System.out.println(s1+1);
        System.out.println(s2+1);
        System.out.println(s3+1);
        System.out.println("=================================");
        // 字符串转数字
        int data1 = Integer.parseInt("1234");
        double data2 = Double.parseDouble("12.34");
        System.out.println(data1+1);
        System.out.println(data2+1);
    }
}

运行结果如下：

2.大小写转换

public class TestDemo {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "HELLO";
        // 小写转大写
        System.out.println(s1.toUpperCase());
        // 大写转小写
        System.out.println(s2.toLowerCase());
    }
}

运行结果如下：

3.字符串转数组

public class TestDemo {
    public static void main(String[] args) {
        String s = "hello";
// 字符串转数组
        char[] ch = s.toCharArray();
        for (int i = 0; i < ch.length; i++) {
            System.out.print(ch[i]);
        }
        System.out.println();
// 数组转字符串
        String s2 = new String(ch);
        System.out.println(s2);
    }
}

运行结果如下：

总结：

1。字符串转数组——char[ ] ch = s.toCharArray();

2. 数组转字符串 String s2 = new String(ch);

4.格式化

public class TestDemo {
    public static void main(String[] args) {
        String s = String.format("%d-%d-%d", 2019, 9,14);
        System.out.println(s);
    }
}

运行结果如下：

1.5字符串替换

public class TestDemo {
    public static void main(String[] args) {
        String str = "helloworld";
        System.out.println(str.replaceAll("l", "_"));
        System.out.println(str.replaceFirst("l", "_"));
    }
}

运行结果如下：

1.6字符串拆分

public class TestDemo {
    public static void main(String[] args) {
        String str = "hello world hello bai" ;
        String[] result = str.split(" ") ; // 按照空格拆分
        for(String s: result) {
            System.out.println(s);
        }
        System.out.println("====================");
        String str1 = "hello world hello bai" ;
        String[] result1 = str.split(" ",2) ;//只拆成2部分
        for(String s: result1) {
            System.out.println(s);
        }
    }
}

运行结果如下：

特殊情况：拆分时含有特殊字符，需要进行转义，其规则如下：

1. 字符"|","*","+"都得加上转义字符，前面加上"\\" .
2. 而如果是"\" ，那么就得写成"\\\\" .
3. 如果一个字符串中有多个分隔符，可以用"|"作为连字符.

public class TestDemo {
    public static void main(String[] args) {
        String str = "192.168.1.1" ;
        String[] result = str.split("\\.") ;
        for(String s: result) {
            System.out.println(s);
        }
    }
}

运行结果如下：

多次拆分：很简单，对拆分的结果进行再拆分即可。

public class TestDemo {
    public static void main(String[] args) {
        String str = "name=zhangsan&age=18";
        String[] result = str.split("&");
        for (int i = 0; i < result.length; i++) {
            System.out.println(result[i]);
        }
        System.out.println("===============");
        for (int i = 0; i < result.length; i++) {
            String[] temp = result[i].split("=");
            System.out.println(temp[0] + " ## " + temp[1]);
        }
    }
}

运行结果如下：

1.7字符串截取

public class TestDemo {
    public static void main(String[] args) {
        String str = "helloworld" ;
        System.out.println(str.substring(5));
        System.out.println(str.substring(0, 5));
    }
}

运行结果如下：

注意:
1. 索引从0开始；
2. 注意前闭后开区间的写法, substring(0, 5) 表示包含 0 号下标的字符, 不包含 5 号下标。

二：字符串常量池

2.1什么是字符串常量池？

在Java程序中，类似于：1， 2， 3，3.14，“hello”等字面类型的常量经常频繁使用，为了使程序的运行速度更快、更节省内存，Java为8种基本数据类型和String类都提供了常量池。

为了节省存储空间以及程序的运行效率，Java中引入了：
1. class文件常量池：每个.java源文件编译后生成的.class文件中会保存当前类中的字面常量以及符号信息；
2. 运行时常量池：在.class文件被加载时，.class文件中的常量池被加载到内存中称为运行时常量池，运行时常量池每个类都有一份；
3. 字符串常量池。

注意：
1. 在JVM中字符串常量池只有一份，是全局共享的；
2. 刚开始字符串常量池是空的，随着程序不断运行，字符串常量池中元素会越来越多；
3. 当类加载时，字节码文件中的常量池也被加载到JVM中，称为运行时常量池，同时会将其中的字符串常量保存在字符串常量池中；
4. 字符串常量池中的内容：一部分来自运行时常量池，一部分来自程序动态添加。

2.2画图解释

2.2.1直接被双引号括起来的字符串

2.2.2new创建的字符串

总结：只要是new的对象，都是唯一的。

2.3intern方法

intern是一个native方法(Native方法指：底层使用C++实现的，看不到其实现的源代码)，该方法的作用是手动将创建的String对象添加到常量池中。

public class TestDemo {
    public static void main(String[] args) {
        char[] ch = new char[]{'a', 'b', 'c'};
        String s1 = new String(ch);
        s1.intern();// s1对象被添加到常量池中
        String s2 = "abc"; // "abc" 在常量池中存在了，s2创建时直接用常量池中"abc"的引用
        System.out.println(s1 == s2);
    }
}

运行结果如下：

总结：

1.S.intern()方法，将创建的String对象S添加到常量池中。

2.只有常量池中没有时，才会入池。

注意:因为String内部的value被final修饰，所以字符串不能被修改.所有对字符串的操作，本质上都是创建了新的字符串。

三：StringBuilder和StringBuffer

在对String类进行修改时，效率是非常慢的，因此：尽量避免对String的直接需要，如果要修改建议尽量使用StringBuffer或者StringBuilder。

说明：所有对String适用的方法，也适用于StringBuilder和StringBuffer。

具体实例如下：

public class TestDemo1 {
    public static void main(String[] args) {
        StringBuilder sb1 = new StringBuilder("hello");
        StringBuffer sb2 = new StringBuffer("hello");
        sb1.append("world");
        sb2.append("world"); 
        System.out.println(sb1); 
        System.out.println(sb2); 
        sb1.reverse();
        sb2.reverse();
        System.out.println(sb1);
        System.out.println(sb2);
}
    }

运行结果如下：

区别：

1.在执行速度方面的比较：StringBuilder> StringBuffer；
2.StringBuffer与StringBuilder，他们是字符串变量，是可改变的对象，每当我们用它们对字符串做操作时，实际上是在一个对象上操作的，不像String一样创建一些对象进行操作，所以速度就快了；
3.StringBuilder：线程非安全的 StringBuffer：线程安全的