Java常用类

字符串类🌟🌟🌟🌟🌟🌟

String字符串

String类代表字符串。 Java程序中的所有字符串文字（例如"abc" ）都被实现为此类的实例。

String类不🉑️变; 它们的值在创建后不能被更改。 因为String对象是不可变的，它们可以被共享。

// 产生了一个字符串"abc",给起了一个别名str
String str = "abc";
System.out.println(str);
// 产生了一个字符串"bcd",也给起了一个别名str
str = "bcd"; // 并没有改变"abc"的值,只是新建了一个字符串
System.out.println(str);

String类包括用于检查序列的各个字符的方法，用于比较字符串，搜索字符串，提取子字符串以及创建将所有字符翻译为大写或小写的字符串的副本。

如何产生String类的对象

// 一般使用这种产生字符串对象
String str1 = "abc";
// 有2个对象，一个是：abc对象，另一个是new 新对象
String str2 = new String("abc");
// 通过一个char数组产生了字符串对象
char[] array = {'a', 'b', 'c', 'd', 'e'};
String str3 = new String(array);
String str4 = new String(array, 1, 2); //bc
// 通过一个byte数组产生了字符串对象
byte[] bytes = {97, 98, 99, 100, 101};
String str5 = new String(bytes);
String str6 = new String(bytes, 0, 4);

String类关于对象比较问题

String str1 = "abc"; // 产生了abc字符串
String str2 = "abc"; // 使用过去产生的abc字符串
// 只要是new出来的就是新对象 只要是新对象，内存地址一定不一样
String str3 = new String("abc");
String str4 = new String("abc");
/*
    ==的作用：
    如果是原始数据类型：比较的是值
    引用数据类型：比较的是地址
 */
System.out.println(str1 == str2); // 比较两个字符串的地址是否相等
System.out.println(str3 == str4);
System.out.println(str3 == "abc");
System.out.println(str3 == str1);
System.out.println(str1 == "abc");

String类的常用方法

// String类的常见方法1⃣️
public static void d() {
    String str = "Hello,World!我是张三！";
    int len = str.length(); //返回此字符串的长度。字符个数
    char c = str.charAt(3); //返回char指定索引处的字符。
    char[] chars = str.toCharArray(); // 将字符串转换成字符数组
    byte[] bytes = str.getBytes(); // 将字符串转换成字节数组
    String lowerStr = str.toLowerCase(); // 获取小写形式
    String upperStr = str.toUpperCase(); // 获取大写形式
    boolean b = str.isEmpty(); // 判断字符串是否是空字符串 ""
​
    System.out.println(len);
    System.out.println(c);
    System.out.println(Arrays.toString(chars));
    System.out.println(Arrays.toString(bytes));
    System.out.println(lowerStr);
    System.out.println(upperStr);
    System.out.println(b ? "空字符串" : "非空字符串");
}
​
​
// String类的常见方法2⃣️
public static void e() {
    String str = "zhangsandechange.txt";
    boolean b1 = str.startsWith("zh"); //判断字符串是否以zh开头
    boolean b2 = str.endsWith(".txt");// 判断字符串是否以.txt结尾
    boolean b3 = str.contains("ab"); // 字符串中是否包含ab
    int index1 = str.indexOf("a"); // 获取a字符串在目标字符串中第一次出现的位置 如果没有返回-1
    int index2 = str.lastIndexOf("a"); // 获取a字符串在目标字符串中最后一次出现的位置 如果没有返回-1
    int index3 = str.indexOf("a", 3); // 获取a字符串在目标字符串中从第4个开始第一次出现的位置 如果没有返回-1
    System.out.println(b1);
    System.out.println(b2);
    System.out.println(b3);
    System.out.println(index1);
    System.out.println(index2);
    System.out.println(index3);
}
​
// String类的常见方法3⃣️
public static void f() {
    String str = "abcdefg";
    String newStr1 = str + "789"; // str和"789"两个字符串拼接产生一个新字符串
    String newStr2 = str.concat("789");// str和"789"两个字符串拼接产生一个新字符串
    System.out.println(newStr1);
    System.out.println(newStr2);
}
​
// String类的常见方法4⃣️
public static void g() {
    String str = "      a            b            c             ";
    System.out.println(str);
    String newStr1 = str.trim(); // 去除前后空格 产生一个新字符串
    String newStr2 = str.replace(" ", ""); // 替换字符串
    System.out.println(newStr1);
    System.out.println(newStr2);
}
​
// String类的常见方法5⃣️
public static void h() {
    String str1 = new String("abc");
    String str2 = new String("aBc");
    boolean b1 = str1.equals(str2); // 比较2个字符串的值是否相等
    boolean b2 = str1.equalsIgnoreCase(str2); // 比较2个字符串的值是否相等 不区分大小写
​
    System.out.println(str1 == str2); // 比较地址是否相等
    System.out.println(b1);
    System.out.println(b2);
}
​
// String类的常见方法6⃣️
public static void i() {
    String str = "陕西省商洛市商洛学院门口有个奶茶店";
    String subStr1 = str.substring(6, 10); // 截取字符串，[6,10)-->[6,9]
    String subStr2 = str.substring(7); // 截取字符串 从索引为7的开始截取到自然节点结束
    System.out.println(subStr1);
    System.out.println(subStr2);
}
​
// String类的常见方法7⃣️
public static void j() {
    String str1 = "sgklj,dslflkds,hfldshfl,kds";
    String str2 = "sdfkjdsfklekfdskfldskfkjldsflkdhfsd";
    String[] array1 = str1.split(","); // 按照,将字符串分割成一次字符串数组
    String[] array2 = str2.split("k"); // 按照k将字符串分割成一次字符串数组
    System.out.println(Arrays.toString(array1));
    System.out.println(Arrays.toString(array2));
}
​
​
// String类的常见方法8⃣️
/*
字符串池:
当调用intern方法时，如果池已经包含与equals(Object)方法确定的相当于此String对象的字符串，则返回来自池的字符串。 否则，此String对象将添加到池中，并返回对此String对象的引用。
 */
