Java - String讲解

于 2024-06-02 12:00:05 发布
阅读量655 收藏 25
点赞数 8
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80678879/article/details/139388072
版权

正文开始

1. String类的重要性

在 C 语言中已经涉及到字符串了，但是在 C 语言中要表示字符串只能使用字符数组或者字符指针，可以使用标准库提供的字符串系列函数完成大部分操作，但是这种将数据和操作数据方法分离开的方式不符合面相对象的思想，而字符串应用又非常广泛，因此Java 语言专门提供了 String 类。

 

在开发和校招笔试中，字符串也是常客，比如：
而且在面试中也频繁被问到，比如： String 、 StringBuff 和 StringBulider 之间的区别等。

2. 常用方法

2.1 字符串构造

String类提供的构造方式非常多，常用的就以下三种：

public static void main(String[] args) {
    // 使用常量串构造
    String s1 = "hello bit";
    System.out.println(s1);
    // 直接newString对象
    String s2 = new String("hello bit");
    System.out.println(s1);
    // 使用字符数组进行构造
    char[] array = {'h','e','l','l','o','b','i','t'};
    String s3 = new String(array);
    System.out.println(s1);
}

其他方法需要用到时，大家参考Java在线文档：String官方文档

【 注意 】
1. String 是引用类型，内部并不存储字符串本身 ，在 String 类的实现源码中， String 类实例变量如下：

 

 public static void main(String[] args) {
// s1和s2引用的是不同对象 s1和s3引用的是同一对象
        String s1 = new String("hello");
        String s2 = new String("world");
        String s3 = s1;
        System.out.println(s1.length()); // 获取字符串长度---输出5
        System.out.println(s1.isEmpty()); // 如果字符串长度为0，返回true，否则返回false
    }

运行结果如下： 

 

2. 在Java中“”引起来的也是String类型对象。 

// 打印"hello"字符串(String对象)的长度
System.out.println("hello".length());

 

 2.2 String对象的比较

字符串的比较是常见操作之一，比如：字符串排序。Java中总共提供了4中方式：

