Java SE String类

一、String类的重要性

在C语言中已经涉及到字符串了

但是在C语言中要表示字符串只能使用字符数组或者字符指针

可以使用标准库提供的字符串系列函数完成大部分操作

但是这种将数据和操作数据方法分离开的方式不符合面相对象的思想

而字符串应用又非常广泛，因此Java语言专门提供了String类

---

写在前面：
Java当中只要对String类进行改变，一定是创建了新的对象

二、常用方法

1、字符串构造

使用常量串构造

        String str = "hello";
        System.out.println(str);

直接newString对象

        String str2 = new String();
        System.out.println(str2);

        String str3 = new String("ppp");
        System.out.println(str3);

使用字符数组进行构造

        char[] array = {'a','b','c'};
        String str4 = new String(array,1,2);
        System.out.println(str4);

【注意】

1. String是引用类型，内部并不存储字符串本身，在String类的实现源码中，String类实例变量如下：
   
2. 在Java中“”引起来的也是String类型对象

public static void main(String[] args) {
        String s1 = new String("hello");
        String s2 = new String("world");
        String s3 = s1;

        System.out.println(s3);
        System.out.println(s1.length()); // 获取字符串长度---输出5
        System.out.println(s1.isEmpty()); // 如果字符串长度为0，返回true，否则返回false

        String str4 = "";//这个空 是指字符里面没有 是0
        System.out.println(str4.length());
        System.out.println(str4.isEmpty());

        String str5 = null;//这个是指所指对象为空 会发生空指针异常
        //System.out.println(str5.length());

    }

2、String对象的比较

1. ==比较是否引用同一个对象
2. boolean equals(Object anObject) 方法：按照字典序比较
3. int compareTo(String s) 方法: 按照字典序进行比较
4. int compareToIgnoreCase(String str) 方法：与compareTo方式相同，但忽略大小写比较

public static void main(String[] args) {
        String s1 = new String("abc");
        String s2 = new String("Abc");
        System.out.println(s1 == s2);//比较的是地址

        System.out.println(s1.equals(s2));//比较内容 返回值是true 或者是false

        //strcmp
        //str1: abc  str2: acd
        /**
         * //s1 he s2 进行比较
         * 如果s1 > s2 返回正数
         * 如果s1 = s2 返回0
         * 如果s1 < s2 返回负数
         */
        System.out.println(s1.compareTo(s2));
        /**
         * 忽略大小写
         */
        System.out.println(s1.compareToIgnoreCase(s2));
    }

3、字符串查找

字符串查找也是字符串中非常常见的操作，String类提供的常用查找的方法

