Java常用类（二）（String类)

追梦的烟火

已于 2022-06-03 20:32:09 修改

阅读量487

点赞数

于 2021-11-22 22:20:41 首次发布

本文链接：https://blog.csdn.net/m0_61470267/article/details/121407642

版权

java基础同时被 2 个专栏收录

16 篇文章 0 订阅

订阅专栏

API

4 篇文章 0 订阅

订阅专栏

1. String 类

由多个字符组成的一串数据，值一旦创建，不可改变。

private final char value[];

String s = "abc"; 底层：char[] c = {'a','b','c'};

s+= 'def';

s+= 'gh';

s+='aaa';

每一步都创建一个新对象。

一旦值改变，就会创建一个新对象。

创建：

（1）简单的创建方式

String s = "abc";

先去字符串常量池中查找，有没有abc，如果没有就在字符串常量中创建一个新的对象（abc），

如果字符串常量中已经存在，那么直接指向已有的对象即可。

（2）new + 构造方法

String s1 = new String();

String s2 = new String();

凡是new出来的对象，在内存空间是独一无二的。

public class StringDemo1 {

    public static void main(String[] args) {
     
        /*
          String对象的创建方法:
          1.String s = "abc";
          2.String s1 = new String();
         */

         
         // 1. 简化的创建方式
            String s = "abc";
            String s1 = "abc";
            System.out.println(s==s1);//true
            System.out.println(s.equals(s1));//true
         
          // 2. new +构造方法
            String s3 = new String("abc");
            String s4 = new String("abc");
            System.out.println(s3==s4); //false
            System.out.println(s3.equals(s4)); //true
    }
}

1.1 构造方法

public String()
public String(String str)
public String(byte[] bytes)
public String(char[] value)


        构造方法：
         public String() {
            this.value = "".value;
        }
        String("字符串")
         public String(String original) {
            this.value = original.value;
            this.hash = original.hash;
       
        }
        String s1 = "abc";
        String s2 = new String("abc");

1.2 判断功能

boolean equals(Object obj)
boolean equalsIgnoreCase(String str)
boolean contains(String str)
boolean isEmpty()
boolean startsWith(String prefix)
boolean endsWith(String suffix)

public class StringDemo1 {
    public static void main(String[] args) {
        String s1 = "abc";
        String s2 = new String("abc");
        String s3 = new String("abC");
//       判断功能方法：
        //比较字符串内容是否相等
        System.out.println(s1.equals(s2));//true
        //比较字符串内容是否相等（忽略大小写）
        System.out.println(s1.equalsIgnoreCase(s3));//true
//        判断是否包含指定的子串
        System.out.println(s1.contains("c"));//true
//        判断是否为空（""）
        System.out.println(s1.isEmpty());//false
//        判断以指定字符串开头
        System.out.println(s1.startsWith("ab"));//true
//        从指定位置开始，判断以指定字符串开头
        System.out.println(s1.startsWith("ab", 0));//true
//        判断以指定字符串结束
        System.out.println(s1.endsWith("bc"));//true

        System.out.println(s1.startsWith("ab", 0));//true
        String s4 = new String("def");
        //字符串比大小
        System.out.println(s1.compareTo(s4));//-3


    }
}

1.3 获取功能

int length()
char charAt(int index)
int indexOf(String str)
int indexOf(String str,int fromIndex)
String substring(int start)
String substring(int start,int end)

public class StringDemo2 {
    public static void main(String[] args) {
        //获取功能
        String s1 = "abcdefgd";
        //           01234567
        System.out.println(s1.length());//8
//        获取指定位置（索引）的字符
        char ch = s1.charAt(4);
        System.out.println(ch);//e
//        从前向后找，只找首次出现的位置
        int index1 = s1.indexOf("d");
        System.out.println(index1);//3
//        从前向后找，从指定位置开始
        int index2 = s1.indexOf("d", index1 + 1);
        System.out.println(index2);//7
//        从后向前查找，首次出现的位置
        int index3 = s1.lastIndexOf("d");
        System.out.println(index3);//7
//        从指定的位置开始截取字符串，直到最后一位，最终返回一个新的字符串对象
        String s2 = s1.substring(3);
        System.out.println(s1);//abcdefgd
        System.out.println(s2);//defgd

//        截取指定区间，包含开始位置，不包含结束位置
        String s3 = s1.substring(2,6);
        System.out.println(s3);//cdef
    }
}