1. == 比较是否引用同一个对象
注意：对于内置类型， == 比较的是变量中的值；对于引用类型 == 比较的是引用中的地址。 
public static void main(String[] args) {
int a = 10;
int b = 20;
int c = 10;
// 对于基本类型变量，==比较两个变量中存储的值是否相同
System.out.println(a == b); // false
System.out.println(a == c); // true
// 对于引用类型变量，==比较两个引用变量引用的是否为同一个对象
String s1 = new String("hello");
String s2 = new String("hello");
String s3 = new String("world");
String s4 = s1;
System.out.println(s1 == s2); // false
System.out.println(s2 == s3); // false
System.out.println(s1 == s4); // true
}
2. boolean equals(Object anObject) 方法：按照字典序比较
字典序：字符大小的顺序
String 类重写了父类 Object 中 equals 方法， Object 中 equals 默认按照 == 比较， String 重写 equals 方法后，按照如下规则进行比较，比如： s1.equals(s2) 
 public boolean equals(Object anObject) {
// 1. 先检测this 和 anObject 是否为同一个对象比较，如果是返回true
        if (this == anObject) {
            return true;
        }
// 2. 检测anObject是否为String类型的对象，如果是继续比较，否则返回false
        if (anObject instanceof String) {
// 将anObject向下转型为String类型对象
            String anotherString = (String) anObject;
            int n = value.length;
// 3. this和anObject两个字符串的长度是否相同，是继续比较，否则返回false
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
// 4. 按照字典序，从前往后逐个字符进行比较
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

 public static void main(String[] args) {
        String s1 = new String("hello");
        String s2 = new String("hello");
        String s3 = new String("Hello");
// s1、s2、s3引用的是三个不同对象，因此==比较结果全部为false
        System.out.println(s1 == s2); // false
        System.out.println(s1 == s3); // false
// equals比较：String对象中的逐个字符
// 虽然s1与s2引用的不是同一个对象，但是两个对象中放置的内容相同，因此输出true
// s1与s3引用的不是同一个对象，而且两个对象中内容也不同，因此输出false
        System.out.println(s1.equals(s2)); // true
        System.out.println(s1.equals(s3)); // false
    }
3. int compareTo(String s) 方法 : 按照字典序进行比较
与 equals 不同的是， equals 返回的是 boolean 类型，而 compareTo 返回的是 int 类型。具体比较方式：
1. 先按照字典次序大小比较，如果出现不等的字符，直接返回这两个字符的大小差值
2. 如果前 k 个字符相等 (k 为两个字符长度最小值 ) ，返回值两个字符串长度差值 
 public static void main(String[] args) {
        String s1 = new String("abc");
        String s2 = new String("ac");
        String s3 = new String("abc");
        String s4 = new String("abcdef");
        System.out.println(s1.compareTo(s2)); // 不同输出字符差值-1
        System.out.println(s1.compareTo(s3)); // 相同输出 0
        System.out.println(s1.compareTo(s4)); // 前k个字符完全相同，输出长度差值 -3
    }
4. int compareToIgnoreCase(String str) 方法：与compareTo方式相同，但是忽略大小写比较 
 public static void main(String[] args) {
        String s1 = new String("abc");
        String s2 = new String("ac");
        String s3 = new String("ABc");
        String s4 = new String("abcdef");
        System.out.println(s1.compareToIgnoreCase(s2)); // 不同输出字符差值-1
        System.out.println(s1.compareToIgnoreCase(s3)); // 相同输出 0
        System.out.println(s1.compareToIgnoreCase(s4)); // 前k个字符完全相同，输出长度差值 -3
    }

 

 2.3 字符串查找

字符串查找也是字符串中非常常见的操作， String 类提供的常用查找的方法： 

public static void main(String[] args) {
        String s = "aaabbbcccaaabbbccc";
        System.out.println(s.charAt(3)); // 'b'
        //找到下标为3的值
        System.out.println(s.indexOf('c')); // 6
        //找到'c'第一次出现的位置
        System.out.println(s.indexOf('c', 10)); // 15
        //从10下标开始，找到'c'第一次出现的位置
        System.out.println(s.indexOf("bbb")); // 3
        //找到'bbb'出现的下标
        System.out.println(s.indexOf("bbb", 10)); // 12
        //从10下标开始，找到'bbb'第一次出现的位置
        System.out.println(s.lastIndexOf('c')); // 17
        //从后往前，找到'c'第一次出现的下标
        System.out.println(s.lastIndexOf('c', 10)); // 8
        //从10下标开始，找到'c'第一次出现的下标
        System.out.println(s.lastIndexOf("bbb")); // 12
        //从后往前，找到'bbb'第一次出现的下标
        System.out.println(s.lastIndexOf("bbb", 10)); // 3
        //从10下标开始，找到'bbb'第一次出现的下标
    }

 注意：上述方法都是实例方法。

2.4 转化

1. 数值和字符串转化

public static void main(String[] args) {
        // 数字转字符串
        String s1 = String.valueOf(1234);
        String s2 = String.valueOf(12.34);
        String s3 = String.valueOf(true);
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
        System.out.println("=================================");
        // 字符串转数字
        // 注意：Integer、Double等是Java中的包装类型，这个后面会讲到
        int data1 = Integer.parseInt("1234");
        double data2 = Double.parseDouble("12.34");
        System.out.println(data1);
        System.out.println(data2);
    }

结果如下： 

 public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "HELLO";
// 小写转大写
        System.out.println(s1.toUpperCase());
// 大写转小写
        System.out.println(s2.toLowerCase());
    }

 结果如下：

3. 字符串转数组

public static void main(String[] args) {
        String s = "hello";
// 字符串转数组
        char[] ch = s.toCharArray();
        for (int i = 0; i < ch.length; i++) {
            System.out.print(ch[i]);
        }
        System.out.println();
// 数组转字符串
        String s2 = new String(ch);
        System.out.println(s2);
    }

 结果如下：

4. 格式化

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

结果如下： 

 

2.5 字符串替换 

使用一个指定的新的字符串替换掉已有的字符串数据，可用的方法如下：

 

代码示例: 字符串的替换处理 

String str = "helloworld" ;
System.out.println(str.replaceAll("l", "_"));
System.out.println(str.replaceFirst("l", "_"));

结果如下： 

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

 

2.6 字符串拆分 

可以将一个完整的字符串按照指定的分隔符划分为若干个子字符串。
可用方法如下：

代码示例: 实现字符串的拆分处理 

String str = "hello world hello bit" ;
        String[] result = str.split(" ") ; // 按照空格拆分
        for(String s: result) {
            System.out.println(s);
        }

结果如下： 

 

代码示例: 字符串的部分拆分

String str = "hello world hello bit" ;
        String[] result = str.split(" ",2) ;
        for(String s: result) {
            System.out.println(s);
        }

结果如下：

拆分是特别常用的操作， 一定要重点掌握 ， 另外有些特殊字符作为分割符可能无法正确切分 ，  需要加上转义。
代码示例 : 拆分 IP 地址 
 public static void main(String[] args) {
        String str = "192.168.1.1" ;
        String[] result = str.split("\\.") ;
        for(String s: result) {
            System.out.println(s);
        }

结果如下：

注意事项：
1. 字符 "|","*","+" 都得加上转义字符，前面加上 "\\" 。
2. 而如果是 "\" ，那么就得写成 "\\\\" 。
3. 如果一个字符串中有多个分隔符，可以用 "|" 作为连字符。
 

代码示例: 多次拆分

String str = "name=zhangsan&age=18" ;
        String[] result = str.split("&") ;
        for (int i = 0; i < result.length; i++) {
            String[] temp = result[i].split("=") ;
            System.out.println(temp[0]+" = "+temp[1]);
        }

结果如下：

2.7 字符串截取

从一个完整的字符串之中截取出部分内容。可用方法如下：

代码示例: 观察字符串截取

 String str = "helloworld" ;
        System.out.println(str.substring(5));
        System.out.println(str.substring(0, 5));
    }

 结果如下：

注意事项 :
1. 索引从 0 开始
2. 注意前闭后开区间的写法 , substring(0, 5) 表示包含 0 号下标的字符 , 不包含 5 号下标

2.8 其他操作方法  

 代码示例: 观察trim()方法的使用

String str = " hello world " ;
        System.out.println("["+str+"]");
        System.out.println("["+str.trim()+"]");

结果如下：

trim 会去掉字符串开头和结尾的空白字符 ( 空格 , 换行 , 制表符等 )。
代码示例 : 大小写转换 
String str = " hello%$$%@#$%world 哈哈哈 " ;
        System.out.println(str.toUpperCase());
        System.out.println(str.toLowerCase());
结果如下：

这两个函数只转换字母。  

2.9 字符串的不可变性  

String是一种不可变对象. 字符串中的内容是不可改变。字符串不可被修改，是因为：

1. String 类在设计时就是不可改变的， String 类实现描述中已经说明了
以下来自 JDK1.8 中 String 类的部分实现：

String类中的字符实际保存在内部维护的value字符数组中，该图还可以看出：

1. String 类被 final 修饰，表明该类不能被继承
2. value 被修饰被 final 修饰，表明 value 自身的值不能改变，即不能引用其它字符数组，但是其引用空间中的内容可以修改。
2. 所有涉及到可能修改字符串内容的操作都是创建一个新对象，改变的是新对象
比如 replace 方法：

【 纠正 】网上有些人说：字符串不可变是因为其内部保存字符的数组被 final 修饰了，因此不能改变。
这种说法是错误的，不是因为 String 类自身，或者其内部 value 被 final 修饰而不能被修改。
final 修饰类表明该类不想被继承， final 修饰引用类型表明该引用变量不能引用其他对象，但是其引用对象中的内 容是可以修改的 。 
public static void main(String[] args) {
        final int array[] = {1,2,3,4,5};
        array[0] = 100;
        System.out.println(Arrays.toString(array));
// array = new int[]{4,5,6}; // 编译报错：Error:(19, 9) java: 无法为最终变量array分配值
    }

结果如下：

 

为什么 String 要设计成不可变的 ? ( 不可变对象的好处是什么 ?) ( 选学 )
        1. 方便实现字符串对象池 . 如果 String 可变 , 那么对象池就需要考虑写时拷贝的问题了 .
        2. 不可变对象是线程安全的 .
        3. 不可变对象更方便缓存 hash code, 作为 key 时可以更高效的保存到 HashMap 中 .

那如果想要修改字符串中内容，该如何操作呢？

2.10 字符串修改

注意：尽量避免直接对 String 类型对象进行修改，因为 String 类是不能修改的，所有的修改都会创建新对象，效率 非常低下。 
 String s = "hello";
        s += " world";
        System.out.println(s); // 输出：hello world
    }
