Java——String类

最新推荐文章于 2024-10-17 19:11:48 发布

Phriya

最新推荐文章于 2024-10-17 19:11:48 发布

阅读量801

点赞数 18

分类专栏： Java SE 文章标签： java 开发语言

本文链接：https://blog.csdn.net/m0_64005051/article/details/138290693

版权

Java SE 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

String类型，即字符串类型。是一种引用数据类型。

下面将对一些String类的常用方法进行详细讲解

String对象的比较

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

注意：对于内置类型，==比较的是变量中的值；对于引用类型==比较的是引用中的地址。

2. boolean equals(Object anObject) 方法

按照字典序比较

字典序：字符大小的顺序

3. int compareTo(String s) 方法

按照字典序比较

与equals不同的是，equals返回的是boolean类型，而compareTo返回的是int类型。具体比较方式：

1. 先按照字典次序大小比较，如果出现不等的字符，直接返回这两个字符的大小差值

2. 如果前k个字符相等(k为两个字符长度最小值)，返回值两个字符串长度差值

3. int compareToIgnoreCase(String str) 方法：与compareTo方式相同，但是忽略大小写比较

public class Test {
public static void main(String[] args) {
        //字符串比较

        String s1 = new String("hello");
        String s2 = new String("hello");
        System.out.println(s1 == s2); //比较的是s1和s2的地址

        //比较s1和s2的值  equals
        System.out.println(s1.equals(s2));//结果为boolean型

        String str1 = new String("abc");
        String str2 = new String("acd");
        String str3 = new String("abcdef");
        String str4 = "Abc";
        /**
         * 比较str1和str2的大小  compareTo
         * 如果str1 > str2  则返回正数
         * 如果str1 == str2  则返回0
         * 如果str1 < str2  则返回负数
         *
         */
        System.out.println(str1.compareTo(str2));
        System.out.println(str1.compareTo(str3));
        /**
         * 忽略大小写比较  compareToIgnoreCase
         */
        System.out.println(str1.compareToIgnoreCase(str4));
    }
}

字符串查找

方法	功能
char charAt(int index)	返回index位置上的字符，如果index为负数或者越界，抛出异常
int indexOf(int ch)	返回ch第一次出现的位置，没有就返回-1
int indexOf(int ch,int fromIndex)	从fromIndex位置开始找ch第一次出现的位置，没有就返回-1
int indexOf(String str)	返回str第一次出现的位置，没有就返回-1
int indexOf(String str,int fromIndex)	从fromIndex位置开始找str第一次出现的位置，没有就返回-1
int lastIndexOf(int ch)	从后往前找，返回ch第一次出现的位置，没有就返回-1
int lastIndexOf(int ch,int fromIndex)	从fromIndex位置从后往前找ch第一次出现的位置，没有就返回-1
int lastIndexOf(String str)	从后往前找，返回str第一次出现的位置，没有就返回-1
int lastIndexOf(String str,int fromIndex)	从fromIndex位置从后往前找str第一次出现的位置，没有就返回-1

public class Test{
public static void main(String[] args) {
        //字符串查找
        String s1 = "hello";

        //charAt
       /* char ch = s1.charAt(1); //不能是负数 或者 超过字符串的长度（越界）
        System.out.println(ch); //e*/
        /*for (int i = 0; i < s1.length(); i++) {
            char ch = s1.charAt(i);
            System.out.println(ch);
        }
*/
        //indexOf  正着找
       /* int index = s1.indexOf('h'); //返回‘h'第一次出现的位置，没有返回-1
        System.out.println(index);

        int index1 = s1.indexOf('h',3); //从3的位置开始查找
        System.out.println(index1);*/

        String s2 = "ababcabcd";
        /*int index2 = s2.indexOf("abc");  //查找子字符串在字符串中第一次出现的位置
        System.out.println(index2);

        int index3 = s2.indexOf("abc",3);  //从3的位置开始查找子字符串
        System.out.println(index3);*/

        //lastIndexOf  倒着找
        int last = s2.lastIndexOf("abc");
        System.out.println(last);

        int last2 = s2.lastIndexOf("abc",4); //从4倒着往回找
        System.out.println(last2);

        int last3 = s1.lastIndexOf('l');
        System.out.println(last3); //3

        int last4 = s1.lastIndexOf('l',2);
        System.out.println(last4);

    }
}

转化

数值和字符串转化

public class Test{
public static void main(String[] args) {
        //数值转为字符串
        String s1 = String.valueOf(1945);
        String s2 = String.valueOf(19.9);
        System.out.println(s1);
        System.out.println(s2);

        //字符串转为数值
        int data1 = Integer.parseInt("156");
        System.out.println(data1);
        double data2 = Double.parseDouble("15.30");
        System.out.println(data2);
    }
}

大小写转换

public class Test{
public static void main(String[] args) {
        //大小写转换
        String s1 = "hello";
        String ret = s1.toUpperCase();//需要用一个新对象来承载，而不是将原来的变化
        System.out.println(s1);
        System.out.println(ret);

        String s2 = "HELLO";
        String ret2 = s2.toLowerCase();
        System.out.println(s2);
        System.out.println(ret2);
    }
}

