JavaSE.06.常用类

最新推荐文章于 2023-12-25 14:11:06 发布

OrangeNotFat

最新推荐文章于 2023-12-25 14:11:06 发布

阅读量215

点赞数

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/OrangeNotFat/article/details/109647749

版权

Java 专栏收录该内容

24 篇文章

订阅专栏

JavaSE.06.常用类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HUhKcpIm-1605170919868)(/image-20201112155004170.png)]

1.String

1.String：字符串，使用一对""引起来表示
①.String声明为final的，不可被继承
②.String实现了Serializable接口：表示字符串是支持序列化的
		   实现了Comparable接口：表示String可以比较大小
③.String内部定义了final char[] value用于储存字符串数据
④.String：代表一个不可变的字符序列。简称：不可变性
	体现：1.当对字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的value值赋值
	 2.当对现有的字符串进行连接操作时，也需要重新制定内存区域赋值，不能使用原有的value值进行赋值
	 3.当调用String的replace()方法修改指定字符或字符串时，也需要重新指定内存区域创建一个新的value并赋值
⑤.通过字面量的方式(区别于new)给一个字符串赋值，此时的字符串值声明在字符串常量池中
⑥.常量池中是不会储存两个相同的字符串

@Test
	public void test1() {
		String s1 = "abc";//字面量的定义方式
		String s2 = "abc";
		System.out.println(s1==s2);//s1和s2的地址值相同,s1,s2同时指向常量池中的一个值
		s1 = "hello";//在常量池中创建新的值，并让地址值赋值给s1
		System.out.println(s1);
		System.out.println(s2);
		
		String s3 = "abc";
		s3 += "aaa";
		System.out.println(s3);
		
		String s4 = "abc";
		String s5 = s4.replace('a', 'm');
		System.out.println(s4);
		System.out.println(s5);
		System.out.println(s4 == s5);//false
	}

2.String对象的创建

①.String str = "hello";
②.String s1 = new String();//本质上this.value = new char[0];
③.String s2 = new String(String original);//this.value = original.value;
④.String s3 = new String(char[] a);//this.value = Arrays.copyOf(value,value.length);
⑤.String s4 = new String(char[] a,int startIndex,int count);

例题：String s = new String("abc");方式创建对象，内存中创建了一个对象？
两个：一个是堆空间中new结构，另一个是char[]对应的常量池中的数据："abc"

@Test
	public void test2() {
		//通过字面量定义的方式：此时s1和s2的数据声明在方法区中的字符串常量池中
		String s1 = "java";
		String s2 = "java";
		//通过new + 构造器的方式：此时的s3和s4保存的地址值，是数据在堆空间中开辟空间以后对应的地址值,并指向常量池中的数据"java"
		String s3 = new String("java");
		String s4 = new String("java");
		//以上四个String类型的地址值可能不相同，但是在常量池中都指向同一个"java"数据
		System.out.println(s1 == s2);//true
		System.out.println(s1 == s3);//false
		System.out.println(s3 == s4);//false
		
		Person p1 = new Person("Tom");
		Person p2 = new Person("Tom");
		
		System.out.println(p1.equals(p2));
		System.out.println(p1.name == p2.name);
		
		p1.name = "Jerry";
		System.out.println(p2.name);//Tom
	}

3.总结

结论：
1.常量与常量的拼接结果在常量池，且常量池中不会存在相同内容的常量
2.只要其中有一个是变量，结果就在堆中

@Test
	public void test3() {
		String s1 = "java";
		String s2 = "had";
		
		String s3 = "javahad";
		String s4 = "java" + "had";//堆空间中开辟新的地址值
		String s5 = s1 + "had";//堆空间中开辟新的地址值
		String s6 = "java" + s2;//堆空间中开辟新的地址值
		String s7 = s1 + s2;//堆空间中开辟新的地址值
		//相同的字符串在堆空间开辟新的地址值，然后指向常量池中已经存在的数值
		
		System.out.println(s3 == s4);//true
		System.out.println(s3 == s5);//false
		System.out.println(s3 == s6);//false
		System.out.println(s5 == s6);//false
		System.out.println(s5 == s7);//fasle
		System.out.println(s6 == s7);//false
		
		String s8 = s5.intern();//返回值等得到s8使用的常量池中的值已经存在的s3的地址值
		System.out.println(s3 == s8);//true
		
		final String s9 = "java";
		String s10 = s9 + "had";
		System.out.println(s10 == s3);//true
	}

