JAVA从入门到精通------基础篇------常用类

-隐函数-

已于 2022-12-23 11:36:14 修改

阅读量221

点赞数

分类专栏： javase 文章标签： java 开发语言后端

于 2022-01-14 20:40:22 首次发布

本文链接：https://blog.csdn.net/weixin_56777219/article/details/122492365

版权

javase 专栏收录该内容

22 篇文章 0 订阅

订阅专栏

1、内部类

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

分为成员内部类，静态内部类，局部内部类，匿名内部类

特点：编译之后可生成独立的字节码文件

内部类可直接访问外部类的私有成员，而不破坏封装

可为外部类提供必要的内部功能组件

2、成员内部类

在类的内部定义，与实例变量，实例方法同级别的类

public class Person {
	
	private String name;
	private char sex;
	
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public char getSex() {
		return sex;
	}
	public void setSex(char sex) {
		this.sex = sex;
	}
	public void sayHi() {
		System.out.println("这是外部类Person的sayHi方法");
	}
	
	
	
	class Head{
		
		
		private String name;
		private char sex; 
		
		public String getName() {
			return name;
		}

		public void setName(String name) {
			this.name = name;
		}

		public char getSex() {
			return sex;
		}

		public void setSex(char sex) {
			this.sex = sex;
		}

		public void sayHi() {
			System.out.println("这是内部类Head的sayHi方法输出的内部类名字" + this.name);
			System.out.println("这是内部类Head的sayHi方法输出的内部类性别" + this.sex);
			System.out.println("这是内部类Head的sayHi放啊输出的外部类名字" + Person.this.name);
		}
		
		
		public void size() {
			
			System.out.println("内部类名字" + this.name + "外部类的属性" +Person.this.sex);
	}
	
	

	}
	
}

public class Test1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Person wang = new Person();
		Person.Head wangjiabao = wang.new Head();
		
		wangjiabao.setName("张三");
		
		wangjiabao.setSex('男');
		
		
		wang.setName("外部类定义的名字  王红");
		wangjiabao.sayHi();
		wang.sayHi();
		
		System.out.println("________________________________________");
		
		wang.setSex('女');
		wangjiabao.size();
	}

}

成员内部类不能定义成静态成员

成员内部类

调用内部类里的成员和方法 this . 名称

调用外部类里的成员和方法 Person . this . 名称

创建对象的时候外部类外部类变量名 = new 外部类();

外部类.内部类内部类变量名 = 外部类变量名.new 内部类()；

给外部类的变量名赋值：外部类变量名.set属性

给内部类的变量名赋值：内部类变量名.set属性

3、静态内部类

public class PersonStatic {
	//静态非成员变量
	private String name;
	private char sex;
	
	
	//静态成员变量
	private static int num;
	
	
	//静态内部类
	static class Head{
		
		private String size;
		//声明static成员
		public static int fair; 
		
		//声明static方法
		public static void test() {
			
			//因为size不是静态的，静态的访问要先new内部类
			Head head = new Head();
			head.size = "此时的这个头围是在静态内部类test方法里赋的值，不是在"
					+ "PersonStatic.Head inner = new PersonStatic.Head();里赋的值";
			System.out.println("内部静态成员：fair = " + Head.fair );
			System.out.println("内部非静态成员size = "+head.size);
		}
		
		public String getSize() {
			return size;
		}

		public void setSize(String size) {
			this.size = size;
		}

		public static int getFair() {
			return fair;
		}

		public static void setFair(int fair) {
			Head.fair = fair;
		}

		//声明非静态方法
		public void test1() {
			System.out.println("内部非静态成员变量：size= " + size + "fair=" + fair);
			//静态内部类的实例方法中，不能直接访问外部类的实例成员
			//System.out.println("name = " + PersonStatic.this.name);
			
			//静态类的实例方法中调用外部非静态成员的方法，先new
			PersonStatic ps = new PersonStatic();
			System.out.println("外部非静态成员：name = " + ps.name);
			
			//非静态类的方法调用静态类
			System.out.println("外部静态成员变量：num= " + PersonStatic.num);
		}
		
		
		
	}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public char getSex() {
		return sex;
	}
	public void setSex(char sex) {
		this.sex = sex;
	}
	
	
	
}

		//调用静态内部类的静态方法   
		PersonStatic.Head.test();    //直接调用
				
		System.out.println("________________________________________");	
				
		
		//先把PersonStatic里的Head类new出来
		PersonStatic.Head inner = new PersonStatic.Head();
		
		//静态内部类的属性要new之后调用
		inner.setFair(123);
		
		//静态内部类的属性要new之后调用
		inner.setSize("----60-------");
		
		//调用静态内部类的非静态方法
		inner.test1();
		
		
		
	}

}