1.4 转换功能

byte[] getBytes()
char[] toCharArray()
static String valueOf(char[] chs)
String toLowerCase()
String toUpperCase()
String concat(String str)
Stirng[] split(分割符);

import java.io.UnsupportedEncodingException;
import java.util.Arrays;

public class StringDemo3 {
    public static void main(String[] args) throws UnsupportedEncodingException{
        String s = "你好";//默认为UTF-8编码，其中一个汉字占3个字节
//        编码和解码不一致，导致出现乱码
        byte[] b = new byte[0];
        b = s.getBytes("UTF-8");
        System.out.println(Arrays.toString(b));//[-28, -67, -96, -27, -91, -67]

        String s1 = new String(b,"UTF-8");
        System.out.println(s1);//你好

        String s2 = new String(b,3,3,"UTF-8");
        System.out.println(s2);//好

        String str = "abcdef";
//        将字符串转换为一个新的char数组
        char[] ch = str.toCharArray();
        System.out.println(Arrays.toString(ch));//[a, b, c, d, e, f]
//       将char 数组 转为字符串
        String str1 = new String(ch);
        System.out.println(str1);//abcdef
        String str2 = String.valueOf(ch);
        System.out.println(str2);//abcdef

        String str3 = "ABCdefg";
//        转大写
        System.out.println(str3.toUpperCase());//ABCDEFG
//        转小写
        System.out.println(str3.toLowerCase());//abcdefg
        // + 可以连接其他类型
        String str4 = str3.concat("abc");
        System.out.println(str4);//ABCdefgabc

//        按照指定的分隔符，将字符串拆分成数组
        String strs = "abc:cdef:fgh";
        String[]  strings = strs.split(":");
        System.out.println(Arrays.toString(strings));//[abc, cdef, fgh]

    }
}

1.5 替换功能

String replace(char old,char new)
String replace(String old,String new)
replaceAll(String regex, String replacement)
replaceFirst(String regex, String replacement)

public class ApiDemo {
    public static void main(String[] args) {
        String s = "abcdefrgcba";
        /*
        target: 连续的字符串
        regex: 规则（正则表达式模式匹配）
         */
        //字符串的替换
        String s1 = s.replace("c", "C");
                              // target 
        System.out.println(s1.replace('a', 'b'));//bbCdefrgCbb
        System.out.println(s1);//abCdefrgCba
        String s2 = "abc12345";
        //替换所有符合规则的字符串
        System.out.println(s2.replaceAll("\\d", "D"));//abcDDDDD
                                          //regex
        String s3 = "abc12345";
        //替换符合规则的第一个字符串
        System.out.println(s3.replaceFirst("\\d", "A"));//abcA2345
    }
}

1.6 去除字符串两空格

String trim()

只能去掉收尾两端的空格，中间的空格不能去掉。

public class ApiDemo {
    public static void main(String[] args) {
        String  s4 = "  abc def   ";
        System.out.println(s4.length());//12
        System.out.println(s4.trim());//abc def
        System.out.println(s4.trim().length());//7
    }
}

2. StringBuffer

StringBuffer ：线程安全，可变的字符序列。只变底层的char 数组。

char[ ] value

初始容量默认为16

可变的字符序列：当向StringBuffer 中添加内容时，是将内容添加到底层的数组中，数组没有被final 修饰，当数组装满时，会创建一个新的数组，将新的数组之地给底层的数组，StringBuffer 对象的地址不会发生改变。

源码：

