java——String和StringBuffer、StringBuilder常用API

最新推荐文章于 2024-07-04 08:43:19 发布

go big

最新推荐文章于 2024-07-04 08:43:19 发布

阅读量325

点赞数

文章标签： java

本文链接：https://blog.csdn.net/xuanxuan9911/article/details/118713965

版权

String和StringBuffer、StringBuilder常用API

一、String

String的特性

String类：代表字符串。Java 程序中的所有字符串字面值（如 “abc” ）都作为此类的实例实现。

String是一个final类，代表不可变的字符序列。字符串是常量，用双引号引起来表示。它们的值在创建之后不能更改。

String对象的字符内容是存储在一个字符数组value[]中的。

在这里插入图片描述

String常用API

boolean isEmpty()：判断是否是空字符串

public static void main(String[] args) {
    String s="www.123.com";
    System.out.println(s.isEmpty());//false
}

int length()：返回字符串的长度

public static void main(String[] args) {
    String s="www.123.com";
    System.out.println(s.length());//11
}

String concat(xx)：将指定字符串连接到此字符串的结尾。等价于用“+”

public static void main(String[] args) {
    String s="www.123.com";
    System.out.println(s.concat("xx"));//www.123.comxx
}

boolean equals(Object obj)：比较字符串的内容是否相同，区分大小写
boolean equalsIgnoreCase(Object obj)：比较字符串的内容是否相同，不区分大小写
int compareTo(String other)：比较字符串大小，区分大小写，从第一位开始比较，如果遇到不同字符，则返回这两个字符ASCII码值的差值，返回值是int类型，如果相等返回0
int compareToIgnoreCase(String other)：比较字符串大小，不区分大小写，从第一位开始比较，如果遇到不同字符，则返回这两个字符ASCII码值的差值，返回值是int类型，如果相等返回0

public static void main(String[] args) {
    String s="www.123.com";
    System.out.println(s.equals("www.123.com"));//true
    System.out.println(s.equalsIgnoreCase("WWw.123.cOm"));//true
    System.out.println(s.compareTo("www.123.Com"));//32
    System.out.println(s.compareToIgnoreCase("WWw.123.cOm"));//0
}

String toLowerCase()：将字符串中大写字母转为小写
String toUpperCase()：将字符串中小写字母转为大写

public static void main(String[] args) {
    String s="www.123.com";
    System.out.println(s.toLowerCase());//www.123.com
    System.out.println(s.toUpperCase());;//WWW.123.COM
}

String trim()：去掉字符串前后空白符（字符串中的空格无法去除）

public static void main(String[] args) {
     String s="  w w w.123.c o m  ";
     System.out.println(s.trim());//w w w.123.c o m
}

boolean contains(xx)：是否包含xx

public static void main(String[] args) {
    String s="www.123.com";
    System.out.println(s.contains("123"));//true
}

int indexOf(String str)：从前往后返回指定子字符串在此字符串中第一次出现处的索引，要是没有返回-1
int indexOf(String str, int fromIndex)：返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始
int lastIndexOf(String str)：从后往前返回指定子字符串在此字符串中最右边出现处的索引，要是没有返回-1
int lastIndexOf(String str, int fromIndex)：返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索

public static void main(String[] args) {
    String s="www.123.com";
    System.out.println(s.indexOf("1"));//4
    System.out.println(s.lastIndexOf("ttt"));//-1
}

String substring(int beginIndex) ：返回一个新的字符串，它是此字符串的从beginIndex开始截取到最后的一个子字符串。
String substring(int beginIndex, int endIndex) ：返回一个新字符串，它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。

public static void main(String[] args) {
   String s="www.123.com";
   System.out.println(s.substring(5));//23.com
   System.out.println(s.substring(5, 9));//23.c
}

boolean startsWith(String prefix)：测试此字符串是否以指定的前缀开始
boolean startsWith(String prefix, int toffset)：测试此字符串从指定索引开始的子字符串是否以指定前缀开始
boolean endsWith(String suffix)：测试此字符串是否以指定的后缀结束

public static void main(String[] args) {
   String s="www.123.com";
   System.out.println(s.startsWith("ww"));//true
     System.out.println(s.startsWith("ww",2));//false
   System.out.println(s.endsWith("om"));//true
}

char charAt(index)：返回[index]位置的字符

public static void main(String[] args) {
        String s1 = "HelloWorld";
        System.out.println(s1.charAt(0));//H
        System.out.println(s1.charAt(9));//d
    }

