JAVA热点基础大盘点＜剖析字符串类＞

Posted 2021-07-31 沉默着忍受

JAVA热点基础大盘点（二）

友友萌，今天我们需要深度的学习java的比较常用的类，不管是平时的算法练习，还是项目的构建都是非常非常重要的。

---

文章目录

• JAVA热点基础大盘点（二）
• 前言
• 一、String类；
• • 1.1 String类 的坑：
  • • 1.1.1 String比较方法
    • 1.1.2 在看String 类，equal（）方法；
  • 1.2 String类 操作
  • • 1.2.1 和长度有关的方法
    • 1.2.2 和数组有关的方法
    • 1.2.3 和判断有关的方法
    • 1.2.4 和改变内容有关的方法
    • 1.2.5 由基本数据型态转换成String
    • 1.2.6 String 转换成 数字的基本数据型态
    • 1.2.7 String与new String()的区别
• 二. StringBuffer类：
• • 2.1 StringBuffer类的理解：
  • 2.2 StringBuffer类的使用：
  • • 2.2.1、构造函数：
    • 2.2.2、长度运算：
    • 2.2.3、获取与修改字符：
    • 2.2.4、获取子字符串：
    • 2.2.5、追加字符或字符串：
    • 2.2.6、插入字符：
    • 2.2.7、字符串翻转：
    • 2.2.8、删除字符和字符串：
    • 2.2.9、替换字符串：
• 三. StringBulider类：
• • 3.1 StringBulider类的理解；
  • 3.2 举例
  • • 3.2.1、创建
    • 3.2.2、添加
    • 3.2.3、链式编程写法
    • 3.2.4、反转字符串
    • 3.2.5、StringBuilder 转换 String
    • 3.2.6、String 转换 StringBuilder
    • 3.2.7、得到字符长度
    • 3.2.7、截取字符串
• 四.结束

---

前言

你知道的愈多，你不知道的越多。应某个小粉丝的反馈，对于一些基础概念的类不是很了解，本人专注java基础解析，就来为大家解惑

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、String类；

1.1 String类 的坑：

String常常用来定义字符串类型，那么我们来看一看下面的实例看看：

public class Demo {
    public static void main(String[] args) {
        String s = "1";
        char s1 = '1';
        int a =1;
    }
}

这里我定义了三个变量，String类，char类型，int类型。
其中，char,int 是8大基本类型，并不是类；（。。。。。。。。）加一句，java中8大类型都有什么？

我给友友萌上个图，自己理解！

我们通过上面可以观察，就可以看出String不是基本类型！不可以参与基本类型的一些转化和计算！
那么问题就来了，如果我想进行转化和计算我要干什么？

1.1.1 String比较方法

问题：String 比较两个值是否相等是用“==”吗？代码给你演示演示！

public class Demo {
    public static void main(String[] args) {
        String s = "1";
        String s1 = "1";
        if(s==s1){
            System.out.println("s==s1");
        }else{
            System.out.println("s!=s1");
        }
    }
}
/*
* 结果：
* s==s1

Process finished with exit code 0
* */

相等！你没有看错！所以我们可以使用==来比较俩个不同的String对象是否相等。
但是我可以告诉你，这里的比较压根和1没有任何关系！你入坑了！
继续来一段代码；

public class Demo {
    public static void main(String[] args) {
        String s = new String("1");
        String s1 = new String("1");

        if(s==s1){
            System.out.println("s==s1");
        }else{
            System.out.println("s!=s1");
        }
    }
}
/*
* 结果：
*s!=s1

Process finished with exit code 0
* */

服了，我明明两个对象的初始值都是1啊，怎么不相等了呢？来来来，我给你画个图。

第一段代码，我是将"1"的内存地址赋值给s,s1。此时s,s1就指向了“1”的地址，所以使用==是相等的。

第二块代码，我们使用的是new String(“1”);那么new 出来相当于独立的创建了另一块空间，那么地址就不样了，比较的是地址值，那么当然是不相等的。
所以String 如果比较对象是不是同一个空间，那么“”就可以进行比较，如果要比较两个对象内的值是否相等，那么就不可以使用“==”来进行比较。这就要实现String重写equals()方法的意义了！

