19_Java中常用的APL
Java常用APL（更多请查看文档）
一、Math
在lang包中无需导包
1、Math类概述：
Math包执行基本数字运算的方法
没有构造方法，如何使用类中的成员呢？
通过查看帮助文档可以看到Math类中的属性和方法都被static修饰了可以直接使用类名进行调用。
2、Math类的常用方法：
| 方法名 | 说明 |
|---|---|
| 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)的随机数 |
package com.itheima;
/*
Math类的常用方法
*/
public class MathDemo {
public static void main(String[] args){
//public static int abs(int a) 返回参数的绝对值
System.out.println(Math.abs(88));
System.out.println(Math.abs(-88));
System.out.println("--------");
//public static double ceil(double a) 返回大于或等于参数的最小double值，等于一个整数(返回值是double类型)
System.out.println(Math.ceil(12.34));
System.out.println(Math.ceil(12.56));
System.out.println("--------");
//public static double floor(double a) 返回小于或等于参数的最大double值，等于一个整数
System.out.println(Math.floor(11.34));
System.out.println(Math.floor(11.78));
System.out.println("--------");
//public static int round(float a) 按照四舍五入返回最接近参数的int
System.out.println(Math.round(11.34F));
System.out.println(Math.round(10.56F));
System.out.println("--------");
//public static int max(int a, int b) 返回两个int值中的较大值
System.out.println(Math.max(16, 88));
System.out.println(Math.max(78, 79));
System.out.println("--------");
//public static int min(int a, int b) 返回两个int值中的较小值
System.out.println(Math.min(22, 33));
System.out.println(Math.min(11, 88));
System.out.println("--------");
//public static double pow(double a, double b) 返回a的b次幂的值
System.out.println(Math.pow(2.0, 10.0));
System.out.println(Math.pow(1.0, 88.0));
System.out.println("--------");
//public static double random() 返回值为double的正值，[0.0, 1.0)的随机数
System.out.println((int)(Math.random() * 100) + 1); //返回0~100
}
}
二、System
1、System类概述：
System包含几个有用的类字段和方法，它不能被实例化，与Math相同，System的成员也均被static修饰可以直接使用类名调用
2、System类的常用方法：
| 方法名 | 说明 |
|---|---|
| public static void exit(int status) | 终止当前运行的Java虚拟机，非零表示异常终止 |
| public static long currentTimeMillis() | 返回当前时间（以毫秒为单位）[起始时间1997/1/1 会因操作系统有单位出入] |
public class SystemDemo {
public static void main(String[] args){
/*
System.out.println("开始");
//public static void exit(int status) 终止当前运行的Java虚拟机，非零表示异常终止
System.exit(0);
System.out.println("结束");
*/
//public static long currentTimeMillis() 返回当前时间（以毫秒为单位）[起始时间1997/1/1 会因操作系统有单位出入]
// System.out.println(System.currentTimeMillis());
//System.out.println(System.currentTimeMillis() * 1.0 / 1000 / 60 / 60 / 24 / 365 + "年");（忽略了闰年）
long start = System.currentTimeMillis();
for(int i = 0; i < 10000; i++){
System.out.println(i);
}
long end = System.currentTimeMillis();
System.out.println("此for循环语句共耗时：" + (end - start) + "毫秒");
}
}
三、Object
1、Object概述：
Object是类层次结构的根，每个类都可以将Object作为超类。所有类都直接或间接的继承自该类
构造方法：public Object()
回想面向对象中，为什么说子类的构造方法默认访问的是父类的无参构造方法？
因为它们的根类只有无参构造方法
package com.itheima;
/*
学生类
*/
public class Student {
private String name;
private int age;
public Student(){}
public Student(String name, int age){
this.name = name;
this.age = age;
}
public void setName(String name){
this.name = name;
}
public String getName(){
return this.name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return this.age;
}
public void show(){
System.out.println(getName() + "," + getAge());
}
//重写超类的 toString方法 建议以后重写，利于查看方法对象信息
@Override
public String toString(){
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
package com.itheima;
/*
1、Object是类层次结构的根，每个类都可以将Object作为超类。所有类都直接或间接的继承自该类
2、看方法的源码：选中方法，按下鼠标右键->点击go to 到Declaration or Usages
或者直接快捷建Ctrl + B
3、子类重写toString()方法 建议所有子类覆盖此方法使其返回简明描述
自动生成
*/
public class ObjectDemo extends Object{ //隐含了继承超类Object
public static void main(String[] args){
Student s = new Student();
s.setName("张三");
s.setAge(18);
System.out.println(s); //com.itheima.Student@5594a1b5
System.out.println(s.toString());
/* public void println(Object x) { //x = s
String s = String.valueOf(x);
synchronized (this) {
print(s);
newLine();
}
}*/
/*public static String valueOf(Object obj) { //obj = x
return (obj == null) ? "null" : obj.toString();
}*/
/*public String toString() {
//返回类的路径，名称 + @ + 地址值
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}*/
}
}
2、Object类的常用方法：
| 方法名 | 说明 |
|---|---|
| public String toString() | 返回对象的字符串表示形式，建议所有子类重写该方法，自动生成 |
| public boolean equals(Object obj) | 比较对象是否相等，默认比较地址，重写可以比较内容，自动生成 |
package com.itheima_02;
/*
学生类
*/
public class Student {
//属性
private String name;
private int age;
//构造方法
public Student(){}
public Student(String name, int age){
this.name = name;
this.age = age;
}
//set/get/show方法
public void setName(String name){
this.name = name;
}
public String getName(){
return this.name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return this.age;
}
public void show(){
System.out.println(getName() + "," + getAge());
}
//重写toString()方法
@Override
public String toString(){
return "Student{" +
"name='" + name + '\'' +
",age=" + age +
"}";
}
//重写equals()方法
/* @Override
public boolean equals(Object object){
//这里使用的条件判断是利用toString返回的是String的对象内容，在利用String中的方法进行比较
if(this.toString().equals(object.toString())){
return true;
}
else{
return false;
}
}*/
/*@Override
//此处传入相当于 Object object = new Student();
//就是子类对象，传递给父类引用 利用向下转型可以让其变为子类对象并调用子类成员
public boolean equals(Object object){
//此方法缺陷 在于不是一个类（这里传入狗类时）时是无法进行向下转型的
if(((Student)object).name == this.name && ((Student)object).age == this.age){
return true;
}
else{
return false;
}
}*/
@Override
public boolean equals(Object o){
// this --- s1
// o --- s2
//首先比较的是地址是否相同 （如果相同直接返回true，这是同一个对象）
if(this == o){
return true;
}
//首先判断参数是否为null getClass()获取字节码 判断这两个对象是否来自同一个类
if(o == null || getClass() != o.getClass()){
return false;
}
//然后在向下转型，将父类应用转换为子类对象然后进行比较
Student student = (Student)o;
//然后依次比较属性
//比较年龄（分开比较，直接比较整型数 若是此处不同可以节约时间效率）
if(age != student.age){ //student --- s2
return false;
}
//比较姓名
return name != null ? name.equals(student.name) : student.name == null;
}
}
package com.itheima_02;
/*
用于测试非本类对象比较
*/
public class Cat {
private String name;
private int age;
public Cat() {
}
public Cat(String name, int age){
this.name = name;
this.age = age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
package com.itheima_02;
/*
测试类
public boolean equals (Object obj); 指示一些其他对象是否等于本对象
*/
public class ObjectDemo {
public static void main(String[] args){
Student s1 = new Student();
s1.setName("张三");
s1.setAge(18);
Student s2 = new Student();
s2.setName("张三");
s2.setAge(18);
//需求，比较两个对象的内容是否相等
System.out.println(s1);
System.out.println(s2);
//通过重写超类Object中的toString方法 我们可以看到这两个对象的内容是相同的
/*//因为new出来的对象存放的是堆区的地址值，直接比较是比较的两个对象的地址值是否相等
System.out.println(s1 == s2); //直接比较 结果是false*/
//public boolean equals (Object obj); 指示一些其他对象是否等于本对象
System.out.println(s1.equals(s2)); //还是false
//这个equals() 方法默认比较的还是地址值 所以我们需要重写该方法
/*public boolean equals(Object obj) {
//this -- s1
//obj -- s2
return (this == obj);
}*/
Student s3 = s1;
System.out.println(s1.equals(s3));
Student s4 = new Student();
System.out.println(s1.equals(s4));
Cat c = new Cat("加菲猫", 4);
System.out.println(s1.equals(c));
}
}
3、注释：
我自己根据前面所学习的方法 重写了两个，并分贝针对各类一些特别情况来进行了测试，并发现了一些问题与知识点
//重写一
@Override
public boolean equals(Object object){
//这里使用的条件判断是利用toString返回的是String的对象内容，在利用String中的方法进行比较
if(this.toString().equals(object.toString())){
return true;
}
else{
return false;
}
}
解释重写一：通过Object类中的重写toString()方法进行比较，将本类对象与传入对象内容先转换为字符串内容，再利用字符串方法进行比较
传入对象本身是Object类的子类（所有类都直接间接的继承于Object超类），对于object.toString()根据多态（此类继承了Object类，并且重写了toString方法，在传参过程中用父类引用指向了子类对象）有编译看左边，Object类中有此方法通过，执行看右边，传入的Student对象最终实现了这两个Student类的内容比较
@Override
//此处传入相当于 Object object = new Student();
//就是子类对象，传递给父类引用 利用向下转型可以让其变为子类对象并调用子类成员
public boolean equals(Object object){
//此方法缺陷 在于不是一个类（这里传入狗类时）时是无法进行向下转型的
if(((Student)object).name == this.name && ((Student)object).age == this.age){
return true;
}
else{
return false;
}
}
解释重写二：有了上面的这里我就不废话了，这个重写方式有个缺陷就是无法比较传入非本类对象
理由非常简单：传入非本类对象“无法直接进行向下转型”，这也是为什么自动重写中会有本类判断的原因利用getClass方法进行判断，可以仿照添加也能处理这个问题（手痒而写，问题可以不止这些，有待测试）
四、Arrays
1、了解冒泡排序：
1、排序：将一组数据按照固定的规则进行排列
2、冒泡排序：一种排序方式，根据数据之间的两两比较来实现数据有序化
3、冒泡排序规则：
如果有n个数据进行排序，总共需要比较n-1次 （最后无需比较交换）
每一个比较完毕，下一次的比较就会少一个数据参与 （每一个都会将对应的末端排好
4、参考代码：
package com.itheima_01;
/*
冒泡排序
*/
//StringBuilder类在lang包中无需导包
public class ArraysDemo {
public static void main(String[] args){
//定义一个数组
int[] arr = {24, 38, 66, 57, 90};
System.out.println("排序前：" + arrayToString(arr));
bubblingSort(arr);
System.out.println("排序后：" + arrayToString(arr));
}
//定义一个方法使得数组以字符形式输出
public static String arrayToString(int[] arr){
//创建一个可以变的StringBuilder类对象
StringBuilder sb = new StringBuilder();
sb.append("[");
for(int i = 0; i < arr.length; i++){
if(i < arr.length - 1) {
sb.append(arr[i]);
sb.append(",");
}
else if(i == arr.length - 1){
sb.append(arr[i]);
}
}
sb.append("]");
return sb.toString(); //通过toString()方法将可变字符串变为String对象
}
//定义一个方法实现冒泡排序
public static void bubblingSort(int[] arr){
//冒泡排序原理：
/*
将较大（较小）值往后面挪，第一次比较把最大（小）放在最后
通过元素1 与后面元素依次比较、交换 把最大（小）放好
后续操作类推
*/
for(int i = 0; i < arr.length - 1; i++){//arr.length - 1 防止内循环for中j = i + 1越界
for(int j = 1; j < (arr.length - 1 - i + 1); j++){//依次将i的后续值与i比较
if(arr[j-1] > arr[j]){//如果这个值大于i对应的值交换位置 此时较大值到达i处
int temp = arr[j-1];
arr[j-1] = arr[j];
arr[j] = temp;
}
}
}
}
}
2、Arrays类的概述和常用方法：
Arrays类包含了用于操作数组的各种方法
| 方法名 | 说明 |
|---|---|
| public static String toString(int[] a) | 返回指定数组的内容的字符串表示形式 |
| public static void sort(int[] a) | 按照指定数字顺序排列指定数组 |
工具类的设计思想：
构造方法用 private 修饰：防止外界创建对象
成员用 public static 修饰：强制外界使用类名调用
package com.itheima_02;
/*
测试Arrays类中的常用方法 在util包中
public static String toString(int[] a) 返回指定数组的内容的字符串表示形式
public static void sort(int[] a) 按照指定数字顺序排列指定数组
可以看到都是静态static修饰的方法可以直接使用类名进行调用
*/
import java.util.Arrays;
public class ArraysDemo {
public static void main(String[] args){
//定义一个整型
int[] arr = {12, 44, 58, 19};
//public static String toString(int[] a) 返回指定数组的内容的字符串表示形式
System.out.println("排序前：" + Arrays.toString(arr));
//public static void sort(int[] a) 按照指定数字顺序排列指定数组
Arrays.sort(arr); //交换了但是不输出
System.out.println("排序后：" + Arrays.toString(arr));
}
}
五、基本类型包装类
1、基本类型包装类概述：
将基本类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据
常用的操作之一：用于基本数据类型与字符串之间的转换
| 基本数据类型 | 包装类 |
|---|---|
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| char | Character |
| boolean | Boolean |
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 |
参考代码：
package com.itheima_02;
/*
构造方法：
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 IntegerDemo {
public static void main(String[] args) {
/* //方法划了横线表示已过时
Integer i1 = new Integer(100); //输出非地址值，表示重新写了toString方法
System.out.println(i1);
Integer i2 = new Integer("100");
//非数字字符串无法解析
// Integer i2 = new Integer("abc"); //NumberFormatException
System.out.println(i2);*/
Integer i1 = Integer.valueOf(100);
System.out.println(i1);
Integer i2 = Integer.valueOf("123");
System.out.println(i2);
}
}
3、int和String的相互转换：
1、基本类型包装类的最常见操作就是：用于基本类型和字符串之间的相互转换
2、int转换为String
public static String vauleOf(int i); 返回int参数的字符串表示形式。该方法时String类中的方法
3、String转换为int
public static int parseInt(String s); 将字符串解析为int类型。给方法时Integer类中的方法
参考代码：
package com.itheima_03;
/*
int和String的相互转换
*/
public class IntegerDemo {
public static void main(String[] args){
//int --- String
int number = 100;
//方式1
String s1 = "" + number; //用字符串拼接实现
System.out.println(s1);
//方式2
/* public static String valueOf(int i)返回int参数的字符串表示形式。
该表示恰好是一个参数的Integer.toString方法返回的表示。*/
String s2 = String.valueOf(number);
System.out.println(s2);
System.out.println("--------");
//String --- int
String s = "666";
//方式1
//String --- integer --- int
Integer i = Integer.valueOf(s);
//public int intValue()
int x = i.intValue();
System.out.println(x);
//方式2
//static int parseInt(String s) 将字符串参数解析为带符号的十进制整数。
int y = Integer.parseInt("888");
System.out.println(y);
}
}
4、案例字符串中数据排序：
需求：将给定字符串数据进行排序输出
package com.itheima_04;
/*
字符串中数据排序
public String[] split(String regex); String类中的方法，将给定义字符串用传入的字符串进行分割，并存入字符串数组
*/
public class IntegerDemo {
public static void main(String[] args){
String s = "91 27 46 38 50";
String[] arrString = s.split(" "); //以空格分开
int[] arr = new int[arrString.length];
StringToInteger(arrString, arr);
//printArray(arr); //用于检测数组
//可以直接使用Arrays中的sort方法
bubblingSort(arr);
//printArray(arr); //用于检测数组
//对于这个int -> String 也可以使用 StringBuilder中的addend() 方法
String s2 = integerToString(arr);
System.out.println(s2);
}
//定义一个方法实现String[] 到 int[] 类型的转换
public static void StringToInteger(String[] arrString, int[] arr){
for(int i = 0; i < arrString.length; i++){
//Integer类中 static int parseInt(String s) 将字符串参数解析为带符号的十进制整数。
arr[i] = Integer.parseInt(arrString[i]);
}
}
//定义一个冒泡排序法
public static void bubblingSort(int[] arr){
for(int i = 0; i < arr.length - 1; i++){
for(int j = i + 1; j < (arr.length - i - 1) + 1; j++){
if(arr[j-1] > arr[j]){
int temp = arr[j-1];
arr[j-1] = arr[j];
arr[j] = temp;
}
}
}
}
//定义一个方法实现int[] 到 String类型的转换 并且字符数据间以空格隔开
public static String integerToString(int[] arr){
String s = "";
for(int i = 0; i < arr.length; i++){
if(i != arr.length - 1){
s += arr[i];
s += " ";
}
else if(i == arr.length - 1){
s += arr[i];
}
}
return s;
}
//定义一个方法打印int[] 数组
public static void printArray(int[] arr){
System.out.print("[");
for(int i = 0; i < arr.length; i++){
if(i != arr.length - 1){
System.out.print(arr[i]);
System.out.print(",");
}
else if(i == arr.length - 1){
System.out.print(arr[i]);
}
}
System.out.println("]");
}
}
5、自动装箱和拆箱：
1、装箱拆箱概述：
装箱：把基本数据类型转换为对应的包装类类型
拆箱：包包装类类型转换为对应的基本数据类型
2、手动和自动装箱拆箱：
可以手动进行装箱或者拆箱，也可以直接自动装箱或者拆箱。但是无论如何都使用了对应的方法（只是自动是在底层实现的，估计是运算符重载即赋予运算符新的运算能力）
特别注意：在使用引用类型时，可以先进行空值null判断，以防止程序出错
参考代码：
package com.itheima_05;
/*
装箱：把基本数据类型转换为对应的包装类类型
拆箱：包包装类类型转换为对应的基本数据类型
*/
public class IntegerDemo {
public static void main(String[] args){
//手动装箱：
Integer i = Integer.valueOf(100); //通过方法将100 转换为 Integer包装类类型
//自动装箱 可以理解为运算符重载
Integer ii = 100; //Integer.valueOf(100); 底层也做了这个动作，只是没有看到而已
//实现ii += 200
//手动拆箱
ii = ii.intValue() + 200; //ii.intValue(); 将ii从Integer类型转换为int类型
System.out.println(ii);
//自动拆箱
ii = ii + 200; //估计又是运算符重载
Integer iii = null; //NullPointerException 对应包装类引用为空值 无法进行方法调用
if(iii != null){
iii += 300;
}
}
}
六、日期类
1、Date类
1、Date类概述和构造方法：
Date代表了一个特定时间，精确到毫秒，它有两个构造函数
| 方法名 | 说明 |
|---|---|
| public Date() | 分配一个Date对象，并初始化，以便代表它被分配的时间，精确到毫秒 |
| public Date(long date) | 分配一个Date对象，并将其初始化为表示从标准基时间起指定的毫秒数 |
参考代码：
package com.itheima;
/*
public Date() 分配一个Date对象，并初始化，以便代表它被分配的时间，精确到毫秒
public Date(long date) 分配一个Date对象，并将其初始化为表示从标准基时间起指定的毫秒数
*/
//导包，注意文档中类名是有同名的，我们看到是util下的
import java.util.Date;
//标准基准时间（称为“时代”）即1970年1月1日00:00:00 GMT起的指定毫秒数。
public class DateDemo01 {
public static void main(String[] args) {
//public Date() 分配一个Date对象，并初始化，以便代表它被分配的时间，精确到毫秒
Date date1 = new Date();
System.out.println(date1); //Sat Oct 08 20:23:03 CST 2022获得了当前日期信息的数据
//public Date(long date) 分配一个Date对象，并将其初始化为表示从标准基时间起指定的毫秒数
long d = 1000 * 60 * 60L;
Date date2 = new Date(d);
System.out.println(date2); //Thu Jan 01 09:00:00 CST 1970 注意要考虑到时区的误差
}
}
2、Date类的常用方法
| 方法名 | 说明 |
|---|---|
| public long getTime() | 获取的是日期对象从1997年1月1日00:00:00到现在的毫秒值 |
| public void setTime() | 设置时间，给的是毫秒值 |
参考代码
package com.itheima;
/*
public long getTime() 获取的是日期对象从1997年1月1日00:00:00到现在的毫秒值
public void setTime() 设置时间，给的是毫秒值
*/
//导包
import java.util.Date;
public class DateDemo02 {
public static void main(String[] args){
//创建日期对象
Date d = new Date();
// public long getTime() 获取的是日期对象从1997年1月1日00:00:00到现在的毫秒值
// System.out.println(d.getTime());
// System.out.println("约" + d.getTime() * 1.0 / 1000 / 60 / 60 / 24 / 365 + "年");
//public void setTime() 设置时间，给的是毫秒值
System.out.println("设置前的时间" + d);
// long time = 1000 * 60 *60;
long time = System.currentTimeMillis(); //也是记录了标准时间到现在的时间 单位毫秒
d.setTime(time);
System.out.println("设置后的时间" + d);
}
}
2、SimpleDateFormat类
simple：简单 date：日期 format：格式 合起来：简单日期格式、易于理解的日期格式
1、SimpleDateFormat类概述：
SimpleDateFormat是一个具体类，用于以区域设置敏感的方式格式化和解析日期。我们重点学习日期格式化和解析
日期和时间格式由日期和时间模式字符串指定，在日期和时间模式字符串中，从 ‘A’ 到 ‘Z’ 以及从 'a' 到 'z' 引号的字母被解释为表示日期或时间字符串的组件的模式字母
常用的模式字母及对应关系如下：
- y 年
- M 月
- d 日
- H 时
- m 分
- s 秒
2、SimpleDateFormat类的构造方法：
| 方法名 | 说明 |
|---|---|
| public SimpleDateFormat() | 构造一个SimpleDateFormat，使用默认模式和日期格式 |
| public SimpleDateFormat(String pattern) | 构造一个SimpleDateFormat使用给定的模式和默认的日期格式 |
3、SimpleDateFormat格式化和解析日期：
格式化（从Date到String）
public final String format(Date date); 将日期格式化成日期/时间字符串
解析（从String到Date）
public Date parse(String source); 从给定字符串的开始解析文本以生成日期
参考代码：
package com.itheima_01;
/*
public SimpleDateFormat() 构造一个SimpleDateFormat，使用默认模式和日期格式
public SimpleDateFormat(String pattern) 构造一个SimpleDateFormat使用给定的模式和默认的日期格式
格式化（从Date到String）
public final String format(Date date); 将日期格式化成日期/时间字符串
解析（从String到Date）
public Date parse(String source); 从给定字符串的开始解析文本以生成日期
*/
//导包
import java.text.ParseException; //是parse()方法报错时 选中Alt + Enter选择第一个添加的默认解决方法
import java.util.Date;
import java.text.SimpleDateFormat;
public class SimpleDateFormatDemo {
public static void main(String[] args) throws ParseException {
//注意解析时：有参构造中的格式参数 要与转换的String格式相同能进行（格式化是先给定格式在返回给字符串的）
//一、格式化（从Date到String）
//属于：SimpleDateFormat类 public final String format(Date date); 将日期格式化成日期/时间字符串
Date d = new Date();
//无参构造 无法给定格式
// SimpleDateFormat sdf = new SimpleDateFormat(); //创建对象
//这样确实更爽了
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日HH时mm分ss秒");//创建对象
String s = sdf.format(d);
System.out.println(s); //这看着确实好很多
System.out.println("---------------------");
//二、解析（从String到Date）
//属于：SimpleDateFormat类 public Date parse(String source); 从给定字符串的开始解析文本以生成日期
String ss = "2048-08-09 11:11:11";
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date dd = sdf2.parse(ss);
System.out.println(dd);
}
}
4、案例：日期工具类
package com.itheima_02;
/*
日期工具类
*/
//导包
import java.text.ParseException; //用于解决parse异常
import java.util.Date;
import java.text.SimpleDateFormat;
public class DateUtils {
//构造方法私有 防止创建对象
private DateUtils(){}
//定义两个方法 都使用static 进行修饰用于直接类名调用
//1、Date --- String
public static String DateToString(Date date, String format){ //参数：日期对象 对应格式
if(date != null){
//通过SimpleDateFormat的有参构造方法来限定格式
SimpleDateFormat sdf = new SimpleDateFormat(format);
//在将限定好格式的Date类对象 转换为字符串形式并返回
String str = sdf.format(date);
return str;
}
else{
//若传入对象的引用为空值，则返回空字符串
return "";
}
}
//2、String --- Date
public static Date StringToDate(String s, String format) throws ParseException { //参数：字符对象 对应格式
SimpleDateFormat sdf = new SimpleDateFormat(format);
Date d = sdf.parse(s);
return d;
}
}
package com.itheima_02;
/*
日期测试类
*/
//导包
import java.text.ParseException; //因为自定义的方法中使用了parse方法所以需要在个类下进行异常处理（异常具有传递性）
import java.util.Date;
public class DateDemo {
public static void main(String[] args) throws ParseException {
//创建一个Date类对象
Date d = new Date();
//调用日期类转换为字符串方法 根据我们传入的指定格式进行输出
//但是注意代表具体时间的占位符还是要以 SimpleDateFormat有参构造方法中的规范来
String s = DateUtils.DateToString(d, "yyyy年MM月dd日HH时mm分ss秒");
System.out.println(s);
String s2 = DateUtils.DateToString(d, "yyyy年MM月dd日");
System.out.println(s2);
String s3 = "2008-12-24 12:12:12";
Date d2 = DateUtils.StringToDate(s3, "yyyy-MM-dd HH:mm:ss");
System.out.println(d2);
}
}
3、Calendar类(从参考文档中看出是抽象类 public abstract class Calendar)：
1、概述：
Calendar 为某一时刻和一组日历字段之间的转换提供了一些方法，并为操作日历字段提供了一些方法
2、对象的获取：
Calendar 提供了一个类方法getlnstance 用于获取Calendar对象，其日历字段已使用当前日期和时间初始化；
Calendar rightNow = Calendar.getlnstance();
参考代码：
package com.itheima_01;
/*
CalenderDemo 类
*/
//导包
import java.util.Calendar;
public class CalenderDemo {
public static void main(String[] args){
//获取对象
//getInstance返回值是Calendar是抽象类做返回值 返回的是其子类（孙子）对象
Calendar c = Calendar.getInstance(); //多态的形式得到对象
// System.out.println(c);
//public int get(int field)
int year = c.get(Calendar.YEAR);
int month = c.get(Calendar.MONTH) + 1; //月份是从零开始的
int date = c.get(Calendar.DATE);
System.out.println("现在是：" + year + "年" + month + "月" + date + "日");
}
}
3、常用的方法：
| 方法名 | 说明 |
|---|---|
| public int get(int field) | 返回给定字段的值 |
| public abstract void add(int field, int amount) | 根据日历的规则，将指定的时间量添加或减去给定的日历字段 |
| public final void set(int year, int month, int date) | 设置当前日历的年月日 |
package com.itheima_02;
/*
Calendar 类常用方法返回给定字段的值
public int get(int field) 返回给定字段的值
public abstract void add(int field, int amount) 根据日历的规则，将指定的时间量添加或减去给定的日历字段
public final void set(int year, int month, int date) 设置当前日历的年月日
*/
//导包
import java.util.Calendar;
public class CalendarDemo {
public static void main(String[] args){
//获取一个日历类的对象 get 获取 instance 实例
Calendar c = Calendar.getInstance();
//一、public int get(int field); 返回给定字段的值
// int year = c.get(Calendar.YEAR);
// int month = c.get(Calendar.MONTH) + 1;
// int date = c.get(Calendar.DATE);
// System.out.println(year + "年" + month + "月" + date + "日");
//二、public abstract void add(int field, int amount) 根据日历的规则，将指定的时间量添加或减去给定的日历字段
//需求1：三年以前的今天
// c.add(Calendar.YEAR, -3);
// int year = c.get(Calendar.YEAR);
// int month = c.get(Calendar.MONTH) + 1;
// int date = c.get(Calendar.DATE);
// System.out.println("三年以前的今天" + year + "年" + month + "月" + date + "日");
//需求2：十年后的五天前
// c.add(Calendar.YEAR, 10);
// c.add(Calendar.DATE, -5);
// int year = c.get(Calendar.YEAR);
// int month = c.get(Calendar.MONTH) + 1;
// int date = c.get(Calendar.DATE);
// System.out.println("十年后的五天前：" + year + "年" + month + "月" + date + "日");
//三、public final void set(int year, int month, int date) 设置当前日历的年月日
c.set(2016, 11, 11); //月从0开始 此处11表示12
int year = c.get(Calendar.YEAR);
int month = c.get(Calendar.MONTH) + 1;
int date = c.get(Calendar.DATE);
System.out.println(year + "年" + month + "月" + date + "日");
}
}
4、案例：二月天
需求：获取任意年份的二月天数
package com.itheima_03;
/*
需求：获取任意一年的二月天数
*/
//导包
import java.util.Scanner;
import java.util.Calendar;
public class CalendarDemo {
public static void main(String[] args){
//从键盘中录入年份
Scanner sc = new Scanner(System.in);
System.out.println("请输入对应的年份：");
int year = sc.nextInt();
System.out.println(year + "年中的二月有：" + getFebruaryDate(Calendar.getInstance(), year) + "天");
}
public static int getFebruaryDate(Calendar c, int year){
//设置当前（传入的参数）年月日
c.set(year, 2, 1);
//根据年月日参数，和改变参数对其进行修改
c.add(Calendar.DATE, -1);
//根据年月日参数获取对应的数值
int date = c.get(Calendar.DATE);
return date;
}
}
浙公网安备 33010602011771号