Java常用类
1.字符串类（String/StringBuilder/StringBuffer）
1.1 API: 应用程序编程接口
Java的API：指的是JDK中提供的各种功能的Java类
这些类将底层封装起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可，我们可以通过帮助文档来学习这些API如何使用。
1.2 String（内容不可变的字符串）
1.2.1 概述
String类在Java.lang包下，所以使用的时候不需要导包
String类代表字符串，Java程序中的所有字符串文字（例如“abc”），都被实现为此类的实例，Java程序中所有的双引号字符串，都是String类的对象
字符串特点：
- 字符串不可变，它们的值被创建后不能被改变
- 虽然String的值是不可以变的，但是它们可以被共享
- 字符串效果上相当于字符数组（char[]）,但是底层原理是字节数组（byte[]）
1.2.2 String 构造方法
| 方法名 | 说明 |
|---|---|
| public String() | 创建一个空白字符串对象，不含有任何内容 |
| public String(char[] chs) | 根据字符数组的内容，来创建字符串对象 |
| public String(byte[] bys) | 根据字节数组的内容，来创建字符串对象 |
| String s = “abc” | 直接赋值来创建字符串对象，内容就是abc |
/*
public String()创建一个空白字符串对象，不含有任何内容
public String(char[] chs) 根据字符数组的内容，来创建字符串对象
public String(byte[] bys)根据字节数组的内容，来创建字符串对象
String s = "abc"直接赋值来创建字符串对象，内容就是abc
推荐使用直接赋值的方式得到字符串
*/
public class test {
public static void main(String[] args) {
//public String()创建一个空白字符串对象，不含有任何内容
String s1 = new String();
System.out.println("s1:"+s1);
//public String(char[] chs) 根据字符数组的内容，来创建字符串对象
char[] chs = {'a','b','c'};
String s2 = new String(chs);
System.out.println("s2:"+s2);
//public String(byte[] bys)根据字节数组的内容，来创建字符串对象
byte[] bys = {97,98,99};//这里97是‘a’的ascii码
String s3 = new String(bys);
System.out.println("s3:"+s3);
//String s = "abc"直接赋值来创建字符串对象，内容就是abc
String s4= "abc";
System.out.println("s4:"+s4);
}
}
1.2.3 String对象的特点
**1.**通过new创建的字符串对象，每一次new都会申请一个内存空间虽然内容相同，但是地址值不同
char[] chs = {'a','b','c'};
String s1 = new String(chs);
String s2 = new String(chs);
System.out.println(s1==s2);//比较s1和s2地址值是否相同，这里是false不相同
上面的代码中，JVM首先会创建一个字符数组，然后每一次new的时候都会i有一个新的地址，只不s1和s2参考的字符串内容是一样的，但是地址不一样
**2.**以“ ”方式给出的字符串，只要字符序列相同（顺序和大小写），无论在程序代码中出现几次，JVM都只会建立一个String对象，并在字符串池中维护
String s3="abc";
String s4="abc";
System.out.println(s1==s2);//比较s3和s4地址值是否相同，这里是true相同
在上面的代码中，针对第一行代码，JVM会建立一个String对象放在字符串池中，并给s3参考；第二行则让s4直接参考字符串池中的String对象，也就是说s3,s4本质上是同一个对象
1.2.4 字符串的比较
使用==作比较：
- 基本类型：比较的是数据值是否相同（int,double,byte…）
- 引用类型：比较的是地址值是否相同(类，接口，数组)
字符串是对象，它比较内容是相同，是通过一个方法来实现的，这个方法叫：equals()
- public boolean equals(Object anobject):将此字符串与指定对象进行比较。由于我们比较的是字符串对象，所以直接传递一个字符串
char[] chs={'a','b','c'};
String s1=new String(chs);
String s2=new String(chs);
String s3="abc";
String s4="abc";
System.out.println(s1==s2);//false
System.out.println(s3==s4);//true
System.out.println(s3==s1);//false
System.out.println(s1.equals(s2));//true
System.out.println(s3.equals(s4));//true
System.out.println(s1.equals(s4));//true
1.2.5 字符串遍历
- public char charAt（int index):返回指定索引处的char值，字符串的索引也是从0开始
- public int length():返回此字符串的长度
- 数组的长度：数组名.length
- 字符串的长度：字符串对象.length（）
- 遍历字符串的通用格式：
for(int i=0;i<s.length();i++){
s.charAt(i); //就是指定索引处的字符值
}
import java.util.Scanner;
public class test {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String s = sc.nextLine();//这里写完sc.nextLine，然Ctrl + Alt + V直接生成代码
for(int i=0;i<s.length();i++){
System.out.println(s.charAt(i));
}
}
}
String用**“+=”是字符串拼接**的意思
具体其他的String用法，查看API文档
1.3 StringBuilder （内容可变的字符串）
运行效率快，线程不安全
在java.lang包下
1.3.1 StringBuilder概述
StringBuilder是一个可变的字符串类，我们可以把它看成是一个容器
这里的可变指的是StringBuilder对象中的内容是可变的
String 和 StringBuilder 的区别：
- String ： 内容是不可变的
- StringBuilder： 内容是可变的
1.3.2 StringBuilder 构造方法
| 方法名 | 说明 |
|---|---|
| public StringBuilder() | 创建一个空白可变的字符串对象，不含有任何内容 |
| public StringBuilder(String str) | 根据字符串的内容，来创建可变字符串对象 |
public class test {
public static void main(String[] args) {
//public StringBuilder()创建一个空白可变的字符串对象，不含有任何内容
StringBuilder s1 = new StringBuilder();
System.out.println("s1:"+s1);
System.out.println("s1.lebgth:"+s1.length());
//public StringBuilder(String str)根据字符串的内容，来创建可变字符串对象
StringBuilder s2 = new StringBuilder("hello");
System.out.println("s2:"+s2);
System.out.println("s2.lebgth:"+s2.length());
}
}
/*
输出：
s1:
s1.lebgth:0
s2:hello
s2.lebgth:5
*/
1.3.3 StringBuilder 的添加和反转方法
| 方法名 | 说明 |
|---|---|
| public StringBuilder append( 任意类型 ) | 添加数据，并且返回对象本身 |
| public StringBuilder reverse( ) | 返回相反的字符序列 |
public class test {
public static void main(String[] args) {
StringBuilder s1 = new StringBuilder();
StringBuilder s2 = s1.append("hello");
System.out.println("s1:"+s1);
System.out.println("s2:"+s2);
System.out.println(s1==s2);
}
}
/*
输出：
s1:hello
s2:hello
true
*/
//因为append返回的是一个对象本身，所以可以用链式编程
//append里面的参数可以是很多数据类型，int，long，double等
public class test {
public static void main(String[] args) {
StringBuilder s1 = new StringBuilder();
s1.append("hello").append(" world").append(" java").append(100);
System.out.println(s1);
}
}
//输出：hello world java100
//反转
public class test {
public static void main(String[] args) {
StringBuilder s1 = new StringBuilder();
s1.append("hello").append(" world").append(" java").append(100);
System.out.println("s1:"+s1);
//反转reverse
s1.reverse();
System.out.println("s1:"+s1);
}
}
/*
输出：
s1:hello world java100
s1:001avaj dlrow olleh
*/
1.3.4 StringBuilder 和 String 相互转换
- StringBuilder 转换为 String
public String toString() : 通过 toString( )就可以实现StringBuilder 转换为 String
public class test {
public static void main(String[] args) {
String s = new String();
StringBuilder sb = new StringBuilder("hello");
//s=sb;这样是不可以的
//public String **toString()** : 通过 toString( )就可以实现StringBuilder 转换为 String
s=sb.toString();
System.out.println("s:"+s);
}
}
- String 转换为 StringBuilder
public StringBuilder(String s) : 通过构造方法就可以实现把String转换为StringBuilder
public class test {
public static void main(String[] args) {
String s="hello";
StringBuilder sb=new StringBuilder(s);
System.out.println("sb:"+sb);
}
}
//输出：sb:hello
一般StringBuilder需要转换成String再输出或者返回
！！！反转字符串可以用一行代码实现
public static String reverse(String s){
return new StringBuilder(s).reverse().toStirng();
//先创建一个匿名StringBuilder对象，然后用链式编程进行操作
}
1.4 StringBuffer（和StringBuilder功能一样）
运行效率慢，线程安全
public class test {
public static void main(String[] args) throws ParseException {
StringBuffer sb = new StringBuffer();
//StringBuild和StringBuffer功能相同，最好用StringBuild
//append追加
sb.append("java");
sb.append("best");
System.out.println(sb.toString());
//insert添加
sb.insert(0,"first");
System.out.println(sb.toString());
//replace替换
sb.replace(0,5,"hello");//前闭后开，[0,5)
System.out.println(sb.toString());
//delete删除
sb.delete(0,5);
System.out.println(sb.toString());
/*
输出：
javabest
firstjavabest
hellojavabest
javabest
*/
}
}
2. Math类
在java.lang包下,方法都是static方法，直接通过类名访问。
| 方法名 | 说明 |
|---|---|
| public static int abs(int a) | 返回参数的绝对值 |
| public static double ceil(double a) | 返回大于或等于参数的最小double值，等于一个整数 |
| public static double floor(double a) | 返回小于或等于参数的最大double值，等于一个整数 |
| public static int round(float a) | 按照四舍五入返回最接近参数的int |
| public static int max(int a,int b) | 返回两个int值中的较大值 |
| public static int min(int a,int b) | 返回两个int值中的较小值 |
| public static double pow(double a,double b) | 返回a的b次幂的值 |
| public static double random() | 返回值为double的正值，[0.0 , 1.0 ) |
public class test {
public static void main(String[] args) {
// public static int abs(int a)返回参数的绝对值
System.out.println(Math.abs(88));//88
System.out.println(Math.abs(-88));//88
System.out.println("----------------");
// public static double ceil(double a)返回大于或等于参数的最小double值，等于一个整数
System.out.println(Math.ceil(12.34));//13
System.out.println(Math.ceil(12.56));//13
System.out.println("----------------");
// public static double floor(double a) 返回小于或等于参数的最大double值，等于一个整数
System.out.println(Math.floor(12.34));//12
System.out.println(Math.floor(12.56));//12
System.out.println("----------------");
// public static int round(float a) 按照四舍五入返回最接近参数的int
System.out.println(Math.round(12.34F));//12
System.out.println(Math.round(12.56F));//13
System.out.println("----------------");
// public static int max(int a,int b) 返回两个int值中的较大值
System.out.println(Math.max(12,20));//20
System.out.println("----------------");
// public static int min(int a,int b) 返回两个int值中的较小值
System.out.println(Math.min(12,20));//12
System.out.println("----------------");
// public static double pow(double a,double b) 返回a的b次幂的值
System.out.println(Math.pow(2.0,3.0));//8.0
System.out.println("----------------");
// public static double random() 返回值为double的正值，[0.0 , 1.0 )
System.out.println(Math.random());
System.out.println(Math.random()*100);
System.out.println("----------------");
}
}
/*
输出：
88
88
----------------
13.0
13.0
----------------
12.0
12.0
----------------
12
13
----------------
20
----------------
12
----------------
8.0
----------------
0.7845903356200989
44.50420389661177
----------------
*/
3. System类
3.1 System概述
在java.lang包下，不能被实例化，都是静态方法，static修饰，直接通过类名调用方法
| 方法名 | 说明 |
|---|---|
| public static void exit(int status) | 终止当前运行的Java虚拟机，非零表示异常终止 |
| public static long currentTimeMillis( ) | 返回当前时间（以毫秒为单位） |
public class test {
public static void main(String[] args) {
//public static void exit(int status) 终止当前运行的Java虚拟机，非零表示异常终止
System.out.println("开始");
System.exit(0);
System.out.println("结束");
}
}
/*
输出：
开始
*/
//格式化快捷键：Ctrl + Alt + L！！！
//计算一段for循环耗时多少时间
public class test {
public static void main(String[] args) {
//public static long currentTimeMillis( )返回当前时间（以毫秒为单位）
long start = System.currentTimeMillis();
for(int i=0;i<10000;i++){
System.out.println(i);
}
long end = System.currentTimeMillis();
System.out.println("共耗时："+(end-start)+"毫秒");
}
}
//共耗时：120毫秒
4. Object类
4.1 Object 概述
Object是类层次结构的根，每个类都可以将Object作为超类。所有类都直接或者间接继承自该类
构造方法: public Object( )//只有无参构造
回想面向对象中，为什么说子类的构造方法默认访问的是父类的无参构造方法？
因为它们的顶级父类只有无参构造方法
4.2 Object 类的常用方法
- toString方法
public class Student {
private int age;
private String name;
public Student() {
}
public Student(int age, String name) {
this.age = age;
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
//重写toString方法
@Override
public String toString() {
return "Student{" +
"age=" + age +
", name='" + name + '\'' +
'}';
}
}
//Object是类层次结构的根，每个类都可以将Object作为超类。所有类都直接或者间接继承自该类
//看方法的源码 ：选中方法后， Ctrl + B
public class test {
public static void main(String[] args) {
Student s = new Student();
s.setAge(20);
s.setName("lhp");
System.out.println(s);//重写前输出：com.operator.test01.Student@1b6d3586
/*
这里调用了Object的toString方法，obj.toString;
返回全路径的字符串
建议子类重写该toString方法
这里可以自动生成 ： Alt + insert 选中toStrin就可以生成了
*/
//重写后输出：Student{age=20, name='lhp'}
}
}
- equals方法
public class Student {
private int age;
private String name;
public Student() {
}
public Student(int age, String name) {
this.age = age;
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Student{" +
"age=" + age +
", name='" + name + '\'' +
'}';
}
//快捷键 Alt + insert 重写equals方法
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
if (age != student.age) return false;
return name != null ? name.equals(student.name) : student.name == null;
}
}
public class test {
public static void main(String[] args) {
Student s1 = new Student();
s1.setAge(20);
s1.setName("lhp");
Student s2 = new Student();
s2.setAge(20);
s2.setName("lhp");
// System.out.println(s1==s2);//false
System.out.println(s1.equals(s2));//false
/*源码：
public boolean equals(Object obj) {
return (this == obj);
}
*/
//重写equals方法，在类里面使用快捷键 Alt + insert， 选择equals
//重写后返回 true，表示这两个对象的内容相同
/*
public boolean equals(Object o) {
//this---->s1, o----->s2
//比较地址是否相同，如果相同返回true
if (this == o) return true;
//判断参数是否为null
//判断两个对象是否来自于同一个类
if (o == null || getClass() != o.getClass()) return false;
//向下转型
Student student = (Student) o;//student代表s2
//比较年龄是否相同
if (age != student.age) return false;
//比较姓名内容是否相同
return name != null ? name.equals(student.name) : student.name == null;
}
*/
}
}
5. Arrays类
5.1 Arrays 概述
Arrays类包含用于操作数组的各种方法，都是静态static方法
工具类的设计思想：
- 构造方法用private修饰
- 成员用public static修饰
5.2 Arrays常用方法
| 方法名 | 说明 |
|---|---|
| public static String toString(int[ ] a) | 返回指定数组的内容的字符串表示形式 |
| public static void sort(int[ ] a) | 按照数字顺序排列指定的数组 |
import java.util.Arrays;
public class test {
public static void main(String[] args) {
int[] arr = {12,11,17,9,48,2};
System.out.println("排序前"+Arrays.toString(arr));
Arrays.sort(arr);
System.out.println("排序后"+Arrays.toString(arr));
}
/*
输出：
排序前[12, 11, 17, 9, 48, 2]
排序后[2, 9, 11, 12, 17, 48]
*/
}
6.基本类型包装类
public class test {
public static void main(String[] args) {
//需求：如何判断int的范围
System.out.println(Integer.MAX_VALUE);
System.out.println(Integer.MIN_VALUE);
}
/*
输出：
2147483647
-2147483648
*/
}
6.1基本类型包装类概述
将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法 操作该数据。
常用的操作之一：用于基本数据类型与字符串之间的转换
| 基本数据类型 | 包装类 |
|---|---|
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| char | Character |
| boolean | Boolean |
6.2 Integer 类的概述和使用
Integer :包装一个对象中的原始类型int的值
| 方法名 | 说明 |
|---|---|
| public Integer(int value) | 根据int值创建Integer对象（过时） |
| public Integer(String s) | 根据String值创建Integer对象（过时） |
| public static Integer valueOf(int i) | 返回表示指定的int值的Integer实例 |
| public static Integer valueOf(String s) | 返回一个保存指定值的Integer对象String |
public class test {
public static void main(String[] args) {
// public static Integer valueOf(int i)返回表示指定的int值的Integer实例
Integer i1 = Integer.valueOf(100);
System.out.println(i1);
// public static Integer valueOf(String s)返回一个保存指定值的Integer对象String
Integer i2 = Integer.valueOf("100");
System.out.println(i2);
Integer i3 = Integer.valueOf("abc");
System.out.println(i3);
}
/*
输出：
100
100
Exception in thread "main" java.lang.NumberFormatException: For input string: "abc"
*/
6.3 int 和 String 的相互转换
基本类型包装类常用的操作之一：用于基本数据类型与字符串之间的转换
6.3.1 int转换为String类型
public static String valueOf(int i):返回int参数的字符串表示形式。该方法是String类中的方法
int 转换为 String：
public class test {
public static void main(String[] args) {
//把 int ------>String
int i = 100;
//方法1
String s = ""+i;
System.out.println(s);
//方法2（重点）
String s2 = String.valueOf(i);
System.out.println(s2);
}
/*
输出：
100
100
*/
}
6.3.2 String转换为int类型
public static int parseInt(String s):将字符串解析为int类型。该方法是Integer类中的方法
String 转换为 int：
public class test {
public static void main(String[] args) {
//把 String ------>int
String s = "100";
//方法1 String--->Integer--->int
Integer i = Integer.valueOf(s);
int i1 = i.intValue();
System.out.println(i1);
//方法2（重点）
int i2 = Integer.parseInt(s);
System.out.println(i2);
}
/*
输出：
100
100
*/
}
6.3.3 字符串中数据排序
字符串“91 27 46 38 11”
把字符串中的数字存储到一个int类型的数组中
- 得到字符串中每一个数字数据
public String[ ] split(String regex)
- 定义一个int数组，把String[ ]数组中的每一个元素存储到int数组中
public static int parseInt(String s)
public class test {
public static void main(String[] args) {
String shu = "12 87 23 11 56";
String[] strs = shu.split(" ");//以空格为分隔符
int num = strs.length;
int[] ints = new int[num];
for (int i = 0; i < num; i++) {
ints[i] = Integer.parseInt(strs[i]);//将字符串数组每一个字符串转为int
}
//将字符串数组进行排序
Arrays.sort(ints);
//用StringBuilder进行拼接
StringBuilder ans = new StringBuilder();
ans.append("[");
for (int j = 0; j < num; j++) {
if(j==num-1){
ans.append(ints[j]);
}else{
ans.append(ints[j]+",");
}
}
ans.append("]");
//将StringBuilder转为String
System.out.println(ans.toString());
}
}
6.4 自动装箱和拆箱
- 装箱：把基本数据类型转换为对应的包装类类型
- 拆箱：把包装类类型转换为对应的基本数据类型
Integer i = 100; //自动装箱
i += 200; //i = i + 200; i+200是自动拆箱；i = i + 200；是自动装箱
注意：
在使用包装类类型的时候，如果做操作，最好先判断是否为null
我们推荐的是，只要是对象，在使用前就必须进行不为null的判断
public class test {
public static void main(String[] args) {
//装箱：把基本数据类型转换为对应的包装类类型
int i = 100;
Integer i1 = Integer.valueOf(i);//手动装箱
i1=i;//自动装箱，自动隐含调用了Integer.valueOf(i)
System.out.println(i1);
//拆箱：把包装类类型转换为对应的基本数据类型
Integer i2 = 100;
i2 = i2.intValue() + 100;//手动拆箱：做+100操作前，需要用intValue做拆箱操作，返回一个int值
System.out.println(i2);
i2+=100;//自动拆箱
System.out.println(i2);
}
}
注意：
public class test {
public static void main(String[] args) {
/*Integer ii = null;
ii+=100;
System.out.println(ii);//异常：NullPointerException*/
//使用包装类前，一定要判断对象是否为空
Integer ii = null;
if(ii!=null){
ii+=100;
}else{
System.out.println("ii is null");
}
}
}
7. 日期类
7.1 Date 类
7.1.1 Date类概述和构造
Date代表一个特定的时间，精确到毫秒
这里是java.util包下的Date
| 方法名 | 说明 |
|---|---|
| public Date( ) | 分配一个Date，并且初始化，以便它代表它被分配的时间，精确到毫秒 |
| public Date(long date) | 分配一个Date对象，并且将其初始化为表示从标准基准时间（1970年）起指定的毫秒数 |
public class test {
public static void main(String[] args) {
//public Date( ) 分配一个Date，并且初始化，以便它代表它被分配的时间，精确到毫秒
Date d1 = new Date();
System.out.println(d1);
//public Date(long date) 分配一个Date对象，并且将其初始化为表示从标准基准时间（1970年）起指定的毫秒数
long l = 1000 * 60 * 60;
Date d2 = new Date(l);
System.out.println(d2);
}
/*
输出：
Sat Mar 12 10:53:03 CST 2022
Thu Jan 01 09:00:00 CST 1970
*/
}
7.1.2 Date类的常用方法
| 方法名 | 说明 |
|---|---|
| public long getTime( ) | 获取的是日期对象从1970年1月1号 00：00：00到现在的毫秒值 |
| public void setTime(long time) | 设置时间，给的是毫秒值 |
import java.util.Arrays;
import java.util.Date;
public class test {
public static void main(String[] args) {
Date d1 = new Date();
//public long getTime( ) 获取的是日期对象从1970年1月1号 00：00：00到现在的毫秒值
System.out.println(d1.getTime());
System.out.println(d1.getTime() * 1.0 / 1000 / 60 / 60 / 24 / 265 + "年");
System.out.println("=============================");
Date d2 = new Date();
//public void setTime(long time)设置时间，给的是毫秒值
long time = System.currentTimeMillis();
d2.setTime(time);
System.out.println(d2);
}
}
/*
输出
1647054388267
71.9363377125699年
=============================
Sat Mar 12 11:06:28 CST 2022
*/
7.2 SimpleDateFormat类（格式化日期信息）
SimpleDateFormat是一个具体的类，用于以区域设计敏感的方式格式化和解析日期
重点学习日期格式化和解析
日期和时间格式由日期和时间模式字符串指定，在日期和时间模式字符串中，从‘A’到‘Z’，从‘a’到‘z’引号的字母被解释为表示日期或者时间字符串的组件的模式字母
常用的模式字母及对应关系如下：
- y 年
- M 月
- d 日
- H 时
- m 分
- s 秒
7.2.1 SimpleDateFormat 的构造方法
| 方法名 | 说明 |
|---|---|
| public SimpleDateFormat( ) | 构造一个SimpleDateFormat,使用默认模式和日期格式 |
| public SimpleDateFormat(String pattern) | 构造一个SimpleDateFormat使用给定的模式和默认的日期格式 |
7.2.2 SimpleDateFormat 格式化和解析日期
- 格式化（从Date到String）
public final String format(Date date):将日期格式化成日期/时间字符串
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
/*
public SimpleDateFormat( )构造一个SimpleDateFormat,使用默认模式和日期格式
public SimpleDateFormat(String pattern)构造一个SimpleDateFormat使用给定的模式和默认的日期格式
格式化（从Date到String）public final String format(Date date):将日期格式化成日期/时间字符串
解析（String 到 Date）public Date parse(String source):从给定字符串的开始解析文本以生成日期
*/
public class test {
public static void main(String[] args) {
//格式化（从Date到String）
Date d = new Date();
SimpleDateFormat sdf = new SimpleDateFormat();//构造一个SimpleDateFormat
String date = sdf.format(d);
System.out.println(date);
//22-3-12 下午2:46
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
String date2 = sdf2.format(d);
System.out.println(date2);
//输出：2022年03月12日 14:46:06
}
}
- 解析（String 到 Date）
public Date parse(String source):从给定字符串的开始解析文本以生成日期
public class test {
public static void main(String[] args) throws ParseException {
//解析（String 到 Date）
String s ="2021-7-1 12:12:12";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//这里会产出异常，需要抛出异常，Alt + enter
Date d = sdf.parse(s);
System.out.println(d);
}
//输出：Thu Jul 01 12:12:12 CST 2021
}
7.3 Calendar 类
7.3.1 Calendar类概述
Calendar为某一时刻和一组日历字段之间的转换提供了一些方法，并且为操作日历字段提供了一些方法
Calendar提供了一类方法getInstance用于获取Calendar对象，其日历字段已经使用当前日期和时间初始化：Calendar rightNow = Calendar.getInstance( );
import java.util.Calendar;
import java.util.Date;
public class test {
public static void main(String[] args) throws ParseException {
//获取对象
Calendar c = Calendar.getInstance();
System.out.println(c);
int year = c.get(Calendar.YEAR);
int month = c.get(Calendar.MONTH)+1;//month是从0开始的，所以要+1
int date=c.get(Calendar.DATE);
System.out.println(year+"年"+month+"月"+date+"日");
//输出：2022年3月12日
}
}
7.3.2 Calendar的常用方法
| 方法名 | 说明 |
|---|---|
| public int get(int field) | 返回给定日历字段的值 |
| pubilc abstract void add(int field,int amount) | 根据日历的规则，将指定的时间量添加或减去给定的日历字段 |
| public final void set(int year,int month.int date) | 设置当前日历的年月日 |
//add方法
public class test {
public static void main(String[] args) throws ParseException {
Calendar c = Calendar.getInstance();
System.out.println(c);
/*int year = c.get(Calendar.YEAR);
int month = c.get(Calendar.MONTH)+1;//month是从0开始的，所以要+1
int date=c.get(Calendar.DATE);
System.out.println(year+"年"+month+"月"+date+"日");*/
//输出：2022年3月12日
c.add(Calendar.YEAR,-3);//三年前的今天
int year = c.get(Calendar.YEAR);
int month = c.get(Calendar.MONTH)+1;//month是从0开始的，所以要+1
int date=c.get(Calendar.DATE);
System.out.println(year+"年"+month+"月"+date+"日");
//输出：2019年3月12日
}
}
//set方法
import java.util.Calendar;
import java.util.Date;
public class test {
public static void main(String[] args) throws ParseException {
Calendar c = Calendar.getInstance();
System.out.println(c);
/*int year = c.get(Calendar.YEAR);
int month = c.get(Calendar.MONTH)+1;//month是从0开始的，所以要+1
int date=c.get(Calendar.DATE);
System.out.println(year+"年"+month+"月"+date+"日");*/
//输出：2022年3月12日
/* c.add(Calendar.YEAR,-3);//三年前的今天
int year = c.get(Calendar.YEAR);
int month = c.get(Calendar.MONTH)+1;//month是从0开始的，所以要+1
int date=c.get(Calendar.DATE);
System.out.println(year+"年"+month+"月"+date+"日");*/
//输出：2019年3月12日
c.set(2021,7,1);
int year = c.get(Calendar.YEAR);
int month = c.get(Calendar.MONTH);
int date=c.get(Calendar.DATE);
System.out.println(year+"年"+month+"月"+date+"日");
//输出：2021年7月1日
}
}
8. BigDecimal类
8.1 问题和BigDicimal的应用场景
public static void main(String[] args){
double d1=1.0;
double d2=0,9;
System.out.println(d1-d2);
}
//输出：0.099999999999998
//输出不是0.1
很多实际应用中需要精确运算，而double是近似值存储，不在符合要求的精度，需要借助BigDecimal。
8.2 BigDecimal使用
- 位置：java.math包中
- 作用：精确计算浮点数
- 创建方式：BigDecimal bd = new BigDecimal(“1.0”);
public class test {
public static void main(String[] args) throws ParseException {
BigDecimal bd1 = new BigDecimal("1.0");
BigDecimal bd2 = new BigDecimal("0.9");
//减法
BigDecimal res = bd1.subtract(bd2);
System.out.println("1.0-0.9=" + res);//输出：1,0-0.9=0.1
//加法
BigDecimal res2 = bd1.add(bd2);
System.out.println("1.0+0.9=" + res2);
//乘法
BigDecimal res3 = bd1.multiply(bd2);
System.out.println("1.0*0.9=" + res3);
//除法
//(1.4-0.5)/0.9
BigDecimal res4 = new BigDecimal("1.4")
.subtract(new BigDecimal("0.5"))
.divide(new BigDecimal("0.9"));//链式编程
System.out.println("(1.4-0.5)/0.9=" + res4);
//当除法除不尽时，需要给divide加几个参数
BigDecimal res5 = new BigDecimal("10").divide(new BigDecimal("3"), 2, BigDecimal.ROUND_HALF_UP);//保留两位小数，并且四舍五入
System.out.println("10/3=" + res5);
}
/*
输出：
1.0-0.9=0.1
1.0+0.9=1.9
1.0*0.9=0.90
(1.4-0.5)/0.9=1
10/3=3.33
Process finished with exit code 0
*/
}
注意：进行除法运算时，如果不能准确的计算出结果时需要指定保留的位数和取舍方式
- 除法：divide(BigDecimal bd, int scal , RoundingMode mode)
- 参数scal：指定精确到小数点后几位
- 参数mode：
- 指定小数部分的取舍模式，通常采用四舍五入的模式
- 取值为BigDecimal.ROUND_HALF_UP
1106
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