public class StringClassTest1 {
	String str = new String("good");
	char[] ch = {'t','e','s','t'};
	
	public void change(String str,char ch[]) {//基本数据类型传的是存储的数据，引用数据类型传递的地址值
//		this.str = "test ok";//输出test ok
		str = "test ok";//String不可变，所以无法改变
		ch[0] = 'b';
	}
	
	public static void main(String[] args) {
		StringClassTest1 ex = new StringClassTest1();
		ex.change(ex.str, ex.ch);
		System.out.println(ex.str);//good
		System.out.println(ex.ch);//best
	}
}

4.String类常用方法

Int length()：返回字符串的长度
char charAt(int index)：返回某索引处的字符
boolean isEmpty()：判断是否是空字符串
String toLowerCase()：将所有字符转换为小写
String toUpperCase()：将所有字符转换为大写
String trim()：返回字符串的副本，忽略前部空白和尾部空白
boolean equals(Object obj)：比较字符串内容是否相同
boolean equalsIgnoreCase(String anotherString)：比较相同，忽略大小写比较
String concat(String str)：将制定字符串连接到此字符串的结尾，等于“+”
int compareTo(String anotherString)：比较两个字符串的大小
String substring(int beginIndex)：返回一个新的字符串，他是此字符串的从beginIndex开始截取到最后的一个子字符串
String substring(int beginIndex,int endIndex)：返回一个新的字符串，他是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串

public class StringMethodTest {
	@Test
	public void test1() {
		String s1 = "helloworld";
		System.out.println(s1.length());//10
		System.out.println(s1.charAt(0));//h
		System.out.println(s1.isEmpty());//false
		System.out.println(s1.toUpperCase());//HELLOWORLD
		System.out.println(s1.toLowerCase());//helloworld
		
		String s2 = "  hello world  ";
		System.out.println(s2.trim());//hello world
		
		String s3 = "helloworld";
		System.out.println(s1.equals(s2));//false
		System.out.println(s1.equals(s2.trim()));//true
		System.out.println(s1.equals(s3));//true
		
		System.out.println(s1.concat(s2));
		
		System.out.println(s1.compareTo(s2));//72: s1 > s2
		
		System.out.println(s1.substring(2));//lloworld
	}

boolean endsWith(String suffix)：测试此字符串是否以指定的后缀结束
boolean startsWith(String prefix)：测试此字符串是否以指定的前缀开始
boolean startsWith(String prefix,int toffset)：测试此字符串从指定索引开始的子字符串是否以指定前缀开始

boolean contains(CharSequence s)：当且仅当此字符串包含指定的char值序列时，返回true
int indexOf(String str)：返回指定字符串在此字符串中第一次出现的索引
int indexOf(String str,int fromIndex)：返回指定子字符串在此字符串中第一次出现的索引，从指定的索引开始
int lastIndexOf(String str)：返回指定子字符串在此字符串中最右边的出现处的索引
int lastIndexOf(String str,int fromIndex)：返回指定字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索
注：indexOf和lastIndexOf方法如果未找到为-1

	@Test
	public void test3() {
		String str1 = "helloworld";
		boolean b1 = str1.endsWith("rld");
		System.out.println(b1);
		boolean b2 = str1.startsWith("h");
		System.out.println(b2);
		boolean b3 = str1.startsWith("w",5);
		System.out.println(b3);
		
		String str2 = "wo";
		System.out.println(str1.contains(str2));
		System.out.println(str1.indexOf("lo"));//3
		System.out.println(str1.indexOf("lol"));//-1
		System.out.println(str1.lastIndexOf("lo"));//3
		
		//什么情况下：indexOf(str)和lastIndexOf(str)返回值相同？
		//情况一：存在唯一的一个str时,情况二：不存在str时
	}

替换
String replace(char oldChar,char newChar):返回一个新的字符串，他是通过newChar替换此字符串中出现的所有oldChar得到的
String replace(CharSequence target,CharSequence replacement)：使用指定的字面值替换序列替换此字符串所匹配字面值目标序列的子字符串里
String replaceAll(String regex,String replacement)：使用给定的replacement替换此字符串所有匹配给定的正则表达式的子字符串
String replaceFirst(String regex,String replacement)：使用给定的replacement替换此字符串匹配给定的正则表达式的第一个子字符串里
匹配
boolean mathches(String regex)：告知此字符串是否匹配给定的正则表达式
切片
String[] split(String regex)：根据给定正则表达式的匹配拆分此字符串
String[] split(String regex,int limlt)：根据匹配给定的正则表达式来拆分此字符串，最多不超过limit个，如果超过了，剩下的全部都放到最后一个元素中

