java绝对值转化成Int

文章目录

• 常用类

• 一. 基本类型包装类

• 以Integer为例
• 常用方法 :
• int Integer String 三者之间的转换 :
• java1.5 开始的新特性：

• 二. 字符串类

• 1. String

• 基本使用
• 构造方法
• 常用方法

• 2. StringBuilder
• 3. StringBuffer

• StringBuffer和StringBuilder

• 三. 数字常用类

• 1. Math
• 2. DecimalFormat

• 数字格式化 :

• 3. Random

• 随机数从 0 开始

• 四. 日期处理类

• Date

• 创建时间

• SimpleDateFormat类

• String转Date
• 十分钟前
• 日历

• 五. 枚举类型

常用类

一. 基本类型包装类

**【问】**想要对基本类型数据进行更多的操作，怎么办？
**【答】**最方便的方式就是将其封装成对象。因为在对象描述中就可以定义更多的属性和行为对该基本数据类型进行操作。我们不需要自己去对基本类型进行封装，JDK已经为我们封装好了。
【概念】

1. 装箱就是自动将基本数据类型转换为包装器类型
2. 拆箱就是自动将包装器类型转换为基本数据类型

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

以Integer为例

类目	表示	描述
构造方法	public Integer(int value)
	public Integer(String s)
常用属性	static int MAX_VALUE	返回int类型的最大值
	static int MIN_VALUE	返回int类型的最小值
常用方法	byte byteValue()	Integer类型转byte类型
(基本类型之间转换)	int intValue()	Integer类型转int类型
	… …	… …
常用方法	static int parseInt(String s)	字符串类型转int类型
(基本类型、字符串转换)	static Integer valueOf(String s)	字符串类型转Integer类型

八中包装类都在 java.lang 下,意味着使用不需要导入
另外都覆写了 toString 和 equals 方法等

public class Integer_01 {

	public static void main(String[] args) {
		byte b = 2;
		Byte b1 = new Byte(b);
		m1(b1);
	}

	// 声明一个方法,要求可以接收任何数据类型
	public static void m1(Object o) {
		System.out.println(o);
	}

}

• 八中包装类操作几乎一致,所以我们以 Integer 为例来讲解

public class Integer_02 {

	public static void main(String[] args) {
		System.out.println("int 最大值" + Integer.MAX_VALUE);
		System.out.println("int 最小值" + Integer.MIN_VALUE);
		System.out.println("long 最大值" + Long.MAX_VALUE);
		System.out.println("Byte 最大值" + Byte.MAX_VALUE);
//		int 最大值2147483647
//		int 最小值-2147483648
//		long 最大值9223372036854775807
//		Byte 最大值127
		// 创建对象
		Integer i1 = new Integer(10);// int --> Integer
		// 必须是纯数字
		Integer i2 = new Integer("123123");// String --> Integer
	}

}

常用方法 :

public class Integer_03 {
	public static void main(String[] args) {
		// int --> Integer
		Integer i1 = new Integer(10);
		// Integer --> int
		int i2 = i1.intValue();

		// static int parseInt(String str) 把纯数字字符转换为 int
		int i3 = Integer.parseInt("123123");
		double d1 = Double.parseDouble("123.12");

		// static String toBinaryString (int value) 把指定的值转换为二进制格式的字符串
		System.out.println(Integer.toBinaryString(10));// 1010

		// static String toOctalString(int value) 把指定的值转换为八进制格式的字符串
		System.out.println(Integer.toOctalString(10));// 12

		// static String toHexString(int value) 把指定的值转换为十六进制格式的字符串
		System.out.println(Integer.toHexString(10));// a

		// String --> Integer
		Integer i4 = Integer.valueOf("123");

		// int --> Integer
		Integer i5 = Integer.valueOf(123123);
	}
}

int Integer String 三者之间的转换 :

public class Integer_04 {

	public static void main(String[] args) {
		// int --> Integer
		Integer i1 = Integer.valueOf(10);

		// Integer --> int
		int i2 = i1.intValue();

		// String --> Integer
		Integer i3 = Integer.valueOf("123123");

		// Integer --> String
		String s1 = i3.toString();

		// String --> int
		int i4 = Integer.parseInt("123");

		// int --> integer
		String s2 = 19 + "";
	}

}

java1.5 开始的新特性：

1. 自动装箱 把基本数据类型自动转换为包装类
2. 自动拆箱 把包装类自动转换为基本数据类型