1.1.2 在看String 类，equal（）方法；

jdk8中String重写Object中的equal()方法；

  public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

那我就好奇了，原来的equal()实现了什么？我们来看一看Object的原生equal()方法：

 private static boolean equels(Objuct anObject) {
        return this.anObject==anObject;
    }

我去，这不是脱了裤子放屁吗？就是说，jdk源码中equals()就是返回了==的结果。。。。。。。
好了我们现在知道了，String比较方法equals();我们来运行一下，比较比较；

    public static void main(String[] args) {
        String s = new String("1");
        String s1 = new String("1");

        if(s==s1){
            System.out.println("s==s1");
        }else{
            System.out.println("s!=s1");
        }
        System.out.println("======================");
        System.out.println("使用equals");
        if(s.equals(s1)){
            System.out.println("s==s1");
        }else {
            System.out.println("s!=s1");
        }
        
    }

结果：

使用==
s!=s1
======================
使用equals
s==s1

这不就对了吗？你理解了吗？

1.2 String类 操作

1.2.1 和长度有关的方法

返回类型 方法名 作用

int length() 得到一个字符串的字符个数（一个中文是一个字符，一个英文是一个字符，一个转义字符是一个字符）

1.2.2 和数组有关的方法

返回类型 方法名 作用

byte[] getBytes() 将一个字符串转换成字节数组

char[] toCharArray() 将一个字符串转换成字符数组

String[] split(String) 将一个字符串按照指定内容劈开

1.2.3 和判断有关的方法

返回类型 方法名 作用

boolean equals(String) 判断两个字符串的内容是否一模一样

boolean equalsIgnoreCase(String) 忽略大小写的比较两个字符串的内容是否一模一样

boolean contains(String) 判断一个字符串里面是否包含指定的内容

boolean startsWith(String) 判断一个字符串是否以指定的内容开头

boolean endsWith(String) 判断一个字符串是否以指定的内容结尾

1.2.4 和改变内容有关的方法

和改变内容有关的方法，都不会直接操作原本的字符串 而是将符合条件的字符串返回给我们，所以注意接收

返回类型 方法名 作用

String toUpperCase() 将一个字符串全部转换成大写

String toLowerCase() 将一个字符串全部转换成小写

String replace(String,String) 将某个内容全部替换成指定内容

String replaceAll(String,String) 将某个内容全部替换成指定内容，支持正则

String repalceFirst(String,String) 将第一次出现的某个内容替换成指定的内容

String substring(int) 从指定下标开始一直截取到字符串的最后

String substring(int,int) 从下标x截取到下标y-1对应的元素 String trim() 去除一个字符串的前后空格

和位置有关的方法
返回类型 方法名 作用

char charAt(int) 得到指定下标位置对应的字符

int indexOf(String) 得到指定内容第一次出现的下标

int lastIndexOf(String) 得到指定内容最后一次出现的下标

1.2.5 由基本数据型态转换成String

String 类别中已经提供了将基本数据型态转换成 String 的 static 方法 ，也就String.valueOf() 这个参数多载的方法

1、String.valueOf(boolean b) : 将 boolean 变量 b 转换成字符串

2、String.valueOf(char c) : 将 char 变量 c 转换成字符串

3、String.valueOf(char[] data) : 将 char 数组 data 转换成字符串

4、String.valueOf(char[] data, int offset, int count) : 将 char 数组 data 中 由 data[offset] 开始取 count 个元素 转换成字符串

5、String.valueOf(double d) : 将 double 变量 d 转换成字符串

6、String.valueOf(float f) : 将 float 变量 f 转换成字符串

7、String.valueOf(int i) : 将 int 变量 i 转换成字符串

8、String.valueOf(long l) : 将 long 变量 l 转换成字符串

9、String.valueOf(Object obj) : 将 obj 对象转换成 字符串, 等于 obj.toString()

1.2.6 String 转换成 数字的基本数据型态

要将 String 转换成基本数据型态转 ，大多需要使用基本数据型态的包装类别
比如说 String 转换成 byte ，可以使用 Byte.parseByte(String s) ，这一类的方法如果无法将 s 分析 则会丢出 NumberFormatException