	@Test
	public void test4() {
		String str1 = "abcde";
		String str11 = str1.replace("c", "m");
		System.out.println(str1);//不改变原有的字符串
		System.out.println(str11);
		String str12 = str1.replace("cd", "mm");
		System.out.println(str12);
		
		String str2 = "12hello34world5java7891mysq1456";
		String string = str2.replaceAll("\\d+", ",").replaceAll("^,|,$", "");//第一个正则去除数字，第二个去除开头和结尾的","
		System.out.println(string);
		
		String str = "12345";
		//判断str字符串中是否全部有数组组成，即有1-n个数字组成
		boolean mathches = str.matches("\\d+");
		System.out.println(mathches);//true
		//判断是否是一个杭州的固定电话
		String tel = "0571-4534289";
		boolean result = tel.matches("0571-\\d{7,8}");
		System.out.println(result);//true
		
		String str3 = "21,24,52,42";
		String[] arr = str3.split(",");
		for (String string2 : arr) {
			System.out.print(string2 + " ");
		}
		
	}

5.String和其他数据类型的转换(复习)

String与基本数据类型，包装类之间的转换
String--->基本数据类型，包装类：调用包装类的静态方法：parseXxx(str)
基本数据类型，包装类--->String：调用String重载的valueOf(xxx)

@Test
	public void test1() {
		String str1 = "123";
		int num = Integer.parseInt(str1);
		System.out.println(num);
		
		int num1 = 123;
		String str2 = String.valueOf(num1);
		System.out.println(str2);
	}

String 与 char[] 之间的转换
String--->char[]：调用String的toCharArray()
char[]--->String：调用String的构造器

@Test
	public void test2() {
		String str = "abc123";//题目：a21cb3，中间反转
		char[] charArray = str.toCharArray();
		for (char c : charArray) {
			System.out.println(c);
		}
		
		char[] arr = new char[] {'s','2','g'};
		String str2 = new String(arr);
		System.out.println(str2);
	}

String和byte[]之间的转换
编码：String--->byte[]：调用String的getByte()
解码：byte[]--->String：调用String的构造器
注：解码时的字符集应与编码时的字符集一致

@Test
	public void test3() {
		String str = "sdsdasd我的";
		byte[] by = str.getBytes();

		String str1 = new String(by);
		System.out.println(str1);
		
		byte[] by1 = null;
		try {
			by1 =str1.getBytes("gbk");//用字符集gbk编码
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
		for (byte b : by) {
			System.out.println(b);
		}
		for (byte b : by1) {
			System.out.println(b);
		}
		System.out.println(new String(by1));//sdsdasd�ҵ�
		String str2 = null;
		try {
			str2 = new String(by1,"gbk");//sdsdasd我的
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
		System.out.println(str2);
	}

2.String、StringBuffer、StringBuilder

1.三者比较

String、StringBuffer、StringBuilder三者的异同？
String：不可变的字符序列
StringBuffer：可变的字符序列，线程安全，效率偏低
StringBuilder：可变的字符序列，jdk5.0新增，线程不安全，效率高
相同：底层使用char[]进行存储

源码分析：
不可变：
String str = new String();//new char[0];
String str1 = new String("abc");//new char[]{'a','b','c'};

可变：
StringBuffer sb1 = new StringBuffer();//new char[16]：底层创建了一个长度为16的数组
System.out.print(sb1.length());//0
sb1.append('a');//value[0] = 'a';
sb1.append('b');//value[1] = 'b';
StringBuffer sb2 = new StringBuffer("abc");//长度为3 + 16

问题1：System.out.print(sb2.length());//3
问题2：扩容问题：如果要添加的数据底层数组盛不下了，那就需要扩容底层的数组
 		默认情况下，扩容为原来容量的2倍 + 2；同时将原有数组中的元素复制到新的数组中
		指导意义：开发中建议大家使用：StringBuffer(int capacity)或StringBuilder(int capacity)

2.StringBuffer常用方法

StringBuffer类的常用方法
StringBuffer append(xxx)：提供了很多的append()方法，用于进行字符串拼接
StringBuffer delete(int start,int end)：删除指定位置的内容
StringBuffer replace(int start,int end,String str)：把[start,end)位置替换为str
StringBuffer insert(int offset,xxx)：在指定位置插入xxx
StringBuffer reverse()：把当前字符序列逆转

int indexOf(String str)
String substring(int start,int end)
int length()
char charAt(int n)
setCharAt(int n,char ch)

对比String,StringBuffer,StringBuilder三者的效率？
从高到低排序：StringBuilder > StringBuffer >>> String

总结：
增：append()
删：delete()
改：setCharAt()/replace()
查：charAt()
插：insert()
长度：length()
遍历：for + charAt()

	@Test
	public void test1() {
		StringBuffer sb1 = new StringBuffer("abc");
		sb1.setCharAt(0, 'm');
		System.out.println(sb1);//mbc
		
	}
	@Test
	public void test2() {
		StringBuffer sb1 = new StringBuffer("abc");
		sb1.append(1);
		sb1.append('1');
		System.out.println(sb1);//abc11
		
		sb1.delete(1, 2);
		System.out.println(sb1);//ac11
		
		sb1.replace(0, 1, "m");
		System.out.println(sb1);//mc11
		
		sb1.insert(0, "n");
		System.out.println(sb1);//nmc11
		
		sb1.reverse();
		System.out.println(sb1);//11cmn
		
		System.out.println(sb1.indexOf("c"));//2
		
		String sub = sb1.substring(0, 2);
		System.out.println(sub);//11
		
		System.out.println(sb1.length());//5
		
		System.out.println(sb1.charAt(2));//c
		
		sb1.setCharAt(2,'b');
		System.out.println(sb1);//11bmn
	}
	
	@Test
	public void testStringBuffer() {
		String str = null;
		StringBuffer sb = new StringBuffer();
		sb.append(str);
		
		System.out.println(sb.length());//4
		System.out.println(sb);//"null"
		/*
		 * private AbstractStringBuilder appendNull() {
		        int c = count;
		        ensureCapacityInternal(c + 4);
		        final char[] value = this.value;
		        value[c++] = 'n';
		        value[c++] = 'u';
		        value[c++] = 'l';
		        value[c++] = 'l';
		        count = c;
		        return this;
    		}
		 */
		
		StringBuffer sb1 = new StringBuffer(str);//NullPointerException
		System.out.println(sb1);
		
	}

3.String总结练习

public class StringClassExercise {
	/**
	 * 将一个字符串进行翻转，将字符串中指定部分进行反转，比如"abcdefg"反转为"abfedcg"
	 * @Description
	 * @Author Mr.chen
	 * @Date 2020年11月4日下午8:24:28
	 * return:
	 */
	public String reverse(String str,int startIndex,int endIndex) {
		//方式一：
//		char[] arr = str.toCharArray();
//		for(int x = startIndex,y = endIndex;x < y;x++,y--) {
//			char temp = arr[x];
//			arr[x] = arr[y];
//			arr[y] = temp;
//		}
//		return new String(arr);
		
		
//		if(str != null) {
//			char[] arr = str.toCharArray();
//			for(int x = startIndex,y = endIndex;x < y;x++,y--) {
//				char temp = arr[x];
//				arr[x] = arr[y];
//				arr[y] = temp;
//			}
//			return new String(arr);
//		}
//		return null;
		
		//方式二
//		if(str != null) {
//			String reStr = str.substring(0,startIndex);
//			for(int i = endIndex;i >= startIndex;i--) {
//				reStr += str.charAt(i);
//			}
//			reStr += str.substring(endIndex + 1);
//			return reStr;
//		}
//		return null;
		
		//方式三：使用StringBuffer和StringBuilder替换String
		if(str != null) {
			StringBuilder sb = new StringBuilder(str.length());
			sb.append(str.substring(0,startIndex));
			for(int i = endIndex;i >= startIndex;i--) {
				sb.append(str.charAt(i));
			}
			sb.append(str.substring(endIndex + 1));
			return sb.toString();
		}
		return null;
	}
	
	@Test
	public void test1() {
		String str = "abcdefg";
		String newStr = new StringClassExercise().reverse(str, 2, 5);
		System.out.println(newStr);
	}
	
	/**
	 * 
	 * @Description 获取subStr在mainStr中出现的次数
	 * @Author Mr.chen
	 * @Date 2020年11月4日下午8:23:55
	 * return:
	 */
	public int getCount(String mainStr,String subStr) {
		int mainLength = mainStr.length();
		int subLength = subStr.length();
		int index = 0;
		int count = 0;
		if(subLength < mainLength) {
			//方式一：
//			while((index = mainStr.indexOf(subStr)) != -1) {
//				count++;
//				mainStr = mainStr.substring(index + subStr.length());
//			}
			//方式二：
			while((index = mainStr.indexOf(subStr,index)) != -1) {
				count++;
				index += subLength;
			}
			return count;
		}else {
			return 0;
		}
	}
	
	@Test
	public void test2() {
		String mainStr = "abkkkdasabodkwodksab";
		String subStr = "ab";
		System.out.println(new StringClassExercise().getCount(mainStr, subStr));
	}
	
	/**
	 * 
	 * @Description 获取两个字符串中最大的相同子串，将短的那个串进行长度依次递减的子串与较长的串比较
	 * @Author Mr.chen
	 * @Date 2020年11月4日下午8:43:54
	 * 
	 * return:
	 *
	 */
	public String getMaxSameString(String str1,String str2) {
		if(str1 != null && str2 != null) {
			String maxStr = str1.length() >= str2.length() ? str1 : str2;
			String minStr = str1.length() < str2.length() ? str1 : str2;
			int length = minStr.length();
			ArrayList<String> list = new ArrayList<>();
			for(int i = 0;i < length;i++) {
				for(int x = 0,y = length - i;y <= length ;x++ ,y++ ) {
					String subStr = minStr.substring(x,y);
					if(maxStr.contains(subStr)) {
						list.add(subStr);
					}
				}
				if(list.size() != 0) {
					break;
				}
			}
			return list.toString();
		}
		return null;
	}
	
	@Test
	public void test3() {
		String str1 = "wdandhelloisndoasabcdef";
		String str2 = "sdhelloadabcdef";
		System.out.println(new StringClassExercise().getMaxSameString(str1, str2));
	}
	
}

4.Comparable、Comparator

实现Comparable接口：涉及对象比较大小
Comparable和Comparator比较
Comparable一旦定义，则每一次可使用，并比较
Comparator只能使用一次

/*
	 * Comparable接口:
	 * 1.像String、包装类等实现了Comparable接口，重写了compareTo()方法，给出了比较两个对象大小的方式
	 * 2.String、包装类重写compareTo()方法以后，进行了从小到大的排列
	 * 3.重写compareTo()规则：
	 * 		大于返回正整数，小于返回负整数，相等返回0
	 */
	@Test
	public void test1() {
		String[] arr = new String[] {"AA","bb","cc","UU","DD"};
		Arrays.sort(arr);
		System.out.println(Arrays.toString(arr));//[AA, DD, UU, bb, cc]

	}

/*
	 * 4.自定义类，实现Comparable接口重写compareTo()方法
	 */
	@Test
	public void test2() {
		Goods[] arr = new Goods[4];
		arr[0] = new Goods("xiaomi",50);
		arr[1] = new Goods("huawei",21);
		arr[2] = new Goods("yijia",34);
		arr[3] = new Goods("luoji",56);
		Arrays.sort(arr);
		System.out.println(Arrays.toString(arr));
		//[Goods [name=huawei, price=21], Goods [name=yijia, price=34], Goods [name=xiaomi, price=50], Goods [name=luoji, price=56]]
	}

/*
	 * 5.Comparator接口的使用：定制排序
	 * 
	 */
	@Test
	public void test3() {
		Goods[] arr = new Goods[4];
		arr[0] = new Goods("xiaomi",50);
		arr[1] = new Goods("huawei",21);
		arr[2] = new Goods("yijia",34);
		arr[3] = new Goods("luoji",56);
		
		Arrays.sort(arr,new Comparator<Object>() {

			@Override
			public int compare(Object o1, Object o2) {
				if(o1 instanceof Goods && o2 instanceof Goods) {
					//方式一：
					Goods goods1 = (Goods)o1;
					Goods goods2 = (Goods)o2;
					if(goods1.getPrice() > goods2.getPrice()) {
						return 1;
					}else if(goods1.getPrice() < goods2.getPrice()) {
						return -1;
					}else {
//						return 0;
						return goods1.getName().compareTo(goods2.getName());
					}
					
					//方式二：
//					return Double.compare(goods1.getPrice(),goods2.getPrice());
				}
				throw new RuntimeException("传入的数据类型不一致");
				
			}
			
		});
		System.out.println(Arrays.toString(arr));
		//[Goods [name=huawei, price=21], Goods [name=yijia, price=34], Goods [name=xiaomi, price=50], Goods [name=luoji, price=56]]
	}

public class Goods implements Comparable<Object>{
	private String name;
	private int price;
	public Goods(String name, int price) {
		super();
		this.name = name;
		this.price = price;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getPrice() {
		return price;
	}
	public void setPrice(int price) {
		this.price = price;
	}
	
	@Override
	public String toString() {
		return "Goods [name=" + name + ", price=" + price + "]";
	}
	@Override
	public int compareTo(Object o) {
		if(o instanceof Goods) {
			//方式一：
			Goods goods = (Goods)o;
			if(this.price > goods.price) {
				return 1;
			}else if(this.price < goods.price) {
				return -1;
			}else {
//				return 0;
				return this.name.compareTo(goods.name);
			}
			
			//方式二：
//			return Double.compare(this.price, goods.price);
		}
		throw new RuntimeException("传入的数据类型不一致");
	}
}

5.System Math BigInteger BigDecimal

System  Math  BigInteger  BigDecimal

System:  native long currentTimeMillis()
			exit(int status)： 退出程序
			gc()：垃圾回收器
			getProperty(String key)：获取系统中属性名为key的属性对应的值
			常用的key：			      	java.version/java.home/os.name/os.version/user.name/user.home/user.dir

BigInteger:可以表示不可变的 任意精度的整数
BigDecimal:商业计算中，要求精度比较高，所以用BigDecimal类

1.Math

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1psPuNhR-1605170919871)(/image-20201112152652897.png)]

2.BigInteger

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-g6YNz6I5-1605170919873)(/image-20201112152844011.png)]