public class Integer_05 {

	public static void main(String[] args) {
		// 1.5之前写法
		Integer i1 = new Integer(19);
		int i2 = i1.intValue();

		// 1.5开始
		Integer i3 = 123;// 自动装箱
		int i4 = i3;// 自动拆箱

		// 装箱,因为接受 Integer 传入 int
		m1(123);

		Double d = 123.2;

	}

	public static int m1(Integer i1) {
		return i1 - 2;// 拆箱
	}
}

深入理解自动装箱和自动拆箱

• 自动装箱和自动拆箱是编译时的概念,和运行时无关
• 方便编码

整型常量池 :
如果是直接赋值,没有 new ,范围在 -128 ~ 127 之间,都保存在常量池
不会去堆内存创建对象

• 如果是直接赋值,没有 new 并且超过范围,会在堆内存创建对象

public class Integer_06 {
	public static void main(String[] args) {
		Integer i1 = new Integer(10);
		Integer i2 = new Integer(10);
		System.out.println(i1 == i2);
		System.out.println(i1.equals(i2));
//		false
//		true

		Integer i3 = 128; // 就等于 Integer i3 = new Interger(128);
		Integer i4 = 128;
		System.out.println(i3 == i4);// false

		Integer i5 = 10; // 这种不等于 Integer i5 = new Interger(10);
		Integer i6 = 10;
		System.out.println(i5 == i6);
	}
}

二. 字符串类

字符串类主要包括String、StringBuilder、StringBuffer。

1. String

基本使用

• String类是通过char数组来保存字符串的。char[]数组是final修饰的，所以String类型的变量值不可变。
• String类是final类，也即意味着String类不能被继承，并且它的成员方法都默认为final方法。
• java.lang.String 是字符串

它的底层是一个字符数组,所以它的很多特性就是数组的特性

• 字符串一旦被创建,这个字符串对象就不可以更改了
• 为了提升字符串的访问效率,java虚拟机采用了一种缓存的技术,String是一个引用数据类型,那么String的值应该保存在堆内存吧?
  但是字符串不一样,字符串对象都会在静态区有一个字符串常量池
• 在程序执行中,如果程序要用到某一个字符串,比如(“abc”),虚拟机首先会去字符串常量池中搜索,有没有这个字符串,
  如果已经有了,就直接指向这个字符串,不需要再创建一个
  如果没有,就创建一个,然后再指向

实例 :

public class String_01 {

	public static void main(String[] args) {
		// 创建一个abc 字符串对象,直接保存在常量池中,然后将内存地址赋值给变量 S1
		// 尽管没有 new 但是s1 还是指向字符串对象
		String s1 = "abd";
		// s1 是 main 方法中局部变量,并且没有使用 final 修饰,所以可以更改s1 的值
		// 因为 s1 只是保存了一个内存地址 , 所以 s1 可以重新赋值一个新的内存地址
		// 但是 abc 对象,更改不了了
		s1 = "def";

		String s2 = "Hello";
		String s3 = "Hello";
		String s4 = "hello";
		System.out.println(s2 == s3);// true
		System.out.println(s3 == s4);// false
		// 创建两个对象,一个Hello 一个 hello

		// true 比较值,因为 String 覆写了
		System.out.println(s2.equals(s3));// true

		String s5 = new String("abc");
		String s6 = new String("abc");
		// false 因为这种方式, s5 和 s6 分别指向堆内存,堆内存再指向数据
		System.out.println(s5 == s6);// false
		System.out.println(s5.equals(s6));// true

	}

}

• 使用String的时候,要注意,尽量不要做频繁的拼接操作

因为字符串一旦创建,不能更改,如果拼接,会频繁的创建字符串对象,浪费空间
实例 :

public class String_02 {

	public static void main(String[] args) {
		String[] arr = { "a", "b", "c" };
		String tmp = "";
		for (int i = 0; i < arr.length; i++) {
			tmp += arr[i];
		}
		// 会频繁的创建字符串对象
		// a,b,c,ab,abc
		System.out.println(tmp);
	}

}

构造方法

String 的构造方法

类目	表示	描述
构造方法	public String()
	public String(String str)
常用方法	equals()	字符串相等比较，不忽略大小写
	startsWith()	判断字符串是否以指定的前缀开始
	indexOf()	取得指定字符在字符串的位置
	length()	取得字符串的长度
	substring()	截取子串

