这些Java常用类，你必须要学会，还不快快收藏？（近两万字详细介绍）-CSDN博客

本文链接：https://blog.csdn.net/2401_84411593/article/details/137983634

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip1024b （备注Java）

正文

… //静态构造方法举例；类名直接调用

}

public String replace(char oldChar, char newChar){

… //非静态方法举例；对象名调用

}

… //其他内容省略

从源码中我们可以看出：

字符串是常量；它们的值在创建之后不能更改；其构造方法有多种；
其方法有静态和非静态的，即有的需要通过类名调用，有的需要通过对象名调用。
字符串的对象是不可变对象，意味着一旦进行修改，就会产生新对象，因此其不适合大量修改字符串的场景使用。字符串对象设计为不可变,那么所以字符串有常量池来保存很多常量对象。

如果程序中涉及到大量的字符串的修改操作，那么此时的时空消耗比较高。可能需要考虑使用StringBuilder或StringBuffer的可变字符序列(这两个后面会介绍)

String对象内部是用字符数组进行保存的；例如：“abc” 等效于 char[] data={ ‘a’ , ‘b’ , ‘c’ }`。

JDK1.9之前有一个char[] value数组，JDK1.9之后byte[]数组

常量池在不同时期位置不同，具体如下：

①JDK1.6及其之前：方法区

②JDK1.7：堆

③JDK1.8：元空间

下面进一步说明String类及其常用的方法。

创建字符串对象

使用构造方法

使用构造方法创建字符串有三种形式：

直接赋值，类似于基本数据类型就可以（创建一个，在常量池中）
通过对象赋值，参数是字符串（创建两个对象，首先指向堆中的一个字符串对象，然后堆中字符串的value数组指向常量池中常量对象的value数组）
也是使用通过对象赋值，只不过参数是数组，数组里面是char类型的数据（创建两个对象，同上）

@Test

public void test1(){

//创建String对象的三种方法

String str1 = “method1”;

String str2 = new String(“method2”);

char[] chars = {‘m’,‘e’,‘t’,‘h’,‘o’,‘d’,‘3’};

String str3 = new String(chars);

System.out.println(str1);

System.out.println(str2);

System.out.println(str3);

}

使用静态方法

这是String类自定义的静态方法；介绍如下：

copyValueOf(char data[]) 返回指定数组中表示该字符序列的 String
copyValueOf(char data[], int offset, int count)返回指定数组中表示该字符序列的 String
valueOf(char c)返回指定数组中表示该字符序列的 String
valueOf(char data[], int offset, int count)返回指定数组中表示该字符序列的 String
valueOf(int i) 支持各种数据类型(int改为其他的也行)，返回各种数据类型的value参数的字符串表示形式。

其源代码如下：

// 返回指定数组中表示该字符序列的 String

public static String copyValueOf(char data[]) {

return new String(data);

}

//返回指定数组中表示该字符序列的 String

public static String copyValueOf(char data[], int offset, int count) {

return new String(data, offset, count);

}

//返回指定数组中表示该字符序列的 String

public static String valueOf(char c) {

char data[] = {c};

return new String(data, true);

}

//返回指定数组中表示该字符序列的 String

public static String valueOf(char data[], int offset, int count) {

return new String(data, offset, count);

}

//支持各种数据类型(int改为其他的也行)，返回各种数据类型的value参数的字符串表示形式。

public static String valueOf(int i) {

return Integer.toString(i);

}

使用" " + 拼接

Java 语言提供对字符串串联符号（“+”）以及将其他对象转换为字符串的特殊支持（toString()方法）。在String类型中，任意数据类型与" "进行拼接，结果都是字符串。

代码示例如下：

public class Demo {

public static void main(String[] args) {

int num = 123456;

String s = “” +num;

System.out.println(s);

Student stu = new Student();

String s2 = stu + “”;//自动调用对象的toString()，然后与""进行拼接

System.out.println(s2);

}

class Student {

int id;

String name;

@Override

public String toString() {

return “Student{” +

“id=” + id +

“, name='” + name + ‘’’ +

‘}’;

}

这里既然说到了拼接，就不得不说字符串其拼接的特殊性问题，即不同形式创建的字符串所存储的位置是不同的，这也就使得即使字符串内容相同，但进行 == 比较时候，结果不同。其具体分类如下：

常量和常量：结果是常量池
常量与变量或变量与变量：结果是堆
任何形式拼接后调用intern方法：结果在常量池
使用contcat()方法拼接：结果在堆

代码示例：

@Test

public void test06(){

String s1 = “hello”; //变量

String s2 = “world”;

String s3 = “helloworld”;

String s4 = (s1 + “world”).intern();//把拼接的结果放到常量池中

String s5 = (s1 + s2).intern();

System.out.println(s3 == s4);//true

System.out.println(s3 == s5);//true

}

@Test

public void test05(){

final String s1 = “hello”; //final变成常量了

final String s2 = “world”;

String s3 = “helloworld”; //变量

String s4 = s1 + “world”;//s4字符串内容是helloworld，s1是常量，"world"常量，常量 + 常量结果在常量池中

String s5 = s1 + s2;//s5字符串内容是helloworld，s1和s2都是常量，常量 + 常量结果在常量池中

String s6 = “hello” + “world”;//常量 + 常量结果在常量池中，因为编译期间就可以确定结果

System.out.println(s3 == s4);//true

System.out.println(s3 == s5);//true

System.out.println(s3 == s6);//true

}

@Test

public void test04(){

String s1 = “hello”; //变量

String s2 = “world”;

String s3 = “helloworld”;

String s4 = s1 + “world”; //s4字符串内容是helloworld，s1是变量，"world"常量，变量 + 常量的结果在堆中

String s5 = s1 + s2;//s5字符串内容是helloworld，s1和s2都是变量，变量 + 变量的结果在堆中

String s6 = “hello” + “world”;//常量+ 常量结果在常量池中，因为编译期间就可以确定结果

System.out.println(s3 == s4);//false

System.out.println(s3 == s5);//false

System.out.println(s3 == s6);//true

}

@Test

public void test03(){

String str = “hello”;

String str2 = “world”;

String str3 =“helloworld”;

String str4 = “hello”.concat(“world”); //concat方法拼接，哪怕是两个常量对象拼接，结果也是在堆。

String str5 = “hello”+“world”;

System.out.println(str3 == str4);//false

System.out.println(str3 == str5);//true

}

字符串对象的比较

字符串的比较有很多种方式，不同方式比较的东西和形式不一样。其比较方式如下：

==：比较是对象的地址
equals：String类型重写equals方法，比较是对象的内容（区分大小写）
equalsIgnoreCase：比较的是对象的内容（不区分大小写）
compareTo：String类型重写了Comparable接口的抽象方法，自然排序，按照字符的Unicode编码值进行比较大小的（区分大小写）
compareToIgnoreCase：按照字符的Unicode编码值进行比较大小（不区分大小写）

代码示例

import org.junit.Test;

public class Demo7 {

// ==：比较的是地址

@Test

public void test1(){

String str1 = “hello”;

String str2 = “hello”;

System.out.println(str1 == str2);//true

String str3 = new String(“hello”);

String str4 = new String(“hello”);

System.out.println(str1 == str4); //false

System.out.println(str3 == str4); //false

}

// equals：比较是对象的内容，因为String类型重写equals，区分大小写

@Test

public void test2(){

String str1 = “hello”;

String str2 = “hello”;

String str5 = “Hello”;

System.out.println(str1.equals(str2));//true

String str3 = new String(“hello”);

String str4 = new String(“hello”);

System.out.println(str1.equals(str3));//true

System.out.println(str3.equals(str4));//true

System.out.println(str1.equals(str5));//false

}

// equalsIgnoreCase：比较的是对象的内容，不区分大小写

@Test

public void test3(){

String str1 = new String(“hello”);

String str2 = new String(“HELLO”);

System.out.println(str1.equalsIgnoreCase(str2)); //true

}

//compareTo：String类型重写了Comparable接口的抽象方法，自然排序，按照字符的Unicode编码值进行比较大小的，严格区分大小写

@Test

public void test4(){

String str1 = “hello”;

String str2 = “world”;

int i = str1.compareTo(str2);

System.out.println(i);//小于0的值

}

//compareToIgnoreCase：不区分大小写，其他按照字符的Unicode编码值进行比较大小

@Test

public void test5(){

String str1 = “hello”;

String str2 = “HELLO”;

int i = str1.compareToIgnoreCase(str2);

System.out.println(i);//0

}

字符串的常用方法

String类是非常常用的类，其方法也有很多，但并不是所有的方法都使用的那么频繁，所以在这里介绍了字符串的常用方法是有必要滴。常用方法介绍如下：

查找相关

boolean contains(xx)：是否包含xx
int indexOf(xx)：从前往后找当前字符串中xx，即如果有返回第一次出现的下标，要是没有返回-1
int lastIndexOf(xx)：从后往前找当前字符串中xx，即如果有返回最后一次出现的下标，要是没有返回-1
String substring(int beginIndex) ：返回一个新的字符串，它是此字符串的从beginIndex开始截取到最后的一个子字符串。

代码示例

@Test

public void test01(){

String str = “这是一个有关查找的测试方法，这个方法很棒”;

System.out.println(“是否包含“这个”：” + str.contains(“这个”));

System.out.println(““这”出现的第一次下标：” + str.indexOf(“这”));

System.out.println(““这”出现的最后一次下标：” + str.lastIndexOf(“这”));

}

字符串相关

String substring(int beginIndex, int endIndex) ：返回一个新字符串，它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。
char charAt(index)：返回[index]位置的字符
char[] toCharArray()：将此字符串转换为一个新的字符数组返回
String(char[] value)：返回指定数组中表示该字符序列的 String。
String(char[] value, int offset, int count)：返回指定数组中表示该字符序列的 String。
static String copyValueOf(char[] data)：返回指定数组中表示该字符序列的 String
static String copyValueOf(char[] data, int offset, int count)：返回指定数组中表示该字符序列的 String
static String valueOf(char[] data, int offset, int count) ：返回指定数组中表示该字符序列的 String
static String valueOf(char[] data) ：返回指定数组中表示该字符序列的 String

@Test

public void test01(){

String str = “helloworldjava”;

String sub1 = str.substring(5); //截取5到最后

String sub2 = str.substring(5,10);//截取5到10

System.out.println(sub1);

System.out.println(sub2);

}

@Test

public void test02(){

String fileName = “快速学习Java的秘诀.dat”;

//截取文件名

System.out.println(“文件名：” + fileName.substring(0,fileName.lastIndexOf(“.”)));

//截取后缀名

System.out.println(“后缀名：” + fileName.substring(fileName.lastIndexOf(“.”)));

}

@Test

public void test03(){

//将字符串中的字符按照大小顺序排列

String str = “helloworldjava”;

char[] array = str.toCharArray();

Arrays.sort(array);

str = new String(array);

System.out.println(str);//输出

}

@Test

public void test04(){

//将首字母转为大写

String str = “jack”;

str = Character.toUpperCase(str.charAt(0));

System.out.println(str);

}

解码编码相关

byte[] getBytes()：编码，把字符串变为字节数组，按照平台默认的字符编码进行编码
byte[] getBytes(字符编码方式)：按照指定的编码方式进行编码
new String(byte[] ) 或 new String(byte[], int, int)：解码，按照平台默认的字符编码进行解码
new String(byte[]，字符编码方式 ) 或new String(byte[], int, int，字符编码方式)：解码，按照指定的编码方式进行解码

代码示例

GBK，UTF-8，ISO8859-1所有的字符编码都向下兼容ASCII码

public static void main(String[] args) throws Exception {

String str = “中国”;

System.out.println(str.getBytes(“ISO8859-1”).length);// 2

// ISO8859-1把所有的字符都当做一个byte处理，处理不了多个字节

System.out.println(str.getBytes(“GBK”).length);// 4 每一个中文都是对应2个字节

System.out.println(str.getBytes(“UTF-8”).length);// 6 常规的中文都是3个字节

不乱码：（1）保证编码与解码的字符集名称一样
```
  （2）不缺字节