3.BigDecimal

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XeGm4qQn-1605170919875)(/image-20201112152757488.png)]

public class SystemMathBigIntegerTest {
	public static void main(String[] args) {
		String version1 = System.getProperty("java.version");
		System.out.println(version1);
		
		String home = System.getProperty("java.home");
		System.out.println(home);
		
		String name = System.getProperty("os.name");
		System.out.println(name);
		
		String version2 = System.getProperty("os.version");
		System.out.println(version2);
	}
}

6.关于时间API

1.Calendar

/*
	 * Calendar
	 * 
	 * 获取Calendar实例化
	 */
	@Test
	public void test1() {
		//1.实例化
		//方式一：创建其子类(GregorianCalendar)的对象
		//方式二：调用其静态方法getInstance()
		Calendar calendar = Calendar.getInstance();
//		System.out.println(calendar.getClass());//class java.util.GregorianCalendar
		
		//常用方法
		//get()：获取年月日时分秒....
		int days = calendar.get(Calendar.DAY_OF_MONTH);
		System.out.println(days);//5
		//set()
		calendar.set(Calendar.DAY_OF_MONTH, 22);
		System.out.println(calendar.get(Calendar.DAY_OF_MONTH));//22
		//add()
		calendar.add(Calendar.DAY_OF_MONTH, 3);
		System.out.println(calendar.get(Calendar.DAY_OF_MONTH));//25
		//getTime()
		Date date = calendar.getTime();
		System.out.println(date);//Wed Nov 25 13:57:50 CST 2020
		//setTime()
		calendar.setTime(new Date());
		System.out.println(calendar.get(Calendar.DAY_OF_MONTH));//5
		
	}