静态内部类

静态方法访问内部静态成员或方法内部类 . 名称

内部非静态成员或方法内部类内部类的变量名 = new 内部类()；

内部类的变量名.名称 --------> 赋值

内部类的变量名 . 名称

外部静态成员或方法外部类 . 名称

外部非静态成员或方法外部类外部类的变量名 = new 外部类()；

外部类的变量名.名称 --------> 赋值

外部类的变量名 . 名称

非静态方法访问内部静态成员或方法内部类 . 名称

内部非静态成员或方法 + 名称

外部静态成员或方法外部类 . 类名

外部非静态成员或方法外部类外部类的变量名 = new 外部类()；

外部类的变量名.名称 --------> 赋值

外部类的变量名 . 名称

调用静态内部类的静态方法外部类.内部类.静态方法名

调用静态内部类的非静态方法外部类.内部类变量名 = new 外部类.内部类()；

变量名.set名称 ---------> 静态内部类的非静态成员

供非静态的方法调用内部非静态成员变量使用

变量名 . 内部类的非静态方法

4、局部内部类

方法里写一个内部类

public class PersonLocal {
	private String name;
	private char sex;
	public static int num;
	
	//声明方法
	public void sayHa(int age) {
		//局部变量
		String content = "我是方法中的局部变量";
		//局部变量的final性质在局部内部类才发现
		
		class Head{
			private String size;
			
			
			public String getSize() {
				return size;
			}

			public void setSize(String size) {
				this.size = size;
			}
			
			public void sayHead() {
				System.out.println("局部内部类开始执行sayHead方法:");
				System.out.println("外部类：PersonLocal.name="+PersonLocal.this.name);
				System.out.println("外部类：PersonLocal.num="+PersonLocal.num);
				System.out.println("局部内部类：size="+this.size);
				//局部内部类使用的所在方法的局部变量默认具有final性质
				//age=20;
				System.out.println("局部内部类所在方法的局部变量age="+age);
				System.out.println("局部内部类所在方法的局部变量content="+content);
			}
			
		}
		
		//在方法内部，创建局部内部类对象
				Head wangHead=new Head();
				wangHead.size="头围666";
				System.out.println("开始调用局部内部类里的方法");
				wangHead.sayHead();
		
		
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public char getSex() {
		return sex;
	}

	public void setSex(char sex) {
		this.sex = sex;
	}

	public static int getNum() {
		return num;
	}

	public static void setNum(int num) {
		PersonLocal.num = num;
	}
}

public class TestPersonLocal {
	public static void main(String[] args) {
		//局部内部类只能在所在的方法里new
		
		PersonLocal p1 = new PersonLocal();
		p1.setName("张三");
		p1.setSex('男');
		p1.sayHa(18);
	}
}

先输出外部类的方法再输出内部类的方法，顺序结构执行，age和content只能在外部类定义

局部内部类

非静态方法外部非静态成员或方法外部类 . this . 名称

外部静态成员或方法外部类 . 名称

局部内部类非静态成员或者方法 this . 名称

传入的标参局部非静态成员变量 +名称

外部类类名变量名 = new 外部类类名()；

变量名 . 名称

5、匿名内部类

//接口定义一个方法
public interface Com {
	public void com1(int num1,int num2);

	
	
}

//定义一个computer类
public class Computer {
	//computer类里写一个computer方法
	public void computer() {
		
		//接口进行new (){};
		Com com = new Com() {

			//重新Com接口里的方法
			public void com1(int num1,int num2) {
				//逻辑语句
				int result = num1 + num2;
				System.out.println("result = " + result);
			}
			
			
		};
		
		//  new接口自己定义的变量名   .  接口方法
		com.com1(10,5);
	}
	
	
}

public class Test {
	public static void main(String[] args) {
		Computer computer = new Computer();
		computer.computer();
	}
}

匿名内部类

1、首先定义一个接口，接口当中写一个方法，因为接口中的方法默认是public abstract 修饰的，所以需要重写该方法，

2、在一个新的类里边，写一个方法，方法里边new 接口 com 变量名 new com(){};

一定要记得大括号结束之后的分号，然后在这个括号里写方法，

3、在主方法里边 new 类然后new后的变量名 . 方法名进行调用

6、Object类

超类，基类，所有类的父类

任何类如果没有用extends指定继承某个类的话全部直接继承Object类

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

Object类可以存储对象

作为参数可以接受任何对象

作为返回值，可返回任何对象

7、getClass方法

public final Class<?>getClass(){}

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

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

System.out.println(str1.getClass());

8、hashCode方法

public int hashCode(){}

返回该对象十进制的哈希码值

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

哈希码并不唯一，可保证相同对象返回相同的哈希码，尽量保证不同对象返回不同哈希码

@Override
	public int hashCode() {
		// TODO Auto-generated method stub
		//前两个是hashCode的值，后边的stuAge本身就是int不用变成hashCode值
		return stuNo.hashCode() + name.hashCode() + stuAge;
	}