```

System.out.println(new String(str.getBytes(“ISO8859-1”), “ISO8859-1”));// 乱码

System.out.println(new String(str.getBytes(“GBK”), “GBK”));// 中国

System.out.println(new String(str.getBytes(“UTF-8”), “UTF-8”));// 中国

}

正则匹配相关

当需要进行表单校验时候，如果进行复杂的校验，比如邮箱，使用普通方式实现特别麻烦，那就可以使用正则匹配化复杂为简单。简单点说正则匹配就是一组实现起来较简单的验证数据的规则。

boolean matchs(正则表达式)：判断当前字符串是否匹配某个正则表达式

常用正则表达式：

字符类

[abc]：a、b 或 c（简单类）
[^abc]：任何字符，除了 a、b 或 c（否定）
[a-zA-Z]：a 到 z 或 A 到 Z，两头的字母包括在内（范围）

预定义字符类

.：任何字符（与行结束符可能匹配也可能不匹配）
\d：数字：[0-9]
\D：非数字： [^0-9]
\s：空白字符：[ \t\n\x0B\f\r]
\S：非空白字符：[^\s]
\w：单词字符：[a-zA-Z_0-9]
\W：非单词字符：[^\w]

边界匹配器

^：行的开头
$：行的结尾

Greedy 数量词

X?：X，一次或一次也没有
X*：X，零次或多次
X+：X，一次或多次
X{n}：X，恰好 n 次
X{n,}：X，至少 n 次
X{n,m}：X，至少 n 次，但是不超过 m 次

Logical 运算符

XY：X 后跟 Y
X|Y：X 或 Y
(X)：X，作为捕获组

代码示例

@Test

public void test01(){

//简单判断是否全部是数字，这个数字可以是1~n位

String str = “12a345”;

//正则不是Java的语法，它是独立与Java的规则

//在正则中\是表示转义，

//同时在Java中\也是转义

boolean flag = str.matches(“\d+”);

System.out.println(flag);

}

@Test

public void test02(){

String str = “123456789”;

//判断它是否全部由数字组成，并且第1位不能是0，长度为9位

//第一位不能是0，那么数字[1-9]

//接下来8位的数字，那么[0-9]{8}+

boolean flag = str.matches(“[1-9][0-9]{8}+”);

System.out.println(flag);

}

替换相关

String replace(xx,xx)：不支持正则
String replaceFirst(正则，value)：替换第一个匹配部分
String repalceAll(正则， value)：替换所有匹配部分

@Test

public void test01(){

String str = “hello244world.java;887”;

//把其中的非字母去掉

str = str.replaceAll(“[^a-zA-Z]”, “”);

System.out.println(str);

}

拆分相关

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

@Test

public void test1(){

String str = “张三.23|李四.24|王五.25”;

// |在正则中是有特殊意义，我这里要把它当做普通的|

String[] all = str.split(“\|”);

//输出结果

for (int i = 0; i < all.length; i++) {

System.out.println(all[i]);

}

其他

boolean isEmpty()：字符串是否为空
int length()：返回字符串的长度
String concat(xx)：拼接，等价于+
boolean equals(Object obj)：比较字符串是否相等，区分大小写
boolean equalsIgnoreCase(Object obj)：比较字符串是否相等，区分大小写
int compareTo(String other)：比较字符串大小，区分大小写，按照Unicode编码值比较大小
int compareToIgnoreCase(String other)：比较字符串大小，不区分大小写
String toLowerCase()：将字符串中大写字母转为小写
String toUpperCase()：将字符串中小写字母转为大写
String trim()：去掉字符串前后空白符

代码示例

@Test

public void test01(){

//将用户输入的单词全部转为小写，如果用户没有输入单词，重新输入

Scanner input = new Scanner(System.in);

String word;

while(true){

System.out.print(“请输入单词：”);

word = input.nextLine();

if(word.trim().length()!=0){

word = word.toLowerCase();

break;

}

System.out.println(word);

}

@Test

public void test02(){

//随机生成验证码，验证码由0-9，A-Z,a-z的字符组成

char[] array = new char[26*2+10];

for (int i = 0; i < 10; i++) {

array[i] = (char)(‘0’ + i);

}

for (int i = 10,j=0; i < 10+26; i++,j++) {

array[i] = (char)(‘A’ + j);

}

for (int i = 10+26,j=0; i < array.length; i++,j++) {

array[i] = (char)(‘a’ + j);

}

String code = “”;

Random rand = new Random();

for (int i = 0; i < 4; i++) {

code += array[rand.nextInt(array.length)];

}

System.out.println(“验证码：” + code);

//将用户输入的单词全部转为小写，如果用户没有输入单词，重新输入

Scanner input = new Scanner(System.in);

System.out.print(“请输入验证码：”);

最后

按照上面的过程，4个月的时间刚刚好。当然Java的体系是很庞大的，还有很多更高级的技能需要掌握，但不要着急，这些完全可以放到以后工作中边用别学。

学习编程就是一个由混沌到有序的过程，所以你在学习过程中，如果一时碰到理解不了的知识点，大可不必沮丧，更不要气馁，这都是正常的不能再正常的事情了，不过是“人同此心，心同此理”的暂时而已。

“道路是曲折的，前途是光明的！”

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
ic void test02(){

//随机生成验证码，验证码由0-9，A-Z,a-z的字符组成

char[] array = new char[26*2+10];

for (int i = 0; i < 10; i++) {

array[i] = (char)(‘0’ + i);

}

for (int i = 10,j=0; i < 10+26; i++,j++) {

array[i] = (char)(‘A’ + j);

}

for (int i = 10+26,j=0; i < array.length; i++,j++) {

array[i] = (char)(‘a’ + j);

}

String code = “”;

Random rand = new Random();

for (int i = 0; i < 4; i++) {

code += array[rand.nextInt(array.length)];

}

System.out.println(“验证码：” + code);

//将用户输入的单词全部转为小写，如果用户没有输入单词，重新输入

Scanner input = new Scanner(System.in);

System.out.print(“请输入验证码：”);

最后

“道路是曲折的，前途是光明的！”

[外链图片转存中…(img-TF1SAscK-1713550714034)]

[外链图片转存中…(img-Q7F29hBn-1713550714035)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）
[外链图片转存中…(img-P4wi2nNY-1713550714036)]

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！