1、byte : Byte.parseByte(String s) : 将 s 转换成 byte

2、byte : Byte.parseByte(String s, int radix) : 以 radix 为基底 将 s 转换为 byte ，比如说 Byte.parseByte(“11”, 16) 会得到 17

3、double : Double.parseDouble(String s) : 将 s 转换成 double

4、float : Float.parseFloat(String s) : 将 s 转换成 float

5、int : Integer.parseInt(String s) : 将 s 转换成 int

6、long : Long.parseLong(String s)

1.2.7 String与new String()的区别

JVM为了提升性能和减少内存开销，避免字符串的重复创建，维护了一块特殊的内存空间——字符串实例池。

String赋值的两种方式。

1、String str = “test”;

以这种方式赋值时，JVM会先从字符串实例池中查询是否存在"test"这个对象，

如果存在，直接把实例池中"test"的地址返回给str。如果不存在，则会在实例池中创建"test"对象，并把该对象的地址返回给str。
所以通过==比较是，str1，str2指向的是同一地址，所以返回true；

2、String str = new String(“test”);

以这种方式赋值时，JVM会先从字符串实例池中查询是否存在"test"这个对象，

若不存在则会在实例池中创建"test"对象，同时在堆中创建"test"这个对象，然后将堆中的这个对象的地址返回赋给引用str。

若实例池存在则直接在堆中创建"test"这个对象，然后将堆中的这个对象的地址返回赋给引用str。

二. StringBuffer类：

2.1 StringBuffer类的理解：

String类表示的字符串是定长的，而StringBuffer类提供了可变长的字符串，同时还提供了大量的字符串功能。在StringBuffer类的字符串中可以再插入字符，此时，StringBuffer会自动增加内存空间，这在String中是无法做到的。

2.2 StringBuffer类的使用：

2.2.1、构造函数：

StringBuffer(); 采用默认的构造函数，会给字符串预留16个字符空间

StringBuffer(int buffersize); buffersize用来设置缓冲区的大小

StringBuffer(String str); str用来初始化StringBuffer中的内容

2.2.2、长度运算：

length()方法用来得到字符串的长度，capacity()用来得到分配给字符串的容量，它通常比实际字符要预留更多的空间，以允许增加字符。

如果初始化了字符串后，要更改缓冲区大小可用ensureCapacity()方法，这样可以为新增字符串预先分配空间，因为再分配空间的代价是比较大的，而且频繁的分配空间会产生碎片。ensureCapacity的格式如下：

void ensureCapacity(int capacitysize); 其中，capacitysize参数用来指定缓冲区的大小。

要改变字符串的长度可用setLength()方法，其格式如下：

void setLength(int length);其中，参数length指出了要设置的字符串的长度，如果length长度大于原长度，则在新加入长度的空间中设为空格，如果length长度小于原长度，则字符串后面小于原长度部分的字符串将会丢失，使用此方法时要特别注意这一点。

2.2.3、获取与修改字符：

使用charAt()方法可从StringBuffer类的字符串中获取指定的字符；通过setCharAt()方法可以修改StringBuffer类字符串中指定的字符。其格式如下：

char charAt(int position); position指出了要获取的字符在字符串中的下标

void setCharAt(int position,char ch); position是要更改的字符的下标，ch是更改后的字符。

2.2.4、获取子字符串：

用getChars()方法把StringBuffer中的子字符串复制给一个数组，格式如下：

void getChars(int sourceStart,int sourceEnd,char target[],int targetStart);

参数sourceStart是StringBuffer中要提取的字符串开始的下标；参数sourceEnd是结束的下标；target[]是接收子字符串的字符数组；targetStart是开始接收数组的下标。

注意：使用此方法一定要确保target[]数组的长度足够长，以容纳子字符串的内容。

另外，substring()方法也可用于获取StringBuffer的一部分，其调用形式如下：

String substring(int startPosition); 用于返回从startPosition开始到末尾的子字符串；

String substring(int startPosition,int endPosition); 用于返回从startPosition开始到下标endPosition结束的子字符串。

