独到理解_Java@常用类

最新推荐文章于 2024-05-17 02:36:32 发布
最新推荐文章于 2024-05-17 02:36:32 发布
阅读量170 收藏
点赞数 1
分类专栏： # 常用类 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ThestarRY/article/details/107744421
版权

文章目录

常用类

一. 基本类型包装类

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

  1. 装箱就是自动将基本数据类型转换为包装器类型
  2. 拆箱就是自动将包装器类型转换为基本数据类型
基本类型封装类型
byteByte
charCharacter
shortShort
intInteger
longLong
floatFloat
doubleDouble
booleanBoolean

以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
}
Malegod丶小飞
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java 常用类之异常处理
尚拙的博客
10-30 1015
Java异常类是对于程序中可能出现的错误或者异常的一种处理方式。在设计程序的过程中，对于可能出现的异常错误，比如说用户输入错误，设备错误，磁盘满了或者代码错误等等，通常采用异常处理的方式来进行处理可能的错误。 JAVA的异常处理机制：如果某个方法不能按照正常的途径完成任务，就可以通过另一种路径退出该方法，并处理可能出现的错误。在这种情况下会抛出一个封装了错误信息的对象。 这个方法会立刻退出同时不返...
JAVA课程设计--记忆测试系统
07-16
在当今众多的计算机程序设计语言中，面向对象技术正逐步替代传统的面向过程的程序设计技术，成为目前软件的主流开发方向，Java语言以它独到的面向对象特性在各类编程语言中脱颖而出，Java语言的快速发展与广泛应用...
Java中的@符号
m0_57598508的博客
12-14 7868
@XXX叫做注解（批注）。它和注释是不一样的！注解是代码里的特殊标志，这些标志可以在编译，类加载，运行时被读取，并执行相应的处理，以便于其他工具补充信息或者进行部署。
Java常用 @注解
hudeyong926的专栏
03-11 3066
@RequestParam注解 @RequestParam接收的参数是来自HTTP请求体或请求url的QueryString中。 RequestParam可以接受简单类型的属性，也可以接受对象类型。 @RequestParam有三个配置参数： required 表示是否必须，默认为 true，必须。 defaultValue 可设置请求参数的默认值。 value 为接收url的参数名（相当于key值）。 在参数不存在的情况下，可能希望变量有一个默认值： @RequestParam(name=
Java中@ - 注解_java @name
最新发布
2401_85013826的博客
05-17 383
Description也可以写成@Description(“测试对应的注释”)，因为注解定义的时候其字段为value。而value比较特殊，它在被指定参数的时候可以不用显示的写出来。实现一个实体类，分别使用了类上的@Description、字段和方法上的@Name。自定义一个类级别的注解Description。main方法查看对应注解是否起效。自定义一个字段、方法级别的注解。4 自定义及使用注解示例。
【JAVA】java中@的作用
Idiot 的博客
12-02 1万+
https://zhidao.baidu.com/question/1387993766650440380.html 严格说@符号并bai未在java 语言中du作为操作符使用。zhi而是在其他附dao属技术中使用 比如zhuan 1、javadoc 文档关键shu字 /** * @author * @version * @since * @see */ 用于自动生成API文档，标注作者、版本、历史变化、参考、功能、参数说明等相关信息 2、Java annotation/Java标注 语法: @关键字(值
“@” Java中的特殊符号——注解（Java中’@‘符号是什么意思？）
ITSM/ITIL/网络安全/IT运维
04-20 8423
在Java中经常看到这样的字眼 1.@Override 2.@Deprecated 3.@SuppressWarnings　　 4.@SafeVarargs 5.@FunctionalInterface 很多小伙伴不知道什么意思，其实这是一种注解，注意是注解 ，不是“ // ”注释哦。 1. 什么是注解（百度百科） 注解，可以看作是对 一个 类/方法 的一个扩展的模版，每个 类/方法 按照注解类中的规则，来为 类/方法 注解不同的参数，在用到的地方可以得到不同的 类/...
《Java基础知识》Java注解“@“详解
Limingmingaa的博客
06-20 4100
Java注解含义：Java注解，顾名思义，注解,就是对某一事物进行添加注释说明，会存放一些信息，这些信息可能对以后某个时段来说是很有用处的。 Java注解又叫java标注，java提供了一套机制，使得我们可以对方法、类、参数、包、域以及变量等添加标准(即附上某些信息)。且在以后某个时段通过反射将标注的信息提取出来以供使用。 样例（实现一个自己的注解）： 运行结果：根据这个案例：1. 注解实现需要关键字：@interface；2. 在注解上我们还使用了注解 @Target，@Retention。这些被称为
服务JAVA岗位职责任职要求.pdf
12-17
其次，编写高质量的代码是必不可少的，需要对主流JAVA框架如Spring MVC、Spring Boot、Mybatis或iBatis、SSH等有熟练掌握，并能运用常用的设计模式。此外，对J2EE框架Spring的深入理解和灵活运用也是关键。同时，...
pid算法独到见解
04-01
pid算法独到见解。 介绍了关于pid算法独到见解的详细说明，提供控制理论工程的技术资料的下载。
java2编程详解(special_edition_using_java)2.rar
07-29
12. **JVM内部机制**：包括类加载器、垃圾回收、内存模型等，帮助理解Java程序的运行方式。 这本书的"Special Edition"可能会包括对Java 2的新特性和改进的深入讨论，例如J2SE 1.4中的正则表达式、枚举类型，或者...
Java设计模式笔记之抽象工厂代码示例
08-28
Java设计模式笔记之抽象工厂代码示例主要介绍了Java设计模式笔记之抽象工厂代码示例，见解独到，代码详细，具有一定参考价值，需要的朋友可以了解下。抽象工厂模式实际上就是在工厂模式的基础上再嵌套一层工厂模式...
Java常用类介绍
Jenhy的专栏
03-24 1万+
7.1 Java类库的结构 类库就是Java API(Application Programming Interface，应用程序接口)，是系统提供的已实现的标准类的集合。在程序设计中，合理和充分利用类库提供的类和接口，不仅可以完成字符串处理、绘图、网络应用、数学计算等多方面的工作，而
java中的类是什么_java中类是什么意思
weixin_34885746的博客
02-12 1万+
类(Class)是面向对象程序设计(OOP，Object-Oriented Programming)实现信息封装的基础。类是一种用户定义的引用数据类型，也称类类型。每个类包含数据说明和一组操作数据或传递消息的函数。类的实例称为对象。类是面向对象语言的程序设计中的概念，是面向对象编程的基础。类可以看成是创建Java对象的模板。 (推荐学习：java课程)类的实质是一种引用数据类型，类似于byt...
“@” Java中的特殊符号——注解（Java中’@‘符号是什么意思？）
weixin_43748564的博客
07-16 3万+
在Java中经常看到这样的字眼 1.@Override 2.@Deprecated 3.@SuppressWarnings　　 4.@SafeVarargs 5.@FunctionalInterface 很多小伙伴不知道什么意思，其实这是一种注解，注意是注解 ，不是“ // ”注释哦。 1. 什么是注解（百度百科） 注解，可以看作是对 一个 类/方法 的一个扩展的模版，每个 类/方法 按照注解类中的规则，来为 类/方法 注解不同的参数，在用到的地方可以得到不同的 类/方法 中...
Java中@ - 注解
临地的博客
10-18 5万+
一、什么是java注解 注解，顾名思义，注解,就是对某一事物进行添加注释说明，会存放一些信息，这些信息可能对以后某个时段来说是很有用处的。 Java注解又叫java标注，java提供了一套机制，使得我们可以对方法、类、参数、包、域以及变量等添加标准(即附上某些信息)。且在以后某个时段通过反射将标注的信息提取出来以供使用。 二、自定义Java标注 1为什么要自...
java中必须了解的常用类
困而学之，学思并重
05-18 8211
java中的包装类为何有包装类的出现？ 基本数据类型不具备对象的特性的，比如基本类型不能调用方法、功能简单。 为了让基本数据类型也具备对象的特性， Java 为每个基本数据类型都提供了一个包装类，这样就可以像操作对象那样来操作基本数据类型。 每个基本类型都有相对应的包装类： 包装类主要提供了两大类方法： 将本类型和其他基本类型进行转换的方法。 将字符串和本类型及包装类互相转换的方法 下面看一个例
深入理解Java注解类型(@Annotation)
热门推荐
zejian的博客
05-21 26万+
【版权申明】未经博主同意，谢绝转载！（请尊重原创，博主保留追究权） http://blog.csdn.net/javazejian/article/details/71860633 出自【zejian的博客】 关联文章： 深入理解Java类型信息(Class对象)与反射机制 深入理解Java枚举类型(enum) 深入理解Java注解类型(@Annotation) 深入理解
java基础（类与类之间的的关系）
qq_27219335的博客
12-18 1734
** 写了这么长时间的代码，今天的突然想画UML图的时候突然间闷了,竟然不知道类与类之间的关系,果断上网找资料学习一下：** 首先在java编程中类与类之间 1.依赖 2.关联（聚合和组合） 3.继承 4.实现 第一种：依赖（Dependence)的定义：表示一个类依赖于另一个类的定义，一个类的方法操纵另一个类的对象，应用于局域变量、方法的形参，或者对静态方法的调用。 /** * @De...
java语言程序设计 姚羽
12-05
姚羽教授是一位资深的计算机科学家，他在java语言程序设计领域有着丰富的经验和深厚的功底。他曾在多家知名的科研机构和企业担任java程序设计方面的技术顾问和项目负责人，主持并完成了多个重要的java程序设计项目，取得了显著的成果和突出的贡献。 姚羽教授在java语言程序设计方面有着独到的见解和深刻的理解，他善于运用java语言的特性和优势，设计和实现高效、稳定、可靠的程序和系统。他的教学风格幽默、风趣，深受学生喜爱，深入浅出地讲解java语言程序设计的原理和方法，使学生们能够快速掌握和应用这一领域的知识和技能。 姚羽教授还积极参与java语言程序设计领域的学术交流和研究工作，他在国内外多个学术会议上发表了多篇备受关注的论文，对java语言程序设计的发展趋势和未来方向进行了深入探讨和研究。同时，他还担任多个学术期刊的编委和评审专家，推动和促进了java语言程序设计领域的学术交流和合作。 总的来说，姚羽教授在java语言程序设计领域的教学、科研和实践方面都取得了卓越的成就，对学生和同行都产生了积极的影响，是这一领域的杰出代表和领军人物。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值