char[] value;
public synchronized int capacity() {
     return value.length;
}
public StringBuffer(String str) {
      super(str.length() + 16);
      append(str);
}
public StringBuffer() {
      super(16);
}
public StringBuffer(int capacity) {
      super(capacity);
}

2.1 构造方法

public StringBuffer() {
      super(16);
}
public StringBuffer(String str) {
      super(str.length() + 16);
      append(str);
}

2.2 添加功能

public StringBuffer append(String str)

public StringBuffer insert(int offset,String str)

2.3 替换功能

public StringBuffer replace(int start,int end,String str)

2.4 删除功能

public StringBuffer deleteCharAt(int index)

public StringBuffer delete(int start,int end)

2.5 反转功能

public StringBuffer reverse()

2.6 截取功能

public String substring(int start)

public String substring(int start,int end)

package javaapi4;

public class ApiDemo2 {
    public static void main(String[] args) {
      //指定StringBuffer的默认值为20;
        StringBuffer stringBuffer1 = new StringBuffer(20);
        /*
        添加功能
         */
        StringBuffer stringBuffer = new StringBuffer("abcd");
        //向末尾添加字符串
        System.out.println(stringBuffer.append(5));// abcd5
        //向指定位置添加字符串
        System.out.println(stringBuffer.insert(2, "xyz"));// abxyzcd5
        /*
        替换功能
         */
        //将指定区域替换成指定字符串
        System.out.println(stringBuffer.replace(1, 3, "ccc"));//acccyzcd5
        /*
        删除功能
         */
        //删除指定位置的字符
        System.out.println(stringBuffer.deleteCharAt(4));// accczcd5
        //删除指定区域的字符串（包含起始位置，不包含结束位置）
        System.out.println(stringBuffer.delete(2, 5));// accd5
        /*
        反转功能
         */
        //将字符串逆序
        System.out.println(stringBuffer.reverse());// 5dcca
        /*
        截取功能
         */
        //从指定位置开始截取字符串
        String s1 = stringBuffer.substring(3);
        System.out.println(s1);//ca
        //截取指定区域字符串，包含开始位置，不包含结束位置
        String s2 = stringBuffer.substring(1,3);
        System.out.println(s2);//dc
        
        //返回是实际存在的数组中的字符个数
        System.out.println(stringBuffer.length());// 返回是实际存在的数组中的字符个数 5
    }
}

3. StringBuilder

线程不安全，可变的字符序列。

其构造方法与功能与StringBuffer相似。

4. String ，StringBuffer 和 StringBuilder

String：字符序列不可变，底层使用char[ ] 数组实现

适用于少量字符串的使用

字符串的每次使用都会创建一个新的对象

final类，不可别继承

StringBuffer：可变的字符序列，底层使用char[ ] 数组实现

适用于大量字符串的使用

任何对它指向的字符串的操作都不会产生新的对象

适用于多线程下的字符串操作

使用同步锁（synchronized）

final类，不可别继承

StringBuilder：可变的字符序列，底层使用char[ ] 数组实现

适用于大量字符串的使用

任何对它指向的字符串的操作都不会产生新的对象

适用于单线程的字符串操作

final类，不可别继承

附加：

线程安全：多个线程对同一资源进行访问时。

同一时间内，有多个线程对同一资源进行访问，可以同时进入多个线程，但是不安全，需要使用同步锁（只允许进入一个）。在同一时间只能有一个线程对同一资源进行访问。（使用StringBuffer）

同一时间内，只有一个线程对同一资源进行访问（使用StringBuilder）

追梦的烟火

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Java常用类（二）（String类)

1. String 类由多个字符组成的一串数据，值一旦创建，不可改变。private final char value[];String s = "abc"; 底层：char[] c = {'a','b','c'}; s+= 'def'; s+= 'gh'; s+='aaa';每一步都创建一个新对象。一旦值改变，就会创建一个新对象。创建：（1）简单的创建方式String s = "abc";先去字符串......
复制链接

扫一扫