2.2.5、追加字符或字符串：

在StringBuffer尾部追加字符或字符串可使用方法append(),调用的方法有多种，统一表述如下：

StringBuffer append(Object obj); 其中，obj可以是任意类型，比较常用的是一些简单数据类型以及String类，该方法返回追加后的StringBuffer。

2.2.6、插入字符：

用inset()方法可将一个字符串插入到另一个字符串中。常用的有：

StringBuffer insert(int insertIndex,char ch);用来在insertIndex处插入一个字符ch

StringBuffer insert(int insertIndex,String str); 用来在insertIndex处插入一个字符串str。

2.2.7、字符串翻转：

要实现StringBuffer字符串的翻转可用方法reverse(),其格式如下：

StringBuffer reverse(); 返回翻转后的字符串

2.2.8、删除字符和字符串：

删除字符和字符串的方法有两种，如下：

StringBuffer delete(int startPosition,int endPosition); delete()用于删除从startPosition下标开始到endPosition下标结束的字符串，返回删除后的StringBuffer对象

StringBuffer deleteCharAt(int deletePosition); deleteCharAt()用于删除位于deletePosition下标处的字符，返回删除后的StringBuffer对象。

2.2.9、替换字符串：

方法replace()完成用一个字符串取代StringBuffer中的部分字符串的功能。

StringBuffer replace(int startPosition,int endPosition,String str);该方法把StringBuffer中从下标startPosition处开始到下标endPosition处结束的字符串替换为str，返回替换后的StringBuffer对象。

三. StringBulider类：

3.1 StringBulider类的理解；

大家要知道字符串（String）在进行拼接操作时，每一次拼接，都会构建一个新的String对象
这样耗时又浪费内存解决方法就是 StringBuilder 类，就可以解决这个问题StringBuilder 类 中方法和 String类基本一样

3.2 举例

3.2.1、创建

//创建StringBuilder 
 StringBuilder sb = new StringBuilder("老八");
 System.out.print(sb);//输出
123

如果括号里不填默认是空字符串

3.2.2、添加

		//创建StringBuilder
        StringBuilder sb = new StringBuilder("老八");
        //添加
        sb.append("giao");
        sb.append("~");
        sb.append("真男人");
        sb.append(666);
        System.out.print(sb);//输出

3.2.3、链式编程写法

		//创建StringBuilder
        StringBuilder sb = new StringBuilder("老八");
        //添加
        sb.append("giao").append("~").append(666).append("真男人");
        System.out.println(sb);//输出

3.2.4、反转字符串

		//创建StringBuilder
        StringBuilder sb = new StringBuilder("老八");
        //添加
        sb.append("giao").append("~").append(666).append("真男人");
        System.out.println(sb);//输出
        //反转字符串
        sb.reverse();
        System.out.print(sb);//输出反转后的字符串

3.2.5、StringBuilder 转换 String

		//创建StringBuilder
        StringBuilder sb = new StringBuilder("老八");
        //添加
        sb.append("giao").append("~").append(666).append("真男人");
        //StringBuilder 转换 String
       	String xs = sb.toString();
        System.out.println(xs);//输出

3.2.6、String 转换 StringBuilder

String 转换 StringBuilder
		//Spring 转换 StringBuilder
        String lb = "老八";//Spring
        //StringBuilder
        StringBuilder sbnb = new StringBuilder(lb);
        System.out.println(sbnb);//输出

3.2.7、得到字符长度

		//创建StringBuilder
        StringBuilder sb = new StringBuilder("长度");
        System.out.println(sb.length());//输出长度

3.2.7、截取字符串

区间截取不包括参数二中的值，包含参数一中的值

        //创建StringBuilder
        StringBuilder sb = new StringBuilder("老八");
        //添加
        sb.append("giao").append("~").append(666).append("真男人");
        System.out.println(sb);//输出
        //截取
        String substring = sb.substring(1, 5);
        System.out.println(substring);//输出

四.结束

小伙伴们，学习java任重道远。String，Stringbuffer,Stringbulider类的方法，需要在大量代码编写中，深入理解。