实例 :

public class String_03 {

	public static void main(String[] args) {
		// 1
		String s1 = "abc";

		// 2
		String s2 = new String("abc");

		// 3 传递字符数组,转换为字符串
		byte[] bytes = { 97, 98, 99 };
		String s3 = new String(bytes);
		System.out.println(s3);// abc

		// 4 截取字符数组中的一部分
		// 下标从 1 开始(包含1),取两个
		String s4 = new String(bytes, 1, 2);
		System.out.println(s4);// bc

		// 5 传递字符串数组,转换为字符串
		char[] chars = { 'q', 'w', 'e', 'r' };
		String s5 = new String(chars);
		System.out.println(s5);// qwer

		// 6 截取字符数组的一部分
		String s6 = new String(chars, 0, 2);
		System.out.println(s6);// qw
	}

}

常用方法

1. 谁的方法,这里肯定是String的
2. 什么方法,成员还是静态,知道是什么方法的时候,才之后怎么调用,使用类名,还是使用对象
3. 方法名是什么
4. 参数是什么,代表什么
5. 返回值是什么
6. 功能是什么,这个方法能做什么是
   实例 :

public class String_04 {

	public static void main(String[] args) {
		// 1 char charAt(int index) : 获取字符串中,某个位置上的字符,相当于 arr[index]
		String s1 = "qwer";
		char c1 = s1.charAt(2);
		System.out.println(c1);// e

		// 2 boolean endsWith(String suffix) : 判断字符串是否以指定字符串结尾
		// startsWith(String prefix) 判断开始
		// true
		System.out.println("Hello.java".endsWith(".java"));// true
		// false 注意空格
		System.out.println("Hello.java".endsWith(".java "));// false

		// 3 boolean equalslgnoreCase(String anotherString) : 不区分大小写比较两个字符串是否相等
		System.out.println("abc".equals("ABC"));// false
		System.out.println("abc".equalsIgnoreCase("ABC"));// true

		// 4 byte[] getBytes() : 把字符串转换为字节数组
		byte[] bytes = "abc".getBytes();
		for (byte b : bytes) {
			System.out.println(b);
		}
//		97
//		98
//		99
		System.out.println("---");

		// 5 int indexOf(String str) : 获取指定字符串的起始索引,找不到就返回 -1
		System.out.println("asdfasdfasdf".indexOf("sd"));// 1

		// 6 int indexOf(String str , int fromIndex) : 从指定位置开始查找,找不到返回 -1
		System.out.println("asdfasdfasdf".indexOf("f", 1));// 3

		// 7 int lastIndexOf(String str) : 最后一次出现位置的索引,找不到返回 -1
		System.out.println("asdfasdfasdf".lastIndexOf("s"));// 9

		// 8 int length() : 获取字符串长度
		System.out.println("abc".length());// 3

		// 9 String replaceAll(String regex , String replacement) : 把指定字符串换为指定字符
		// 还有一个方法 replace 这两个功能一样,只不过replace支持正则表达式
		System.out.println("12h,dha!sioh@#213!23><".replaceAll("[^0-9a-zA-Z]", ""));// 12hdhasioh21323

		// 10 String[] split(String regit) : 分割字符串,需要指定分隔符,返回值是字符串数组,支持正则表达式
		String myTime = "2008.08.08";
		// 如果是以 . 进行分割,需要 \\. 因为 split 支持正则表达式,而 . 在正则表达式中有特殊含义,所以需要转义
		// 在正则表达式中,通过 \. 对 . 进行转义,但是 \ 在 java 中也是转义符,所以需要 \\. 来进行转义 \
		String[] ymd = myTime.split("\\.");
		for (String string : ymd) {
			System.out.println(string);
		}
//		2008
//		08
//		08
		System.out.println("---");

		// 11 String substring (int begin) : 获取该字符串以某个下标开始的子字符串(包括)
		System.out.println("asdfasdf".substring(2));// dfasdf

		// 12 String substring(int beginIndex , int endIdex)
		// 以某个下标开始(包括),到某个下标结束的子字符串(不包括)
		System.out.println("asdfasdf".substring(2, 6));// dfas

		// 13 char[] toCharArray() : 转换为 char 数组
		char[] c2 = "qwer".toCharArray();
		for (char c : c2) {
			System.out.println(c);
		}
//		q
//		w
//		e
//		r
		System.out.println("---");

		// 14 转大写和转小写
		System.out.println("asdFASdf".toUpperCase());// ASDFASDF
		System.out.println("asdFASdf".toLowerCase());// asdfasdf

		// 15 String trim() : 去除字符串首尾的空格
		System.out.println("   asdf  a  s   ".trim());// asdf a sasdf a s

		// 16 static String valueOf(Object obj) : 调用对象的 toString 方法,并处理 null 值
	}

}

