String类的简单理解

1. String类的常用方法

        每一个string类型的对象，都是有hash和value来存储，对于value里面用来通过数组的形式来存放每一个字母。String类对象用来存放value的地址。

1.1 字符串构造

        1、使用常量串构造

          

        2、直接newString对象

          

        3、使用字符数组进行构造

         

【注意】

        1. String是引用类型，内部并不存储字符串本身，在String类的实现源码中，String类实例变量如下图所示，string类的数据存放在一个final修饰的字符型的数组里面，所以不能对string类的对象进行数据修改。

        2、字符串数据包含两部分，一部分是value一部分是hash

 上图代码的详细解如下所示：

        虚拟机栈                                 堆栈

        由以上讲解可知，s1和s2引用的是不同对象 s1和s3引用的是同一对象

        3. 在Java中“ ”引起来的也是String类型对象。 

以上代码会报出以下问题：

        StringIndexOutOfBoundsException:该异常是字符串下标越界了；具体解决情况见于后面异常部分。

 1.2 String对象的比较

        字符串的比较是常见操作之一，Java中总共提供了4中方式：

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

// 对于引用类型变量，==比较两个引用变量引用的是否为同一个对象
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

        注意：对于基本数据类型，==比较的是变量中的值；对于引用类型（数组，string类）==比较的是引用中的地址。

        2. boolean equals(Object anObject) 

        方法：按照字典序比较（字符大小的顺序）

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

// equals比较：String对象中的逐个字符
// 虽然s1与s2引用的不是同一个对象，但是两个对象中放置的内容相同，因此输出true
// s1与s3引用的不是同一个对象，而且两个对象中内容也不同，因此输出false
System.out.println(s1.equals(s2)); // true
System.out.println(s1.equals(s3)); // false
}

         equals比较：String对象中的逐个字符

        3. int compareTo(String s)

        方法: 按照字典序进行比较，与equals不同的是，equals返回的是boolean类型，而compareTo返回的是int类型。

        具体比较方式： 1. 先按照字典次序大小比较，如果出现不等的字符，直接返回这两个字符的大小差值 2. 如果前k个字符相等(k为两个字符长度最小值)，返回值两个字符串长度差值

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.compareTo(s2)); // 不同输出字符差值-1
System.out.println(s1.compareTo(s3)); // 相同输出 0
System.out.println(s1.compareTo(s4)); // 前k个字符完全相同，输出长度差值 -3
}

         4. int compareToIgnoreCase(String str)

        方法：与compareTo方式相同，但是字符串对象忽略大小写比较

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 字符串查找 

public static void main(String[] args) {
String s = "aaabbbcccaaabbbccc";
System.out.println(s.charAt(3)); // 'b'
System.out.println(s.indexOf('c')); // 6
System.out.println(s.indexOf('c', 10)); // 15
System.out.println(s.indexOf("bbb")); 
}

1.4 转化 

        1. 数值和字符串转化

// 数字转字符串
String s1 = String.valueOf(1234);
String s2 = String.valueOf(12.34);


// 字符串转数字
// 注意：Integer、Double等是Java中的包装类型，这个后面会讲到
int data1 = Integer.parseInt("1234");
double data2 = Double.parseDouble("12.34");

        Integer、Double等是Java中的包装类型 

        2. 大小写转换

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

        3. 字符串转数组

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);
}

4. 格式化 

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

1.5 字符串替换 

        使用一个指定的新的字符串替换掉已有的字符串数据，可用的方法如下：

注意事项: 由于字符串是不可变对象, 所以不能再原来字符串的基础上按照我们的需求进行更改,最终显示出来的字符串是在堆里面新创建出来的字符串 

1.6 字符串拆分

        可以将一个完整的字符串按照指定的分隔符划分为若干个子字符串

1、String[] split(String regex)-------> 将字符串全部拆分

public class Main {
    public static void main(String[] args) {
        String str = "hello world hello smallye" ;
        String[] result = str.split(" ") ; // 按照空格拆分
        for(String s: result) {
            System.out.println(s);
        }
    }
}

 

2、String[] split(String regex, int limit) ------------>将字符串以指定的格式，拆分为limit组

public class Main {
    public static void main(String[] args) {
        String str = "hello world hello smallye" ;
        String[] result = str.split(" ",2) ;
        for(String s: result) {
            System.out.println(s);
        }
    }
}

        3、有些特殊字符作为分割符可能无法正确切分, 需要加上转义

String str = "192.168.1.1" ;
String[] result = str.split("\\.") ;
for(String s: result) {
System.out.println(s);
}

1.7 字符串截取

        从一个完整的字符串之中截取出部分内容。可用方法如下 ：

        1、String substring(int beginIndex) 从指定索引截取到结尾

         2、String substring(int beginIndex, int endIndex) 截取部分内容

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