2.LocalDate LocalTime LocalDateTime

/*
	 * jdk8中新的日期时间API
	 * LocalDate LocalTime LocalDateTime
	 */
	@Test
	public void test2() {
		//jdk8之前
//		Date date1 = new Date(2020 - 1900,9-1,8);
//		System.out.println(date1);//Tue Sep 08 00:00:00 CST 2020
		
		//LocalDate 
		LocalDate localDate = LocalDate.now();
		System.out.println(localDate);//2020-11-05
		//LocalTime 
		LocalTime localTime = LocalTime.now();
		System.out.println(localTime);//14:25:59.285
		//LocalDateTime
		LocalDateTime localDateTime = LocalDateTime.now();
		System.out.println(localDateTime);//2020-11-05T14:25:59.285
		 
		//of():设置时间的年月日时分秒没有偏移量
		LocalDateTime localDateTime1 = LocalDateTime.of(2020,11,5,14,27,20);
		System.out.println(localDateTime1);//2020-11-05T14:27:20
		
		//get()
		System.out.println(localDateTime1.getDayOfMonth());//5
		System.out.println(localDateTime1.getDayOfYear());//310
		
		//体现不可变性
		LocalDate localDate1 = localDate.withDayOfMonth(22);
		System.out.println(localDate1);//2020-11-22
		System.out.println(localDate);//2020-11-05
		
		//设置with
		LocalDateTime localDateTime2 = localDateTime1.withHour(4);//2020-11-05T04:27:20
		System.out.println(localDateTime2);
		
		//加plus
		LocalDateTime localDateTime3 = localDateTime1.plusMonths(3);//2021-02-05T14:27:20
		System.out.println(localDateTime3);
		
		//减minus
		LocalDateTime localDateTime4 = localDateTime1.minusDays(6);//2020-10-30T14:27:20
		System.out.println(localDateTime4);
	}

