Java常用类（完整版）

其他类

Object类

超类、基类，所有类的直接或间接父类，位于继承树的最高层

任何类，如果没有书写extends显示继承某个类，都默认直接继承Object类

Object类中所定义的方法，是所有对象都具备的方法

Object类型可以存储任何对象：

​ 作为参数，可接受任何对象

​ 作为返回值，可接受任何对象

public class Student {private String name;private int age;public Student() {}public Student(String name,int age){super();this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}@Overridepublic String toString() {return "Student [name = " + name + " , age = " + age + "]";}@Overridepublic boolean equals(Object obj) {// 1. 判断俩个对象是否是同一个引用if (this==obj){return true;}// 2. 判断obj是否为nullif (obj == null){return false;}// 3. 判断是否是同一个类型if (obj instanceof Student){// 4. 强制类型转换Student s = (Student) obj;// 5. 比较属性if (this.name.equals(s.getName()) && this.age==s.getAge()){return true;}}return false;}
}// 测试类
public class TestStudent {public static void main(String[] args) {Student s1 = new Student("aaa",25);Student s2 = new Student("bbb",35);}
}

getClass()方法

语法：public final Class<?> getClass(){}

返回引用中存储的实际对象类型

应用：通常用于判断俩个引用中实际存储对象类型是否一致

// getClass方法// 判断s1和s2是不是同一个类型Class class1 = s1.getClass();Class class2 = s2.getClass();if (class1 == class2){System.out.println("s1和s2属于同一个类型");}else {System.out.println("s1和s2不属于同一个类型");}System.out.println("----------------------");//运行结果：// s1和s2属于同一个类型

hashCode()方法

语法：public int hashCode(){}

返回该对象的哈希码值

哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的数值

一般情况下相同对象返回相同哈希码值

// hashCode方法System.out.println(s1.hashCode());  // 460141958System.out.println(s2.hashCode());  // 1163157884Student s3 = s1;System.out.println(s3.hashCode());  // 460141958System.out.println("----------------------");

toString()方法

语法：public String toString(){}

返回该对象的字符串表示（表现形式）

可以根据程序需要覆盖该方法，如：展示对象各个属性值（重写方法）

        // toString方法System.out.println(s1.toString());System.out.println(s2.toString());System.out.println("----------------------");运行结果：Student [name = aaa , age = 25]Student [name = bbb , age = 35]

equals()方法

语法：public boolean equals(Object obj){}

默认实现为（this == obj），比较俩个对象地址是否相同

可进行覆盖（重写），比较俩个对象的内容是否相同

// equals方法System.out.println(s1.equals(s2));  // falseStudent s4 = new Student("小明",18);Student s5 = new Student("小明",18);System.out.println(s4.equals(s5));  // true 重写方法后运行结果：falsetrue

equals()方法覆盖步骤1. 比较俩个引用是否指向同一个对象2. 判断obj是否为null3. 判断俩个引用指向的实际对象类型是否一致4. 强制类型转换5. 依次比较各个属性值是否相同

finalize()方法

当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象，进入回收队列

垃圾对象：没有有效引用指向此对象，为垃圾对象

垃圾回收：由GC销毁垃圾对象，释放数据存储空间

自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象

手动回收机制：使用 System.gc(); 通知JVM执行垃圾回收

完整代码

public class Student {private String name;private int age;public Student() {}public Student(String name,int age){super();this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}@Overridepublic String toString() {return "Student [name = " + name + " , age = " + age + "]";}@Overridepublic boolean equals(Object obj) {// 1. 判断俩个对象是否是同一个引用if (this==obj){return true;}// 2. 判断obj是否为nullif (obj == null){return false;}// 3. 判断是否是同一个类型if (obj instanceof Student){// 4. 强制类型转换Student s = (Student) obj;// 5. 比较属性if (this.name.equals(s.getName()) && this.age==s.getAge()){return true;}}return false;}
}// 测试类public class TestStudent {public static void main(String[] args) {Student s1 = new Student("aaa",25);Student s2 = new Student("bbb",35);// getClass方法// 判断s1和s2是不是同一个类型Class class1 = s1.getClass();Class class2 = s2.getClass();if (class1 == class2){System.out.println("s1和s2属于同一个类型");}else {System.out.println("s1和s2不属于同一个类型");}System.out.println("----------------------");//运行结果：// s1和s2属于同一个类型// hashCode方法System.out.println(s1.hashCode());  // 460141958System.out.println(s2.hashCode());  // 1163157884Student s3 = s1;System.out.println(s3.hashCode());  // 460141958System.out.println("----------------------");// toString方法System.out.println(s1.toString());System.out.println(s2.toString());System.out.println("----------------------");// equals方法System.out.println(s1.equals(s2));  // falseStudent s4 = new Student("小明",18);Student s5 = new Student("小明",18);System.out.println(s4.equals(s5));  // true 重写方法后}
}

包装类

什么是包装类

Java的基本数据类型（如int、char、boolean等）是非对象的，不能直接参与面向对象的操作，也不能直接调用方法。为了解决这个问题，Java提供了对应的包装类。

包装类就是：基本数据类型所对应的引用数据类型

Object 可统一所有数据，包装类的默认值是 null

包装类对应

基本数据类型	包装类型
byte	Byte
short	Short
long	Long
float	Float
double	Double
boolean	Boolean
int	Integer
char	Character

类型转换与装箱、拆箱

• 8种包装类提供不同类型间的转换方式：