			Student s1 = new Student("小李","SD001",25);
			Student s2 = new Student("小李","SD001",25);	
			System.out.println(s1.hashCode() == s2.hashCode());

9、toString()方法

public String toString(){}

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

可以根据程序需求覆盖该方法,如，展示对象各个属性值

重写toString方法来实现我们想返回的值，例如数组，返回的是地址，我们就可以用toString来返回值

@Override
	public String toString() {
		// TODO Auto-generated method stub
		return "\t" + this.name + "\t" + this.stuNo + "\t"+ this.stuAge ;
	}

10、equals方法

public boolean equals(Object obj){}

默认实现为（this == obj） ====> 比较当前两个对象是否相同

可进行覆盖，比较两个对象的内容是否相同

equals()方法覆盖步骤

判断obj是否为null

判断两个引用指向的实践对象类型是否一致

强制类型转换

以此比较各个属性值是否相同

@Override
	public boolean equals(Object object) {
		//传进来的不能为空
		if(object == null) {
			return false;
		}
		//当前类型不等于传进来的类型
		if(this.getClass() != object.getClass()) {
			return false;
		}
		//地址相等
        //this就是代表当前地址，object是传进来的，实际就是和自身比较是否是同一个
		if(this == object) {
			return true;
		}
		//分别值去实现,每一个值,和每一个值进行对比
		Student s = (Student)object;
		if(this.stuAge == s.getStuAge() &&
			   this.stuNo.equals(s.getStuNo())&&
			   this.getName().equals(s.getName())) {
			return true;
		}else {
			return false;
		}
		
	}

11、finalize()方法

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

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

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

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

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

12、包装类

integer.parseint（)是将整型数据Integer转换为基本数据类型int

Java预先创建了256个常用的整数包装类型对象。（-128~127）

在实际应用当中，对己创建的对象进行复用。

13、String

String类型的数组里边每一个元素都可以当String类型使用，也就是说，可以调用String的所有方法

字符串字面值是常量，创建之后不可变

字符串放在方法区里的常量池内，

public class Demo1 {
	public static void main(String[] args) {
		String str1 = "大家好，我是Java1";
		//首先定义一个变量false
		boolean flag = false;
		//遍历字符串的每一个值，字符串是一个final类型的数组
		for (int i=0; i < str1.length(); i++) {
			char c = str1.charAt(i);
			System.out.print(c + "\t");

			//判断字符串中的数字
			if(c >= '0' && c <= '9') {
				flag = true;
				break;
			}
		}
		
		System.out.println("");
		if(flag == true) {
			System.out.println("字符串中包含数字");
		}else if(flag == false){
			System.out.println("字符串中没有数字");
		}
		
		String str2 = "大家好，我是Java1";
		System.out.println(str1 == str2);
		//当字符串中进行改变的时候，不能直接改变原字符串，需要在新空间中进行改变
		//String 不要进行过多的 + 计算，浪费内存
		
		//此时在常量池里，又开辟了一块内存空间，地址值发生了改变
		//只要是计算后的值就不和一样的值一样，就是false
		
		str1 = str1 + "很高兴认识你们";
		System.out.println(str1 == str2);
		
	}
}






public class Demo2 {
	public static void main(String[] args) {
		String str1 = "大家好！"; //常量池的地址
		String str2 = new String("大家好!"); //堆地址 		
		System.out.println(str1);
		System.out.println(str2);
		
		String str3 = new String("大家好！");
		System.out.println(str1 == str2); //false
		System.out.println(str2 == str3); //false
		
		//注意：
		String str4 = "大家好！";  //优先到常量池里找是否有大家好！，如果有，则把地址赋值给str4    
		System.out.println(str1 == str4); //存放同一个常量地址 true
	}
}