3.System类中的currentTimeMillis()

@Test
	public void test1() {
		long time = System.currentTimeMillis();//1970年到现在的时间差，毫秒
		//称为时间戳
		System.out.println(time);
	}

4.Date类

java.util.Date类
		---java.sql.Date类
1.两个构造器的使用
		Date date = new Date();
		Date date1 = new Date(1604389602965l);
2.两个方法的使用
		toString()：显示当前的年、月、日、时、分、秒
		getTime()：获取当前Date对象对应的毫秒数。(时间戳)
3.java.sql.Date对应着数据库中的日期类型的变量
		如何实例化
		如何将java.util.Date对象转换为java.sql.Date对象

@Test
	public void test2() {
		//构造器一：Date()：创建一个对应当前时间的Date对象
		Date date = new Date();
		System.out.println(date);//Tue Nov 03 15:46:42 CST 2020
		
		System.out.println(date.getTime());//1604389602965
		
		//构造器二：
		Date date1 = new Date(1604389602965l);
		System.out.println(date1);//Tue Nov 03 15:46:42 CST 2020
		
		//创建java.sql.Date对象
		java.sql.Date date2 = new java.sql.Date(1604389602965l);
		System.out.println(date2);//2020-11-03
		
		//如何将java.util.Date对象转换为java.sql.Date对象
		//情况1：
		Date date3 = new java.sql.Date(1604389602965l);
		java.sql.Date date4 = (java.sql.Date)date3;
		//情况2：
		Date date5 = new Date();
		//java.sql.Date date6 = (java.sql.Date)date5;//异常：java.lang.ClassCastException: java.util.Date cannot be cast to java.sql.Date
		java.sql.Date date6 = new java.sql.Date(date5.getTime());
		System.out.println(date6);//2020-11-03
	}

