java笔记——Java常用类

theone_ID

已于 2022-10-06 15:17:16 修改

阅读量737

点赞数

文章标签： java 开发语言 jvm

于 2022-09-29 15:40:33 首次发布

本文链接：https://blog.csdn.net/theone_ID/article/details/126962930

版权

Java常用类目标

1.内部类 2.包装类 3.Object类 4.String类 5.BigDecimal类 6.system类

1.1内部类

成员内部类、静态内部类、局部内部类、匿名内部类

概念：在一个类的内部再定义一个完整的类

特点：

编译之后可生成独立的字节码文件
内部类可直接访问外部类私有成员，而不破坏封装
可为外部类提供必要的内部功能组件

//身体
public class Body {
	private String name="黄存钦";
//头部
	class Header{
		//在内部类中添加方法
		public void show() {
			//打印
			System.out.println(name);
		}
	}

1.2成员内部类

在类的内部定义，与实例变量、实例方法同级别的类
外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象
第一种写法：Outer out = new Outer();
Inner in = out.new Inner() ;
第二种写法：Inner inner=new Outer().new Inner();
当外部类、内部类存在重名属性时，会优先访问内部类属性

//外部类
public class Outer {
	//定义实际变量
	private String name="张三";
	private int age=20;
	//内部类
	class Inner{
		private String name="李四";
		private String city="上海";
		private String phone="110";

测试类优先打印李四，要想打印张三要在属性前，加上类名

public void show() {
			//打印外部类属性
			System.out.println(Outer.this.name);
			System.out.println(age);

成员内部类里不能定义静态成员、可以包含静态常量(final)

//外部类
public class Outer {
	//定义实际变量
	private String name="张三";
	private int age=20;
	//内部类
	class Inner{
		private String name="李四";
		private String city="上海";
		private String phone="110";
		//成员内部类里不能定义静态成员、可以包含静态常量(final)
		//有(final)合法，反之
		private static final String country="中国";
		//方法
		public void show() {
			//打印外部类属性
			//当外部类、内部类存在重名属性时，会优先访问内部类属性
			//要想打印外部类：外部类名.this.属性
			System.out.println(Outer.this.name);
			System.out.println(age);
			//同理
			System.out.println(name);
			System.out.println(city);
			System.out.println(phone);
		}
	}
}
//测试类
public class TestOuter {
	public static void main(String[] args) {
		//1.创建一个外部类对象
		//Outer outer=new Outer();
		//2.创建一个内部类对象
		//Inner inner=outer.new Inner();
		//一步到位写法
		Inner inner=new Outer().new Inner();
		inner.show();
	}
}

1.3静态内部类

不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员

static只能修饰内部类

//外部类
public class Outer {
	private String name="张三";
	private int age=20;
	//静态内部类，级别与外部类相同
	static class Inner{
		private String city="上海";
		private String phone="110";
		//静态成员
		public static int count=10000;
		public void show() {
			//怎么调用外部类属性
			//1先创建外部类对象
			Outer outer=new Outer();
			//2调用外部类对象属性
			System.out.println(outer.name);
			System.out.println(outer.age);
			//调用静态内部类属性
			System.out.println(city);
			System.out.println(phone);
			//调用静态内部类的静态属性
			System.out.println(Inner.count);
		}
	}
}
//测试类
public class TeatOuter {
	public static void main(String[] args) {
		//直接创建静态内部类对象
		Outer.Inner inner=new Outer.Inner();
		//调用方法
		inner.show();
	}
}

1.4匿名内部类

没有类名的局部内部类（一切特征都与局部内部类相同）
必须继承一个父类或者实现一个接口
定义类、实现类、创建对象的语法合并，只能创建一个该类的对象
优点：减少代码量
缺点可读性较差

//接口
public interface Usb {
	//服务
	void service();
}
//子类
public class Mouse implements Usb {

	@Override
	public void service() {
		System.out.println("连接电脑成功，鼠标开始工作");
		
	}
	
}
//测试
public class TestUsb {
	public static void main(String[] args) {
		 //创建一个接口类型的变量
		/*Usb usb=new Mouse();	
		usb.service();
		*/
		//局部内部类
//		class Fan implements Usb{
//			@Override
//			public void service() {
//				System.out.println("连接电脑成功，风扇开始工作");
//			}
//		}
//		//使用局部内部类创建对象
//		Usb usb=new Fan();
//		usb.service();
		
		//匿名内部类优化(相当于创建了一个局部类 )
		Usb usb=new Usb() {
			@Override
			public void service() {
				System.out.println("连接电脑成功，风扇开始工作");
				
			}
		};
		usb.service();
	}
}

2.Object类

超类、基类，所有类的直接或间接父类，位于继承树的最顶层
任何类，如没有书写extends显示继承某个类，都默认直接继承Object类，否则为间接继承
Object类中所定义的方法，是所有对象都具备的方法
Object类型可以存储任何对象
1. 作为参数，可接受任何对象
2. 作为返回值，可返回任何对象

2.1getClass（）方法

public final Class<?> getClass(){}
返回引用中存储的实际对象类型
应用：通常用于判断两个引用中实际存储对象类型是否一致

package com.Object.getClass;

public class Student {
	private String name="张三";
	private int age=20;
	public Student() {
		// TODO Auto-generated constructor stub
	} 
	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;
	}
}

//测试类
package com.Object.getClass;

public class TestStudent {
	public static void main(String[] args) {
		Student s1=new Student("aaa", 20);
		Student s2=new Student("bbb", 22);
		//判断s1和s2是不是一个类型
		Class class1=s1.getClass();
		Class class2=s2.getClass();
		if (class1==class2) {
			System.out.println("s1和s2属于同一个对象");
		}else {
			System.out.println("s1和s2不属于同一个对象");
		}
	}
}

2.2hasCode（）

public int hashCode(){}
返回该对象的哈希码值
哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的值
一般情况下相同对象返回相同哈希码

package com.Oject.hasCode;

public class Syudent {
	private String name;
	private int age;
	public Syudent() {
		// TODO Auto-generated constructor stub
	}
	public Syudent(String name, int age) {//alt+shift+s”,然后再按一下“o”。
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {//alt+shift+s”,然后再按一下“r”。
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
}
 //测试类
package com.Oject.hasCode;


public class TestStudent {
	public static void main(String[] args) {
		Syudent s1=new Syudent("aaa", 20);
		Syudent s2=new Syudent("bbb", 22);
        Syudent s3=s1;//3的内存是1的复制，二者内存地址相同，返回的哈希值相同
		System.out.println(s1.hashCode());
		System.out.println(s2.hashCode());
		System.out.println(s3.hashCode());
	}
}

2.3toString()方法

public String toSring(){}
返回该对象的字符串表示（表现形式）
可以根据程序需求覆盖该方法，如：展示对象各个属性值

package com.Object.toString;

public class Student {
	private String name;
	private int age;
	public Student() {
		// TODO Auto-generated constructor stub
	}
	public Student(String name, int i) {
		super();
		this.name = name;
		this.age = i;
	}
	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;
	}
	@Override
	public String toString() {//重写方法
		return "Student [name=" + name + ", age=" + age + "]";
	}
	
}
 //测试类
package com.Object.toString;

public class TestStudent {
	public static void main(String[] args) {
		Student s1=new Student("aaa",30);
		Student s2=new Student("bbb",25);
		System.out.println(s1.toString());
		System.out.println(s2.toString());
		/*
		 * 在还没有重写toString方法时打印的是1和2的哈希值
		 * com.Object.toString.Student@7852e922
		 * com.Object.toString.Student@4e25154f
		 * 重写方法后返回内容
		 * Student [name=aaa, age=30]
		 * Student [name=bbb, age=25]
		 * */
	}
}

2.4equals（）方法

public boolean equals(Object obj){}
默认实现为(this == obj), 比较两个对象地址是否相同
可进行覆盖，比较两个对象的内容是否相同

2.4.1 重写equals（）方法步骤

1. 比较两个应用是否指向同一个对象
2. 判断obj是否为null
3. 判断两个引用只想的实际对象类型是否一致
4. 强制类型转换
5. 依次比较各个属性值是否相同

package com.Object.equals;

public class Student {
	private String name;
	private int age;
	public Student() {
		// TODO Auto-generated constructor stub
	}
	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;
	}
	@Override
	public boolean equals(Object obj) {
		//1判断两个对象是否是一个引用
		if (this==obj) {
			return true;
		}
		//2判断obj是否为空
		if (obj==null) {
			return false;
		}
		//3判断是否是同一个类型
//		if (this.getClass()==obj.getClass()) {
//			
//		}
		//instanceof 可以判断对象是否是某种类型
		if (obj instanceof Student) {
			//4强制类型转换
			Student student=(Student)obj;
			//5比较属性
			if (this.name.equals(student.getName())&&this.age==student.getAge()) {
				return true;
			}
		}
		return false;
	}
}

//测试类
package com.Object.equals;

public class TestSudent {
	public static void main(String[] args) {
		Student s1=new Student("aaa",25);
		Student s2=new Student("bbb",15);
		System.out.println(s1.equals(s2));
		Student s3=new Student("张三",22);
		Student s4=new Student("张三",22);
		System.out.println(s3.equals(s4));
		/*
		 * false
		 * false
		 * 虽然内容相同，但是在堆中不同，
		 * 就像酒店中的房间哪怕名字相同，但不是同一个房间
		 *重写方法后
		 *true
		 * */
	}
}

2.5finalize（）方法

当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象，进入回收队列
垃圾对象：没有有效引用指向此对象时，为垃圾对象
垃圾回收：由gc销毁垃圾对象，释放数据存储空间
自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象
手动回收机制：使用System.gc();通知JVM执行垃圾回收

package com.Object.finalize;

public class Student {
	private String name;
	private int age;
	public Student() {
		// TODO Auto-generated constructor stub
	}
	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;
	}
	@Override
	protected void finalize() throws Throwable {
		System.out.println(this.name+"对象被回收 ");
	}
}

//测试类
package com.Object.finalize;

public class TestStudent {
	public static void main(String[] args) {
//		Student s1=new Student("aaa",25);
//		Student s2=new Student("bbb",20);
//		Student s3=new Student("ccc",20);
//		Student s4=new Student("ddd",20);
//		Student s5=new Student("eee",20);
		new Student("aaa",25);
		new Student("bbb",20);
		new Student("ccc",20);
		new Student("ddd",20);
		new Student("eee",20);		
		//回收垃圾
		System.gc();
		System.out.println("回收垃圾");
	}
}

3.包装类

基本数据类型所对应的引用数据类型
Object 可统一所有数据，包装类的默认值是null

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

3.1类型转换与装箱、拆箱

8种包装类提供不用类型间的转换方式
1. 1.Number父类中提供的6个共性方法
  2. parseXXX( )静态方法
  3. valueOf( )静态方法

package com.heap.mode;

public class Mode {
	public static void main(String[] args) {
//		int num=10;
		//类型转换：装箱，基本类型转换成引用类型的过程
		int num1=18;//基本类型，存放在栈空间中
		//使用Integer类创建对象
		Integer integer=new Integer(num1);//装箱
		Integer integer2=Integer.valueOf(num1);
		System.out.println("装箱");
		System.out.println(integer);
		System.out.println(integer2);
		//类型转换：拆箱，引用类型转换成基本类型
		Integer integer3=new Integer(100);
		int num2=integer3.intValue();
		System.out.println("拆箱");
		System.out.println(num2);
		//JDK1.5之后，提供自动装箱和拆箱功能
		int age=30;
		//自动装箱
		Integer integer4=age;
		System.out.println("自动装箱");
		System.out.println(integer4);
		//自动拆箱
		int age2=integer4;
		System.out.println("自动拆箱");
		System.out.println(age2);
	}
}

3.1.1基本类型和字符串类型之间的转换

//基本类型和字符串类型之间的转换
		//1.基本类型装换成为字符串
		int n1=15;
		//1.1使用+号实现
		String s1=n1+"";
		//1.2使用Integer中的toString方法,还有一个重载方法
		String s2=Integer.toString(n1, 16);//radix表示是几进制，这里表示n116进制表示
		//String s2=Integer.toString(n1);
		System.out.println(s1);
		System.out.println(s2);
		//2字符串转换成基本类型
		String str="150";
		//使用Integer.paresXXX();注意：使用这个是不能出现非字符串的符号
        //否者会出现报错，抛出NumberFormatException异常
		int n2=Integer.parseInt(str);
		System.out.println(n2);
		
