# java API
一、什么是api?
API(Application Programming Interface)，应用程序编程接口,是JDK中提供给我们使用的类的说明文档。
@Deprecated：表示这个方法快过时了。
什么方法和属性都没有的接口，标记接口。
Cloneable标记接口（没有方法，没有属性），凡是实现该接口的类都可以克隆。
native是调用c语言内容的修饰符。
二、Object类
2.1简介:java.lang.Object类是Java语言中的根类，即所有类的父类。它中描述的所有方法子类都可以使用。如果一个类没有继承父类，那么默认则继承自Object类。
2.2常用方法。
Object类一共有11个方法，其中重要的有两个。
| 方法名 | 说明 |
|---|---|
| public String toString() | 返回该对象的字符串表示。 |
| public boolean equals(Object obj) | 指示其他某个对象是否与此对象“相等”。 |
toString方法返回该对象的字符串表示，其实该字符串内容就是对象的类型+@+十六进制内存地址值（对象.hashCode()）。
syso打印任何一个对象都是调用该对象的toString()方法。
Object类中的equals是使用==判断是否相等。
覆盖equals套路
public boolean equals(Object obj){
//判断比较双方的地址是否相同
if(this == obj)
return true;
//如果传入的对象是空则返回false.
if(obj == null)
return false;
//判断类型信息是否相等（getClass()!=obj.getClass()）//getClass():获取当前对象的类名.
if(!(obj instanceof 对象名))
return false;
//转换当前类型。
对象名 变量名 = (对象名)obj;
//下面是我们自己的业务逻辑
}
equals()的覆盖原则：
1.自反性：x.equals(x)为true
2.对称性 : x.equals(y)和y.equals(x)的值相同。
3.传递性：x.equals(y) y.equals(z)结果相同,那么x.equals(z)的结果也相同。
JDK7添加了一个Objects工具类，它提供了一些方法来操作对象，它由一些静态的实用方法组成，这些方法是null-save（空指针安全的）或null-tolerant（容忍空指针的），用于计算对象的hashcode、返回对象的字符串表示形式、比较两个对象。
public static boolean equals(Object a, Object b) { //判断两个对象是否相等
return (a == b) || (a != null && a.equals(b));
}
public boolean equals(Object obj) {
//如果对象地址一致返回true
if(this==obj)
return true;
//如果对象为空则返回false
if(obj==null)
return false;
//如果类型不一致，则返回false
if(!(obj instanceof Person))
return false;
//转换当前对象的格式。
Person person = (Person) obj;
// 要求基本类型相等，并且将引用类型交给java.util.Objects类的equals静态方法取用结果
return age==person.age && Objects.equals(this.name, person.name);
}
2.3克隆
克隆就是在堆空间里又申请了一个空间。
克隆会破坏单例
克隆如何使用？
被克隆的类/接口实现Cloanable接口
被克隆的类重写clone()方法
使用克隆
2.4：Objects类
java.util.Objects：Objects工具类，它提供了一些方法来操作对象，它由一些静态的实用方法组成，这些方法是null-save（空指针安全的）或null-tolerant（容忍空指针的），用于计算对象的hashcode、返回对象的字符串表示形式、比较两个对象。
三、Class类
getClass()方法
返回类型是Class类的对象。
对象.getClass().getPackage()：获取包名
getFields()获取类中的公开的属性信息
getDeclaredFields()获取类中属性的信息
getModifiers():修饰符类型
getType():数据类型
getName():属性名。
getConstructors()：获取构造对象。
完全破坏了封装。
Class 类的类
Class clazzStu = stu.getClass();
classStu:引用指向的是"类的类"的对象，一般情况下我们称之为"类对象".
你写的类的类型是Class
我写的类在java虚拟机中运行的时候就是Class的对象。
C c = new C();
System.out.println(c.getClass());//class cn.yunhe.java.C
System.out.println(c.getClass().getPackage());//package cn.yunhe.java
System.out.println(c.getClass().getFields());//获取类中的公开的属性信息
System.out.println(c.getClass().getDeclaredFields());//获取类中属性的信息
System.out.println(c.getClass().getConstructors());//获取构造对象。
java.lang.reflect.Field [] fields = c.getClass().getDeclaredFields();
for(java.lang.reflect.Field f : fields) {
//getModifiers()修饰符类型
//getType()数据类型
//getName()属性名
System.out.println(f.getModifiers()+" "+ f.getType()+" "+f.getName() );
}
四、String类。
4.1概述
String代表字符串，java程序中所有的字符串文字(“abc”)都可以被看作此类的实例。
4.2池化思想？
池化的思想，把需要共享的数据放在池中（节省空间，共享数据）
只有String类可以用“”中的字面值创建对象。在String类中，以字面值创建时，会到Java方法空间的串池空间中去查找，如果有就返回串池中字符串的地址，并把这个地址付给对象变量。如果没有则会在串池里创建一个字符串对象，并返回其地址付购对象变量，当另一个以字面值创建对象时则会重复上述过程。
如果是new在堆空间中创建String类的对象，则不会有上述的过程。
双引号直接写的字符串在池中，new的不在池当中。
4.3.String对象的特点。
- 2.1：字符串不变：字符串的值在创建后不能被更改。
String a = “1231”;//字符串在jvm中有一个串池。
a = “345”;//在串池中创建了"345"，将引用a指向1231。 - 2.2：string对象是不可变的，它们可以被共享
St s1 = “abc”;
st s2 = “abc”;
s1和s2是相等的。只创建了一个对象。 - 2.3：String本质是使用数组实现的。
jdk8之前使用char[]数组，jdk8之后是byte[]数组。
2.4:String类在java.lang包下。
4.4构造方法
| 方法名 | 说明 |
|---|---|
| public String() | 初始化新创建的String对象，以使其表示空字符序列 |
| public String(char[] value) | 通过当前参数中的字符数组来构造新的String。 |
| String(char[] value, int offset, int count) | 通过当前参数中的字符数组的一部分来构造新的String。 |
| String(byte[] bytes) | 通过使用平台的默认字符集解(可以更改该字符编码 )当前参数中的字节数组来构造新的 |
| String(byte[] bytes, int offset, int length) | 通过使用平台的默认字符集解码(可以更改该字符编码 )当前参数中的字节数组的一部分来构造新的String |
// 无参构造
String str = new String();
// 通过字符数组构造
char chars[] = {'a', 'b', 'c'};
String str2 = new String(chars);
// 通过字节数组构造
byte bytes[] = { 97, 98, 99 };
String str3 = new String(bytes);
4.5常用方法。
1.比较功能的方法
equals()：密码验证。
equalsIgnoreCase()：验证码。
public boolean equals (Object anObject)：将此字符串与指定对象进行比较
public boolean equalsIgnoreCase(String anotherString)： 将此字符串与指定对象进行比较，忽略大小写
public boolean endsWith(String suffix): 判断此字符串是否以指定的后缀结束
public boolean startsWith(String prefix): 判断此字符串是否以指定的前缀开始
2.获取功能的方法
public int length() ：返回此字符串的长度
public String concat(String str): 将指定的字符串连接到该字符串的末尾
public char charAt(int index): 返回指定索引处的char值。
public int indexOf(int ch)：返回指定子字符串第一次出现在该字符串内的索引。
public String substring(int beginIndex)：返回一个子字符串，从beginIndex开始截取字符串到字符串结尾。
public String substring(int beginIndex,int endIndex)：返回一个子字符串，从beginIndex到endIndex截取字符串。含beginIndex，不含endIndex。
3.转换功能的方法
public char[] toCharArray()：将此字符串转换为新的字符数组。
public byte[] getBytes()：使用平台的默认字符集（中间可以加入转换的字符编码解码）将该String编码转换为新的字节数组。
public String replace(char oldChar, char newChar)：将oldChar匹配的字符串使用newChar字符串替换。
public String replaceFirst(String regex,String replacement)用给定的 replacement 替换此字符串匹配给定的regex的第一个子字符串。
public String toUpperCase() : 将字符中转换为大写
public String toLowerCase(): 将字符中转换为小写
4.分割和去空格的功能方法。
public String[] split(String regex)：将此字符串按照给定的regex（规则）拆分为字符串数组。
public String trim()：去除该字符串的两端空格
拼接字符串的时候使用StringBuilder() StringBuffer();
反转字符串
5.其他方法
String.join(拼接符，字符)：拼接字符。
valueOf():返回boolen参数的字符串boolean形式。字符串个数的boolean
str.contains():看看一个字符串是不是在str中。
String.format("%s java %s",“学习”,“好工作”);返回格式化的字符串。
拼接字符串的时候，少用+=,会导致heap space(堆)满。使用append,join
==：比较的是引用类型指向的对象的地址，基本数据类型就是数据
xxx.equals(xxx),比较的是对象的内容。
intern();返回字符串的规范化表示。str.intern()，str就进串池
String类中的intern()方法会将在堆空间中创建的String类对象中的字符串和串池中的比对，如果有相同的串就返回这个串的串池中的地址。
设计模式总共有24个：不变模式，适配器模式。
不变模式在对于对象进行修改，添加操作是使相当麻烦的，他会产生很多的中间垃圾对象。创建和销毁的资源的开销是相当大的。
String类在字符串连接时的效率很低，就是因为它所产生的对象的属性是不能够修改的，当连接字符串时也就是只能创建新的对象。
对于很多的字符串连接，应当使用StringBuffer类，在使用这个类的对象来进行字符串连接时就不会有多余的中间对象生成，从而优化了效率。
//string构造方法
//直接创建一个对对象。
String s = new String();//创建一个空字符串
System.out.println(s);
char[] sChar = {'z','h','o','n','g'};
String s2 = new String(sChar);
System.out.println(s2);
byte[] sByte = {65,66,67,68,69,65,97};
String s3 = new String(sByte);
System.out.println(s3);
String s4 = new String(sByte,0,3);
System.out.println(s4);//ABC
//1.比较方法
//public boolean equals (Object anObject)：将此字符串与指定对象进行比较
System.out.println(s2.equals(s3));//false
//public boolean equalsIgnoreCase(String anotherString)： 将此字符串与指定对象进行比较，忽略大小写
System.out.println("ABC".equalsIgnoreCase("abc"));//true;
//public boolean endsWith(String suffix): 判断此字符串是否以指定的后缀结束
System.out.println("ABC".endsWith("C"));//true
//public boolean startsWith(String prefix): 判断此字符串是否以指定的前缀开始
System.out.println("ABC".startsWith("a"));//false
//2.获取功能的方法
//public int length() ：返回此字符串的长度
System.out.println("ABC".length());//3
//public String concat(String str): 将指定的字符串连接到该字符串的末尾
//链式编程
System.out.println("abc".concat("def").concat("ghi").concat("jkl"));
//public char charAt(int index): 返回指定索引处的char值。
System.out.println("abcdefg".charAt(0));
//public int indexOf(int ch)：返回指定子字符串第一次出现在该字符串内的索引。有重载方法，没有返回-1
System.out.println("abcdefg".indexOf("h"));//-1
//public String substring(int beginIndex)：返回一个子字符串，从beginIndex开始截取字符串到字符串结尾。
//public String substring(int beginIndex,int endIndex)：返回一个子字符串，从beginIndex到endIndex截取字符串。含beginIndex，不含endIndex。
System.out.println("abcdefg".substring(0,5));
//3.转换功能的方法
//public char[] toCharArray()：将此字符串转换为新的字符数组。
System.out.println("abc".toCharArray());
//public byte[] getBytes()：使用平台的默认字符集（中间可以加入转换的字符编码解码）将该String编码转换为新的字节数组。
System.out.println("abc".getBytes());
//public String replace(char oldChar, char newChar)：将oldChar匹配的字符串使用newChar字符串替换。
System.out.println("abc".replace('b', 'c'));//acc
//public String replaceFirst(String regex,String replacement)用给定的 replacement 替换此字符串匹配给定的regex的第一个子字符串。
System.out.println("abc".replaceFirst(".*", "def"));//def
//public String toUpperCase() : 将字符中转换为大写
System.out.println("abc".toUpperCase());//ABC
//public String toLowerCase(): 将字符中转换为小写
System.out.println("Abc".toLowerCase());//abc
//4.分割和去空格的功能方法。
//public String[] split(String regex)：将此字符串按照给定的regex（规则）拆分为字符串数组。
System.out.println("A B C".split(" "));
String[] str = "A B C".split(" ");
for(String s1:str) {
System.out.println(s1);
}
//public String trim()：去除该字符串的两端空格
System.out.println(" ABC ".trim());//ABC
面试题：数组有length属性，字符串中是length()方法。
五、StringBuilder
1.定义：StringBuilder是一个可变(String类内容是不可变的)的字符串类，我们可以把它看成是一个容器，这里的可变指的是 StringBuilder对象中的内容是可变的。
方法
1.构造方法：
public StringBuilder()：创建一个空白可变字符串对象，不含有任何内容
public StringBuilder(String str)：根据字符串的内容，来创建可变字符串对象
charSequence(字符序列）
capacity(容量)
2.常见方法
2.1添加和反转方法
public StringBuilder append(Object obj):添加数据，并返回对象本身
public StringBuilder reverse():返回相反的字符序列
2.2转换方法
public String toString()：将StringBuilder转换为String
StringBuilder和String相互转换
StringBuilder转换为String
public String toString()：通过 toString() 就可以实现把 StringBuilder 转换为 String
String转换为StringBuilder
public StringBuilder(String s)：通过构造方法就可以实现把 String 转换为 StringBuilder
//构造方法
StringBuilder sb = new StringBuilder();
System.out.println(sb);
StringBuilder sb2 = new StringBuilder("abc");
System.out.println(sb2);//abc
//常见方法
//1.添加和反转方法
//public StringBuilder append(Object obj):添加数据，并返回对象本身
System.out.println(sb.append("123"));
//public StringBuilder reverse():返回相反的字符序列
System.out.println(sb.reverse());
//2.转换方法
//public String toString()：将StringBuilder转换为String
System.out.println(sb.toString());
六、Math方法
1.概述？
java.lang.Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。类似这样的工具类，其所有方法均为静态方法，并且不会创建对象，调用起来非常简单。
2.Math类常用方法？
| 方法 | 说明 |
|---|---|
| Math.PI | 常量，圆周率 |
| public static double abs(double num) | 取绝对值 |
| public static double ceil(double num) | 向上取整 |
| public static double floor(double num) | 向下取整 |
| public static long round(double num) | 四舍五入 |
| public static int max(int a, int b) | 求最大值 |
| public static int min(int a, int b) | 求最小值 |
| public static double pow(double a, double b) | 求a的b次幂 |
| public static double random() | 随机数，随机的范围[0,1) |
七、Array类
1.概述？
java.util.Arrays 此类包含用来操作数组的各种方法，比如排序和搜索等。其所有方法均为静态方法，调用起来非常简单
2.常用方法
| 方法名 | 说明 |
|---|---|
| public static String toString(int[] a) | 返回指定数组内容的字符串表示形式。 |
| public static void sort(int[] a) | 对指定的int型数组按数字升序进行排序。 |
| static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) | 数组拷贝 |
八、System类
任何语言都有in/out/err输入，输出流，错误流
1.概述
java.lang.System类中提供了大量的静态方法，可以获取与系统相关的信息或系统级操作，在System类的API文档中。
| 方法 | 说明 |
|---|---|
| public static long currentTimeMillis() | 返回以毫秒为单位的当前时间。 |
| public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) | 将数组中指定的数据拷贝到另一个数组中。 |
| public static void exit(int status) | 用来结束正在运行的Java程序。参数传入一个数字即可。通常传入0记为正常状态，其他为异常状态 |
九、包装类
都继承自Number接口
Number接口中定义了基本类型Value()方法，能够将一个类型转换为对应的类型。
SeriAble是序列化，能够在网路上传输
IntegerCach：integer缓存，小于127的数字会缓存，不会。使用
9.1.概述？
Java提供了两个类型系统，基本类型与引用类型，使用基本类型在于效率，然而很多情况，会创建对象使用，因为对象可以做更多的功能，如果想要我们的基本类型像对象一样操作，就可以使用基本类型对应的包装类，如下：
| 基本类型 | 对应的包装类（位于java.lang包中） |
|---|---|
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| char | Character |
| boolean | Boolean |
9.2.装箱与拆箱
基本类型与对应的包装类对象之间，来回转换的过程称为【装箱】与【拆箱】
什么是装箱 ：从基本类型转换为对应的包装类对象。
什么是拆箱：从包装类对象转换为对应的基本类型。
数值 转 包装对象
Integer i = new Integer(4);//使用构造函数函数
Integer iii = Integer.valueOf(4);//使用包装类中的valueOf方法
包装对象 转 数值
int num = i.intValue();
9.3.自动装箱与自动拆箱
由于我们经常要做基本类型与包装类之间的转换，从Java 5（JDK 1.5）开始，基本类型与包装类的装箱、拆箱动作可以自动完成。
Integer i = 4;//自动装箱。相当于Integer i = Integer.valueOf(4);
i = i + 5;//等号右边：将i对象转成基本数值(自动拆箱) i.intValue() + 5;
//加法运算完成后，再次装箱，把基本数值转成对象。
9.4.基本类型与字符串之间的转换
一、基本类型转换为String
1.基本类型的值+
int i = 10;
String s = i +"";
2.包装类的静态方法toString(参数)
static String toString(int i) 返回一个表示指定整数的 String 对象
String s = Integer.toString(10);
3.String类的静态方法valueOf(参数)
static String valueOf(int i) 返回 int 参数的字符串表示形式。
String s = String.valueOf(20);
System.out.println(s+20);
4.String转换成对应的基本类型
所有包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型：
| 方法 | 说明 |
|---|---|
| public static byte parseByte(String s) | 将字符串参数转换为对应的byte基本类型。 |
| public static short parseShort(String s) | 将字符串参数转换为对应的short基本类型。 |
| public static int parseInt(String s) | 将字符串参数转换为对应的int基本类型。 |
| public static long parseLong(String s) | 将字符串参数转换为对应的long基本类型。 |
| public static float parseFloat(String s) | 将字符串参数转换为对应的float基本类型。 |
| public static double parseDouble(String s) | 将字符串参数转换为对应的double基本类型。 |
| public static boolean parseBoolean(String s) | 将字符串参数转换为对应的boolean基本类型。 |
除了Integer类之外，其他所有包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型：
如果字符串参数的内容无法正确转换为对应的基本类型，则会抛java.lang.NumberFormatException异常。
十、BigInteger
1.概述？
在Java的世界中,超过long型的整数已经不能被称为整数了,它们被封装成BigInteger对象.在BigInteger类中,实现四则运算都是方法来实现,并不 是采用运算符。(在java.math下，父类是Number)
2.BigInteger类的构造方法
| 方法 | 说明 |
|---|---|
| public BigInteger(String val) | 将字符串的数组封装成BigInteger对象 |
| 3.BigInteger类的常用方法 | |
|---|---|
| 方法 | 说明 |
| public BigInteger add(BigInteger val) | 两个BigInteger进行相加，并返回BigInteger |
| public BigInteger subtract(BigInteger val) | 两个BigInteger进行相减，并返回BigInteger |
| public BigInteger multiply(BigInteger val) | 两个BigInteger进行相乘，并返回BigInteger |
| public BigInteger divide(BigInteger val) | 两个BigInteger进行相除，并返回BigInteger |
Long a = 1231231231231231231L;
String str1 = "1231231231231231231";
String str2 = "1231231231231231231";
BigInteger bi1 =new BigInteger(str1);
BigInteger bi2 =new BigInteger(str2);
BigInteger rst = bi1.add(bi2);//加
BigInteger rst2 = bi1.subtract(bi2);//减
BigInteger rst3 = bi1.multiply(bi2);//乘
BigInteger rst4 = bi1.divide(bi2);//除以
System.out.println(rst);//2462462462462462462
System.out.println(rst2);//0
System.out.println(rst3);//1515930344759173587433018604189775361
System.out.println(rst4);//1
十一、BigDecimal类。
1.概述？(把double和float参与的运算使用BigDecimal处理)
double和float类型在运算中很容易丢失精度,造成数据的不准确性,Java提供我们BigDecimal类可以实现浮点数据的高精度运算。
2.BigDecimal类的构造方法。
| 方法名 | 说明 |
|---|---|
| public BigDecimal(String val) | 将String类型的数组封装为BigDecimal对象 |
建议浮点数据以字符串形式给出,因为参数结果是可以预知的
3.常用方法。
| 方法名 | 说明 |
|---|---|
| public BigDecimal add(BigDecimal augend) | 浮点类型数据相加操作 |
| public BigDecimal subtract(BigDecimal subtrahend) | 浮点类型数据相减操作 |
| public BigDecimal multiply(BigDecimal multiplicand) | 浮点类型数据相乘操作 |
| public BigDecimal divide(BigDecimal divisor) | 浮点类型数据相除操作 |
| public BigDecimal divide(BigDecimal divisor,int scale,int roundingMode) | 浮点类型数据相除操作，按照指定的模式，保留几位小数 |
| public BigDecimal setScale(int newScale,int roundingMode) | Returns a BigDecimal whose scale is the specified value, and whose unscaled value is determined by multiplying or dividing this BigDecimal’s unscaled value by the appropriate power of ten to maintain its overall value. |
对于浮点数据的除法运算,和整数不同,可能出现无限不循环小数,因此需要对所需要的位数进行保留和选择舍入模式
System.out.println(0.09 + 0.01);
System.out.println(1.0 - 0.32);
System.out.println(1.015 * 100);
System.out.println(1.301 / 100);
//大数据封装为BigDecimal对象
BigDecimal big1 = new BigDecimal("0.09");
BigDecimal big2 = new BigDecimal("0.01");
//常用方法
BigDecimal bigAdd = big1.add(big2);//加
BigDecimal bigSub = big1.subtract(big2);//减
BigDecimal bigMul = big1.multiply(big2);//乘
System.out.println(bigAdd);
System.out.println(bigSub);
System.out.println(bigMul);
//
BigDecimal big3 = new BigDecimal("10.0");
BigDecimal big4 = new BigDecimal("3.0");
//BigDecimal bigDiv = big3.divide(big4);//报错ArithmeticException
/*
* 什么问题导致的呢？
* BigDecimal计算的结果要的是一个精确的数，而10/3 是一个无限循环的，不能够精确，所以就报错了!
此时我们要用到另一个重载的方法，让计算的结果有一个精确度！
*/
/*
参数一：表示参与运算的另外一个对象
参数二：表示小数点后精确多少位
参数三：舍入模式
BigDecimal.ROUND_UP： 进一法
BigDecimal.ROUND_FLOOR：去尾法
BigDecimal.ROUND_HALF_UP 四舍五入
ROUND_HALF_UP：保留小数位后一位如果满足5，就进一
ROUND_FLOOR：保留小数位后一位不管满足5还是不满足5直接舍去掉
*/
BigDecimal divide1 = big3.divide(big4,2,BigDecimal.ROUND_UP);
System.out.println(divide1);//3.34
BigDecimal divide2 = big3.divide(big4,2,BigDecimal.ROUND_FLOOR);
System.out.println(divide2);//3.33
BigDecimal divide3 = big3.divide(big4,2,BigDecimal.ROUND_HALF_UP);
System.out.println(divide3);//3.33
十二、日期时间类
1.Date类概述
java.util.Date类 表示特定的瞬间，精确到毫秒(1秒等于1000毫秒)。
2.Date类的构造方法.
| 方法名 | 说明 |
|---|---|
| public Date() | 分配Date对象并初始化此对象，以表示分配它的时间（精确到毫秒） |
| public Date(long date) | 分配Date对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”， 即1970年1月1日00:00:00 GMT）以来的指定毫秒数。 |
由于我们处于东八区，所以我们的基准时间为1970年1月1日8时0分0秒。
在使用println方法时，会自动调用Date类中的toString方法。Date类对Object类中的toString方法进行了覆盖重写，所以结果为指定格式的字符串。
3.常用方法
| 方法名 | 说明 |
|---|---|
| public long getTime() | 把日期对象转换成对应的时间毫秒值 |
//创建日期对象，把当前的时间
System.out.println(new Date());//Mon Nov 01 17:29:32 CST 2021
//创建日期对象那个，把当前的毫秒值转换成日期对象。
System.out.println(new Date(0L));//Thu Jan 01 08:00:00 CST 1970
Date date = new Date();
//获取从1970年到现在的毫秒值差。
long time = date.getTime();
System.out.println(time);//毫秒值
System.out.println(time/1000);//秒
System.out.println(time/1000/60);//分钟
System.out.println(time/1000/60/60);//小时
System.out.println(time/1000/60/60/24);//天
十三、DateFormat类
1.DateFormat类概述?
java.text.DateFormat 是日期/时间格式化子类的抽象类，我们通过这个类可以帮我们完成日期和文本之间的转换,也就是可以在Date对象在String对象之间进行来回转换。
格式化：按照指定的格式，从Date对象转换为String对象。
解析：按照指定的格式，从String对象转换为Date对象。
2.DateFormat类的构造方法？
由于DateFormat为抽象类，不能直接使用，所以需要常用的子类java.text.SimpleDateFormat。这个类需要一个模式（格式）来指定格式化或解析的标准。
| 方法名 | 说明 |
|---|---|
| public SimpleDateFormat() | 用默认的模式和默认语言环境的日期格式符号构造SimpleDateFormat。 |
| public SimpleDateFormat(String pattern) | 用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormat。 |
参数pattern是一个字符串，代表日期时间的自定义格式。
| 标识字母（区分大小写） | 含义 |
|---|---|
| y | 年 |
| M | 月 |
| d | 日 |
| H | 时 |
| m | 分 |
| s | 秒 |
3.DateFormat类的常用方法
| 方法名 | 说明 |
|---|---|
| public String format(Date date) | 将Date对象格式化为字符串。 |
| public Date parse(String source) | 将字符串解析为Date对象。 |
Date date = new Date();
DateFormat df = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
String str = df.format(date);
System.out.println(str);
DateFormat df = new SimpleDateFormat("yyyy年MM月dd日");
String str = "2018年12月11日";
Date date = df.parse(str);
System.out.println(date); // Tue Dec 11 00:00:00 CST 2018
public static void function() throws Exception {
System.out.println("请输入出生日期 格式 YYYY-MM-dd");
// 获取出生日期,键盘输入
String birthdayString = new Scanner(System.in).next();
// 将字符串日期,转成Date对象
// 创建SimpleDateFormat对象,写日期模式
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
// 调用方法parse,字符串转成日期对象
Date birthdayDate = sdf.parse(birthdayString);
// 获取今天的日期对象
Date todayDate = new Date();
// 将两个日期转成毫秒值,Date类的方法getTime
long birthdaySecond = birthdayDate.getTime();
long todaySecond = todayDate.getTime();
long secone = todaySecond-birthdaySecond;
if (secone < 0){
System.out.println("还没出生呢");
} else {
System.out.println(secone/1000/60/60/24);
}
}
十四、Calendar类
1 Calendar类概述.
java.util.Calendar是日历类，在Date后出现，替换掉了许多Date的方法。该类将所有可能用到的时间信息封装为静态成员变量，方便获取。日历类就是方便获取各个时间属性的。
2 Calendar类获取方式.
Calendar为抽象类，由于语言敏感性，Calendar类在创建对象时并非直接创建，而是通过静态方法创建，返回子类对象.
| 方法名 | 说明 |
|---|---|
| public static Calendar getInstance() | 使用默认时区和语言环境获得一个日历 |
| 3 Calendar类常用方法 | |
|---|---|
| 方法名 | 说明 |
| public int get(int field) | 返回给定日历字段的值。 |
| public void set(int field, int value) | 将给定的日历字段设置为给定值。 |
| public abstract void add(int field, int amount) | 根据日历的规则，为给定的日历字段添加或减去指定的时间量。 |
| public Date getTime() | 返回一个表示此Calendar时间值（从历元到现在的毫秒偏移量）的Date对象 |
Calendar类中提供很多成员常量，代表给定的日历字段：
| 字段值 | 含义 |
|---|---|
| YEAR | 年 |
| MONTH | 月（从0开始，可以+1使用） |
| DAY_OF_MONTH | 月中的天（几号） |
| HOUR | 时（12小时制） |
| HOUR_OF_DAY | 时（24小时制） |
| MINUTE | 分 |
| SECOND | 秒 |
| DAY_OF_WEEK | 周中的天（周几，周日为1，可以-1使用） |
public static void method1() {
Calendar cal = Calendar.getInstance();
//设置年
int year = cal.get(Calendar.YEAR);
//设置月
int month = cal.get(Calendar.MONTH)+1;//0-11
//设置日
int dayOfMonth = cal.get(Calendar.DAY_OF_MONTH);
System.out.println(year+"年"+month+"月"+dayOfMonth+"日");
cal.set(Calendar.YEAR, 2000);
System.out.println(year + "年" + month + "月" + dayOfMonth + "日");
}
public static void method2() {
Calendar cal = Calendar.getInstance();
// 设置年
int year = cal.get(Calendar.YEAR);
// 设置月
int month = cal.get(Calendar.MONTH) + 1;
// 设置日
int dayOfMonth = cal.get(Calendar.DAY_OF_MONTH);
System.out.print(year + "年" + month + "月" + dayOfMonth + "日");
System.out.print(year + "年" + month + "月" + dayOfMonth + "日"); // 2018年1月17日
// 使用add方法
cal.add(Calendar.DAY_OF_MONTH, 2); // 加2天
cal.add(Calendar.YEAR, -3); // 减3年
System.out.print(year + "年" + month + "月" + dayOfMonth + "日"); // 2015年1月18日;
}
public static void method3() {
Calendar cal = Calendar.getInstance();
Date date= cal.getTime();
System.out.println(date);
}
715
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