  • Number父类中提供的6个共性方法
  • parseXXX ( )静态方法
  • valueOf ( )静态方法

• 注意：需要保证类型兼容，否则抛出 NumberFromatException 异常

public class Demo01 {public static void main(String[] args) {// int num = 10;// 类型转换：    装箱：基本类型转成引用类型的过程// 基本类型int num1 = 18;// 使用Integer类创建对象Integer integer1 = new Integer(num1);Integer integer2 = Integer.valueOf(num1);System.out.println("装箱");System.out.println(integer1);System.out.println(integer2);// 类型转型：    拆箱：引用类型转成基本类型Integer integer3 = new Integer(100);int num2 = integer3.intValue();System.out.println("拆箱");System.out.println(num2);// 在JDK1.5之后，Java提供了自动装箱和自动拆箱int age = 30 ;// 自动装箱Integer integer4 = age;System.out.println("自动装箱");System.out.println(integer4);// 自动拆箱int age2 = integer4;System.out.println("自动拆箱");System.out.println(age2);System.out.println("=============基本类型和字符串之间转换==============");// 基本类型和字符串之间转换// 1. 基本类型转换成字符串int n1 = 255;int n2 = 15;// 1-1 使用 +    相连String s1 = n1+"";String s2 = n2+"";// 1-2 使用Integer中的 toString()方法String s3 = Integer.toString(n1,16);String s4 = Integer.toString(n2,16);System.out.println(s1);  // 255System.out.println(s2);  // 15System.out.println(s3);  // ffSystem.out.println(s4);  // f// 2. 字符串转基本类型String str = "150";// 使用 Integer.parseXXX();int n3 = Integer.parseInt(str);System.out.println(n3);  // 150// boolean 字符串形式转成基本形式。 "true" --> true    非true --> falseString str2 = "true";String str3 = "abcd";boolean b1 = Boolean.parseBoolean(str2);boolean b2 = Boolean.parseBoolean(str3);System.out.println(b1);  // trueSystem.out.println(b2);  // false}
}

整数缓冲区

Java预先创建了256个常用的整数包装类型对象

在实际应用中，对已创建的对象进行复用

// 整数缓冲区public static void main(String[] args) {Integer integer1 = new Integer(100);Integer integer2 = new Integer(100);System.out.println(integer1==integer2);  // false// 自动装箱  Integer.valueOfInteger integer3 = 100;Integer integer4 = 100;System.out.println(integer3==integer4);  // trueInteger integer5 = 200;Integer integer6 = 200;System.out.println(integer5==integer6);  // false}

integer3 与 integer4 相等是因为：在整数缓冲区范围内（-128~127）

integer5 与 integer6 不相等是因为：范围（200）已经超出缓冲区范围，变为 使用new 关键字

String 类

定义

字符串是常量。创建之后不可改变

字符串字面值存储在字符串池中，可以共享

String s = “Hello” ; // 产生一个对象，字符串池中存储

String s = new String (“Hello”) ; // 产生俩个对象，堆、池各存储一个。

如图所示

在JDK1.7之前运行时常量池逻辑包含字符串常量池存放在方法区, 此时hotspot虚拟机对方法区的实现为永久代
在JDK1.7 字符串常量池被从方法区拿到了堆中, 这里没有提到运行时常量池,也就是说字符串常量池被单独拿到堆,运行时常量池剩下的东西还在方法区, 也就是hotspot中的永久代
在JDK1.8 hotspot移除了永久代用元空间(Metaspace)取而代之, 这时候字符串常量池还在堆, 运行时常量池还在方法区, 只不过方法区的实现从永久代变成了元空间(Metaspace)String name = "hello";  // "hello" 常量存储在字符串池中
name = "zhangsan";  // "zhangsan" 赋值给name变量，给字符串赋值时，并没有修改数据，而是重新开辟一个空间
String name2 = "zhangsan";
System.out.println(name==name2);  // true// 演示字符串的另一种创建方式， new String();
String str = new String("java");
String str2 = new String("java");  // 在堆的空间新开辟了str2，虽然指向的是同一个数据，但是地址是不一样的
System.out.println(str==str2);  // false  使用 == 比较的是地址
System.out.println(str.equals(str2));  // true  使用 equals 比较的是数据

常用方法

1. public int length () ; 返回字符串的长度

2. public char charAt (int index) ; 根据下标获取字符

3. public boolean contains (String str) ; 判断当前字符串中是否包含str

