Java常用类之String(超详细+大量代码)

最新推荐文章于 2024-03-16 11:32:19 发布

黑洞晓威

最新推荐文章于 2024-03-16 11:32:19 发布

阅读量551

点赞数 10

文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/m0_69383623/article/details/127286361

版权

🏠个人主页：黑洞晓威
🧑个人简介：大家好，我是晓威，一名普普通通的大二在校生，希望在CSDN中与大家一起成长。

🎁如果你也在正在学习Java，欢迎各位大佬来到我的博客查漏补缺呀，如果有哪里写的不对的地方也欢迎诸佬指正啊。

常用类String

String的特点

声明为final，不可被继承
实现了Serializable接口，字符串支持序列化
实现了Comparable接口，表示String可比较大小
String内部定义了final char[] value用于存储字符串数据
String代表不可变字符序列，简称不可变性

体现：

当对字符串重新赋值时，需要重写指定内存区域赋值，不能用原有的value进行赋值
当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能在原有的基础上赋值
调用String的replace（）方法修改字符或字符串时，也需要重新指定内存区域

通过字面量的方式（区别于new）给一个字符串赋值，此时的字符串值声明在字符串常量池中。
字符串的常量池不会存储相同的字符串。

String的实例化方式：

方式一：通过字面量定义的方式

通过字面量定义的方式实例化的String声明在方法区的字符串常量池中

方式二：通过new+构造器的方式

通过new+构造器的方式实例化的tring声明在堆空间中开辟的空间

public static void main(String[] args) {
    String s1 = "abc";
    String s2 = "abc";
    System.out.println(s1==s2);//true；s1与s2地址相同指向常量池中的"abc"

    String s3 = new String("123");
    String s4 = new String("123");
    System.out.println(s3==s4);//false；s3与s4地址不同，指向堆空间中不同的对象
}

注意：1拼接生成的字符串，只要其中一个为变量，结果就在堆中

2，如果拼接的结果中调用intern（），结果则在字符串常量池中

public static void main(String[] args) {
    String s0 = "abc123";
    String s1 = "abc";
    String s2 = "123";

    String s3 = "abc"+"123";
    String s4 = s1+"123";
    String s5 = "abc"+s2;
    String s6 = s1+s2;
    String s7 = (s1+s2).intern();

    System.out.println(s3==s0);//true,两个字符串连接结果在字符串常量池中
    System.out.println(s4==s0);//false，含有变量的拼接结果在堆中
    System.out.println(s5==s0);//false
    System.out.println(s6==s0);//false
    System.out.println(s7==s0);//true,s7结果仍在常量池中
}

一道面试题：

public static void main(String[] args) {
    String s1 = "abc";
    char[] ch = new char[]{'a','b','c'};
    change(s1,ch);
    System.out.println(s1);//结果为：abc
    System.out.println(ch);//结果为：Abc
}

public static void change(String str,char[] ch){
    str = str+"123";
    ch[0]='A';
}

解释：
首先String是一个不可变类型，在方法调用时JVM只能再开辟一块新的内存，把“abcdef”放进去，然后把新的地址给了s1，如果你在方法中输出str的值肯定是“abc123”，当这个方法返回时main方法中时，s1依然是那个没修改前的引用，所以输出结果为“abc”。

而char[]数组是引用类型且是可变的所以输出结果为”Abc“；

String的常用方法

public char charAt(int index) ：用于查找字符串中下标为index的字符，返回一个字符。

String s1="Hello Word";
System.out.println(s1.charAt(0));//H
System.out.println(s1.charAt(9));//r

public int length()：返回当前字符串的长度。

String s1="Hello Word";
System.out.println(s1.length());//10

public int compareTo(String anotherString)：按照字典顺序比较两个字符串大小。

String s1="Hello Word";
String s2 = "ABC";
System.out.println(s1.compareTo(s2));//7,（正数大于，负数小于，0为等于）

public boolean equals(Object anObject)：判断当前字符串内容是否与后面字符串内容相同。

 String s1="Hello Word";
 String s2="hello word";
System.out.println(s2.equals(s1));//false

public boolean equalsIgnoreCase(String anotherString)：忽略大小写，判断当前字符串内容是否与后面字符串内容相同。

 String s1="Hello Word";
 String s2="hello word";
System.out.println(s2.equalsIgnoreCase(s1));//true

public boolean contains(CharSequence s)：判断前面的字符串是否包含后面的字字符串。

 String s1="Hello Word";   
System.out.println(s1.contains("ell"));//true

public boolean startsWith(String prefix)：判断当前字符串是否以prefix字符串开头。

String s1="hello word";
System.out.println(s1.startsWith("hello"));//true

public boolean endsWith(String suffix)：判断当前字符串是否以suffix字符串开结尾。

String s1="hello word";
System.out.println(s1.endsWith("Word"));//false