但是这种方式不推荐使用，因为其效率非常低，中间创建了好多临时对象。 
public static void main(String[] args) {
        long start = System.currentTimeMillis();
        String s = "";
        for(int i = 0; i < 10000; ++i){
            s += i;
        }
        long end = System.currentTimeMillis();
        System.out.println(end - start);
        start = System.currentTimeMillis();
        StringBuffer sbf = new StringBuffer("");
        for(int i = 0; i < 10000; ++i){
            sbf.append(i);
        }
        end = System.currentTimeMillis();
        System.out.println(end - start);
        start = System.currentTimeMillis();
        StringBuilder sbd = new StringBuilder();
        for(int i = 0; i < 10000; ++i){
            sbd.append(i);
        }
        end = System.currentTimeMillis();
        System.out.println(end - start);
    }

结果如下：

可以看待在对 String 类进行修改时，效率是非常慢的，因此：尽量避免对 String 的直接需要，如果要修改建议尽量使用StringBuffer 或者 StringBuilder 。
借助 StringBuffer 和 StringBuilder

 

3. StringBuilder和StringBuffer

3.1 StringBuilder的介绍

由于 String 的不可更改特性，为了方便字符串的修改， Java 中又提供 StringBuilder 和 StringBuffer 类。这两个类大部分功能是相同的，这里介绍 StringBuilder 常用的一些方法，其它需要用到了大家可参阅StringBuilder在线文档。 

    public static void main(String[] args) {
        StringBuilder sb1 = new StringBuilder("hello");
        StringBuilder sb2 = sb1;
    // 追加：即尾插-->字符、字符串、整形数字
        sb1.append(' '); // hello
        sb1.append("world"); // hello world
        sb1.append(123); // hello world123
        System.out.println(sb1); // hello world123
        System.out.println(sb1 == sb2); // true
        System.out.println(sb1.charAt(0)); // 获取0号位上的字符 h
        System.out.println(sb1.length()); // 获取字符串的有效长度14
        System.out.println(sb1.capacity()); // 获取底层数组的总大小
        sb1.setCharAt(0, 'H'); // 设置任意位置的字符 Hello world123
        sb1.insert(0, "Hello world!!!"); // Hello world!!!Hello world123
        System.out.println(sb1);
        System.out.println(sb1.indexOf("Hello")); // 获取Hello第一次出现的位置
        System.out.println(sb1.lastIndexOf("hello")); // 获取hello最后一次出现的位置
        sb1.deleteCharAt(0); // 删除首字符
        sb1.delete(0,5); // 删除[0, 5)范围内的字符
        String str = sb1.substring(0, 5); // 截取[0, 5)区间中的字符以String的方式返回
        System.out.println(str);
        sb1.reverse(); // 字符串逆转
        str = sb1.toString(); // 将StringBuffer以String的方式返回
        System.out.println(str);
    }