           // 字符串方法的使用// 1. length(); 返回字符串的长度    注意：这里空格也算一个字符串长度// 2. charAt(int index); 返回某个位置的字符// 3. contains(String str); 判断是否包含某个子字符串String s = "Java是世界上最好的编程语言,Java就是最简单的,Java最好";System.out.println(s.length());  // 15System.out.println(s.charAt(5));  // 世System.out.println(s.charAt(s.length()-1));  // 言System.out.println(s.contains("java"));  // falseSystem.out.println(s.contains("Java"));  // trueSystem.out.println(s.contains("JavaScript"));  // false
   

4. public char[ ] toCharArray ( ) ; 将字符串转换成数组

5. public int indexOf (String str) ; 查找str首次出现的下标，存在，则返回该下标；不存在，则返回-1

6. public int lastIndexOf (String str) ; 查找字符串在当前字符串中最后一次出现的下标索引

   		// 4. toCharArray(); 返回字符串对应的数组// 5. indexOf(); 返回字符串首次出现的位置，如果未找到，返回-1。后面如果＋数字表示：从第几个位置开始查找// 6. lastIndexOf(); 返回字符串最后一次出现的位置System.out.println(s.toCharArray());  // Java是世界上最好的编程语言,Java就是最简单的,Java最好System.out.println(Arrays.toString(s.toCharArray()));  // [J, a, v, a, 是, 世, 界, 上, 最, 好, 的, 编, 程, 语, 言, ,, J, a, v, a, 就, 是, 最, 简, 单, 的, ,, J, a, v, a, 最, 好]System.out.println(s.indexOf("Java"));  // 0System.out.println(s.indexOf("Java",4));  // 16System.out.println(s.lastIndexOf("Java"));  // 27
   

7. public String trim () ; 去掉字符串前后的空格

8. public String toUpperCase () ; 将小写转为大写

9. public boolean endWith (String str) ; 判断字符串是否以str结尾