注意事项:

        1. 字符串截取索引从0开始

        2. 注意前闭后开区间的写法, substring(0, 5) 表示包含 0 号下标的字符, 不包含 5 号下标，下图为执行结果。

 

1.8 其他操作方法

2、细说字符串的不可变性

        String是一种不可变对象. 字符串中的数据内容是不可改变。原因如下：  

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

//在ided中，连续按三遍shift键，出现搜索框；

        string类首先是被final修饰的，其次string类对象的引用的存放地址（char型数组）也是也是被final所修饰的。 （可能不太对，我的理解）

        String类中的字符实际保存在内部维护的value字符数组中，该图还可以看出 ：

        1. String类被final修饰，表明该类不能被继承

        2. value被修饰被final修饰，表明value自身的值不能改变，即不能引用其它字符数组，但是其引用空间中的内容可以修改。

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

Q：字符串不可变是因为其内部保存字符的数组被final修饰了，因此不能改变。

A:这种说法是错误的，不是因为String类自身（其内部value被final修饰而不能被修改） 。首先final修饰类表明该类不想被继承，其次final修饰引用类型表明该引用变量不能引用其他对象，但是其引用对象中的内容是可以修改的。

Q：为什么 String 要设计成不可变的?(不可变对象的好处是什么?)  

A：1. 方便实现字符串对象池. 如果 String 可变, 那么对象池就需要考虑写时拷贝的问题了.

        2. 不可变对象是线程安全的.

        3. 不可变对象更方便缓存 hash code, 作为 key 时可以更高效的保存到 HashMap 中.

all in all：

        字符串相加得到新的字符串，该新的字符串存放于新的对象里面，原来的字符串依旧没有发生变化。若我们要修改str对象的字符串，我们只能通过string的原函数中的value [ ]变量来修改，但是由于该变量是有private修饰的，我们不能通过修改value [ ]来在str对象里面修改其对应的值。所以字符串中的替换原理就是在原来对象的基础上替换好我们要替换的字符后生成一个新的对象返回到replace方法中。

3 StringBuilder和StringBuffer

3.1 StringBuilder的介绍

        由于String的不可更改特性，为了方便字符串的修改，Java中又提供StringBuilder和StringBuffer类。这两个类大 部分功能是相同的，下面介绍 StringBuilder常用的一些方法，

public class Main {
    public static void main(String[] args) {
        StringBuilder sb1 = new StringBuilder("hello");
        StringBuilder sb2 = sb1;// 追加：即尾插-->字符、字符串、整形数字
        sb1.append(' '); // hello
        sb1.append("world"); // hello world
        sb1.append(123); // hello world123
        System.out.println(sb1); // hello world123
        System.out.println(sb1 == sb2); // true
        System.out.println(sb1.charAt(0)); // 获取0号位上的字符 h
        System.out.println(sb1.length()); // 获取字符串的有效长度14
        System.out.println(sb1.capacity()); // 获取底层数组的总大小
        sb1.setCharAt(0, 'H'); // 设置任意位置的字符 Hello world123
        sb1.insert(0, "Hello world!!!"); // Hello world!!!Hello world123
        System.out.println(sb1);
        System.out.println(sb1.indexOf("Hello")); // 获取Hello第一次出现的位置
        System.out.println(sb1.lastIndexOf("hello")); // 获取hello最后一次出现的位置
        sb1.deleteCharAt(0); // 删除首字符
        sb1.delete(0,5); // 删除[0, 5)范围内的字符
        String str = sb1.substring(0, 5); // 截取[0, 5)区间中的字符以String的方式返回
        System.out.println(str);
        sb1.reverse(); // 字符串逆转
        str = sb1.toString(); // 将StringBuffer以String的方式返回
        System.out.println(str);
    }
}

        从代码可以看出：String和StringBuilder最大的区别在于String的内容无法修改，而StringBuilder的内容可以修改。故此频繁修改字符串的情况考虑使用StringBuilder。

注意：

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

        2、StringBuilder变为String: 调用toString()方法。 

Q: String、StringBuffer、StringBuilder的区别?

A:

        1、Stringbuilder和stringbuffer相较于string的优点：前二者返回值的地址是一样的，在里面多次使用append添加其它字符时，直接添加到同一个地址里面，但是后者在进行添加时再不停的额创造和销毁新的地址，且后者最终返回的地址是新创建的地址。

        2、三者的区别：

        2.1前两者的对象创建出来后修改完是可变的，string的对象是不可变的。

        2.3两者的方法不一样：

Stringbuffer方法前面有synchronized修饰，主要是让该方法保证线程安全。该方法在多线程使用时由于频繁的开锁和关锁会造成资源的浪费。

Stringbuilser：不是一个线程安全的方法。

ps：本次内容就到这里了，还请大家点赞，投币，关注，一键三连哦！

给大家安利一下b站up主紫菜xixixi，向自律的人看齐，你就会自律哦！