public static void k() {
    // 字符串池  重复使用字符串
    // 3个对象
    String s1 = "abc"; // 创建一个字符串"abc" 把字符串放入到池(字符串池)子中
    String s2 = "abc"; // 只需要将池子里边的"abc"给s2就行  共享使用了池子里的"abc"
    String s3 = new String("abc"); // 就是新建对象
    String s4 = new String("abc"); // 就是新建对象
    // 手动的从池子里获取内容
    String s5 = s1.intern(); // 从池子中获取到值为"abc"的字符串
    String s6 = s2.intern(); // 从池子中获取到值为"abc"的字符串
    String s7 = s3.intern(); // 从池子中获取到值为"abc"的字符串
    String s8 = s4.intern(); // 从池子中获取到值为"abc"的字符串
    System.out.println(s5==s6);
    System.out.println(s5==s7);
    System.out.println(s5==s8);
}

StringBuilder字符串

可变的字符序列，线程非安全。 字符串缓冲区就像一个String ，但可以修改。 在任何时间点，它包含一些特定的字符序列，但可以通过某些方法调用来更改序列的长度和内容。

在可能的情况下，建议使用这个类别优先于StringBuffer ，因为它在大多数实现中将更快。

如何产生对象

StringBuilder str1 = new StringBuilder();
StringBuilder str2 = new StringBuilder("abc");
// StringBuilder str3 = "abc"; ❌
System.out.println(str1);
System.out.println(str2);

StringBuilder类和String类之间类型转换

String s1 = "abc";
// String--->StringBuilder
StringBuilder s2 = new StringBuilder(s1);
// StringBuilder--->String
String s3 = s2.toString();

常见方法

StringBuilder s = new StringBuilder("abc");
// 追加方法
s.append("aa"); //abcaa
s.append(66);
s.append(5.6);
// 插入方法
s.insert(3, "张三"); // 将张三插入到第4个字符之前
// 删除方法
s.deleteCharAt(3); // 删除一个字符
s.delete(2, 5);// 删除区间 [2,5)
// 反转字符串
s.reverse();

StringBuffer字符串

线程安全，可变的字符序列。 字符串缓冲区就像一个String ，但可以修改。 在任何时间点，它包含一些特定的字符序列，但可以通过某些方法调用来更改序列的长度和内容。

