String StringBuffer StringBulider三类的特点以及比较

（看完还不明白顺着网线来捶我）)

String StringBuffer StringBulider三类

String

Strin类创建对象

两种方式

1. 字面量方式
2. new+构造器

 String str1 = new String("hello");
 String str2 = "hello";
 String str3 = "HelloWorld";
  String str4 = new String("HelloWorld");
 

内存方式

String 内容是存放在常量池中的。
而常量池位置是不同的。
jdk1.6常量池在方法区
jdk1.7常量池在堆内存
jdk1.8常量池在元空间（Sun公司的HotSpot虚拟机）

 String str1 = new String("hello");

这种方式创建String类的对象是用new的方式，栈保存堆空间的地址值，堆空间保存方法区常量池的地址值。最终字符串还是在常量池中

String str1 = "hello";

这种方式创建String类的对象是用字面量方式直接在常量池中创建

String类的特性

String：字符串使用一堆""来表示

1. 字符串常亮池中不会保存相同内容的字符串

2. String类声明为final的不可以继承

3. String实现了Serialiazable接口，表示可以序列化
   实现了Comparable皆苦，表示可以比较大小的

4. String内部定义了finale char[] value 用于存放字符串数据

5. String：代表不可变的字符序列。

   • 当堆字符串重新赋值时，需要重写指定内存区域赋值，不能再远属性的Value进行赋值
   • 堆当前现有的字符串进行连接操作时，也需要重新指定内促区域赋值。
   • 当用String调用repla（）方法改变内容时，也需要重新指定内存区域赋值

/**
* @Author： 冀十三
* @DescIption： Strng类不可变性演示
* @Date:2021--06--14--15:12
*/
 String  s1 = "hello";
       String  s2 = "world";
       String  s3 = "helloworld";
       String  s4 = "hello"+"world";
       String  s5 = "hello"+s2;
       String  s6 = s1+"world";
       String  s7 = s1+s2;         // 执行结果
       System.out.println(s3==s4);  //(true)
       System.out.println(s3==s5);  //(false)
       System.out.println(s3==s6);  //(false)
       System.out.println(s3==s7);  //(false)
       System.out.println(s5==s6);  //(false)
       System.out.println(s6==s7);  //(false)

结论

• 常亮与常亮拼接（两个字面量）结果在常量池中，且常亮不存在相同内容的常亮
• 只要有一个是变量（有变量名参与），结果就在堆中开辟

例外intern（方法）

• intern（）方法返回值是在常量池中已经存在的常亮

String s8 = s5.intern();     // 执行结果
 System.out.println(s8==s3);  // (true)

String类的常用方法

方法演示

/**
 * @Author： 冀十三
 * @DescIption： Strng方法演示
 * @Date:2021--06--14--15:12
 */
String  s1 = "HelloWorld";
        String  s2 = "   He  llo  Wo  rld  ";
        String  s3 = "abca";
        String  s4 = "abcz";

        System.out.println(s1.length());
        //返回int型，字符串长度(Return Value.length)（10）

        System.out.println(s1.charAt(5));
        //返回char型，数组中指定第几个(return value[index])需要满足长度否则报错（W）

        System.out.println(s1.isEmpty());
        //返回boolean型，判断是否为空（return Value.length==0 ）（false）

        System.out.println(s1.toLowerCase());
        //返回String型，将所有大写转换为小写（helloworld）

        System.out.println(s1.toUpperCase());
        //返回String型，将所有小写转换为大写（HELLOWORLD）

        System.out.println(s2.trim());
        //返回String型，忽略前后的空白（He  llo  Wo  rld）

        System.out.println(s1.toLowerCase().equals(s1.toUpperCase()));
        //返回boolean型，比较两个是否相同（false）

        System.out.println(s1.toLowerCase().equalsIgnoreCase(s1.toUpperCase()));
        //返回boolean型，忽略大小写比较两个是否相同（true）

        System.out.println(s1.concat(s2));
        //返回String型，将指定字符串连接到末尾等同于+（HelloWorld   He  llo  Wo  rld）

        System.out.println(s3.compareTo(s4));
        //返回int型， 实质上是对于两个字符串的元素相比如果不等做差（根据ASCII）做差(-25)

        System.out.println(s1.substring(3));
        //返回String型，从begIndex（包含）开始截取到末尾最后一个结束。（loWorld）

        System.out.println(s1.substring(3,6));
        //返回String型，从begIndex（包含）开始截取到endIndex（不包含）结束。（loW）

        System.out.println(s1.endsWith("World"));
        //返回boolean型，检测是否以指定字符串结束(true)

        System.out.println(s1.startsWith("Hello"));
        //返回boolean型，检测是否以指定字符串开始(true)

        System.out.println(s1.startsWith("Wor", 5));
        //返回boolean型，检测是否以指定位置的子字符串是否以指定字符串开始(true)

        System.out.println(s1.contains("oWo"));
        //返回boolean型，检测是否包含指定的char值序列(true)

        System.out.println(s1.indexOf("llo"));
        //返回int型，（从前往后）返回指定子字符串的首次出现的索引（如果没有找到返回-1）（2）

        System.out.println(s1.indexOf("llo", 7));
        //返回int型，（从前往后）返回指定子字符串从指定位置开始向后的首次出现的索引（如果没有找到返回-1）（-1）

        System.out.println(s1.lastIndexOf("l"));
        //返回int型，（从后往前）返回指定子字符串的首次出现的索引（如果没有找到返回-1，这里的索引值还是从前往后数的）（8）

        System.out.println(s1.lastIndexOf("l",7));
        //返回int型，从指定位置（从后往前）返回指定子字符串的首次出现的索引（如果没有找到返回-1，这里的索引值还是从前往后数的）（3）

        System.out.println(s1.replace("oWo", "LoL"));
        //返回String型，根据参数匹配修改原本字符串中的内容返回新的字符串，参数为（target，replacment）（HellLoLrld）

        System.out.println(s3.replace('a', 'z'));
        //返回String型，根据参数匹配修改原本字符串中的内容返回新的字符串，参数为（olechar，newchar）（zbcz）

        System.out.println(s3.replaceAll("[a-z]", "123"));
        //返回String型，用正则表达式匹配修改原本字符串中的内容返回新的字符串，参数为（regex，replacment）（123123123123）

        System.out.println(s1.matches("([A-Z])\\w+"));
        //返回boolean型，用正则表达式检查字符串是否完全匹配，参数为（regex）（true）

        String[] split = s2.split("\\s");
        for (int i = 0; i < split.length; i++) {
            System.out.println(split[i]);
        }
        //这里是对数组根据正则表达式进行切割返回一个数组(这里我用\\s是匹配了数组s2中的空格来切割)
        //遍历输出结果为
        // He
        //
        //llo
        //
        //Wo
        //
        //rld