5.SimpleDateFormat

SimpleDateFormat的使用：SimpleDateFormat对日期Date类的格式化和解析
	1.两个操作
	1.1格式化：日期--->字符串
	1.2解析：格式化的逆过程，字符串--->日期
 
	2.SimpleDateFormat的实例化

@Test
	public void test1() throws ParseException {
		//1.实例化SimpleDateFormat:使用默认的构造器
		SimpleDateFormat sdf = new SimpleDateFormat();
		
		//格式化：日期--->字符串
		Date date = new Date();
		System.out.println(date);//Thu Nov 05 13:08:46 CST 2020
		String format = sdf.format(date);
		System.out.println(format);//20-11-5 下午1:08
		
		//解析：格式化的逆过程，字符串--->日期
//		String str = "2019-08-09";
//		Date date1 = sdf.parse(str);
//		System.out.println(date1);//java.text.ParseException: Unparseable date: "2019-08-09"
		String str = "2019-08-09 上午 11:43";//默认格式
		Date date1 = sdf.parse(str);
		System.out.println(date1);
		
		System.out.println("--------------------------");
		//2.使用带参数的构造器
		SimpleDateFormat sdf1 = new SimpleDateFormat("yyyyy.MMMMM.dd GGG hh:mm aaa");
		String str2 = sdf1.format(date);
		System.out.println(str2);//02020.十一月.05 公元 01:17 下午
		
		//解析
		Date date2 = sdf1.parse(str2);
		System.out.println(date2);
		
	}