public int indexOf(String str)：返回某个子字符串在当前字符串中第一次出现的下标，没有就返回-1。

String s1="hello word"; 
System.out.println(s1.indexOf("el"));//1

public int lastIndexOf(String str)：返回某个子字符串在当前字符串中最后一次出现的下标，没有就返回-1。

String s1="hello word"; 
System.out.println(s1.lastIndexOf("o"));//7

public boolean isEmpty()：判断某个字符串是否为空字符串。

String s1="Hello Word";
System.out.println(s1.isEmpty());//false

public String replace(CharSequence target, CharSequence replacement)：将当前字符串当中的所有target字符串换成replacement字符串。

String s1="Hello Word";
System.out.println(s1. replace("o","a"));//Hella Ward

public String[] split(String regex)：将当前字符串以regex字符串隔开，隔开后的片段以String[]形式返回。

String s1 = "a,b,c";
String[] str = s1.split(",");
for (String x: str) {
    System.out.print(x + "  ");  //输出：a b c  
}

public String substring(int beginIndex, int endIndex)：在当前字符串中，从beginIndex开始截取，截取到endIndex的新字符串（不包含 int endIndex），返回新字符串。

String s1="Hello Word";
System.out.println(s1.substring(3));//Hel
System.out.println(s1.substring(0,4));//hell

public String toLowerCase()：将字符串全都转换成小写字母。

String s1="Hello Word";
String s2=s1.toLowerCase();
System.out.println(s1);
System.out.println(s2);

public String trim()：去除字符串前后的空格。

String s1="   Hello Word      ";
String s2=s1.trim();
System.out.println(s2);//Hello Word

String与其他类型之间的转化

1,String与基本类型、包装类之间的转换

String---->基本类型，包装类：调用包装类的静态方法：parseXxx（str）

基本类型，包装类---->String：调用String重载的valueOF(xxx),或者+“”

int num0 = 123;
String s0 = "456";

//String---->基本类型，包装类：
int num1 = Integer.parseInt(s0);//"456"-->456

//基本类型，包装类---->String：
String s1 = String.valueOf(num0);//123-->"123"
String s1 = num0+"";//123-->"123"

2，String与char[]之间的转换

string–>char[] : 调用String的toCharArray()

char[]–>string : 调用String的构造器

char[] chars = new char[]{'a','b','c'};
String str = new String("def");

//char[]-->string :
String s1 = new String(chars);
System.out.println(s1);//"abc"

//string-->char[] : 
char[] ch = str.toCharArray();
for (int i = 0; i < ch.length; i++) {
    System.out.println(ch[i]);//def
}

3，String与byte[]之间类型转换

String–>byte[] : 调用String中的getByte()

byte[]–> String : 调用String的构造器

String str = "abc";
byte[] by = new byte[]{'4','5','6'};

//String-->byte[]
byte[] b1 = str.getBytes();
for(byte b : b1){
System.out.print(b+",");//a，b，c
}

//byte[]-->String
String s1 = new String(by);
System.out.println(s1);//456

补充：编码与解码

编码：String–>byte[]（看得懂的字符串———到看不懂的二进制数据）
解码：byte[]–> String（看不懂的二进制数据———看得懂的字符串）

String str = "abc你好";

byte[] b1 = str.getBytes();//按设置使用默认编码方式（此时为UTF-8）
String s1 = new String(b1);//按设置使用默认解码方式(此时为UTF-8)
System.out.println(s1);//正常输出"abc你好'

byte[] b2 = str.getBytes("gbk");//按gbk编码
String s2 = new String(b2);//按设置默认解码方式(此时为UTF-8)
System.out.println(s2);//出现乱码

String s3 = new String(b2,"gbk");//按gbk方式解码
System.out.println(s3);

一道面试题

String s1 = "HelloWord";
String s2 = "Hello";
final String s3 = "Hello";

String s4 = s2 + "Word";
String s5 = s3 + "Word";

System.out.println(s1==s4);//false
System.out.println(s1==s5);//true

为什么s1==s5为true？

因为s3被final修饰，此时s3为常量

常量池中不会出现相同内容的常量

常量拼接的String实例s5与s1都在常量池中，此时二者的地址相同

🎉文章到这里就结束了，感谢诸佬的阅读。🎉
💕欢迎诸佬对文章加以指正，也望诸佬不吝点赞、评论、收藏加关注呀😘

黑洞晓威

关注

10
点赞
踩
3

收藏

觉得还不错? 一键收藏
打赏
6
评论
Java常用类之String(超详细+大量代码)

String的特点1. 声明为final，不可被继承2. 实现了Serializable接口，字符串支持序列化3. 实现了Comparable接口，表示String可比较大小4. String内部定义了final char[] value用于存储字符串数据5. String代表不可变字符序列，简称不可变性字符串重新赋值时，需要重写指定内存区域赋值，不能用原有的value进行赋值> 2. 当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能在
复制链接

扫一扫