2. StringBuilder

既然在Java中已经存在了String类，那为什么还需要StringBuilder和StringBuffer类呢？
我们看个例子来分析一下。

public class StringDemo {
    public static void main(String[] args) {
        String str = "";
        for(int i=0;i<100;i++){
            str += "hello";
        }
    }
}

分析：

string += “hello”; 相当于将原有的string变量指向的对象内容取出与
“hello”做字符串相加操作再存进另一个新的String对象当中，再让string变量指向新生成的对象。浪费时间和空间。StringBuilder类为可变字符串，解决String在字符变更方面的低效问题，低层依赖字符数组实现。

构造方法 :

类目	表示	描述
构造方法	StringBuilder()
	StringBuilder(String s)
常用方法	toString()	返回此序列中数据的字符串表示形式
	append()	表示将括号里的某种数据类型的变量插入某一序列中
	delete()	移除此序列的子字符串中的字符
	insert()	表示将括号里的某种数据类型的变量插入某一序列中
	reverse()	将此字符序列用其反转形式取代
	subString()	返回一个新的 String，它包含此序列当前所包含的字符子序列

String和StringBuilder对比
• 都是 final 类, 都不允许被继承
• String 长度是不可变的, StringBuilder长度是可变的

实例 :

public class String_05 {

	public static void main(String[] args) {
		String[] arr = { "a", "b", "c" };
		StringBuilder sb = new StringBuilder();
		for (String string : arr) {
			sb.append(string);
		}

		// 调用 toString 方法,转换为 String 类型
		String string = sb.toString();
		System.out.println(string);
		// abc

	}

}

实例 :

public class String_06 {

	public static void main(String[] args) {
		// String 是不能任意拼接的字符串
		String s1 = "ab";
		String a = "a";
		String b = "b";
		// 两个字面量相加,在编译阶段,会把 + 去掉,这个 + 相当于字符串连接符
		String s3 = "a" + "b";
		// 这种不一样,因为在编译,没有办法确定 a 和 b 的值,所以只能等运行起来之后在操作
		// 会创建一个 StringBuffer 对象进行拼接,然后在通过 toString 方法把拼接之后的值返回
		// 因为使用 == 比较,就不对, equals()比较就没有问题
		// 所以不管哪种赋值方式,我们比较字符串就是用 equals() 是最正确的,也是最保准的
		String s2 = a + b;

		String s4 = "a" + new String("b");

		System.out.println(s1 == s2);// false
		System.out.println(s1 == s3);// true
		System.out.println(s1 == s4);// false
		System.out.println(s1.equals(s4));// true
	}

}

3. StringBuffer

StringBuffer类的构造方法和用法与StringBuilder相同，可以认为是线程安全的StringBuilder。

StringBuffer和StringBuilder

1. StringBuffer和StringBuilder是什么?
   是可变的字符串缓冲区
2. 原理预先在内存中申请一块空间,用来容纳字符序列(字符数组)
   如果预留空间不够的话,会自动扩容
3. String和 StringBuffer以及StringBuilder最大的区别
   String是不可变的字符序列,存储在字符串常量池中
   StringBuilder和StringBuffer是可变的,底层也是char数组,并且可以自动扩容
4. StringBuffer和StringBuilder的默认初始化容量是16个字符
5. StringBuffer 和 StringBuilder 的区别
   StringBuffer是线程安全,在多线程环境下使用,不会出现问题,所以常用于类中
   StringBuilder是非线程安全,在多线程环境下使用,可能出现问题,所以常用于方法中

如果不考虑安全性的情况下,使用 StringBuilder 运行效率高

• StringBuilder速度快，线程不安全的
• StringBuffer线程安全的
• StringBuffer、StringBuilder 长度是可变的
  备注：线程安全的内容后面章节会具体讲解。

三. 数字常用类

1. Math

提供科学计算和基本的数字操作方法