从上述例子可以看出： String 和 StringBuilder 最大的区别在于 String 的内容无法修改，而 StringBuilder 的内容可 以修改 。频繁修改字符串的情况考虑使用 StringBuilder 。
注意： String 和 StringBuilder 类不能直接转换。如果要想互相转换，可以采用如下原则 :
String 变为 StringBuilder: 利用 StringBuilder 的构造方法或 append() 方法
StringBuilder 变为 String: 调用 toString() 方法。
什么都不会要死了
关注
  • 8
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
string类函数详解，带用法示例
kumoue的博客
03-30 1万+
详解string类函数，每种用法示例
JAVA-SE基础知识.pdf
最新发布
08-18
文档包含for/while/do-while、方法、方法重载、数组、面向对象、单例、重写、多态、抽象类、内部类、异常、String、八大基本数据类型、日期、集合、文件、多线程、网络编程、反射等基础讲解笔记。
程序员（转）
camel的blog
09-06 1967
写字楼里写字间，写字间里程序员；程序人员写程序，又拿程序换酒钱。酒醒只在网上坐，酒醉还来网下眠；酒醉酒醒日复日，网上网下年复年。但愿老死电脑间，不愿鞠躬老板前；奔驰宝马贵者趣，公交自行程序员。别人笑我忒疯癫，我笑自己命太贱；不见满街漂亮妹，哪个归得程序员。
string及其常见函数
wanxiangzx的博客
08-29 2325
查找、截字串、替换、与数字相互转换
string类常用函数
jikelk的博客
03-03 4619
lk常用string类函数
C++库函数——string类
qq_73201597的博客
06-01 6642
源文档译：1.字符串是表示字符序列的类2.标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作单字节字符字符串的设计特性。3. string类是使用char(即作为它的字符类型，使用它的默认和分配器类型关于模板的更多信息，请参阅basic_string)。4. string类是模板类的一个实例，它使用char来实例化模板类，并用char_traits和allocator作为的默认参数根于更多的模板信息请参考。5.
java string 转date方法如何实现
09-05
以下将详细讲解如何在Java中实现这一转换，并提供多种不同的方法来处理不同格式的日期字符串。 首先，我们需要了解`SimpleDateFormat`类，它是Java中用于日期和时间格式化的关键工具。`SimpleDateFormat`遵循特定的...
Java String不可变性实现原理解析
08-19
本文将详细介绍 Java String 不可变性实现原理，并通过示例代码进行了详细的讲解。 一、不可变模式（Immutable Pattern） 在并行软件开发过程中，同步操作似乎是必不可少的。当多线程对同一个对象进行读写操作时，...
java里的string
10-14
讲解java中的String和StringBuffer的基本应用
Java中Date与String相互转换的方法
09-01
本文将详细讲解如何在Java中进行Date与String之间的转换，以及需要注意的关键点。 首先，让我们了解一下Date对象。在Java中，`java.util.Date`类表示特定的瞬间，精确到毫秒。然而，直接使用Date对象进行格式化并不...
String的认识及常用函数的使用
weixin_64643507的博客
04-16 857
由于String的不可更改特性，为了方便字符串的修改，Java中又提供StringBuilder和StringBuffer类。这两个类大部分功能是相同的，这里介绍 StringBuilder常用的一些方法，其它需要用到了大家可参阅StringBuilder在线文档// 追加：即尾插-->字符、字符串、整形数字 sb1 . append(' ');// 获取0号位上的字符 h System . out . println(sb1 . length());
深度剖析 string —— strlen & strtok
十里坡小白的博客
07-14 485
深度剖析 string 库函数 —— 源码实现
C++ string常用函数用法总结
qq_61514490的博客
08-13 1万+
能够将 string 字符串转换为C风格的字符串，并返回该字符串的 const 指针（const char*）-简而言之：将const string*转化为const char*string s(str, str_begin, str_len)：将字符串str中从下标str_begin开始、长度为str_len的部分作为字符串初值。string s(cstr, char_len)：以C_string类型cstr的前char_len个字符串作为字符串s的初值。运算符">","=","...
【C++入门基础】C++中的String的常用函数用法总结及其模拟实现
AMor_05的博客
10-21 6364
c语言中，字符串是以 '\0' 结尾的一些字符的集合，为了操作方便，C标准库中提供了一些str系列的库函数，但是这些库函数与字符串是分离开的，不太符合OOP的思想，而且底层空间需要用户自己管理，稍不留神可能还会越界访问。所以我们需要掌握c++中的string类。
C++中的String的常用函数用法总结
热门推荐
qq_37941471的博客
08-27 34万+
一. string的构造函数的形式： string str：生成空字符串 string s(str)：生成字符串为str的复制品 string s(str, strbegin,strlen)：将字符串str中从下标strbegin开始、长度为strlen的部分作为字符串初值 string s(cstr, char_len)：以C_string类型cstr的前char_len个字...
String类的几种常见函数
taojin_16138的博客
05-17 8107
String类的几种常见函数 1.char类型的charAt(int index)函数 作用：返回当前字符串中给定位置对应的字符 String string = "helloworld"; char c = string.charAt(5); System.out.println(c); 运行结果： 2.int类型的indexOf(String str) 作用：返回给定字符串在当前字符串中的位置，若当前字符串不包含该内容时返回值为-1 重载方法 indexOf(String str,int ind
string类型的函数大全
m0_52380556的博客
03-29 3480
s.empty(): 这是一个判断字符串s是否为空串的函数，有返回值，若s为空串，则返回1，否则返回0； s.size(): 这是一个求字符串s的长度的函数，有返回值，返回s中字符的个数。另外，s.length()函数的用法与s.size()函数的用法相同； +的用法: s1+s2返回s2接在s1后面所形成的新字符串，同时不改变s1和s2的值； 但是使用＋号的时候，左右必须有一个是字符串类型的变量，形如“asdf”的在这里的运算中是字符数组类型。 例如 s=”1234”+”asdf”是非法的。 s=”123
string的一些常见函数
qq_30747875的博客
07-26 1749
目录前言string的查找与截取find查找函数substr截取(切片)函数 前言 之前说过的strlen strcpy strcat strcmp都是对于两个字符串之间来搞事情的，今天我们说的一些函数是对字符串本身来操作的。就是python中的对字符串的切片与检索。 string的查找与截取 find查找函数 这个在python中也有，具体来说是找到就返回下标，没找到就返回-1. 在C++中也是通过s来调用find的 。如果有多个需要查找的值，往往返回的是第一个被找到的下标，若想找后面的，可以在find后
标准C++中string函数介绍
foxhello的专栏
04-17 3291
Java ------Integer类----toString函数讲解
05-27
Java中的Integer类是一个包装类，它提供了一些方法来操作基本类型int数据类型的值。其中，toString()方法是Integer类中的一个方法，用于将整数转换为字符串。 具体来说，toString()方法有两个重载形式： 1. public...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值