常用API
1、String
字符串是不可变的
字符串一旦创建是不可变的，对字符串的任何操作实际上都是创建一个新的字符串对象，然后将当前变量的引用地址替换为新对象的地址。
常见创建字符串方式
//1.直接赋值
String str = "hello";
//2.通过构造方法，空参
String str1 = new String();
//3.构造方法传入字符数组创建字符串
char[] chars = {'h','e','l','l','o'};
String str2 = new String(chas);
//4.字节数组传参
byte[] bytes = {104,101,108,108,111};
String str3 = new String(bytes);
字符串拼接
String talk = "你好，你是干什么的"；
String result = talk.substring(3,5);//包左不包右
System.out.println(result);
你是
2、StringBuilder类
StringBuilder类输出的是属性而不是一个地址。
StringBuilder sb = new StringBuilder("abc");
/*sb.append(123);
System.out.println(sb);
结果为:abc123
*/
/*sb.reverse();
System.out.println(sb);
结果为：cba
*/
/*int len = sb.length();
System.out.println(len);
结果为：3
*/
String str = sb.toString();
System.out.println(str);
结果为：abc//转换为string对象可以使用该对象的方法
字符串的拼接没有变量参与，字符串的值都在字符串常量池中，值相同，他们就相等。如果有变量参与，新的字符串就是通过new创建的对象，存在堆中，他们的值相同，却不相等。
Stringjoiner类
将数组按要求拼接成字符串的类。
int[] arr1 = {1,2,3};
//将整数数组转为字符串
String string = Arrays.toString(arr1);
StringJoiner sj = new StringJoiner("[",",","]");//三个参数分别代表“开始”，“间隔”，“结束”
sj.add(string);
System.out.println(string);
3、Math类
进行数学计算的工具类，方法一般都是静态的，可以通过类名调用。
4、System类
exit()方法，退出程序。
currentTimeMiles()方法，获取自1970年1月1号八点开始的时间戳。
arraycopy(数据源数组,起始索引,目标数组,目标索引,拷贝个数)，获取数组拷贝。
5、Runtime类
Runtime runtime = Runtime.getRuntime();
runtime.totalMemory();//已占用的内存
runtime.freeMemory();//剩余可占用内存
runtime.maxMemory();//最大内存
6、Object类
重写toString()方法
public InterTest(String name) {
super(name);
}
@Override
public String toString() {
return getName();
}
如果toString方法不重写，默认返回的是对象的地址。
重写equals()方法
@Override
public final boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass()!=o.getClass()) return false;
InterImpl inter1 = (InterImpl) o;
return Objects.equals(name, inter1.name);
}
@Override
public int hashCode() {
return Objects.hashCode(name);
}
在实际应用中自定义规则校验是否存在重复对象。
clone()方法
- 使用该方法需要先重写，然后再使用。
- 实现类要继承Cloneable接口（没有抽象方法，标记性接口，表示一旦实现，当前类对象就可被克隆）。
//浅拷贝
import java.util.StringJoiner;
//实现类要实现Cloneable接口
public class User implements Cloneable{
private int id;
private String userName;
private String password;
private String path;
private int[] data;
public User() {//空参构造
}
public User(int id, String userName, String password, String path, int[] data) {//带参构造
this.id = id;
this.userName = userName;
this.password = password;
this.path = path;
this.data = data;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getPath() {
return path;
}
public void setPath(String path) {
this.path = path;
}
public int[] getData() {
return data;
}
public void setData(int[] data) {
this.data = data;
}
//重写toString方法将用户信息作为字符串返回
@Override
public String toString() {
return "id为" + id + ", 用户名；" + userName + ", 密码：" + password + ", 游戏图片；" + path + ", 进度；" +arrToString();
}
//arrToString方法，将游戏进度数组转为字符串
public String arrToString() {
StringJoiner sj = new StringJoiner(",", "[", "]");
for (int i = 0; i < data.length; i++) {
sj.add(data[i] + "");
}
return sj.toString();
}
//重写克隆方法，空参方法，重写用户对象才能调用
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
//测试类
public class cloneTest {
public static void main(String[] args) throws CloneNotSupportedException {
int[] data = {1,2,3,4,5,6,7,8,9};
User user = new User(1,"zhangsan","1234qwer","girl11",data);
//将Object类强转用户类
User user2 = (User)user.clone();
System.out.println(user);
System.out.println(user2);
}
}
================这是一个分界线======================
//深拷贝
@Override
protected Object clone() throws CloneNotSupportedException {
int[] data = this.data;
//创建一个和对象同样长度的数组
int[] newData = new int[data.length];
//手动拷贝数组
System.arraycopy(data, 0, newData, 0, data.length);
//克隆的对象
User u = (User) super.clone();
//用拷贝后的数组覆盖原先的地址引用(浅拷贝)
u.data = newData;
return u;
}
为什么是浅拷贝
克隆时，基本数据类型克隆的是具体的值，引用对象克隆的是具体数据的引用，也就是地址。克隆前后实际指向的是同一个地址的数据。
误区
字符串处理中，建立的新字符串不代表原数组的数据备份，只是为了在输出时输出的是具体内容，而非对象的地址。
1.重写Object的clone()方法。
2.让对象类实现Cloneable接口。
3.创建对象并调用clone()。
6、Objects工具类
equals()方法
底层先做非空判断，再比较两个对象。
isNull方法
空为true，非空为false。
7、正则表达式(Pattern)
变量名.matches(正则表达式)
public class RegexDemo01 {
public static void main(String[] args) {
String qq = "12341236547804256789";
//表示第一位非零数字，后面是5-19位数字，范围在0-9之间
boolean result = qq.matches("[1-9]\\d{5,19}");
System.out.println(result);
}
}
any-rule插件工具。
replaceAll()方法
按制定规则替换字符串。
String s = "小诗诗anfiubaeiu123小丹丹sadushnfi156小惠惠";
//将除下划线的大小写字符和数字替换成vs
String result =s.replaceAll("[\\w&&[^_]]+","vs");
System.out.println(result);
split()方法
按制定规则截取字符串。
String s = "小诗诗anfiubaeiu123小丹丹sadushnfi156小惠惠";
//按照除下划线的大小写字符和数字截取字符串，截取的结果成一个数组
String[] arr = s.split("[\\w&&[^_]]+");
for(int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
1.爬取
Pattern&Matcher
按照规则获取指定的内容。
public class RegexDemo02 {
public static void main(String[] args) {
String str = "今天天气不错，适合学习java。java8是一门强大的语言，不管是java17还是java21，都很有趣。我的博客地址是： https://blog.java.net/artificial/4399 。";
//1.建立一个爬取规则
Pattern p = Pattern.compile("java\\d{0,2}");
//2.一个依赖规则的爬取对象
Matcher m = p.matcher(str);
//循环查找符合条件内容，并输出
while(m.find()) {
String s = m.group();
System.out.println(s);
}
}
}
浙公网安备 33010602011771号