   		// 7. trim(); 去掉字符串前后的空格// 8. toUpperCase(); 把小写转为大写   toLowerCase(); 把大写转为小写// 9. endsWith(str); 判断是否以str结尾   startsWith(str); 判断是否以str开始String s2 = "     Hello World !   ";System.out.println(s2.trim());  // Hello World !System.out.println(s2.toUpperCase());  //      HELLO WORLD !System.out.println(s2.toLowerCase());  //      hello world !String s3 = "hello.java";System.out.println(s3.endsWith("va"));  // trueSystem.out.println(s3.startsWith("he"));  // trueSystem.out.println(s3.startsWith("ll"));  // false
   

10. public String replace (char oldChar , char newChar) ; 将旧字符串替换成新字符串

11. public String[ ] split (String str) ; 根据str做拆分

    		String s4 = "java is the best language java";String say = "java is the best    programing language,java is good.";System.out.println(s4.replace("java","php"));  // php is the best language phpString[] arr = say.split("[ ,.]+");System.out.println(arr.length);  // 9for (String string:arr) {System.out.println(string);}
    /*
    java
    is
    the
    best
    programing
    language
    java
    is
    good*/
    

12. 补充

    补充俩个方法 equals、compareTo(); 比较大小String str3 = "hello";String str4 = "HELLO";System.out.println(str3.equals(str4));  // falseSystem.out.println(str3.equalsIgnoreCase(str4));  // trueString a1 = "abc";  // 97  比较ASCII码String a2 = "ayzawe";  // 120System.out.println(a1.compareTo(a2));  // -23   比较大小String a3 = "abc";  // 3String a4 = "abcdefg";  // 7System.out.println(a3.compareTo(a4));  // -4    比较长度 3-7
    

测试

已知 String str = “this is a text”;

1. 将 str 中的单词单独获取出来
2. 将 str 中的text替换为 practice
3. 在 text 前面插入一个 easy
4. 将每个单词的首字母改为大写

public class Test {public static void main(String[] args) {String str = "this is a text";// 1. 将 str 中的单词单独获取出来String[] arr =str.split(" ");// System.out.println(arr);for (String s:arr) {System.out.println(s);}System.out.println("----------------");// 2. 将 str 中的text替换为 practiceString str2 = str.replace("text","practice");System.out.println(str2);System.out.println("----------------");// 3. 在 text 前面插入一个 easyString str3 = str.replace("text","easy text");System.out.println(str3);System.out.println("----------------");// 4. 将每个单词的首字母改为大写for (int i = 0; i < arr.length; i++) {char first = arr[i].charAt(0);// 把第一个字符转为大写char upperfirst = Character.toUpperCase(first);//System.out.println(upperfirst);  // 把所有首字母大写 遍历String str4 = upperfirst + arr[i].substring(1);System.out.println(str4);}}
}运行结果：
1.
this
is
a
text
2.
this is a practice
3.
this is a easy text
4.
This
Is
A
Text

可变字符串

StringBuffer： 可变长字符串，JDK 1.0 提供，运行效率慢、线程安全

StringBuilder： 可变长字符串，JDK 5.0 提供，运行效率快、线程不安全

​ StringBuffer 和 StringBuilder 的使用 与String的区别：

   1. 效率比String高
1. 效率比String高