字符串转数组

public class Test{
public static void main(String[] args) {
        //字符串转数组
        String s1 = "hello";
        char[] array = s1.toCharArray();
        System.out.println(Arrays.toString(array));

        //数组转为字符串
        char[] array2 = {'a','b','c'};
        String s2 = new String(array2);
        System.out.println(s2);
    }
}

格式化

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

字符串替换

使用一个指定的新的字符串替换掉已有的字符串数据

方法	功能
String replaceAll(String regex,String replacement)	替换所有的指定内容
String replaceFirst(String regex,String replacement)	替换首个内容

【注意】: 由于字符串是不可变对象, 替换不修改当前字符串, 而是产生一个新的字符串.

public class Test{
 public static void main(String[] args) {
        //字符串替换
        String str = "ababcabcd";
        String ret = str.replace("ab","88");  //将所有的ab 替换成88
        System.out.println(ret);

        String ret2 = str.replace('a','8');
        System.out.println(ret2);

        String ret3 = str.replaceFirst("ab","22"); //将第一个ab替换为22
        System.out.println(ret3);

        String ret4 = str.replaceAll("ab","123");  //将所有的ab替换成123
        System.out.println(ret4);
    }
}

字符串拆分

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

方法	功能
String[] split(String regex)	将字符串全部拆分
String[] split(String regex,int limit)	将字符串以指定的格式，拆分为limit组

public class Test{
public static void main(String[] args) {
        //字符串拆分
        String str = "hello world hahaha";
        String[] ret = str.split(" ");
        //System.out.println(Arrays.toString(ret));
        for (int i = 0; i < ret.length; i++) {
            System.out.println(ret[i]);
        }

        String[] ret1 = str.split(" ",2); //分两组
        for (int i = 0; i < ret1.length; i++) {
            System.out.println(ret1[i]);
        }

        String str2 = "192.168.1.1";
        String[] ret2 = str2.split("\\.");
        for (int i = 0; i < ret2.length; i++) {
            System.out.println(ret2[i]);
        }

        String str3 = "192\\168\\1\\1";
        String[] ret3 = str3.split("\\\\");
        for (int i = 0; i < ret3.length; i++) {
            System.out.println(ret3[i]);
        }

        String str4 = "name=zhangsan&age=15";
        /*String[] ret4 = str4.split("=|&");
        for (int i = 0; i < ret4.length; i++) {
            System.out.println(ret4[i]);
        }*/
        String[] ret4 = str4.split("&");
        for (int i = 0; i < ret4.length; i++) {
            //System.out.println(ret4[i]);
            String x = ret4[i];
            String[] ret5 = x.split("=");//可以在第一次分割的基础上进行第二次分割
            for (int j = 0; j < ret5.length; j++) {
                System.out.println(ret5[j]);
            }
        }
    }
}

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

【注意】

1. 字符"|","*","+"都得加上转义字符，前面加上 "\\" .

2. 而如果是 "\" ，那么就得写成 "\\\\" .

3. 如果一个字符串中有多个分隔符，可以用"|"作为连字符

字符串截取

从一个完整的字符串之中截取出部分内容

方法	功能
String substring(int beginIndex)	从指定索引截取到结尾
String substring(int beginIndex，int endIndex)	截取部分内容

public class Test{
public static void main(String[] args) {
        //字符串截取
        String str = "ababc";
        String ret = str.substring(0,3);  //[0,3)
        System.out.println(ret);

        String ret2 = str.substring(2); //从2开始截取
        System.out.println(ret2);
    }
}

其他操作方法

方法	功能
String trim()	去掉字符串中的左右空格，保留中间的空格

public class Test{
public static void main(String[] args) {
        //去掉字符串的左右两边的空格,中间的空格无法去掉
        String str = "   abc   abc   ";
        System.out.println(str.trim());
    }
}

字符串的不可变性

String是一种不可变对象. 字符串中的内容是不可改变。

这是因为：

是因为：

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

2. String类中的字符实际保存在内部维护的value字符数组中，value被修饰被final修饰，表明value自身的值不能改变，即不能引用其它字符数组，但是其引用空间中的内容可以修改。

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

字符串修改

StringBuilder和StringBuffer

由于String的不可更改特性，为了方便字符串的修改，Java中又提供StringBuilder和StringBuffer类。

注意：String和StringBuilder类不能直接转换。如果要想互相转换，可以采用如下原则:

String变为StringBuilder: 利用StringBuilder的构造方法或append()方法
StringBuilder变为String: 调用toString()方法

public class Test{
public static void main(String[] args) {
        /*StringBuilder stringBuilder = new StringBuilder("hello"); //线程不安全
        stringBuilder.reverse();
        System.out.println(stringBuilder);*/

        StringBuffer stringBuffer = new StringBuffer("hello");//线程安全
        stringBuffer.reverse();
        System.out.println(stringBuffer);
    }
}

String、StringBuffer、StringBuilder的区别：

String的内容不可修改，StringBuffer与StringBuilder的内容可以修改.

StringBuffer与StringBuilder大部分功能是相似的

StringBuffer采用同步处理，属于线程安全操作；而StringBuilder未采用同步处理，属于线程不安全操作