类目	表示	描述
常用方法	static double abs(数值型 a)	返回指定数值的绝对值
	static double ceil(double a)	返回最小的（最接近负无穷大）double值，大于或等于参数，并等于一个整数
	static double floor(double a)	返回最大的（最接近正无穷大）double值小于或相等于参数，并相等于一个整数
	static long max(数值型 a, 数值型 b)	返回比较参数的较大的值
	static long min(数值型 a, 数值型 b)	返回比较参数的较小的值
	static double random()	返回一个无符号的double值，大于或等于0.0且小于1.0
	static double sqrt(double a)	返回正确舍入的一个double值的正平方根

常用方法,都是静态方法,使用 Math 类名调用,并且 Math 在 java.lang 下,不需要导入
【示例】

public class Math_01 {

	public static void main(String[] args) {
		// abs : 绝对值
		System.out.println(Math.abs(-1.2));
		// 1.2

		// ceil : 向上取整, 13, 如果是 -12.1 就是 -12
		// 正数 +1 负数不变(不要小数)
		System.out.println(Math.ceil(12.000001));
		// 13.0

		// floor : 向下取整 ,如果是 -12.999 就是 -13
		// 正数不变(不要小数),负数 -1
		System.out.println(Math.floor(12.9999));
		// 12.0

		// 比较大小
		// 谁大返回谁
		System.out.println(Math.max(2.2, 1.2));// 2.2
		// 谁小返回谁
		System.out.println(Math.min(2.2, 1.2));// 1.2

		// 开平方
		System.out.println(Math.sqrt(25));// 5.0

		// 开立方
		System.out.println(Math.cbrt(8));// 2.0

		// 随机数 大于等于 0 且小于 1 的随机数,不会等于 1
		System.out.println(Math.random());// 0.5617399125616064

		// 四舍五入,xxx.5的时候取偶数
		System.out.println(Math.rint(2.4));// 2.0
		System.out.println(Math.rint(2.6));// 3.0
		System.out.println(Math.rint(2.5));// 2.0
		System.out.println(Math.rint(3.5));// 4.0

		// N 的 M 次方 : 2 ^ 3
		System.out.println(Math.pow(2, 31));// 2.147483648E9
	}

}

2. DecimalFormat

DecimalFormat类主要的作用是用来格式化数字使用，可以直接按用户指定的方式进行格式化。

类目	表示	描述
构造方法	public DecimalFormat()
	public DecimalFormat(String pattern)
常用方法	public final String format(double number)	按照指定格式对数值进行格式化

数字格式化 :

java.text.DecimalFormat

# 任意数组 , 0-9任意单个数字
, 千分位
. 小数点
0 补位

public class Number_01 {

	public static void main(String[] args) {
		// 1.创建数字格式化对象
		// 需求 : 千分位分割
		DecimalFormat df = new DecimalFormat("###,###");
		// 123,456,789
		System.out.println(df.format(1234562789));

		// 2.需求 : 加入千分位 并且保留两位小数
		df = new DecimalFormat("###,###.##");
		// 会四舍五入
		System.out.println(df.format(12345.6555));
		// 12,345.66
		System.out.println(df.format(132.554));
		// 132.55

		// 3.需求 : 加入千分位,保留 4 位小数,不够补 0
		df = new DecimalFormat("###,###.000");
		System.out.println(df.format(1234.65));
//		1,234.650
	}
}

java.math.BigDecimal;

实例 :

public class Number_02 {

	public static void main(String[] args) {
//		System.out.println(sum(100));

		BigDecimal v1 = new BigDecimal(10);
		BigDecimal v2 = new BigDecimal(20);

		// +
		BigDecimal v3 = v1.add(v2);
		System.out.println(v3);
		// 30

		// -
		v3 = v1.subtract(v2);
		System.out.println(v3);
		// -10

		// *
		v3 = v1.multiply(v2);
		System.out.println(v3);
		// 200

		// /
		v3 = v1.divide(v2);
		System.out.println(v3);
		// 0.5

		// %
		v3 = v1.remainder(v2);
		System.out.println(v3);
		// 10

		System.out.println(sum(100));// 0
		System.out.println(sum(100));
		// 93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000
	}

	public static long sum(long i) {
		if (i < 1) {
			return 1;
		}
		return i * sum(i - 1);
	}

	public static BigDecimal sum(int i) {
		if (i < 1) {
			return new BigDecimal(1);
		}
		return new BigDecimal(i).multiply(sum(i - 1));
	}
}