常用的13种String方法

public char charAt(int index)

根据下标获取字符

import java.util.Scanner;

public class Demo3 {
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		//next()代表定义一个字符串,也可看成数组,0就是数组的下角标为0的元素,也就是第一个元素
		char result = input.next().charAt(0);
	}
}

piblic boolean contains(String 输入的字符)

判断当前字符串是否包含输入的字符

import java.util.Scanner;

public class Demo3 {
	public static void main(String[] args) {
		//设定一个数组这里边的东西定义为不让搜索的关键字
		String[] nokeys = {"张三","李四","王五"};
		//定义Scanner流输数
		Scanner input = new Scanner(System.in);
		System.out.println("请输入你要搜索的关键字:");
		//输数
		String key = input.next();
		//定义一个flag,为false,如果要是搜索到了就变为true,通过flag来输出搜到的东西能否显示
		boolean flag =false;
		//遍历带不让搜索字的数组
		for (int i=0; i<nokeys.length; i++) {
			//用contains来判断  输入的key和关键字数组里的元素是否重复
			if(key.contains(nokeys[i])) {
				//重复的话定义为true
				flag = true;
				//重复一次就结束
				break;
			}
		}
		
		if(flag == true) {
			System.out.println("你搜索的内容不允许访问");
		}else {
			System.out.println("你搜索的内容是:  " + key);
		}
	}
}

public char[] toCharArray()

将字符串转换成数组

public class Demo4 {
	public static void main(String[] args) {
		String str = "大家好!, 我是JAVA";
		char[] ary = str.toCharArray();
		for(char newAry : ary) {
			System.out.print(newAry+" ");
		}
	}
}

public int indexOf(String 输入的字符)

查找输入的字符首次出现的下标，存在，则返回该下标，不存在则返回-1

public class Demo4 {
	public static void main(String[] args) {
		String str = "大家好!, 我是JAVA";
	
		int index = str.indexOf("家好");
		
		//只要查找到第一个字符所在的索引位置就输出
		System.out.println("该字符在字符串中的索引位置" + index);
	}
}

public int lengh()

返回字符串的长度

public class Demo4 {
	public static void main(String[] args) {
		String str = "大家好!我是JAVA";
	
		System.out.println(str.length());
	}
}

public String trim()

去掉字符串前后的空格

1）去掉字符串两端的空格

	String str1 = "      我 是  JAVA     ";
		//去掉字符串两端的空格
		String newStr1 = str1.trim();
		System.out.println("|" + newStr1 + "|");

public String replace(要替换什么,替换成什么)

2）去掉所有的空格

		String str1 = "      我 是  JAVA     ";
		System.out.println("替换前str1: |" + str1 + "|");
		
		String newStr1 = str1.replace(" ", "");
		System.out.println("替换后newStr1: |" + newStr1 + "|");

public String toUpperCase()

将小写转换成大写

		String str = "hello,my name is java";
		String newStr = str.toUpperCase();
		System.out.println(newStr);

public String toLowerCase();

将大写转换成小写

		String str = "HELLO,MY NAME IS JAVA";
		String newStr = str.toLowerCase();
		System.out.println(newStr);

public boolean endsWith(String 输入的字符)

判断字符串是否以要输入的字符结尾

	String str = "Hello,Java";
		
		System.out.println(str.endsWith("Java"));





     String file="111.jpg";
		boolean result=file.endsWith(".jpg");
		if(result){
			System.out.println("是jpg文件");
		}else{
			System.out.println("图片格式不正确！");
		}

public String replace(char oldChar,char newChar)

将字符串替换成新字符串

String str = "Hello,Java";
		String newStr = str.replace(",", "! ");
		System.out.println(newStr);

public String[] split(String 输入的字符)

根据要输入的字符做拆分

	String str = "张三,李四,王五";
		//默认把字符串的所有值进行分割
	
		
		String[] newStr = str.split(",");
		
		for(String newStr1 : newStr) {
			System.out.println(newStr1);
		}




        String str = "张三,李四,王五,赵六,刘七";
		
	    //参数1:按照什么分割
		//参数2:分割几个,也就是数组的长度,碰到一次参数1,就分割一次,最后一次就把所有的放一起
		String[] newStr = str.split(",",3);
		
		for(String newStr1 : newStr) {
			System.out.println(newStr1);
		}