static String copyValueOf(char[] data)：返回指定数组中表示该字符序列的 String

static String copyValueOf(char[] data, int offset, int count)：返回指定数组中表示该字符序列的 String

 public static void main(String[] args) {
        char[] Str1 = {'g', 'o', 'o', 'd', ' ', 'm', 'o', 'r', 'n', 'i', 'n', 'g'};
        String Str2 = "";

        Str2 = Str2.copyValueOf( Str1 );
        System.out.println("返回结果：" + Str2);
     //返回结果：good morning

        Str2 = Str2.copyValueOf( Str1, 2, 6 );
        System.out.println("返回结果：" + Str2);
     //返回结果：od mor

    }

String replace(xx,xx)：不支持正则替换

public static void main(String[] args) {
    String str1 = "一二三四五一二";
    String str2 = str1.replace('一', '十');

    System.out.println(str1);//一二三四五一二
    System.out.println(str2);//十二三四五十二

    String str3 = str1.replace("一二", "六七");
    System.out.println(str3);//六七三四五六七
}

String replaceFirst(正则，value)：替换第一个匹配部分

String repalceAll(正则， value)：替换所有匹配部分

public static void main(String[] args) {
    String str = "12hello34world5java7891mysql456";
        //把字符串中的数字替换成,，如果结果中开头和结尾有，的话去掉
        String string = str.replaceAll("\\d+", ",").replaceAll("^,|,$", "");
        System.out.println(string);//hello,world,java,mysql
}

匹配:boolean matches(String regex)：告知此字符串是否匹配给定的正则表达式。

public static void main(String[] args) {
		  str = "12345";
        //判断str字符串中是否全部有数字组成，即有1-n个数字组成
        boolean matches = str.matches("\\d+");
        System.out.println(matches);//true
        String tel = "0571-4534289";
        //判断这是否是一个杭州的固定电话
        boolean result = tel.matches("0571-\\d{7,8}");
        System.out.println(result);//true
}

String[] split(正则)：按照某种规则进行拆分

public static void main(String[] args) {
	 	 str = "hello|world|java";
        String[] strs = str.split("\\|");
        for (int i = 0; i < strs.length; i++) {
            System.out.println(strs[i]);
        }
    //结果：
    //hello
	//world
	//java
        System.out.println();
        str2 = "hello.world.java";
        String[] strs2 = str2.split("\\.");
        for (int i = 0; i < strs2.length; i++) {
            System.out.println(strs2[i]);
        }
     //结果：
     //hello
	//world
	//java
}

String 与基本数据类型、包装类之间的转换。

String 转为基本数据类型、包装类：调用包装类的静态方法：parseXxx(str)
基本数据类型、包装类转为 String:调用String重载的valueOf(xxx)

 public void test1(){
        String str1 = "123";
//        int num = (int)str1;//错误的
        int num = Integer.parseInt(str1);//string转int
     //int转string
        String str2 = String.valueOf(num);//"123"

        String str3 = num + "";

        System.out.println(str1 == str3);//false
    }

String 与 char[]数组之间的转换

String 转为 char[]:调用String的toCharArray()
char[] 转为 String:调用String的构造器

  @Test
    public void test2(){
        String str1 = "abc123";  //题目： a21cb3

        char[] charArray = str1.toCharArray();
        for (int i = 0; i < charArray.length; i++) {
            System.out.println(charArray[i]);
        }
//结果：
/*
a
b
c
1
2
3
*/
        char[] arr = new char[]{'h','e','l','l','o'};
        String str2 = new String(arr);
        System.out.println(str2);//hello
    }

String 与 byte[]字节之间的转换

编码：String转为 byte[]:调用String的getBytes()
解码：byte[] 转为String:调用String的构造器

编码：字符串 -->字节 (看得懂 —>看不懂的二进制数据)

解码：编码的逆过程，字节 --> 字符串（看不懂的二进制数据 —> 看得懂）