字符串缓冲区可以安全地被多个线程使用。 这些方法在必要时进行同步，以便任何特定实例上的所有操作都按照与所涉及的各个线程所执行的方法调用顺序一致的顺序发生。

StringBuffer的主要StringBuffer是append和insert方法，它们被重载以便接受任何类型的数据。 每个都有效地将给定的数据转换为字符串，然后将该字符串的字符附加或插入到字符串缓冲区。 append方法总是在缓冲区的末尾添加这些字符; insert方法将insert添加到指定点。

它和StringBuilder类的作用基本一致，除过它是线程安全，而StringBuilder是线程非安全的。

时间日期相关类

Date类

Date类表示特定的时间。其中一些方法被Calendar类所替代。

产生对象

// 获取当前系统时间
Date d1 = new Date();
// 设置自定义的时间 将其初始化为表示自称为“时代”的标准基准时间以后的指定毫秒数，即1970年1月1日00:00:00 GMT。
Date d2 = new Date(19999838088800L);
// 设置自定义的时间 已过时 年:1900开始 月:0
Date d3 = new Date(110,4,6,7,8,9);

常见方法

long time = d.getTime(); // 距离1970年1月1日 0:0:0的毫秒差
// 剩下方法已过时
int year = d.getYear(); // 1900
int month = d.getMonth();// 0
int date = d.getDate(); // 1
int hour = d.getHours();// 0
int minute = d.getMinutes(); // 0
int second = d.getSeconds(); // 0
Date d1 = new Date(9999877L);   
Date d2 = new Date(972837637L); 
// 比较两个时间之间的关系                  
int result = d1.compareTo(d2);  // 正数:d1时间新 负数:d2时间新 0:一样

LocalDateTime类🌟🌟🌟

LocalDateTime是一个不可变的日期时间对象，代表日期时间，通常被视为年 – 月 – 日 – 时 – 分 – 秒。 也可以访问其他日期和时间字段，例如日期，星期几和星期。 时间表示为纳秒精度。 例如，值“2007年10月2日在13：45.30.123456789”可以存储在LocalDateTime 。

产生对象

// 获取到当前时间 因为构造器私有，不能通过new来产生时间
LocalDateTime dateTime = LocalDateTime.now();
// 产生了一个指定日期的时间
LocalDateTime dateTime1 = LocalDateTime.of(2011,8,4,19,23,17);

常见方法

LocalDateTime d = LocalDateTime.now();
int year = d.getYear();
int month = d.getMonthValue();
int date = d.getDayOfMonth();
int dayOfYear = d.getDayOfYear(); // 获取到当前年的第几天
int hour = d.getHour();
int minute = d.getMinute();
int second = d.getSecond();
int week = d.getDayOfWeek().getValue(); // 获取到星期
LocalDateTime d1 = LocalDateTime.of(1900,7,8,1,1,1);
int result = d.compareTo(d1); // 比较时间的远近

Calendar类

所述Calendar类是一个抽象类，可以为在某一特定时刻和一组之间的转换的方法calendar fields如YEAR ， MONTH ， DAY_OF_MONTH ， HOUR ，等等，以及用于操纵该日历字段，如获取的日期下个星期。 时间上的瞬间可以用毫秒值表示，该值是从1970年1月1日00:00 00：00.000 GMT（Gregorian）的Epoch的偏移量。

产生对象

// Calendar 是一个抽象类
Calendar c = Calendar.getInstance();

常见方法

Calendar c = Calendar.getInstance();
int year = c.get(Calendar.YEAR);
int month = c.get(Calendar.MONTH);
int date = c.get(Calendar.DAY_OF_MONTH);
int hour = c.get(Calendar.HOUR_OF_DAY);
int minute = c.get(Calendar.MINUTE);
int second = c.get(Calendar.SECOND);

格式化相关类

SimpleDateFormat类格式化日期

Date date = new Date();
/*
    y:年 M:月 d:天
    H|h:时 m:分 s:秒
    E:星期 D:一年第几天 w:一年中第几周 W:月的周数
    a:上午AM下午PM z:代表时区
 */
String pattern = "E yyyy年MM月dd日 HH:mm:ss z"; // 格式化规则
SimpleDateFormat format = new SimpleDateFormat(pattern);
String formatStr = format.format(date); // 格式化成一个字符串
System.out.println(formatStr);