public String subString(int beginIndex,int endIndex)

在字符串中截取出一个字符串

		 String email = "java@qq.com";
		 int index = email.lastIndexOf("@");
		 //从参数1开始截取 字母重复的话按最后一个重复字符算
		 //+1是因为截取后带lastIndexOf定义的值
		 String net = email.substring(index);
		 System.out.println(net);

index+1之后

String email = "java@qq.com";
		 int index = email.lastIndexOf("q");
		 //参数1: 开始截取的索引位置  字母重复的话按最后一个重复字符算
		 //参数2: 截取结束的索引,但是不包含结束位置
		 String net = email.substring(0,index);
		 System.out.println(net);

14、可变字符串

概念：可在内存中创造可变的缓存空间，存储频繁改变的字符串

StringBuffer:从java1.0开始的，可变字符串在原空间改变字符串值

线程安全、效率低

StringBuilder:从java5开始，可变字符串在原空间改变字符串值

线程不安全、效率高

public class Demo4 {
	public static void main(String[] args) {
		 //频繁改变字符串的时候使用
		 StringBuffer stringBuffer = new StringBuffer("abc");
		 System.out.println(stringBuffer);
		 //追加字符串  相当于+拼接计算
		 stringBuffer.append("def");
		 stringBuffer.append("ghi");
		 System.out.println(stringBuffer);
	}
}

public class Demo4 {
	public static void main(String[] args) {
		 //频繁改变字符串的时候使用
		 StringBuffer stringBuffer = new StringBuffer("abc");
		 System.out.println(stringBuffer);
		 //追加字符串  相当于+拼接计算
		 stringBuffer.append("def");
		 stringBuffer.append("ghi");
		 System.out.println(stringBuffer);
		 //插入
		 //参数1：插入的索引位置,从索引的位置也就是1就是第二个位置开始插入
		 //参数2： 插入的内容
		 //插入后，原位置的内容及之后的内容统统向后挪
		 stringBuffer.insert(1, "www");
		 System.out.println(stringBuffer);
		 //删除指定位置的字符
		 //索引为4的位置删除
		 stringBuffer.deleteCharAt(4);
		 System.out.println(stringBuffer);
		 //参数1：删除的起时索引位置
		 //参数2：删除到的索引位置，不包括该位置
		 stringBuffer.delete(3, 7);
		 System.out.println(stringBuffer);
	}
}

15、BigDecimal

精确的小数类型

创建方式

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

import java.math.BigDecimal;

public class Demo5 {
	public static void main(String[] args) {
		double num1 = 1.0;
		double num2 = 0.9;
		//数据不精确
		System.out.println(num1 - num2);
		
		//用BigDecimal
		BigDecimal big1 = new BigDecimal("1.0");
		BigDecimal big2 = new BigDecimal("0.9");
		//执行加法
		BigDecimal result1 = big1.add(big2);
		System.out.println("big1 + big2 = " + result1);
		//执行减法
		BigDecimal result2 = big1.subtract(big2);
		System.out.println("big1 - big2 = " + result2);
		//执行加法
	    BigDecimal result3 = big1.multiply(big2);
	    System.out.println("big1 * big2 = " + result3);
		//执行除法
	    //以下方式会报错,因为会有除不开的情况
//	    BigDecimal result4 = big1.divide(big2,5);
//	    System.out.println("big1 * big2 = " + result4);
	    
	    //【注意】如果除不开，会报错，需要指定保留的小数位数及保留方式
	    //参数1：除数
	  	//参数2：保留的小数位数
	  	//参数3：保留方式BigDecimal.ROUND_HALF_UP 四舍五入
	    BigDecimal result4 = big1.divide(big2,3,BigDecimal.ROUND_HALF_UP);
	    System.out.println("big1 * big2 = " + result4);
	}
}

16、Date

Date表示特定的时间，精确到毫秒

Date类中的大部分方法都已经被Calendar类中的方法所取代

时间：1秒 = 1000毫秒

1毫秒 = 1000微秒

1微秒 = 1000纳秒

import java.util.Date;

import com.qf.javasepro2105.util.DateUtil;

public class Demo1 {
	public static void main(String[] args) {
		Date date = new Date();
		//英文版本的输出时间
		System.out.println(date);
		//过时已经不需要了
		System.out.println(date.toLocaleString());
		//过时，已经不需要了
		System.out.println(date.toGMTString());
		
		//调用自己写的工具类里边的时间函数
		String strTime = DateUtil.getTime();
		System.out.println("当前系统的时间为：" + strTime);
	}
}


