Object类
-
超类，基类，所有类的直接或间接父类，位于继承树最顶层。
-
任何类，如没有书写extends显示继承某个类，都默认直接继承Object类，否则为间接继承。
-
Object类中所定义的方法，是所有对象都具备的方法。。
-
Object类型可以储存任何的对象。
-
作为参数，可接受任何对象。
-
作为返回值，可以返回任何对象。
-
-
方法摘要：
-
clone();创建并返回此对象的一个副本。
-
equals(Object obj);指示其他某个对象是否与此对象“相等”。
-
getClass();返回此Object的运行时类。
-
hashCode();返回该对象的哈希码值。哈希码值可以理解为该对象的地址。
-
notify();唤醒在此对象监视器上等待的单个线程。
-
notifyAll();唤醒在此对象监视器上等待的所有线程。
-
toString();返回该对象的字符串表示。
-
wait();在其他线程调用此对象的notify()或notifyAll()方法前，导致当前线程等待
-
wait(long timeout);在其他线程调用此对象的notify()或notifyAll()方法，或超过某个指定时间量前,导致当前线程等待。
-
wait(long timeout , int nanos);在其他线程调用此对象的notify()或notifyAll()方法，或者其他某个线程中断当前的线程，或超过某个实际时间量前，导致当前线程等待。
-
getClass()方法
public class Student extends Person{
//属性
private String name;
private int age;
private char sex;
//构造方法
public Student() {
}
public Student(String name, int age, char sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
//get/set
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;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
}public class TestStudent {
public static void main(String[] args) {
Student s1 = new Student("小明", 22, '男');
Student s2 = new Student("小红", 21, '女');
Class class1 = s1.getClass();
Class class2 = s2.getClass();
if (class1 == class2){
System.out.println("属于同一类型");
}else {
System.out.println("不属于同一类型");
}
}
}输出结果：
属于同一类型
hashCode()方法
-
哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的数值。
-
一般情况下，相同的对象返回相同的哈希码值。
public class TestStudent {
public static void main(String[] args) {
Student s1 = new Student("小明", 22, '男');
Student s2 = new Student("小红", 21, '女');
System.out.println(s1.hashCode());//输出结果：460141958
System.out.println(s2.hashCode());//输出结果：1163157884
Student s3 = s1;
System.out.println(s3.hashCode());//输出结果：460141958
}
}toString()方法
-
返回该对象的字符串表示。
-
可以根据程序具体业务需求覆盖(重写)该方法。如：展示对象各个属性值。
public class TestStudent {
public static void main(String[] args) {
Student s1 = new Student("小明", 22, '男');
Student s2 = new Student("小红", 21, '女');
System.out.println(s1.toString());//结果：com.wsn.javase.Student@1b6d3586
//@后面是该对象的地址（哈希码值）
System.out.println(s2.toString());//结果：com.wsn.javase.Student@4554617c
}
}-
在Student类中重写toString方法，使返回name，age和sex。
//重写getclass()方法 @Override public String toString() { return name+age+sex; }public class TestStudent { public static void main(String[] args) { Student s1 = new Student("小明", 22, '男'); Student s2 = new Student("小红", 21, '女'); System.out.println(s1.toString());//结果：小明22男 System.out.println(s2.toString());//结果：小红21女 } }
equals()方法
-
默认实现为（this == obj），判断两个对象地址是否相同。
-
可以进行重写，比较两个对象的内容是否相同。
public class TestStudent {
public static void main(String[] args) {
Student s1 = new Student("小明", 22, '男');
Student s2 = new Student("小红", 21, '女');
System.out.println(s1.equals(s2));//结果：false
Student s3 = new Student("aaa", 1, '男');
Student s4 = new Student("aaa", 1, '男');
System.out.println(s3.equals(s4));//结果：false
}
}-
重写equals()方法,当name相同时，输出为ture。
-
比较两个引用是否指向同一个对象。
-
判断obj是否为null。
-
判断两个引用指向的实际对象类型是否一致。（instanceof）
-
强制类型转换。
-
依次比较各个属性值是否相同。
@Override public boolean equals(Object obj) { //比较两个引用是否指向同一个对象。 if(this == obj)return true; //判断obj是否为null。 if (obj == null)return false; //判断两个引用指向的实际对象类型是否一致。（instanceof） if(obj instanceof Student){ //强制类型转换。 Student stu=(Student)obj; //依次比较各个属性值是否相同。 if(this.name.equals(stu.getName())&&this.age==stu.getAge()&&this.sex== stu.getSex()) return true; } return false; }public class TestStudent { public static void main(String[] args) { Student s1 = new Student("小明", 22, '男'); Student s2 = new Student("小红", 21, '女'); System.out.println(s1.equals(s2));//结果：false Student s3 = new Student("aaa", 1, '男'); Student s4 = new Student("aaa", 1, '男'); System.out.println(s3.equals(s4));//结果：true } } -
finalize()方法
-
一般情况下，我们不会去调用这个方法。
-
当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象。
-
垃圾对象：没有有效引用指向此对象，为垃圾对象。
-
垃圾回收：有GC销毁垃圾对象，释放数据存储空间。
-
自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象。
-
手动回收机制：使用System.gc();通知JVM执行垃圾回收。
重写System.gc();使当调用此方法时输出此对象被回收了
@Override
protected void finalize() throws Throwable {
System.out.println(this.name+"垃圾被回收了");
}public class TestStudent {
public static void main(String[] args) {
new Student("小明", 22, '男');
new Student("小红", 21, '女');
new Student("aaa", 1, '男');
new Student("ccc", 1, '男');
new Student("ddd", 1, '男');
System.gc();
//输出结果：
//ddd垃圾被回收了
//ccc垃圾被回收了
//aaa垃圾被回收了
//小红垃圾被回收了
//小明垃圾被回收了
}
}包装类
-
基本数据类型所对应的引用数据类型。
类型转换与装箱和拆箱
-
装箱：将栈中的基本类型转移到堆中变成引用类型（对象）。
-
拆箱：将堆中的引用类型（对象）转移到栈中变成基本类型。
JDK1.5之前（装箱和拆箱的操作）：
public class PackingAndUnpacking {
public static void main(String[] args) {
//装箱：基本类型转换成引用类型的过程
int num1 = 18;//基本类型
Integer integer1 = new Integer(num1);//使用Integer创建对象
Integer integer2 = Integer.valueOf(num1);//使用Integer的valueOf()方法也可以创建对象
//拆箱：应用类型转换成基本类型的过程
Integer integer3 = new Integer(100);//创建引用类型并传值100
int num2 = integer3.intValue();//使用引用类型对象的intValue()方法转换成基本类型num2
}
}JDK1.5之后（装箱和拆箱的操作）：
public class PackingAndUnpacking {
public static void main(String[] args) {
//自动装箱和拆箱，实际上是将上面手动装箱拆箱的操作隐藏了。
int age = 30;
//自动装箱
Integer integer4 = age;
//自动拆箱
int age2=integer4;
}
}-
基本类型和字符串之间的转换。valueOf()静态方法和parseXXX()静态方法
public static void main(String[] args) { //基本类型和字符串之间的转换 //1.基本类型转换为字符串 int n1 =100; //第一种方法：在一本类型后加双引号 String s1 = n1+""; //第二种方法：使用Integer中的toString方法 String s2 = Integer.toString(n1); //Integer中的toString方法还有许多重载方法，下面为部分展示。 String s3 = Integer.toString(n1,16);//16代表输出为16进制 String s4 = Integer.toHexString(n1);//输出为16进制,和上面一样，写法不一样 String s5 = Integer.toBinaryString(n1);//输出为2进制 //2.字符串转换为基本类型 String str = "150"; //使用Integer.parseXXX()转换 int n2 = Integer.parseInt(str);//如果str中不全为数字，则会报错，因为parseInt只能解析数字 //3.boolean字符串形式转为基本类型 “true”可以转成true 除此之外的boolean字符串都会转成false String str2 = "true"; boolean b1 = Boolean.parseBoolean(str2);//结果：true String str3 = "trueee"; boolean b2 = Boolean.parseBoolean(str3);//结果：false }
整数缓冲区
-
Java预先创建了256个常用的整数包装类型对象。
-
为什么存在这个缓冲区？因为在实际应用当中，这些数字用的较多，对已创建的对象进行复用节省空间，提高代码效率。
-
1.用构造器创建Integer对象
Integer integer1 = new Integer(100); Integer integer2 = new Integer(100); System.out.println(integer1==integer2);//结果：false结果为false因为比较的实际上是在栈中integer1和integer2的地址。
-
2.用自动装箱创建Integer对象
Integer integer3 = 100; //自动装箱：代码实际上是Integer integer3 = Integer.valueOf(100); Integer integer4 = 100; //自动装箱：代码实际上是Integer integer4 = Integer.valueOf(100); System.out.println(integer3==integer4);//结果为true Integer integer5 = 200;//自动装箱：代码实际上是Integer integer5 = Integer.valueOf(200); Integer integer6 = 200;//自动装箱：代码实际上是Integer integer6 = Integer.valueOf(200); System.out.println(integer5==integer6);//结果为false都是自动装箱代码一致只是赋的值不同结果也不同，是因为Integer缓冲区。
在源码中valueOf()方法代码：
-
如果i在IntegerCache.low和IntegerCache.high的范围中，返回的是cache数组中对象。
如果i不在范围中，返回的是创建新的Integer对象。
点进查看low和high：
-
当赋值为100时integer3和integer4实际上是去堆中数组（-128至127）中取的100这个对象的地址，所以integer3和integer4两个对象的地址相同，结果为true。
-
而赋值为200的integer5和integer6中，200大于127，所以走的是图1的return new Integer(i);这句代码去创建新的对象，integer5和integer6地址不同，结果为false。
String概述
-
字符串是常量，创建后不可改变。
-
字符串字面值存储在字符串池中，可以共享。
public class StringBuffer { public static void main(String[] args) { String name ="Hello"; //"Hello"存放在字符串池中 name = "张三";//对name进行修改 } } 
对name进行修改，不是将原来的“Hello”的值改为“张三”，而是在字符串池中重新创建一个空间指向它。
原来的“Hello”变为垃圾后续被gc清理。如果name2也赋值为"张三"，则他们的地址相同。实现了共享。
-
创建字符串两种方式：
-
String s1= ”Hello“; 产生一个对象，字符串池中储存。
-
String s2 = new String(”Hello“); 产生两个对象，堆和字符串池各存储一个。
String str = new String("JAVA"); String str2 = new String("JAVA"); System.out.println(str==str2);//结果：false 比较的是对象的地址 System.out.println(str.equals(str2));//结果：true 比较的是字面值
-
String常用方法
-
public int length();返回字符串长度。
-
public char charAt();根据下标获取字符。
-
public boolean contains(String str);判断当前字符串中是否包含str。
public class StringTest { public static void main(String[] args) { String str = "Java是世界上最好的语言"; //返回字符串长度 System.out.println(str.length());//结果：13 //根据下表获取字符 System.out.println(str.charAt(4));//结果：是 System.out.println(str.charAt(str.length()- 1));//结果：言 //判断当前字符串是否包含str System.out.println(str.contains("Java"));//结果：true System.out.println(str.contains("php"));//结果：false } } -
public char[] toCharArray();将字符串转换为数组。
-
public int indexOf(String str);查找字符串str首次出现的下标，存在则返回该下标，不存在则返回-1。
-
public int lastIndexOf(String str);查找字符串str在当前字符串中最后一次出现的下标索引。
public class StringTest { public static void main(String[] args) { String str = "Java是世界上最好的语言"; //返回字符串对应的数组 System.out.println(Arrays.toString(str.toCharArray()));//结果：[J, a, v, a, 是, 世, 界, 上, 最, 好, 的, 语, 言] //查找字符串str首次出现的下标 System.out.println(str.indexOf("是世界上"));//结果：4 //查找字符串str在当前字符串中最后一次出现的下标索引 System.out.println(str.lastIndexOf("a"));//结果：3 } } -
public String trim();去掉字符串前后的空格。
-
public String toUpperCase(); 将小写转换成大写。
-
public boolean endWith(String str);判断字符串是否以str结尾。
public class StringTest { public static void main(String[] args) { String str = " Java 是世界上 最好的语言 "; String str1 = "Java是世界上最好的语言"; //去掉字符串前后的空格 System.out.println(str.trim());//结果：Java 是世界上 最好的语言 //将小写转换成大写 System.out.println(str1.toUpperCase(Locale.ROOT));//结果：JAVA是世界上最好的语言 //判断字符串是否以str为结尾 System.out.println(str1.endsWith("语言"));//结果：true System.out.println(str1.endsWith("语"));//结果：false } } -
public String replace(char oldChar,char newChar);将旧字符替换为新字符。
-
public String[] split(String str);根据str进行拆分
public class StringTest { public static void main(String[] args) { String str = " Java 是世界上 最好的语言 "; String str1 = "Java是世界上最好的语言"; //将旧字符替换为新字符 System.out.println(str1.replace("最好", "最垃圾"));//结果:Java是世界上最垃圾的语言 //根据str进行拆分 String[] s = str.split(" ");//根据空格进行拆分 for (String string:s) { System.out.println(string); //遍历结果：Java //是世界上 //最好的语言 } } }注：split("[ ,]")表示根据空格或者逗号进行拆分，split("[ ,]+")表示根据多个空格或者括号进行拆分。
-
equal()和compareTo()方法的区别。
//equals比较的是字符串字面值是否相同,equalsIgnoreCase比较忽略大小写后字面值是否相同 String s1 ="Hello"; String s2 ="hello"; System.out.println(s1.equals(s2));//结果：false System.out.println(s1.equalsIgnoreCase(s2));//true //compareTo比较的是字符串的编码表位置然后用第一个字符串（s1）的第一个字符的位置减去第二个字符串（s2）第一个字符位置的差值，只比较第一个字符，后面的忽略 String s3 ="abc";//a的位置为97 String s4 ="xyz";//b的位置为120 System.out.println(s3.compareTo(s4));//结果：-23 //如果两个字符串第一个字符相同，那么比较的是字符串长度，第一个字符串长度减去第二个字符串长度的差 String s5 ="abc"; String s6 ="abcxyz"; System.out.println(s5.compareTo(s6));//结果：-3
String案例演示
需求：
-
有字符串str内容为this is a test
-
将str中的单词单独取出来
-
将str中的text替换为practice
-
在text前插入一个easy
-
将每个单词的首字母变为大写
代码实现：
public class StringTest {
public static void main(String[] args) {
String str ="this is a text";
//将str中的单词单独获取出来
String[] sp1 = str.split("[ ]+");
for (String string:sp1) {
System.out.print(string+"\t");
}
System.out.println();
//将str中text替换为practice
System.out.println(str.replace("text", "practice"));
//在text前插入一个easy
System.out.println(str.replace("text", "easy text"));
//将首字母变为大写
//1.第一种方法
String[] sp2 = str.split("");
for (int i = 0; i < sp2.length; i++) {
if (i==0){
sp2[i]=sp2[i].toUpperCase(Locale.ROOT);
}
if (sp2[i].contains(" ")){
sp2[i+1]=sp2[i+1].toUpperCase(Locale.ROOT);
}
}
for (String s:sp2) {
System.out.print(s);
}
//2.第二种方法
for (int i = 0; i < sp1.length; i++) { //四个单词循环四次
//用字符串数组的charAt()方法定位下标找单词的第一个字母
char first = sp1[i].charAt(0);
//用char的包装类Character的toUpperCase方法转换为大写
char upperCase = Character.toUpperCase(first);
//创建一个新字符串news拼接转换后首字母upperCase和利用substring()剪切后的字符串
String news=upperCase+sp1[i].substring(1);//substring(1)中的1表示前切掉sp1[i]字符串中的第一个字符，保留剩下的字符串。
System.out.print(news);
}
}
}输出结果为：
this is a text
this is a practice
this is a easy text
This Is A Text
StringBuffer和StringBuilder
-
StringBuffer：可变长字符串，JDK1.0提供，运行效率慢，线程安全。
-
StringBuilder：可变长字符串，JDK5.0提供，运行效率快，线程不安全。
-
两者功能一样，是String的增强版，两者效率都比String高，提供了缓冲区。
-
StringBuffer和StringBuilder主要的四个方法：
-
append()方法追加数据。
-
insert()方法添加，插入。
-
replace()方法替换。
-
delete()方法删除。
public class StringBufferAndStringBuilderTest { public static void main(String[] args) { //创建StringBuffer或StringBuilder //StringBuffer sb1 = new StringBuffer(); StringBuilder sb1 = new StringBuilder(); //append()方法追加数据 sb1.append("Java世界第一"); System.out.println(sb1);//结果：Java世界第一 sb1.append("Java牛波一"); System.out.println(sb1);//结果：Java世界第一Java牛波一 sb1.append("原神，启动！"); System.out.println(sb1);//结果：Java世界第一Java牛波一原神，启动！ //insert()方法添加，插入 sb1.insert(0,"我在最前面");//第一个数字是插入的位置（下标） System.out.println(sb1);//结果：我在最前面Java世界第一Java牛波一原神，启动！ //replace()方法替换 sb1.replace(0,5,"我被替换了"); System.out.println(sb1);//结果：我被替换了Java世界第一Java牛波一原神，启动！ //delete()方法删除 sb1.delete(0,5); System.out.println(sb1);//结果：Java世界第一Java牛波一原神，启动！ sb1.delete(0,sb1.length());//清空 } }
-
-
用程序去验证String，StringBuffer，StringBuilder三者的效率
-
String：
public class StringBufferAndStringBuilderTest { public void prove(){ //开始时间 long start = System.currentTimeMillis(); String str = ""; for (int i = 0; i < 99999; i++) { str+=i; } System.out.println(str); long end = System.currentTimeMillis(); System.out.println("运行用时"+(end-start)); } public static void main(String[] args) { new StringBufferAndStringBuilderTest().prove();//结果：运行用时20175 } }String用时20175。
-
StringBuffer：
public class StringBufferAndStringBuilderTest { public void prove(){ //开始时间 long start = System.currentTimeMillis(); StringBuffer stringBuffer = new StringBuffer(); for (int i = 0; i < 99999; i++) { stringBuffer.append(i); } System.out.println(stringBuffer); long end = System.currentTimeMillis(); System.out.println("运行用时"+(end-start));//结果：运行用时28 } public static void main(String[] args) { new StringBufferAndStringBuilderTest().prove(); } }StringBuffer用时28，效率是String的720倍
-
StringBuilder：
public class StringBufferAndStringBuilderTest { public void prove(){ //开始时间 long start = System.currentTimeMillis(); StringBuilder stringBuilder = new StringBuilder(); for (int i = 0; i < 99999; i++) { stringBuilder.append(i); } System.out.println(stringBuilder); long end = System.currentTimeMillis(); System.out.println("运行用时"+(end-start));//结果：运行用时26 } public static void main(String[] args) { new StringBufferAndStringBuilderTest().prove(); } }StringBuilder用时26，比StringBuffer效率更高。
-
BigDecimal的使用
-
思考一个问题：为什么以下代码运行结果不是0.1而是0.09999999999999998.
public class BigDecimalTest { public static void main(String[] args) { double d1 = 1.0; double d2 = 0.9; System.out.println(d1-d2);//结果：0.09999999999999998 } }因为double和float类型在内存中存储数据是一个近似值，例如：在程序中定义的值是1.0，可能在内存中就是0.99999999998。
-
在一些特殊的业务环境下，例如银行就要求数值的精度要高不能有误差，所以解决上面这种近似值的问题就要使用到BigDecimal精确存储。
-
BigDecimal作用：精确计算浮点数。
-
创建方式：
BigDecimal b1 = new BigDecimal("1.0");//传入的数值最好是字符串，因为精度高，程序会自动处理。 -
BigDecimal的几种方法：
public class BigDecimalTest { public static void main(String[] args) { BigDecimal b1 = new BigDecimal("1.0"); BigDecimal b2 = new BigDecimal("1.0"); //减法 System.out.println(b1.subtract(b2));//结果：0.0 //加法 System.out.println(b1.add(b2));//结果：2.0 //乘法 System.out.println(b1.multiply(b2));//结果：1.00 //除法 System.out.println(b1.divide(b2));//结果：1 //除法除不尽会报错,例如10除3除不尽，我们可以使用一些重载方法和四舍五入解决问题 //divide(new BigDecimal("3"), 2, BigDecimal.ROUND_UP),第一个参数是创建的被除数，第二个参数2是精确几位，第三个参数ROUND_HALF_UP是四舍五入 System.out.println(new BigDecimal("10").divide(new BigDecimal("3"), 2, ROUND_HALF_UP));//结果：3.34 } }
Date类（大部分过时，仅了解）
-
Date表示特定的瞬间，精确到毫秒，Date类中大部分方法都已经被Calendar类中的方法所取代。一些老的项目还在用，所以仅作了解。
-
时间单位：
-
1秒=1000毫秒
-
1毫秒=1000微秒
-
1微秒=1000纳秒
-
-
构造方法中：Date（），Date（long date）两个还没有过时，其他的构造方法都已过时。
-
方法摘要：
-
after(Date when)测试此日期是否在指定日期之后。
-
before(Date when)测试此日期是否在指定日期之前。
-
clone()返回此对象副本。
-
compareTo(Date anotherDate)比较两个日期的顺序。
-
equals(Object obj)比较两个日期的相等性。
-
getTime()返回自1970年1月1日至今的毫秒数。
-
setTime(long time)设置此对象，以表示1970年1月1日以后time毫秒的时间点
-
toString()把Date对象转换为以下形式的String：dow mon dd hh：ss zzz yyyy（dow是一周中的某一天）
public class DateTest { public static void main(String[] args) { //1.创建对象 Date today = new Date(); //今天 System.out.println(today);//结果：Sun Oct 22 14:39:51 CST 2023 //昨天 Date yesterday = new Date(today.getTime()-(60*60*24*1000)); System.out.println(yesterday);//结果：Sat Oct 21 14:39:51 CST 2023 //2.方法after before System.out.println(today.after(yesterday));//结果：true System.out.println(today.before(yesterday));//结果：false //3.compareTo比较毫秒值，前面比后面大返回1，否则返回-1，相同返回0 System.out.println(yesterday.compareTo(today));//结果：-1 //4.equals方法比较是否相等，相等返回ture，不相等返回false System.out.println(today.equals(yesterday));//结果：false } }
-
Calendar类
-
Calendar类提供了获取或设置各种日历字段的方法。
-
构造方法：
protected Calendar():由于修饰符是protected，所以无法直接创建该对象。
-
其他方法：
-
-
虽然无法直接创造对象，但Calendar类中有一个静态方法getlnstanc()我们可以通过这个方法来创造对象。
Calendar calendar = Calendar.getInstance(); -
public class CalendarTest { public static void main(String[] args) { //1.通过静态方法创建对象 Calendar calendar = Calendar.getInstance(); System.out.println(calendar.getTime().toLocaleString());//结果：2023-10-22 15:36:57 System.out.println(calendar.getTimeInMillis());//结果：1697960217767 //2.获取时间信息 //获取年 int year = calendar.get(Calendar.YEAR);//通过get方法Calendar类中的静态常量YEAR获取年份 //获取月 这里月份获取默认是从0-11，所以要正确显示需要手动加1 int month = calendar.get(Calendar.MONTH)+1;//通过get方法Calendar类中的静态常量MONTH获取月份 //获取日 int day = calendar.get(Calendar.DAY_OF_MONTH);//通过get方法Calendar类中的静态常量DAY_OF_MONTH获取日 //获取小时 int hour =calendar.get(Calendar.HOUR_OF_DAY);//通过get方法Calendar类中的静态常量HOUR获取小时 //获取分钟 int minute = calendar.get(Calendar.MINUTE);//通过get方法Calendar类中的静态常量MINUTE获取分钟 //获取秒 int second = calendar.get(Calendar.SECOND);//通过get方法Calendar类中的静态常量SECOND获取秒 System.out.println(year+"年"+month+"月"+day+"日"+hour+"时"+minute+"分"+second+"秒");//结果：2023年10月22日15时36分57秒 //3.修改时间 set和add的区别就是set是直接设置值为多少，而add是在原有时间上增加或减少多少 Calendar calendar1 = Calendar.getInstance(); calendar1.set(Calendar.DAY_OF_MONTH,5);//set（1，2）第一个参数是要修改的类型，第二个是参数是要修改多少 System.out.println(calendar1.getTime().toLocaleString());//结果：2023-10-5 15:36:57 //4.add方法修改时间 calendar1.add(Calendar.HOUR_OF_DAY,1);//add（1，2）第一个参数是要修改的类型，第二个是参数是要修改多少 System.out.println(calendar1.getTime().toLocaleString());//结果：2023-10-5 16:36:57 //5.补充方法getActualMaximum和getActualMinimum获取时间的最大值和最小值 int max = calendar1.getActualMaximum(Calendar.DAY_OF_MONTH);//获取calendar1当前月份最大天数 System.out.println(max);//结果：31 int min = calendar1.getActualMinimum(Calendar.DAY_OF_MONTH);获取calendar1当前月份最少天数 System.out.println(min);//结果：1 } }
SimpactDateFormat类
-
SimpactDateFormat就是用来设置时间格式与格式化和解析时间的类。
-
格式化（日期->文本），解析（文本->日期）。
-
常用的时间模式字母
-
-
public class SimpleDateFormatTest { public static void main(String[] args) throws ParseException { //创建对象 y表示年 M表示月 SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy年MM月dd日HH：mm：ss");//"yyyy年MM月dd日HH：mm：ss"设置格式 //创建Date Date date = new Date(); //格式化date 文本->日期 String str = simpleDateFormat.format(date);//format方法是将传入的时间参数按照设置好的格式输出 System.out.println(str);//结果：2023年10月22日15：36：40 //解析date 日期->文本 Date parse = simpleDateFormat.parse("2000年08月11日13：13：13"); System.out.println(simpleDateFormat.format(parse));//结果：2000年08月11日13：13：13 } }
System类
-
System系统类，主要用于获取系统的属性数据和其他操作，构造方法是私有的。
-
-
arraycopy()：
Array.copyOf()方法中用的其实就是System.arraycopy方法,源码中arraycopy修饰符是native本地的，方法没有方法体，是由JVM底层c++实现的，所以效率特别高。
public class SystemTest { public static void main(String[] args) { //arraycopy：数组的复制 //System.arraycopy(src,srcPos,dest,destPos,length); //src:原数组 //srcPos:从哪个位置开始复制 //dest:目标数组 //destPos:目标数组位置 //length:复制的长度 int[] arr = {10,29,31,36,57,25,24,80,75}; int[] arrDest=new int[9]; System.arraycopy(arr,4,arrDest,4,4); System.out.println(Arrays.toString(arrDest));//结果：[0, 0, 0, 0, 57, 25, 24, 80, 0] } } -
currentTimeMillis():
这个方法用的也比较多，可以用来计算程序运行的时间。在上面StringBuffer和StringBuilder中有提到。
public class StringBufferAndStringBuilderTest { public void prove(){ //开始时间 long start = System.currentTimeMillis(); String str = ""; for (int i = 0; i < 99999; i++) { str+=i; } System.out.println(str); long end = System.currentTimeMillis(); System.out.println("运行用时"+(end-start)); } public static void main(String[] args) { new StringBufferAndStringBuilderTest().prove();//结果：运行用时20175 } } -
System.gc()
告诉垃圾回收器回收，不过这个方法只是通知，具体回收不回收我们控制不了，由JVM决定。之前finalize()方法中也有提到过。一般我们不需要去重写或使用这个方法。JVM会自动调用。
-
System.exit();
System.exit(0);//退出程序。
4467
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