        StringBuffer sb1 = new StringBuffer();StringBuilder sb2 = new StringBuilder();// 1. append();     追加sb1.append("java ");System.out.println(sb1.toString());sb1.append("javascript ");System.out.println(sb1.toString());sb1.append("c++ ");System.out.println(sb1.toString());System.out.println("---------------------");// 2. insert();     添加sb1.insert(0,"我要学");sb1.insert(sb1.length(),"做一个高级程序员");System.out.println(sb1.toString());System.out.println("---------------------");// 3. replace();    替换sb1.replace(0,3,"hello ");System.out.println(sb1.toString());System.out.println("---------------------");// 4. delete();     删除sb1.delete(0,3);System.out.println(sb1.toString());System.out.println("--------------------------");// 清空sb1.delete(0,sb1.length());System.out.println(sb1.toString());System.out.println("------------------------------==");运行结果：
java
java javascript
java javascript c++
---------------------
我要学java javascript c++ 做一个高级程序员
---------------------
hello java javascript c++ 做一个高级程序员
---------------------
lo java javascript c++ 做一个高级程序员
--------------------------------------------------------==

package OOP.Class_6;public class Demo03 {public static void main(String[] args) {double num1 = 0.9;double num2 = 0.8;System.out.println(num1 - num2);//0.09999999999999998double result = (1.4 - 0.5) / 0.9;System.out.println(result);//0.9999999999999999}
}
/*
0.09999999999999998
0.9999999999999999
*/

BigDecimal类

位置： Java.math 包中

作用：精确计算浮点数

创建方法：BigDecimal bd = new BigDecimal (“1.0”);

方法：

​ BigDecimal add(BigDecimal bd); 加

​ BigDecimal subtract(BigDecimal bd); 减

​ BigDecimal multiply(BigDecimal bd); 乘

​ BigDecimal divide(BigDecimal bd); 除

除法：divide(BigDecimal bd,int scal,RoundingMode mode)

参数：scal: 指定精确到小数点后几位

​ mode: 指定小数部分的取舍模式，通常采用四舍五入的模式

​ 取值为BigDecimal.ROUND_HALF_UP

下面是代码演示：

public static void main(String[] args) {// 思考：double d1 = 1.0;double d2 = 0.9;System.out.println(d1-d2);  // 0.09999999999999998double result = (1.4-0.5)/0.9;System.out.println(result);  // 0.9999999999999999
//        double res = (d1*d2);
//        System.out.println(res);  // 0.9// 这些结果都丢失了精度// 在很多实际应用中需要精确计算，而double是近似值存储，不在符合要求，需要借助 BigDecimal 进行精确计算// BigDecimal   大的浮点数精确计算BigDecimal bd1 = new BigDecimal("1.0");BigDecimal bd2 = new BigDecimal("0.9");// 减法   subtractBigDecimal r1 = bd1.subtract(bd2);System.out.println(r1);  // 0.1// 加法   addBigDecimal r2 = bd1.add(bd2);System.out.println(r2);  // 1.9// 乘法   multiplyBigDecimal r3 = bd1.multiply(bd2);System.out.println(r3);  // 0.90// 除法   divideBigDecimal r4 = new BigDecimal("1.4").subtract(new BigDecimal("0.5")).divide(new BigDecimal("0.9"));System.out.println(r4);  // 1// BigDecimal r5 = new BigDecimal("10").divide(new BigDecimal("3"));// System.out.println(r5);  // ArithmeticExceptionBigDecimal r5 = new BigDecimal("20").divide(new BigDecimal("3"),2,BigDecimal.ROUND_UP);System.out.println(r5);  // 6.67  // " 2,BigDecimal.ROUND_UP " 保留俩位小数 向上取}

Date类

Date表示特定的瞬间，精确到毫秒。Date类中的大部分方法都已经被Calendar类中的方法取代

时间单位：

• 1秒=1000毫秒
• 1毫秒=1000微秒
• 1微秒=1000纳秒

创建一个今天的此时此刻

// 今天 此时此刻(这是我当时打代码的时间)Date date1 = new Date();System.out.println(date1.toString());  // Thu Dec 12 15:06:35 CST 2024System.out.println(date1.toLocaleString());  // 2024-12-12 15:07:14     toLocaleString 已过时

昨天

 // 昨天 此时此刻(今天的时间-一天的毫秒数)Date date2 = new Date(date1.getTime()-(60*60*24*1000));  // (60秒 * 60分 * 24时 * 1000毫秒)System.out.println(date2.toLocaleString());  // 2024-12-11 15:09:31

方法：

after与before

        boolean b1 = date1.after(date2);boolean b2 = date1.before(date2);System.out.println(b1);  // trueSystem.out.println(b2);  // false

比较 compareTo();

        int d = date1.compareTo(date2);int d1 = date1.compareTo(date1);int d2= date2.compareTo(date1);System.out.println(d);  // 1  date1 > date2System.out.println(d1);  // 0  date1 = date2System.out.println(d2);  // -1 date1 < date2

是否相等 equals

        boolean b3 = date1.equals(date2);System.out.println(b3);  // false

Calendar类

Calendar提供了获取或设置各种日历字段的方法

构造方法：

​ protected Calendar(); 由于修饰符是protected ，所以无法直接创建该对象

其他方法：

方法名	说明
static Calendar getlnstance()	使用默认时区和区域获取日历
void set (int year,int month,int date,int hourofday,int minute,int secong)	设置日历的年，月，日，时，分，秒
int get(int field)	返回给定日历字段的值，字段比如年月日等
void setTime(Date date)	用给定的Date设置此日历的时间。Date-Calendar
Date getTime()	返回一个Date表示此日历的时间。Calendar-Date
void add(int field,int amount)	按照日历的规则，给指定字段添加或减少时间量
long getTimeInMillies()	毫秒为单位返回该日历的时间值

        // 1. 创建Calendar对象Calendar calendar = Calendar.getInstance();System.out.println(calendar.getTime().toLocaleString());  // 2024-12-12 15:35:53System.out.println(calendar.getTimeInMillis());  // 1733988983773   1970年距今毫秒数

获取时间信息

// 2. 获取时间信息// 获取 年int year = calendar.get(Calendar.YEAR);  // 也可以直接输 1System.out.println(year);  // 2024// 获取 月     0-11 相当于 1-12int month = calendar.get(Calendar.MONTH);  // 也可以直接输 2System.out.println(month);  // 11   相当于12月// 获取 日int date = calendar.get(Calendar.DAY_OF_MONTH);  // DATE  或   5System.out.println(date);  // 12// 获取 时int hour = calendar.get(Calendar.HOUR_OF_DAY);  // HOUR_OF_DAY 是24小时制，HOUR 是12小时制System.out.println(hour);  // 15// 获取 分int minute = calendar.get(Calendar.MINUTE);System.out.println(minute);  // 44// 获取 秒int secod = calendar.get(Calendar.SECOND);System.out.println(secod);  // 35System.out.println(year+"年"+(month+1)+"月"+date+"日 "+hour+"时"+minute+"分"+secod+"秒");  // 2024年12月12日 15时51分46秒

修改时间

        Calendar calendar2 = Calendar.getInstance();calendar2.set(Calendar.DAY_OF_MONTH,11);System.out.println(calendar2.getTime().toLocaleString());  // 2024-12-11 15:53:53

add方法修改时间

        calendar2.add(Calendar.HOUR,-1);System.out.println(calendar2.getTime().toLocaleString());  // 2024-12-11 14:55:17

补充方法

        calendar2.add(Calendar.MONTH,1);int max = calendar2.getActualMaximum(Calendar.DAY_OF_MONTH);int min = calendar2.getActualMinimum(Calendar.DAY_OF_MONTH);System.out.println(max);  // 31System.out.println(min);  // 1

完整代码：

package com.object.Calendar;import java.util.Calendar;public class Demo01 {public static void main(String[] args) {// 1. 创建Calendar对象Calendar calendar = Calendar.getInstance();System.out.println(calendar.getTime().toLocaleString());  // 2024-12-12 15:35:53System.out.println(calendar.getTimeInMillis());  // 1733988983773   1970年距今毫秒数// 2. 获取时间信息// 获取 年int year = calendar.get(Calendar.YEAR);  // 也可以直接输 1System.out.println(year);  // 2024// 获取 月     0-11 相当于 1-12int month = calendar.get(Calendar.MONTH);  // 也可以直接输 2System.out.println(month);  // 11   相当于12月// 获取 日int date = calendar.get(Calendar.DAY_OF_MONTH);  // DATE  或   5System.out.println(date);  // 12// 获取 时int hour = calendar.get(Calendar.HOUR_OF_DAY);  // HOUR_OF_DAY 是24小时制，HOUR 是12小时制System.out.println(hour);  // 15// 获取 分int minute = calendar.get(Calendar.MINUTE);System.out.println(minute);  // 44// 获取 秒int secod = calendar.get(Calendar.SECOND);System.out.println(secod);  // 35System.out.println(year+"年"+(month+1)+"月"+date+"日 "+hour+"时"+minute+"分"+secod+"秒");  // 2024年12月12日 15时51分46秒// 3. 修改时间Calendar calendar2 = Calendar.getInstance();calendar2.set(Calendar.DAY_OF_MONTH,11);System.out.println(calendar2.getTime().toLocaleString());  // 2024-12-11 15:53:53// 4. add方法修改时间calendar2.add(Calendar.HOUR,-1);System.out.println(calendar2.getTime().toLocaleString());  // 2024-12-11 14:55:17// 5. 补充方法calendar2.add(Calendar.MONTH,1);int max = calendar2.getActualMaximum(Calendar.DAY_OF_MONTH);int min = calendar2.getActualMinimum(Calendar.DAY_OF_MONTH);System.out.println(max);  // 31System.out.println(min);  // 1}
}

SimpleDateFormat类

SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类

进行格式化（日期 -> 文本）、解析(文本 -> 日期)

常用的时间模式字母

字母	日期或时间	示例
y	年	2024
M	月	12
d	日/天	12
H	小时（0-23）	19
m	分钟	13
s	秒	59
S	毫秒	357

package com.object.SimpleDateFormat;import java.text.SimpleDateFormat;
import java.util.Date;public class Demo01 {public static void main(String[] args) throws Exception{// 1. 创建SimpleDateFormat对象  y 年 M 月// SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");// 2. 创建DateDate date = new Date();// 3. 格式化date(把日期转成字符串)String str = sdf.format(date);System.out.println(str);  // 2024年12月12日 16:50:18// 4. 解析 (把字符串转成日期)Date date2 = sdf.parse("2018年12月12日");System.out.println(date2);  // Wed Dec 12 00:00:00 CST 2018}
}

System类

System系统类，主要用于获取系统的属性数据和其他操作，构造方法私有的

方法名	说明
static void arraycopy(…);	复制数组
static long currentTimeMillis();	获取当前系统时间，返回的是毫秒值
static void gc();	建议JVM赶快启动垃圾回收器回收垃圾
static void exit(int status);	退出JVM，如果参数是0表示正常退出jvm，非0表示异常退出jvm

代码验证

package com.object.System;public class Demo01 {public static void main(String[] args) {// arraycopy    数组的复制// src 原数组// srcPos 从哪个位置开始复制// dest 目标数组// destPos 目标数组的位置// length 复制的长度int[] arr = {22,4,69,52,33,95,10,71,43};int[] dest = new int[9];System.arraycopy(arr,1,dest,0,5);for (int i = 0; i < dest.length; i++) {System.out.print(dest[i]+" ");  // 4 69 52 33 95 0 0 0 0}//  currentTimeMillis 从1970 到现在的毫秒数System.out.print("\n");System.out.println(System.currentTimeMillis());  // 1733998980366long start = System.currentTimeMillis();for (int i = 0; i < 99999; i++) {for (int j = 0; j < 99999; j++) {int result = i+j;}}long end = System.currentTimeMillis();System.out.println("用时："+ (end-start));  // 用时：0  // 我这里设置的数小，电脑性能高的可以往大设}
}

总结

内部类

• 在一个类的内部再定义一个完整的类
• 成员内部类、静态内部类、局部内部类、匿名内部类

Object类

• 所有类的直接或间接父类，可存储任何对象

包装类

• 基本数据类型所对应的引用数据类型，可以使Object统一所有数据

String类

• 字符串是常量，创建之后不可改变，字面值保存在字符串池中，可以共享

BigDecimal类

• 可以精确计算浮点数

Date

• 特定时间

Calendar

• 日历

SimpleDateFormat

• 格式化时间

System

• 系统类