printf来格式化日期

Date date = new Date();
/*
    c:全部时间
    F:年-月-日
    D:年/月/日
    r:HH:MM:SS PM格式 12小时进制
    T:HH:MM:SS 24小时进制
    R:HH:MM 24小时进制
 */
// printf方法输出格式化之后的时间 必须以%t开头  %n:换行 类似于\n
System.out.printf("格式化1：%tc%n",date);
System.out.printf("格式化2：%tF%n",date);
System.out.printf("格式化3：%tD%n",date);
System.out.printf("格式化4：%tr%n",date);
System.out.printf("格式化5：%tT%n",date);
System.out.printf("格式化6：%tR%n",date);

包装类

Java将数据类型分为：原始数据类型和引用数据类型，其中原始类型是系统自带，简单方便，但是没有方法，JVM引入原始类型对应的引用数据类型，那么这些引用数据类型被称之为包装类。

Number类的常用方法

Integer i = 77;
byte b = i.byteValue(); // 返回byte类型结果
double d = i.doubleValue(); // 返回double 类型结果
int a = i.intValue(); // 返回int类型结果

String和int之间的类型转换

// 如何将字符串--->int
int a1 = Integer.parseInt("12345"); // String--->int 重点
int a2 = Integer.parseInt("1101",2); // 二进制转换 转成一个数字(10)
int a3 = Integer.parseInt("12345",8); // 八进制转换 转成一个数字(10)
int a4 = Integer.parseInt("abc4f",16); // 十六进制转换 转成一个数字(10)
// int--->String
String s1 = a1 + "";
String s2 = String.valueOf(a2);

String和double之间的类型转换

// String--->double
double d = Double.parseDouble("789");
// double--->String
String s1 = d + "";
String s2 = String.valueOf(d);

拆箱装箱

拆箱：将包装类转换成对应的原始数据类型

装箱：将原始数据类型转换成对应的包装类

手动拆箱装箱

int a1 = 7; // 基本数据类型
double b1 = 7.5;
Integer a2 = new Integer(a1); // 装箱操作
Double b2 = new Double(b1);
int a3 = a2.intValue(); // 拆箱操作
double b3 = b2.doubleValue();

自动拆箱装箱

int a1 = 5;
double b1 = 5.6;
Integer a2 = a1; // 系统会自动装箱
Double b2 = b1;
int a3 = a2; // 系统会自动拆箱
double b3 = b2;

数学类

Math类包含执行基本数字运算的方法，如基本指数，对数，平方根和三角函数。

// Math类不能产生对象，内容都是静态的
double e = Math.E;
double pi = Math.PI;
double random = Math.random(); // 随机数 返回[0,1)的一个随机小数
double max = Math.max(5, 6); // 返回2个数之间的最大数
double min = Math.min(5, 6); // 返回2个数之间的最小叔
int abs = Math.abs(-5);// 返回绝对值
double a1 = Math.floor(6.7); // 向下取整
double a2 = Math.ceil(6.7); // 向上取整
double a3 = Math.round(6.7); // 四舍五入取整
int a4 = (int) (6.7); // 一般使用这个 向下取整

系统相关类

System类代表系统，系统级的很多属性和控制方法都放置在该类的内部。该类位与java.lang包。

由于该类的构造方法是private的，所以无法创建该类的对象，也就是无法实例化该类。其内部的成员变量和成员方法都是static的，所以也可以很方便的进行调用。

// 获取out和in对象
OutputStream out = System.out;
InputStream in = System.in;
// 返回当前的时间(以毫秒为单位)，要减去1970年的毫秒数
long time = System.currentTimeMillis();
// 终止当前运行的Java虚拟机，非零表示异常终止
System.exit(1);
// 数组复制操作
System.arraycopy(src,srcPos,desc,descPos,length);

Object类🌟🌟🌟🌟

Class Object是类Object结构的跟类。 每个class都有Object作为超类。 所有对象（包括数组）都实现了这个类的方法。

equals方法的注意

问：equals方法有什么作用？

答：比较对象的地址是否相等，而String的equals方法重写了父类的方法，比较对象的值是否相等，我们自己也可以重写这个方法，按照自己的规则进行比较。