//工具

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

public class DateUtil {
	

	public static String getTime(){
		Date date = new Date();
		//创建 时间格式化类的对象
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss:SSS");
		String strTime = sdf.format(date);
		return strTime;
	}	
}

数据库中存datetime类型

 //计算截至当前的日期
        Date date = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //获取String类型的时间
        String dateNowStr = sdf.format(date);

        SimpleDateFormat ft=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date1 = null;
        try {
            date1 = ft.parse(dateNowStr);
            t821.setCreatetime(date1);

        }catch (ParseException e) {
            e.printStackTrace();
        }


//计算60天之后的时间
        Date date60=new Date(System.currentTimeMillis()+24*60*60*1000*60L);
        t821.setCreatetime(date60);

String转date

 String dateStr="2000-01-01 00:00:00";
 Date oldDate = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(dateStr);

import java.util.Calendar;
import java.util.Date;

public class Demo2 {
	public static void main(String[] args) {
		//日历对象的使用
		//当没有对日历做任何设置的时候，日历默认是当前时间
		Calendar calendar = Calendar.getInstance();
		//从日历当中获取当前年份
		int year = calendar.get(Calendar.YEAR);
		//从日历当中获取当前月份
		//Calendar.MONTH是0-11之间，一年12个月要+1
		int month = calendar.get(Calendar.MONTH)+1;
		//从日历当中获取当前天数
		int day = calendar.get(Calendar.DATE);
		System.out.println("年："+ year +",月："+month + ",号：" + day);
		//获取星期几
		//结果的星期，是因为从周日开始算的，周日是第一天
		int week = calendar.get(Calendar.DAY_OF_WEEK);
		System.out.println(week);
		
		
		//设置日历的初始时间
		Calendar ca2 = Calendar.getInstance();
		//设置时间
		//不设置就是一天当中最大的时间，23h23m23s
		ca2.set(2022, 1,20);
		
		//0  两个时间相同
		//正数  第一个时间 ca2 > 第二个时间 calendar
		//负数  第一个时间 ca2 < 第二个时间 calendar
		System.out.println(ca2.compareTo(calendar));
		
		//在当前的月份,也就是目前的时间 减3
		calendar.add(Calendar.MONTH, -3);
		//重新获取当前的时间
		//创建时间对象，将当前的时间给date
		Date date = calendar.getTime();
		//输出date
		System.out.println(date);
		//今天距离1970年millis的时间到现在的毫秒数
//		System.out.println(calendar.getTimeInMillis());
		
		
		//当前时间距离1970年millis的时间到现在的毫秒数
		//一般用下边的
		System.out.println(System.currentTimeMillis());
	}
}

用于判断程序运行的时间

import java.util.Random;

//查看冒泡排序的编写时间
public class Demo3 {
	public static void main(String[] args) {
		//定义一个长度为10000的数组
		int[] ary = new int[10000];
		Random random = new Random();
		//数组里的元素是1000~10000中的数
		for (int i=0; i<ary.length; i++) {
			ary[i] = random.nextInt(100000-1000+1)+1000;
		}
		//long类型的来接收，定义一开始的时间beginTime是多少
		long beginTime = System.currentTimeMillis();
		//编写冒泡排序
		for (int i=0; i<ary.length-1; i++) {
			for (int j=0; j<ary.length-1-i; j++) {
				if(ary[j] > ary[j+1]) {
					int temp = ary[j];
					ary[j] = ary[j+1];
					ary[j+1] = temp;
				}
			}
		}
		//定义结束后的时间
		long endTime = System.currentTimeMillis();
		//定义一个result变量 将结束的时间减去开始的时间就可以得到排序的时间
		long result = endTime - beginTime;
		//输出result
		System.out.println("长度为10000的数组，冒泡排序所需时间：" + result);
	}
}

17、System

public class Demo4 {
	public static void main(String[] args) {
		int num = 3;
		if(num == 3) {
			//退出
			//0正常退出，释放掉所有资源
			//1异常退出 抛异常，直接退出，没有进行资源释放
			System.out.println("程序运行结束");
			//直接释放资源
			//回收干净再退出
			System.exit(0);
			//直接退出
			System.exit(1);
			
		}else {
			System.out.println("程序正在运行");
		}
	}
}