public static void main(String[] args) {
        String s1 = "ababcabcd";

        int index = s1.lastIndexOf("abc");
        System.out.println(index);

        int index1 = s1.indexOf("abc",3);
        System.out.println(index1);

        //从头到后 查某个字符第一次出现的下标
        int index2 = s1.indexOf('l');
        System.out.println(index2);

        for (int i = 0; i < s1.length(); i++) {
            char ch = s1.charAt(i);
            System.out.println(ch);
        }

        char ch = s1.charAt(1);
        

4、转化

1. 数值和字符串转化

        //数字转字符串
        String s = String.valueOf(19.9);
        System.out.println(s);

        //字符串转数字
        int data = Integer.parseInt("19");
        System.out.println(data);

2. 大小写转换

String s1 = "hello";
        // 小写转大写 不是在原来的基础上 转变 是转变成大写是一个新的对象
        String ret = s1.toUpperCase();
        System.out.println(s1);
        System.out.println(ret);

        // 大写转小写
        String s2 = "HELLO";
        String re2 = s2.toLowerCase();
        System.out.println(s2);
        System.out.println(re2);

3. 字符串转数组

        //字符串转数组
        String s1 = "hello";
        char[] array = s1.toCharArray();
        System.out.println(Arrays.toString(array));

        //数组转字符串
        char[] array2 = {'a','b','c'};
        String str2 = new String(array2);
        System.out.println(str2);

4. 格式化

	String s = String.format("%d-%d-%d", 2019, 9,14);
	System.out.println(s);

5、字符串替换

public static void main(String[] args) {
        String str = "ababcabcdabcd";
        String ret = str.replace("ab","999");

        System.out.println(ret);

        ret = str.replace('a','8');
        System.out.println(ret);

        ret = str.replaceFirst("ab","pp");
        System.out.println(ret);

        ret = str.replaceAll("ab","123");
        System.out.println(ret);
    }

6、字符串拆分

实现字符串的拆分 和 处理字符串的部分拆分

public static void main8(String[] args) {
        String str = "hello abc world";
        String[] ret = str.split(" ",2);
        for (int i = 0; i < ret.length; i++) {
            System.out.println(ret[i]);
        }
    }

拆分IP地址

public static void main9(String[] args) {
        /*String str = "198.168.1.1";
        String[] ret = str.split("\\.");// \.
        for (int i = 0; i < ret.length; i++) {
            System.out.println(ret[i]);
        }*/

        String str = "198\\168\\1\\1";
        String[] ret = str.split("\\\\");// \.
        for (int i = 0; i < ret.length; i++) {
            System.out.println(ret[i]);
        }
    }

多次拆分

public static void main10(String[] args) {
        String str = "name=zhangsan&age=15";
        /*String[] ret =  str.split("=|&");
        for (int i = 0; i < ret.length; i++) {
            System.out.println(ret[i]);
        }*/

        //可以再第一次分割的基础上进行第二次分割
        String[] ret = str.split("&");
        for (int i = 0; i < ret.length; i++) {
            String x = ret[i];
            String[] ret2 = x.split("=");
            for (int j = 0; j < ret2.length; j++) {
                System.out.println(ret2[j]);
            }
        }
    }

注意事项:

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

7、字符串截取

        String str = "ababc";
        String ret = str.substring(0,3);//给两个位置是区间
        System.out.println(ret);

        ret = str.substring(2);//一个参数是从这个下标往后输出
        System.out.println(ret);

注意事项:

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

8、其他方法

去掉字符串中的左右空格,保留中间空格

        String str2 = " shiednfjfhif oufoh ";
        //去掉字符串的左右两边的空格 中间空格无法去掉
        System.out.println(str2.trim());

9、字符串的不可变性

String是一种不可变对象. 字符串中的内容是不可改变

1. String类在设计时就是不可改变的，String类实现描述中已经说明了
   

• String类被final修饰，表明该类不能被继承
• value被修饰被final修饰，表明value自身的值不能改变，即不能引用其它字符数组，但是其引用空间中的内容可以修改
• 在这个代码中最重要的是final 前面的 private 是不能被拿出来的

2. 所有涉及到可能修改字符串内容的操作都是创建一个新对象，改变的是新对象

10、字符串修改

我们在写代码的时候，有时会出现要在打印的字符串后面增加别的字符串，因此我们会对字符串进行修改

但是 要尽量避免直接对String类型对象进行修改，因为String类是不能修改的，所有的修改都会创建新对象，效率非常低下

public static void main1(String[] args) {
        String str = "hello";
        System.out.println(str);

        str = str +"abc";//helloabc
        //在这个情况下 helloabc是一个全新的对象
        System.out.println(str); 
    }

由上图可知，在进行修改的时候 增加了很多新的对象 效率非常的低

---

public static void main(String[] args) {
        long start = System.currentTimeMillis();
        String s = "";
        for(int i = 0; i < 10000; ++i){
            s += i;
        }
        long end = System.currentTimeMillis();
        System.out.println("String：" + (end - start));//得出String 先后执行的时间

        start = System.currentTimeMillis();
        StringBuffer sbf = new StringBuffer("");
        for(int i = 0; i < 10000; ++i){
            sbf.append(i);
        }
        end = System.currentTimeMillis();
        System.out.println("StringBuffer：" + (end - start));//得出StringBuffer 先后执行的时间

        start = System.currentTimeMillis();
        StringBuilder sbd = new StringBuilder();
        for(int i = 0; i < 10000; ++i){
            sbd.append(i);
        }

        end = System.currentTimeMillis();
        System.out.println("StringBuilder：" + (end - start));//得出StringBuilder 先后执行的时间
    }

因此在我们修改的时候需要借助StringBuffer 和 StringBuilder

11、StringBuffer 和 StringBuilder

由于String的不可更改特性，为了方便字符串的修改，Java中又提供StringBuilder和StringBuffer类。
这两个类大部分功能是相同，但也有些许的不同
由于String的不可更改特性，为了方便字符串的修改，Java中又提供StringBuilder和StringBuffer类。
这两个类大部分功能是相同的

在StringBuffer 中 多了Synchronized 这个提供了线程安全
在多线程的情况下StringBuffer的效率会比较低，因为会不断地开锁和关锁

注意：
String和StringBuilder类不能直接转换。如果要想互相转换，可以采用如下原则:
String变为StringBuilder: 利用StringBuilder的构造方法或append()方法
StringBuilder变为String: 调用toString()方法

---

String、StringBuffer、StringBuilder的区别：

• String的内容不可修改，StringBuffer与StringBuilder的内容可以修改.
• StringBuffer与StringBuilder大部分功能是相似的
• StringBuffer采用同步处理，属于线程安全操作；而StringBuilder未采用同步处理，属于线程不安全操作