@Test
	public void test2() throws ParseException {
		/*
		 * 练习一：字符串"2020-09-08"转换为java.sql.Date
		 * 
		 */
		String birth = "2020-09-08";
		SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");
		Date date = sdf1.parse(birth);
		java.sql.Date date1 = new java.sql.Date(date.getTime());
		
		/*
		 * 练习二："三天打鱼两天晒网"  1990-01-01   xxxx-xx-xx  打鱼还是晒网？
		 */
		String startDate = "1990-01-01";
		String endDate = "2000-01-01";
		SimpleDateFormat ssdf = new SimpleDateFormat("yyyy-MM-dd");
		Date sdate = sdf1.parse(startDate);
		Date edate = sdf1.parse(endDate);
		
		long time = edate.getTime() - sdate.getTime();
		long day = (time/1000/24/60/60)%5;
		System.out.println(day);//2  他在打鱼 0 1 2  晒网 3 4
	}

6.Instant

瞬时 Instant
时间线上的一个瞬时点，这可能被用来记录应用程序中的事件时间戳

@Test
	public void test1() {
		
		//now()：获取本初子午线对应的标准时间
		Instant instant = Instant.now();
		System.out.println(instant);//2020-11-05T06:49:22.105Z
		
		//添加时间的偏移量
		OffsetDateTime odt = instant.atOffset(ZoneOffset.ofHours(8));
		System.out.println(odt);//2020-11-05T14:49:22.105+08:00
		
		//获取自1970年1月1日0时0分0秒(UTC) 开始的毫秒数
		long milli = instant.toEpochMilli();
		System.out.println(milli);//1604559286990
		
		//ofEpochMilli()根据给定毫秒数，获取Instant实例--->Date类的get
		Instant ins = Instant.ofEpochMilli(1604559286990l);
		System.out.println(ins);//2020-11-05T06:54:46.990Z
	}

7.DateTimeFormatter

DateTimeFormatter：格式化或解析日期、时间
类似于SimpleDateFormat

@Test
	public void test2() {
		//方式一：DateTimeFormatter.ISO_LOCAL_DATE_TIME
		DateTimeFormatter formatter1 = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
		//格式化
		LocalDateTime ldt = LocalDateTime.now();
		String str1 = formatter1.format(ldt);
		System.out.println(ldt);//2020-11-05T15:02:30.979
		System.out.println(str1);//2020-11-05T15:02:30.979
		//解析 字符串--->日期
		TemporalAccessor parse = formatter1.parse(str1);
		System.out.println(parse);//{},ISO resolved to 2020-11-05T15:04:06.268
		
		
		//方式二：ofLocalizedDateTime()
		//FormatStyle.LONG / FormatStyle.MEDIUM / FormatStyle.SHORT：适用于LocalDateTime
		DateTimeFormatter formatter2 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.SHORT);
		//格式化
		String str2 = formatter2.format(ldt);
		System.out.println(str2);//20-11-5 下午3:08
		//ofLocalizedDate()
		//FormatStyle.LONG / FormatStyle.MEDIUM / FormatStyle.SHORT / FormatStyle.FULL：适用于LocalDate
		DateTimeFormatter formatter3 = DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL);
		//格式化
		String str3 = formatter3.format(LocalDate.now());
		System.out.println(str3);//2020年11月5日 星期四
		
		
		//方式三：自定义格式，如：ofPattern("yyyy-MM-dd hh:mm:ss")
		DateTimeFormatter formatter4 = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");
		//格式化
		String str4 = formatter4.format(LocalDateTime.now());
		System.out.println(str4);//2020-11-05 03:16:13
		//解析
		TemporalAccessor accessor = formatter4.parse("2020-11-05 03:16:13");
		System.out.println(accessor);//{MinuteOfHour=16, MilliOfSecond=0, NanoOfSecond=0, HourOfAmPm=3, SecondOfMinute=13, MicroOfSecond=0},ISO resolved to 2020-11-05
		
	}