说明：解码时，要求解码使用的字符集必须与编码时使用的字符集一致，否则会出现乱码。

 @Test
    public void test3() throws UnsupportedEncodingException {
        String str1 = "abc123中国";
        byte[] bytes = str1.getBytes();//使用默认的字符集，进行编码。UTF-8三个字节存储一个汉字
        System.out.println(Arrays.toString(bytes));//[97, 98, 99, 49, 50, 51, -28, -72, -83, -27, -101, -67]

        byte[] gbks = str1.getBytes("gbk");//使用gbk字符集进行编码。gbk两个字节存储一个汉字
        System.out.println(Arrays.toString(gbks));//[97, 98, 99, 49, 50, 51, -42, -48, -71, -6]

        System.out.println("******************");

        String str2 = new String(bytes);//使用默认的字符集，进行解码。
        System.out.println(str2);//abc123中国

        String str3 = new String(gbks);
        System.out.println(str3);//abc123�й�     出现乱码。原因：编码集和解码集不一致！


        String str4 = new String(gbks, "gbk");//abc123中国
        System.out.println(str4);//没有出现乱码。原因：编码集和解码集一致！


    }

二、StringBuffer、StringBuilder常用API

String、StringBuffer、StringBuilder三者的异同？

String:不可变的字符序列；底层使用char[]存储

String str = new String();//char[] value = new char[0];
String str1 = new String("abc");//char[] value = new char[]{'a','b','c'};

StringBuffer:可变的字符序列；线程安全的，效率低；底层使用char[]存储
StringBuilder:可变的字符序列；jdk5.0新增的，线程不安全的，效率高；底层使用char[]存储

 StringBuffer sb1 = new StringBuffer();//char[] value = new char[16];底层创建了一个长度是16的数组。
    System.out.println(sb1.length());//
    sb1.append('a');//value[0] = 'a';
    sb1.append('b');//value[1] = 'b';

    StringBuffer sb2 = new StringBuffer("abc");//char[] value = new char["abc".length() + 16];

 System.out.println(sb2.length());//3

扩容问题:如果要添加的数据底层数组盛不下了，那就需要扩容底层的数组。
默认情况下，扩容为原来容量的2倍 + 2，同时将原有数组中的元素复制到新的数组中。

StringBuffer/StringBuilder的常用API：

StringBuffer append(xxx)：提供了很多的append()方法，用于进行字符串拼接
StringBuffer delete(int start,int end)：删除指定位置的内容
StringBuffer replace(int start, int end, String str)：把[start,end)位置替换为str
StringBuffer insert(int offset, xxx)：在指定位置插入xxx
StringBuffer reverse() ：把当前字符序列逆转
public int indexOf(String str)
public String substring(int start,int end):返回一个从start开始到end索引结束的左闭右开区间的子字符串
public int length()
public char charAt(int n )
public void setCharAt(int n ,char ch)

public class Demo {
    public static void main(String[] args) {
      StringBuffer s1 = new StringBuffer("abc");
        s1.append(1);
        s1.append('1');
        System.out.println(s1);//abc11
        s1.delete(2, 4);//删除字符串索引为2到4的字符（左闭右开原则，包括2但不包括4）
        System.out.println(s1);//ab1
        s1.replace(2, 4, "hello");//替换字符串索引2到4的字符（左闭右开）
        System.out.println(s1);//abhello
        s1.insert(2, false);//从索引为2的字符开始插入，原字符串索引为2的数据向后移动
        System.out.println(s1);//abfalsehello
        s1.reverse();//把当前字符序列逆转
        System.out.println(s1);//olleheslafba
        String s2 = s1.substring(1, 3);//根源索引截取原字符串，变成一个新的字符串
        System.out.println(s1.length());//12
        System.out.println(s2);//lle
    }
}

对比String、StringBuffer、StringBuilder三者的效率：

从高到低排列：StringBuilder > StringBuffer > String


public class Demo {
    public static void main(String[] args) {
        //初始设置
        long startTime = 0L;
        long endTime = 0L;
        String text = "";
        StringBuffer buffer = new StringBuffer("");
        StringBuilder builder = new StringBuilder("");
        //开始对比
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 20000; i++) {
            buffer.append(String.valueOf(i));
        }
        endTime = System.currentTimeMillis();
        System.out.println("StringBuffer的执行时间：" + (endTime - startTime));

        startTime = System.currentTimeMillis();
        for (int i = 0; i < 20000; i++) {
            builder.append(String.valueOf(i));
        }
        endTime = System.currentTimeMillis();
        System.out.println("StringBuilder的执行时间：" + (endTime - startTime));

        startTime = System.currentTimeMillis();
        for (int i = 0; i < 20000; i++) {
            text = text + i;
        }
        endTime = System.currentTimeMillis();
        System.out.println("String的执行时间：" + (endTime - startTime));
    }
}