		//boolean字符串形式转化成基本类型，"true"---->true 非"true"---->false
		String str2="true";
		boolean b1=Boolean.parseBoolean(str2);
		System.out.println(b1);//打印true
		
		
		String str3="trues";//注意这里只要不是true就是false，false就是本身
		boolean b2=Boolean.parseBoolean(str3);
		System.out.println(b2);//打印false

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

3.2整数缓冲区

Java预先创建了256个常用的证书包装类型对象
在实际应用当中，对已创建的对象进行复用

package com.heap.mode;

public class Mode2 {
	public static void main(String[] args) {
		//面试题
		Integer integer1=new Integer(100);
		Integer integer2=new Integer(100);
		System.out.println(integer1==integer2);
		/*
		 * 结果：false
		 * 因为二者是引用类型，在栈里面是存放地址，再根据地址在堆里面找到内容
		 * 虽然二者内容相同，但是地址不同
		 * */
//		Integer integer3=100;//自动装箱
//		Integer integer4=100;
		//上面两行代码等价于
		Integer integer3=Integer.valueOf(100);
		Integer integer4=Integer.valueOf(100);
		System.out.println(integer3==integer4);//结果：true
		
		Integer integer5=200;//自动装箱,同理
		Integer integer6=200;
		System.out.println(integer5==integer6);//结果：false
		/*
		 * Integer.valueOf方法在队里面是一个从-128~127共256个地址的数组
		 * 只要i大于等于-128或小于等于127，数组就会把i的地址赋值给引用类型
		 * 就像4和3一样，100的地址同时给到4和3
		 * 而5和6超出了范围，就像1和2一样，栈里面创建两个地址，再根据地址在内存里存放内容
		 * */
	}
}

4.1String类

字符串是常量，创建之后不可改变
字符串字面值存储在字符串池中，可以共享
String s = "Hello";产生一个对象，字符串池中存储
String s = new String("Hello"); 产生两个对象，堆、池各一个

package com.study.string1;

public class Mode {
	public static void main(String[] args) {
		String name="hello";//"hello"常量存放在字符串池中，name指向"hello"
		name="zhangsan";//在字符串池中开辟一个新空间把"zhangsan"赋值给name，
		//不是对"hello"进行修改
		String name2="zhangsan";
		//系统会先在字符串池中查找有没有"zhangsan"，有的话就把"zhangsan"赋值给name2
		String str1=new String("java");
		String str2=new String("java");
		/*
		 * String s = new String("Hello"); 产生两个对象，堆、池各一个
		 * 池指向堆，堆再指向栈
		 * String str1=new String("java");
		 * String str2=new String("java");
		 * 字符串池如果存在Java，就会指向str1的堆，str2的堆
		 * str1的堆，str2的堆各自指向自己的栈
		 * str1栈-->str1的堆
		 * 					-->池
		 * str2栈-->str2的堆
		 * */
		System.out.println(str1==str2);
		//所以二者的地址不同，才打印出false
		System.out.println(str1.equals(str2));
		//equals是比较二者的内容
		
	}
}

4.2String类常用方法

package com.study.string1;

import java.util.Arrays;

public class Mode2 {
	public static void main(String[] args) {
		// 1. length(); 返回字符串长度
		// 2. charAt(int index); 返回某个位置的字符
		// 3. contains(String str); 判断是否包含某个子字符串
		System.out.println("----------------字符串使用方法1-------------------");
		String content="java是世界上最好的编程语言,java,java真香";
		System.out.println(content.length());//一个字符算一个，空格也算上一个
		System.out.println(content.charAt(0));
		System.out.println(content.charAt(content.length()-1));
		System.out.println(content.contains("java"));
		System.out.println(content.contains("php"));
		
		System.out.println("---------------字符串使用方法2-------------------");
		// 4. toCharArray(); 返回字符串对应数组 
		// 5. indexOf(); 返回子字符串首次出现的位置
		// 6. lastIndexOf(); 返回字符串最后一次出现的位置
		System.out.println(Arrays.toString(content.toCharArray()));
		System.out.println(content.indexOf("java"));
		System.out.println(content.indexOf("java", 4));
		//content.indexOf(str, fromIndex)方法中，fromIndex可以定义从那一个下标中开始找
		System.out.println(content.lastIndexOf("java"));
		
		System.out.println("---------------字符串使用方法3-------------------");
		// 7. trim(); //去掉字符串前后空格
		// 8. toUpperCase(); toLowerCase(); 转换大小写
		// 9. endWith(str); startWith(str);  判断是否以str 结尾、开头
		String content2="      Hello World    ";
		System.out.println(content2.trim());
		System.out.println(content2.toUpperCase());
		System.out.println(content2.toLowerCase());
		String filename="hello.java";
		System.out.println(filename.endsWith(".java"));
		System.out.println(filename.startsWith("hello"));
		
		System.out.println("---------------字符串使用方法4-------------------");
		// 10. replace(char old, char new); 用新的字符或字符串替换旧的字符或字符串
		// 11. split(); 对字符串拆分
		System.out.println(content.replace("java", "php"));
		String say="java is the best  programing language,jave xiang";
		String[] arr=say.split("[ ,]+");
		//使用方法split时用[ ,]+就可以删除空格和逗号，而+的使用可以删除多个空格
		System.out.println(arr.length);
		for (String string : arr) {
			System.out.println(string);
		}
		
		System.out.println("---------------补充-------------------");
		// 补充两个equals/compareTo();比较大小
		String s1="hello";
		String s2="HELLO";
		System.out.println(s1.equals(s2));
		System.out.println(s1.equalsIgnoreCase(s2));//equalsIgnoreCase忽略大小写比较
		// compareTo(); 两字符不同时比较字符字典序的ascii码
		// 字符相同时比较长度 返回差值
		String s3="abc";
		String s4="xyz";
		System.out.println(s3.compareTo(s4));//97-120
		String s5="abc";
		String s6="abcxyz";
		System.out.println(s5.compareTo(s6));//3-6
	}
}

4.3例子：

已知String str = "this is a text";
将str中的单词单独获取
将str中的text替换成practice
在text前面插入一个easy
将每个单词的首字母改为大写

package com.study.string1;
//已知String str = "this is a text";
//将str中的单词单独获取
//将str中的text替换成practice
//在text前面插入一个easy
//将每个单词的首字母改为大写
public class Mode3 {
	public static void main(String[] args) {
		System.out.println("=======将str中的单词单独获取==========");
		String str="this is a text";
		String[] arr=str.split(" ");
		for (String s : arr) {
			System.out.println(s);
		}
		System.out.println("===========将str中的text替换成practice=============");
		String str2=str.replace("text", "practice");
		System.out.println(str2);
		
		System.out.println("==========在text前面插入一个easy=============");
		String str3=str.replace("text", "easy text");
		System.out.println(str3);
		
		System.out.println("============将每个单词的首字母改为大写===============");
		for (int i = 0; i < arr.length; i++) {
			char first=arr[i].charAt(0);//charAt() 这个意思是检索字符串某个位置的字符
			//我们这里只检索首字母
			char newfirst=Character.toUpperCase(first);
			String newstr=newfirst+arr[i].substring(1);
			System.out.println(newstr);
		}
	}	
}

4.4 可变字符串

StringBuffer : 可变长字符串，运行效率慢、线程安全
StringBuilder : 可边长字符串、运行快、线程不安全
效率都比String高且节省内存

package com.study.string1;

public class Mode4 {
	public static void main(String[] args) {
		StringBuffer sb=new StringBuffer();
		// 1. append(); 追加
		sb.append("java世界第一");
		System.out.println(sb.toString());
		sb.append(",java真香");
		System.out.println(sb.toString());
		// 2. insert();可以在某个位置添加、插入
		sb.insert(8, "javanb");
		sb.insert(0, "我认为");
		System.out.println(sb.toString());
		// 3.replace(); 可以自己决定从那个位置开始替换,遵循含头不含尾的原则
		sb.replace(3, 6, "PHP");
		System.out.println(sb.toString());
		// 4. delete(); 删除，也可以指定位置,遵循含头不含尾的原则
		sb.delete(3, 7);
		System.out.println(sb.toString());
		// 5. 清空
		sb.delete(0, sb.length());
		System.out.println(sb.length());
	}

	
}

package com.study.string1;
/*
 * StringBuilder效率高于string
 * */
public class Mode5 {
	public static void main(String[] args) {
		long start=System.currentTimeMillis();
//		String string="";
//		for (int i = 0; i < 99999; i++) {
//			string+=i;
//		}
//		System.out.println(string);//消耗时间：12133
		StringBuilder sb=new StringBuilder();
		for (int i = 0; i < 99999; i++) {
			sb.append(i);
		}
		System.out.println(sb);//消耗时间：41
		long end=System.currentTimeMillis();
		System.out.println("消耗时间："+(end-start));
	}
}

5.BigDecimal类

位置 java.math 包中
作用精确计算浮点数
创建方式 BigDecimal bd = new BigDecimal("1.0");
方法：
1. new BigDecimal("1.0").add(new BigDecimal("0.5")); 加
2. new BigDecimal("1.0").subtract(new BigDecimal("0.5")); 减
3. new BigDecimal("1.0").multiply(new BigDecimal("0.5")); 乘
4. new BigDecimal("1.0").divide(new BigDecimal("0.5")); 除

package com.study.BigDecimal;

import java.math.BigDecimal;

public class Mode {
	public static void main(String[] args) {
		double d1=1.0;
		double d2=0.9;
		System.out.println(d1-d2);
		//0.09999999999999998 double精度不够
		//BigDecimal大的浮点数的精确运算
		BigDecimal bd1=new BigDecimal("1.0");//注意：一定要使用字符串的方法
		BigDecimal bd2=new BigDecimal("0.9");
		//减法
		BigDecimal num=bd1.subtract(bd2);
		System.out.println(num);
		//加法
		BigDecimal num1=bd1.add(bd2);
		System.out.println(num1);
		//乘法
		BigDecimal num2=bd1.multiply(bd1);
		System.out.println(num2);
		//除法
		BigDecimal num3=new BigDecimal("1.4")
				.subtract(new BigDecimal("0.5"))
				.divide(new BigDecimal("0.9"));
		System.out.println(num3);
		//10/3除不尽，如果我们没有告诉电脑保留几位小数会报错
		BigDecimal num4=new BigDecimal("10").divide(new BigDecimal("3"),2,BigDecimal.ROUND_HALF_UP);
		//2,BigDecimal.ROUND_HALF_UP 意思是保留两位，ROUND_HALF_UP四舍五入
		System.out.println(num4);
		
	}
}

注意：
1. 除法: divide(BigDecimal bd,int scal, RoundingMode mode)
2. ·参数scal :指定精确到小数点后几位。
3. ·参数mode :
  1. 指定小数部分的取舍模式，通常采用四舍五入的模式,。取值为BigDecimal.ROUND_HALF_UP

6.Date类

Date表示特定的瞬间，精确到毫秒。Date类中的大部分方法都已经被Calendar类中的方法所取代
时间单位：1s = 1,000ms = 1,000,000 μs = 1,000,000,000 = ns

package com.study.Date;

import java.util.Date;

public class Mode1 {
	public static void main(String[] args) {
		Date date1=new Date();
		//今天时间
		System.out.println(date1.toString());
		System.out.println(date1.toLocaleString());
		//创建昨天时间
		Date date2=new Date(date1.getTime()-60*60*24*1000);
		System.out.println(date2.toLocaleString());
		//方法：after before
		boolean b1=date1.after(date2);
		System.out.println(b1);
		boolean b2=date1.before(date2);
		System.out.println(b2);
		//比较 compareTo
		int d=date1.compareTo(date2);
		int d2=date2.compareTo(date1);
		System.out.println(d);
		System.out.println(d2);
		boolean b3=date1.equals(date2);//二者比较
		System.out.println(b3);
	}
	
}

7.Calendar类

Calendar提供了获取或设置各种日历字段的方法
构造方法 protected Calendar(); 由于是protected 所以无法直接创建
其他方法

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

package com.study.Calendar;

import java.time.Year;
import java.util.Calendar;

public class Mode {
	public static void main(String[] args) {
		//创建Calendar对象
		Calendar calendar=Calendar.getInstance();
		System.out.println(calendar.getTime().toLocaleString());
		System.out.println(calendar.getTimeInMillis());
		//获取时间信息
		//获取年
		int year=calendar.get(calendar.YEAR);
		//获取月 老外月是从0-11
		//我们使用时要加一
		int month=calendar.get(calendar.MONTH);
		//获取日
		int day=calendar.get(calendar.DAY_OF_MONTH);
		//获取时间
		int hour1=calendar.get(calendar.HOUR_OF_DAY);//24小时进制
		int hour2=calendar.get(calendar.HOUR);//12小时进制
		//获取分钟
		int minute=calendar.get(calendar.MINUTE);
		//获取秒
		int second=calendar.get(calendar.SECOND);
		System.out.println(year+"年"+(month+1)+"月"+day+"日"+hour1+"时"+minute+"分钟"+second+"秒");
		//修改时间
		Calendar calendar2=calendar.getInstance();
		calendar2.set(calendar.DAY_OF_MONTH, 5);
		System.out.println(calendar2.getTime().toLocaleString());
		//add方法修改时间
		calendar2.add(calendar.HOUR_OF_DAY, 1);
		System.out.println(calendar2.getTime().toLocaleString());
		//
		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);
		System.out.println(min);
	}
}

8.SimpleDateFormat类

SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类
进行格式化（日期→文本）、解析（文本→日期）
常用的时间模式字母

字母	日期或时间	示例
y	年	yyyy年
M	月	MM月
d	日	dd日
H	时（0-23）	HH时
m	分	mm分
s	秒	ss秒

package com.study.SimpleDateFormat;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Mode {
	public static void main(String[] args) throws ParseException {
		//创建simpleDateFormat对象
//		SimpleDateFormat simpleDateFormat =new SimpleDateFormat("yyyy年MM月dd日 HH:mm：ss");
		SimpleDateFormat simpleDateFormat =new SimpleDateFormat("yyyy年MM月dd日");
		//时间用上面那种格式输出，可以自己定义
		//创建Date
		Date date=new Date();
		//格式化date（日期转换成字符串）
		String str=simpleDateFormat.format(date);
		System.out.println(str);
		//解析 （字符串转化成日期）
		Date date2=simpleDateFormat.parse("1999年12月13日");
		//使用这个要符合上面的格式，否则会报错
		System.out.println(date2);
	}
}

9.System类

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

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

package com.study.System;

public class Mode {
	public static void main(String[] args) {
		//arraycopy 数组复制
		/*
		 * src,原数组
		 * srcPos,从那个位置开始复制
		 * dest,目标数组
		 * destPos,放在目标数组的那个位置
		 * length,复制的长度
		 * */
		int[] arr= {20,15,41,59,48,34,48,348};
		int[] dest=new int[8];
		System.arraycopy(arr, 0, dest, 0, arr.length);
		for (int i = 0; i < dest.length; i++) {
			System.out.println(dest[i]);
		}
		//计算用时
		long start=System.currentTimeMillis();
		for (int i = -999999999; i < 999999999; i++) {
			for (int j = -999999999; j < 99999999; j++) {
				int sum=i+j;
			}
		}
		long end=System.currentTimeMillis();
		System.out.println("耗时："+(end-start));
		//System.gc(); 告诉垃圾回收器回收
		new Student("张三", 19);
		new Student("李四", 19);
		new Student("王五", 19);
		System.gc();
//		Student s1=new Student("张三", 19);
//		Student s2=new Student("李四", 19);
//		Student s3=new Student("王五", 19);
		//上面这三条还有被引用，不是垃圾，System.gc();没有被启动
//		new Student("张三", 19);
//		new Student("李四", 19);
//		new Student("王五", 19);
		//这时没有被人引用，成为垃圾，垃圾回收期启动 
		//System.exit(0);退出jvm
		System.exit(0);
		System.out.println("退出jvm");
	}
}