3. Random

Random类专门用于生成一个伪随机数，它有两个构造器。
相对于Math的random()方法而言，Random类提供了更多方法来生成各种伪随机数，它不仅可以生成浮点类型的伪随机数，也可以生成整形类型的伪随机数，还可以指数定生成随机数的范围。

随机数从 0 开始

public class Random_01 {

	public static void main(String[] args) {
		// 1 创建一个随机数生成器
		Random r = new Random();

		// 0 ~ 10 内随机生成
		int i = r.nextInt(11);
		System.out.println(i);

		// 比如想生成 10 ~ 20
		int tmp = r.nextInt(11) + 10;
		System.out.println(tmp);

		// 生成 a~z
		int i1 = r.nextInt(26);
		char c = (char) (i1 + 97);
		System.out.println(c);
	}

}

生成 5 个不同的随机数 [1-5]

1. 每次输出打印的话,不能保证唯一性
2. 因此,我们需要在输出之前,先保存数据,如果有这个数,就跳过,没有就存到数组中,最后遍历数组即可

实例 :

public class Random_02 {

	public static void main(String[] args) {
		// 1 声明一个随机数生成器
		Random r = new Random();
		// 2 声明一个数组用来存储
		int[] arr = new int[5];

		int index = 0;
		while (index < 5) {
			int tmp = r.nextInt(11);
			// 如果这个数不是0 并且 数组中也没有这个数,就添加到数组中
			if (tmp != 0 && !contains(arr, tmp)) {
				arr[index] = tmp;
				index++;
			}
		}

		for (int i : arr) {
			System.out.println(i);
		}
	}

	// 判断数组中是否有某个数据,有就是true,没有就是false
	public static boolean contains(int[] a, int tmp) {
		for (int i = 0; i < a.length; i++) {
			if (a[i] == tmp) {
				return true;
			}
		}
		return false;
	}
}

四. 日期处理类

Java提供了一系列用于处理日期、时间的类，包括创建日期、时间对象，获取系统当前日期、时间等操作。

Date

类目	表示	描述
构造方法	Date()
	Date(long date)
常用方法	long getTime()	返回该时间对应的long型整数
	int compareTo(Date anotherDate)	比较两个日期的大小
	void setTime(long time)	设置该Date对象的时间

实例 :

创建时间

计算机时间 是以 1970年1月1日8点开始 (北京时间)

System.currentTimeMillis() 获取时间原点到当前时间的毫秒数
1秒 = 1000毫秒
实例 :

public class Date_01 {

	public static void main(String[] args) {
		// 时间原点到当前时间的毫秒数
		long now = System.currentTimeMillis();
		System.out.println(now / 1000 / 60 / 60 / 24 / 365);
		// 50
		String s = "12";

	}

}

获取当前系统时间:

public class Date_02 {

	public static void main(String[] args) {
		// 获取当前系统时间
		Date date = new Date();
		System.out.println(date);
		// 上面打印的默认是欧美习惯,可以自定义格式
		// 日期格式:
		// 年 : y 月 : M 日 : d 小时 H 分 m 秒 s 毫秒 S

		// 时间格式化对象
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss:SSS");
		// 格式化时间,返回String类型
		String strTime = sdf.format(date);
		System.out.println(strTime);
//		Wed Jul 15 19:38:42 CST 2020
//		2020年07月15日 19:38:42:996

	}

}

实例 :

public class Date_04 {

	public static void main(String[] args) {
		// 也可以传入 long 值,表示毫秒数
		// 意思是获取时间原点到指定毫秒数的时间
		Date t1 = new Date(1000);
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss SSS");
		System.out.println(sdf.format(t1));
//		1970年01月01日 08:00:01 000

		// 获取当前系统时间的前 10 分钟
		Date t2 = new Date(System.currentTimeMillis() - 1000 * 60 * 10);
		System.out.println(sdf.format(t2));
//		2020年07月15日 19:36:52 121
	}

}

SimpleDateFormat类

String转Date

SimpleDateFormat是最常用的日期处理类，创建对象时需要传入一个日期模板字符串。

类目	表示	描述
构造方法	public SimpleDateFormat()	按照日期模板格式化
	public SimpleDateFormat(String pattern)
常用方法	public final String format(Date date)	对日期格式化把一个字符串解析成Date对象
	public Date parse(String source)

把日期格式的字符串,转换为 Date 对象 :