String类转换

字符串转换数据类型，包装类

• Strigl类转换int型
• 需要转换成什么类型就调用那个类型包装类的静态方法parseXXX（String str）

String str1 = "12345";
int i1 = Integer.parseInt(str1);
double d1 =Double.parseDouble(str1) ;

数据类型，包装类转换字符串

• 需要转换那个类型就使用String类的重载方法valueOf()
• z直接该数字加上空的字符串

int i2 = 34567;
String str2 = String.valueOf(i2);
String str3 = ""+i2;

字符串转换char[]数组

• 使用String的toCharArry()方法

String str1 = "12345";
char[] char1 = str1.toCharArray();

char[]数组转换字符串

• 使用String 的构造器

String str1 = "12345";
char[] char1 = str1.toCharArray();
String str2 = new String(char1);

字符串转换byte[]数组

• 使用String的getBytes()方法

String str1 = "123abc";
byte[] bytes = str1.getBytes() //默认编码集;
System.out.println(Arrays.toString(bytes));
//结果（[49, 50, 51, 97, 98, 99]）
try {
           byte[] bytes1 = str1.getBytes("GB2312");//可以指定编码集但是会抛出异常
       } catch (UnsupportedEncodingException e) {
           e.printStackTrace();
       }

byte[]数组转换字符串

• 使用String 的构造器

String str1 = "123abc";
        byte[] bytes = str1.getBytes();
        String str2 = new String(bytes);

StringBuffer和StringBulider

因为这两个类很接近所以放一块讲
可变的字符串

创建对象

StringBuffer sbf1 = new StringBuffer("hello");
StringBuilder sbd1 = new StringBuilder("helloWorld");

可以添加数据数据类型可以是任意基本数据类型也可以是字符串

StringBuffer sbf1 = new StringBuffer("hello");
StringBuilder sbd1 = new StringBuilder("helloWorld");
sbf1.append(1230f);
sbd1.append(5555d);
System.out.println(sbf1);//结果(hello1230.0)
System.out.println(sbd1);//结果(hello1230.0)
System.out.println(sbf1.length());//结果(11)
System.out.println(sbd1.length());//结果(16)

可变机制

StringBuffer sbf1 = new StringBuffer("hello");
//当有参数是将创建参数内容数目再加上长度16
StringBuffer sbf1 = new StringBuffer("");
用构造器的时候相当于创建一个char[16],长度为16的char型数组

可变机制扩容问题

• 当使用append方法加入内容但是内存不够的情况下他会自动扩容
• 新创建一个人字符串容量是当前容量的2倍并且加2，并将原本的移入新的

**扩容源码**
int oldCapacity = value.length >> coder;
 if (minimumCapacity - oldCapacity > 0) {
value = Arrays.copyOf(value,
newCapacity(minimumCapacity) << coder);

StringBuffer和StringBulider常用方法

因为常用方法很接近这里以StringBuffer为例

   StringBuffer sbf1 = new StringBuffer("HelloWorld");
        System.out.println(sbf1.append(5678));
        //添加（HelloWorld5678）

        System.out.println(sbf1.delete(10, sbf1.length()));
        //删除指定int start 到int end 的内容（HelloWorld)

        System.out.println(sbf1.replace(4, 7, "LOL"));
        //替换指定指定int start 到int end的内容为str（HellLOLrld）

        System.out.println(sbf1.insert(4, "Play"));
        //在指定位置插入可以插入数据类型也可以插入字符串和append适用范围一样（HellPlayLOLrld）

        System.out.println(sbf1.reverse());
        //逆转字符串序列（dlrLOLyalPlleH）

这里仅举例几个，多数String类的方法StringBuffer以及StringBuliderr也可以用

String和StringBuffer以及StringBulider的比较

你学会了吗
会了麻烦点个赞支持下一下谢谢