public class Date_03 {

	public static void main(String[] args) throws ParseException {
		// 准备日期
		String strTime = "2020年07月15日 14:47:54 841";
		// 1.创建格式化对象
		// 日期格式必须和字符串中的日期格式对应才行
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss SSS");

		// 2.转换为 Date
		Date t = sdf.parse(strTime);
		System.out.println(t);
//		Wed Jul 15 14:47:54 CST 2020

	}

}

十分钟前

实例 :

public class Date_04 {

	public static void main(String[] args) {
		// 也可以传入 long 值,表示毫秒数
		// 意思是获取时间原点到指定毫秒数的时间
		Date t1 = new Date(1000);
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss SSS");
		System.out.println(sdf.format(t1));
//		1970年01月01日 08:00:01 000

		// 获取当前系统时间的前 10 分钟
		Date t2 = new Date(System.currentTimeMillis() - 1000 * 60 * 10);
		System.out.println(sdf.format(t2));
//		2020年07月15日 19:36:52 121
	}

}

日历

日历类 :

public class Date_05 {

	public static void main(String[] args) throws ParseException {
		// 获取当前日历
		Calendar c = Calendar.getInstance();
//		System.out.println(c);

		// 获取今天是本周的第几天,周日是第一天
		int i = c.get(Calendar.DAY_OF_WEEK);
		System.out.println(i);// 4

		// 今天是本月第几天,也就是多少号
		System.out.println(c.get(Calendar.DAY_OF_MONTH));// 15

		// 获取年
		System.out.println(c.get(Calendar.YEAR));// 2020

		// 获取月,范围是0~11 所以获取到之后 + 1 就是当前月份
		System.out.println(c.get(Calendar.MONTH) + 1);// 7

		// 获取日
		System.out.println(c.get(Calendar.DAY_OF_MONTH));// 15

		// 获取时 12小时
		System.out.println(c.get(Calendar.HOUR));// 7
		// 24小时
		System.out.println(c.get(Calendar.HOUR_OF_DAY));// 19

		// 获取分
		System.out.println(c.get(Calendar.MINUTE));// 57

		// 获取秒
		System.out.println(c.get(Calendar.SECOND));// 50

		// 获取指定时间的日历
		String strTime = "2016.04.01";
		Date d = new SimpleDateFormat("yyyy.MM.dd").parse(strTime);
		// 该句会生成指定时间对应的日历
		c.setTime(d);
		// 获取星期,周日是第一天
		System.out.println(c.get(Calendar.DAY_OF_WEEK));// 6
	}

}

五. 枚举类型

【介绍】
枚举类型是Java 5新增的特性，它是一种新的类型
枚举类型的定义中列举了该类型所有可能值
使用java.lang.Enum类型来定义枚举
【语法格式】

[修饰符] enum 类名{
… …
}

【示例】
使用枚举实现交通管理：

1. 列举出交通信号灯颜色
2. 列举出交通信号对应的车辆行为

【意义】
可以替代常量定义，自动实现类型检查，便于维护、编程，减少出错概率 。

Enumeration : 枚举类型,简单来说,可以看做是常量的集合

当我们需要一系列有限的值的时候,并且用的比较多,可以使用枚举

写枚举的话,更容易发现错误,在编译器会对类型进行检查,从而减少错误

• 由class 变为 enum
  可以替代常量定义，自动实现类型检查，便于维护、编程，减少出错概率

public class Enum_01 {

	public static void main(String[] args) {
		int a = 1;
		int b = 2;
		String retValue = divide(a, b);
		if (retValue.equals("SUCEESS")) {
			System.out.println("成功");
		} else {
			System.out.println("失败");
		}
	}

	public static String divide(int a, int b) {
		try {
			int c = a / b;
			return "SUCCESS";
		} catch (Exception e) {
			return "FAIL";
		}
	}
}

实例 :

public class Enum_02 {
	public static void main(String[] args) {
		int a = 1;
		int b = 2;
		Result retValue = divide(a, b);
		if (retValue.equals(Result.SUCCESS)) {
			System.out.println("成功");
		} else {
			System.out.println("失败");
		}
	}

	public static Result divide(int a, int b) {
		try {
			int c = a / b;
			return Result.SUCCESS;
		} catch (Exception e) {
			return Result.FAIL;
		}
	}
}

enum Result {
	SUCCESS, FAIL
}