常用类及其常用方法
Object类
Object类是所有类的父类
注意：基本数据类型不是一个类，所以不是Object的子类，说明Java并不是一个完全面向对象的语言。
Object类提供的方法
public int hashCode()
表示是一个Hash映射函数，该函数作用是对于传入的数据进行计算，得到一个唯一确定的结果。
Object o = new Object();
System.out.println(o.hashCode());
对于相同内存地址的对象，进行Hash计算时，结果一样
public final Class getClass()
获取类对象，其中有getName（）方法可以获取到当前对象的类路径
//<? extends Animal>表示一个泛型 Class表示一个类 canimal.getClass()表示获取到一个类对象
Class<? extends Animal> aClass = animal.getClass();
System.out.println(aClass);
输出：>>>>class com.demoproject.day09.Animal
public String toString()
System.out.println(animal.toString());
System.out.println(animal);
输出：>>>>>
com.shujia.day09.Animal@7f31245a
com.shujia.day09.Animal@7f31245a
在println调用时，如果传入的是一个类对象，那么在源码中使用balueOf()去调用对象的toString方法。
默认情况下，返回当前类的对象的内存地址，一般自定义类会对该方法进行重写，将其属性打印。
public boolean equals(Object obj)
传入一个对象，比较两个对象的内存地址是否相同，源码中使用==判断
Cat cat1 = new Cat("招财", 1);
Cat cat2 = new Cat("咪咪", 2);
Cat cat3 = new Cat("咪咪", 2);
Cat cat4 = cat2;
System.out.println("cat1.equals(cat2):"+cat1.equals(cat2)); // false
// 对于cat2和cat3的属性是一致的
System.out.println("cat3.equals(cat2):"+cat3.equals(cat2)); // false
// cat2和cat4的内存地址一致
System.out.println("cat4.equals(cat2):"+cat4.equals(cat2)); // true
若要判断两个对象的属性相同就认为相等，则需重写equals（）方法：通过String字符串的equals（）方法（Object的equals方法和String的equals方法不同一个传入对象，一个传入字符串）比较属性的内容是否相同，判断两个类的属性是否相同，从而判断两个类是否相等。
protected void finalize()
注意：该方法是protected修饰。
finalize()方法是Object类中提供的一个方法，在gc准备释放对象所占用的内存空间之前，它将首先调用finalize()方法，当对象没有引用时，该对象可以被垃圾回收器进行回收，当该方法被执行时，当前对象消失。
如何触发垃圾收集器？
- 手动触发
- 内存不足时自动触发
如何验证该方法在gc操作前执行了呢？
自定义一个类，对finalize方法进行重写
例如定义一个Student类，对finalize方法进行重写
public class Student {
@Override
protected void finalize() throws Throwable {
System.out.println("当对象没有引用时，该对象可以被垃圾回收器进行回收，当该方法被执行时，当前对象消失");
}
}
定义一个测试类进行测
public class Test{
public static void main(String[] args) {
Student student = new Student("ww", 18);
//重新赋值为null，将引用去除，此时new出来的Student对象没有任何引用。
student = null;
//当student=null时，引用消失但new 出来的Student对象还存在
System.out.println("开始gc操作");
System.gc();
System.out.println("gc操作结束");
}
}
输出：>>>>>
开始gc操作
gc操作结束
当对象没有引用时，该对象可以被垃圾回收器进行回收，当该方法被执行时，当前对象消失
为什么finalize中的内容是最后打印的？
需要了解多线程并发执行，当System.gc()执行时，会创建一个垃圾回收线程，和当前的main线程同时进行执行，而System.out.println(“GC操作完成”); 执行相对较快，对于垃圾回收执行较慢，所以 finalize的内容会最后打印。
protected Object clone()
// protected native Object clone() => native修饰的称为本地方法 Java可以调用当前系统中的一些方法 该方法称为本地方法
Object clone() 方法用于创建并返回一个对象的拷贝。
clone 方法是浅拷贝，对象内属性引用的对象只会拷贝引用地址，而不会将引用的对象重新分配内存，也可以重写clone方法，创建一个新的该类的对象返回出去，相对应的深拷贝则会连引用的对象也重新创建。
例如重写clone方法后创建一个新的对象返回
public class Student {
String name;
int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age && Objects.equals(name, student.name);
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
@Override
protected void finalize() throws Throwable {
System.out.println("垃圾回收前，finalize方法被调用");
}
@Override
protected Object clone() throws CloneNotSupportedException {
return new Student(this.name,this.age);
}
}
//测试类
public class Test{
public static void main(String[] args) throws CloneNotSupportedException, InterruptedException {
Student student2 = new Student("ww", 18);
Student clone = (Student) student2.clone();
System.out.println(student2.equals(clone));
System.out.println(student2==clone);
}
}
输出：>>>
true//在Student中已经对equals方法进行重写，比较的是两个对象的属性
false//==号判断两个对象的地址，由于是新创建的对象，所以内存地址不同
Scanner类
public Scanner(InputStream source)
Scanner的成员方法
-
hasNextxxx() 判断是否还有下一个输入项,其中xxx可以是Int,Double等。如果需要判断是否包含下一个字符串，则可以省略xxx
-
nextxxx() 获取下一个输入项。xxx的含义和上个方法中的xxx相同
-
默认情况下，Scanner使用空格，回车等作为分隔符
import java.io.InputStream;
import java.util.Scanner;
public class Demo02Scanner {
public static void main(String[] args) {
InputStream in = System.in;//输入流
Scanner scanner = new Scanner(in);
System.out.println("输入一个整数");
if (scanner.hasNextInt()) {
int i = scanner.nextInt();
System.out.println(i);
}else {
System.out.println("输入类型不正确");
}
}
}
String类
创建一个字符串的两种方式
1.表示对一个常量进行赋值，在jvm中的方法区的常量池中保存
//方式1：
String str = "hello";
2.创建一个String对象，传入一个字符串参数，保存在jvm的堆内存中
//方式2：
String hello = new String("hello");
注意：String中的参数可以传入字符串也可以传入字符型数组，字节型数组等，但是传入字节型数组时会将数组中的字节转成一个字符，之后再去拼接成一个字符串
char [] chars = {'h','e','l','l','o'};
String charStr = new String(chars);
System.out.println(charStr);
输出：hello
byte [] bytes = {97,98,99};
String byteStr = new String(bytes);
System.out.println(byteStr);
输出：abc
对于
public String(byte[] bytes,int offset,int length)
public String(char[] value,int offset,int count)
该构造方法，offset表示起始下标，length表示长度，可以用于字符串的截取。
String字符串是否可以改变?
字符串可以使用+号拼接进而重新赋值给一个新的变量，也可以使用+=拼接字符串赋值给原本的变量，但是已经定义的字符串不能被改变。 所以不论是+号赋值一个新的变量，还是+=赋值给原本的变量，字符串的地址都会发生改变。
String s1 = "world";
String s11 = s1;
String s2 = "java";
String s22 = s2;
s2 += s1;
String s3 = s1+s2;
System.out.println(s11==s2);
System.out.println(s2==s22);
System.out.println(s3==s1);
System.out.println(s3==s2);
输出>>>
false
false
false
false
String s1 = new String("hello");
String s2 = new String("hello");
System.out.println(s1==s2); // false
System.out.println(s1.equals(s2)); // true
String s3 = new String("hello");
String s4 = "hello";
System.out.println(s3==s4); // false
System.out.println(s3.equals(s4)); // true
String s5 = "hello";
String s6 = "hello";
System.out.println(s5==s6); // true
System.out.println(s5.equals(s6)); // true
String s1 = "hello";
String s2 = "world";
String s3 = "helloworld";
System.out.println(s3 == s1 + s2); // false
System.out.println(s3.equals(s1 + s2)); // true
String s4 = new String("hello"); // 堆
String s5 = "hello"; //常量
s5 += s4;
System.out.println(s5); // s5的位置？
/*
对于常量池和堆里的字符串相加会存放在堆中
原因：
s5 最初是一个指向常量池中 "hello" 对象的引用。然后，通过 += 运算符连接了两个字符串，创建了一个新的字符串对象 "hellohello"，并将 s5 的引用指向了这个新创建的对象。所以，最终 s5 存储在堆中，指向连接后的新字符串对象。原始的 "hello" 字符串仍然存在于常量池中，但是 s5 的引用指向了新创建的对象。
*/
String ss = s1+s2;//ss存放在哪？
/*
对于常量池中的s1 和 s2 变量进行相加，会在堆空间中创建一个String类型的对象空间，并将s1和s2的值进行拼接，放入对象的堆空间中
*/
String s6 = "hello" + "world";
System.out.println(s3 == s6); // true 为什么？
/*
1.会将hello和world分别放在常量区
2.会将其相加的结果也放在常量区中
3.常量区中多个相同的helloworld会指向同一个内存地址
*/
String s7 = "helloworld";
System.out.println(s3 == s7); // true
总节：
- 对于字符串常量来说，只要字符串内容相同，它们指向的地址也相同，例如：String s1 ="helloworld"和String s2 = “hello”+“world”,s1和s2地址相同
- 对于用对象创建的字符串来说，多个对象创建的字符串虽然内容相同，但它们在堆中保存在不同的对象里，所以内存地址不同
- 对于两个常量字符串相加：例如String s1 = “hello”+“world”;和String s2 = “helloworld”;保存的地址相同，不同的存放在栈中的变量s1，s2会指向相同的常量池中的helloworld地址
- 对于两个定义好的字符串的引用相加，例如String s1 = “hello”;String s2=“world”;String s3 = s1+s2; s3会在堆内存中创建一个String类型的对象空间，并将s1和s2进行拼接，放入对象的堆空间中，故s3会存放在堆空间中
- 对于一个常量字符串给和一个堆空间里的字符串相加，例如String s1 = “hello”;String s2 = new String(“world”);因为字符串拼接操作在编译期和运行期都会被优化，以避免创建过多的临时对
String类的判断方法
- boolean equals(Object obj)：比较两个字符串内容是否相同，对Object的equals（Object是比较地址）的方法进行了重写。
String s1 ="hello";
String s2 ="hello";
System.out.println(s1.equals(s2));
- boolean equalsIgnoreCase(String str): 如果两个字符串的长度相同，并且两个字符串中的相应字符等于忽略大小写，则两个字符串被认为是相等的。
String s3 = "HELLo";
System.out.println(s3.equalsIgnoreCase(s1));
- boolean contains(String str):判断被传入的字符串是否被包含
String s4 = "helloworld";
System.out.println(s4.contains(s1));
- boolean startsWith(String str):判断是否以某个字符串开头
String s5 ="hell";
System.out.println(s1.startsWith(s5));
System.out.println(s4.startsWith(s1));
- boolean endsWith(String str):判断是否以某个字符串结尾
String s6 = "world";
System.out.println(s4.endsWith(s6));
- boolean isEmpty():判断是否为空
System.out.println(s1.isEmpty());
System.out.println(s2.isEmpty());
System.out.println(s4.isEmpty());
String类的获取方法
String str = "ABLKSHBCH";
- int length() ：获取字符串的长度
//底层是字符数组，故就是获取字符数组的长度
System.out.println(str.length());
- char charAt(int index): 获取下标所在位置的字符
System.out.println(str.charAt(3));
- int indexOf(String str) ：获取字符串对应的的起始下标
System.out.println(str.indexOf("KS"));
- int indexOf(String str,int fromIndex) :从对应下标开始查找对应的字符串
System.out.println(str.indexOf("K",2));
- String substring(int start) :给定起始位置，截取字符串到末尾
System.out.println(str.substring(4));
- String substring(int start,int end):给定起始位置和结束位置截取字符串
System.out.println(str.substring(3,7));
String的转换方法
- byte[] getBytes()：把字符串放入字节数组,并转换成对应的ASCLL码值 。
String str = "shHLpONBVl";
byte[] bytes = str.getBytes();
System.out.println(bytes);//直接打印会打印出地址
System.out.println(Arrays.toString(bytes));
//[115, 104, 72, 76, 112, 79, 78, 66, 86, 108]
String str2 = "我爱学Java";
byte[] str2Bytes = str2.getBytes("UTF-8"); System.out.println(Arrays.toString(str2Bytes));
//[-26, -120, -111, -25, -120, -79, -27, -83, -90, 74, 97, 118, 97],一个中文占3个字节
//-26, -120, -111, -25, -120, -79, -27, -83, -90=>我爱学
//74, 97, 118, 97=>Java
- char[] toCharArray() ：把字符串放入字符数组.
char[] charArray = str.toCharArray();
char[] str2CharArray = str2.toCharArray(); System.out.println(Arrays.toString(str2CharArray));//一个中文表示一个字符
System.out.println(Arrays.toString(charArray));
//[我, 爱, 学, J, a, v, a]
//[s, h, H, L, p, O, N, B, V, l]
- static String valueOf(char[] chs) ：将字符数组转换成字符串，static修饰，可以直接使用"String.方法名"的形式直接调用。
System.out.println(String.valueOf(str2CharArray));//我爱学Java
- static String valueOf(int i) ：传入一个int类型，转换成字符串
System.out.println(String.valueOf(65));//65
- String toLowerCase() ：大写字母转换为小写（不改变原字符串）
System.out.println(str.toLowerCase());
System.out.println(str);
>>>>>>>>输出
shhlponbvl
shHLpONBVl
- String toUpperCase() ：小写字母转换为大写（不改变原字符串）
System.out.println(str.toUpperCase());
System.out.println(str);
>>>>输出
SHHLPONBVL
shHLpONBVl
- String concat(String str)：拼接字符串（不改变原字符串）
String concat = str.concat(str2);//concat不会改变本身的字符串
System.out.println(concat);
>>>>>输出
shHLpONBVl我爱学Java
String类的其他功能
String str3 = " aabcca \n \t";
- String replace(char old,char new) ：替换原字符串里的字符
System.out.println(str3.replace('a', '='));
>>>>输出
==bcc=
- String replace(String old,String new) ：替换原字符串中的子字符串
System.out.println(str3.replace("ab", "ll"));
>>>>输出
allcca
- String trim() ：去除字符串两端的空格，换行，制表符等
System.out.println(str3.trim());
>>>>输出
aabcca
- split():表示为一个切分函数，给定一个切分的字符串，将字符串进行分割成多个字符串，并返回一个字符串数组
String s3 = "abbkkkaooappakka";
String[] as = s3.split("a");
System.out.println(Arrays.toString(as));
输出>>>>>
[, bbkkk, oo, pp, kk]
统计大串中小串出现的次数
举例：在字符串” woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun”中java出现了5次
//方法1：
int cnt = 0;
while (s.contains("java")) {
cnt++;
int start = s.indexOf("java")+4;
s = s.substring(start);
}
System.out.println(cnt);
//方法2：
String s1 = "javawoaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagunjava";
String s2 = " "+s1+" ";//防止头部或尾部出现子字符串无法计数
String[] splitRes = s2.split("java");
System.out.println(Arrays.toString(splitRes));
System.out.println(splitRes.length - 1);
- int compareTo(String str) ：
- 如果两个字符串首字母不同，则该方法返回首字母的asc码的差值
String a1 = "a";
String a2 = "c";
System.out.println(a1.compareTo(a2));
//结果为-2
- 即参与比较的两个字符串如果前面几个字符相同，则比较下一个字符，直到有不同的为止，返回该不同的字符的asc码差值.
String a1 = "aa";
String a2 = "ad";
System.out.println(a1.compareTo(a2));//结果为-3
- 如果两个字符串不一样长，可以参与比较的字符又完全一样，则返回两个字符串的长度差值
String a1 = "aa";
String a2 = "aa12345678";
System.out.println(a1.compareTo(a2));//结果为-8
- int compareToIgnoreCase(String str):忽略大小写比较
- compareto方法的源码
/*
字符串比较(字典比较)
str4.compareTo(str3) // 当前对象是属于 str4 => char[] value
public int compareTo(String anotherString) {
int len1 = value.length; // str4的 char[] 字符串数组长度
int len2 = anotherString.value.length; // str3 字符串数组长度
int lim = Math.min(len1, len2); // 比较两个长度最小值 1
char v1[] = value; // str4 ['b']
char v2[] = anotherString.value; // str3 ['a']
int k = 0; // 表示下标
while (k < lim) { // 小于最小长度
char c1 = v1[k]; // b
char c2 = v2[k]; // a
if (c1 != c2) {
return c1 - c2; // b-a
}
k++;
}
return len1 - len2;
}
*/
把字节数组转换为字符串
byte [] byteStr = {65,66,67};
String s = new String(byteStr);
System.out.println(s);
//ABC
StringBuffer类
StringBuffer和String的区别：
简单地说，就是一个变量和常量的关系。StringBuffer对象的内容可以修改；而String对象一旦产生后就不可以被修改，重新赋值其实是两个对象。
StringBuffer的内部实现方式和String不同，StringBuffer在进行字符串处理时，不生成新的对象，在内存使用上要优于String类。所以在实际使用时，如果经常需要对一个字符串进行修改，例如插入、删除等操作，可预先分配指定长度的内存块建立一个字符串缓冲区，而String的+ 操作符每一次将字符添加到一个字符串中去时，字符串对象都需要寻找一个新的内存空间来容纳更大的字符串，这无凝是一个非常消耗时间的操作。添加多个字符也就意味着要一次又一次的对字符串重新分配内存。所以使用StringBuffer要更加适合一些。
StringBuffer和StringBuilder的区别
StringBuffer是为了多线程的安全，但是频繁的上锁解锁会降低代码的运行效率，而StringBuilder虽然没有安全性的考虑，但是它不用开锁解锁，所以运行效率更高，我们在编程中如果需要安全性就使用StringBuffer，如果是为了高效率就使用StringBuilder。
StringBuffer的构造方法
-
public StringBuffer()
-
public StringBuffer(int capacity)：给定起始容量。
-
public StringBuffer(String str)：把字符串转换成StringBuffer类型。
StringBuffer就相当于在底层创建另一个字符数组,每当追加数据到StringBuffer中 ，StringBuffer会动态的去扩充其容量。
StringBuffer类的方法
- 添加功能
- public StringBuffer append(String str):在字符串后面追加字符串
StringBuffer stringBuffer = new StringBuffer();
System.out.println(stringBuffer.append("safdhjgkaslkj"));
输出>>>>safdhjgkaslkj
public StringBuffer insert(int offset,String str)：指定下标，在指定下标的位置添加字符串
System.out.println(stringBuffer.insert(2, "ooooooo"));
输出>>>
saooooooofdhjgkaslkj
System.out.println(stringBuffer.insert(0, 8));
输出>>>
8saooooooofdhjgkaslkj
- 删除功能
public StringBuffer deleteCharAt(int index)：删除指定下标的字符
System.out.println(stringBuffer.deleteCharAt(0));
输出>>>>
saooooooofdhjgkaslkj
public StringBuffer delete(int start,int end):删除对应起始下标到指定末尾下标的字符串
System.out.println(stringBuffer.delete(2, 5));
输出>>>>
saoooofdhjgkaslkj
- 替换功能
public StringBuffer replace(int start,int end,String str):替换指定起始下标到指定末尾下标的字符串
System.out.println(stringBuffer.replace(3, 6, "qqq"));
输出>>>>>>>>
saoqqqfdhjgkaslkj
- 反转功能 public StringBuffer reverse():反转字符串
System.out.println(stringBuffer.reverse());
输出>>>>
jklsakgjhdfqqqoas
- 截取功能（返回值类型是String类型，字符串本身没有发生改变）
public String substring(int start):截取指定起始位置到末尾的字符串
System.out.println(stringBuffer.substring(2));
输出>>>>
lsakgjhdfqqqoas
public String substring(int start,int end):截取指定起始位置到指定末尾位置的字符串
System.out.println(stringBuffer.substring(3, 7));
输出>>>>sakg
Arrays类
Arrays类：针对数组进行操作的工具类。提供了排序，查找等功能
Arrays类的成员方法
int [] arr = {83,9,37,30,66,12,88,2,76};
- public static String toString(int[] a):直接打印数组名的话，会把数组的地址打印出来(Object的toString方法是打印地址)，所以需要借助Arrays类打印数组（Arrays对Object的toString方法进行了重写）。
System.out.println(Arrays.toString(arr));
输出>>>>
[83, 9, 37, 30, 66, 12, 88, 2, 76]
public static void sort(int[] a):对数组进行排序(无返回值),对原数组进行操做。
Arrays.sort(arr);
输出>>>
[2, 9, 12, 30, 37, 66, 76, 83, 88]
public static int binarySearch(int[] a,int key)：二分查找,返回对应值的下标，未查找到返回一个负值。
System.out.println(Arrays.binarySearch(arr, 66));
输出>>>
5
包装类
对于基本数据类型，由于其并不是一个类，所以无法构建其对象，通过操做对象的方法来完成相关操做
于是java提供了对于基本数据类型的包装类.
包装类的好处：将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据。
常用操做：用于基本数据类型与字符串之间的转换
基本数据类型对应的包装：Byte,Short,Integer,Long,Float,Double，Character,Boolean
注意：对于基本数据类型，其内部之间可以通过强制类型转换进行类型转换，除了boolean。
String str = "10";
//int i2 = (int)str;//String无法直接转换成基本数据类型
long l = 76L;
System.out.println(l);
char c = (char) l;
System.out.println(c);
Integer类
Integer 类在对象中包装了一个基本类型 int 的值，该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，还提供了处理 int 类型时非常有用的其他一些常量和方法。
- 自动装箱：当所需要的类型是包装类，但此时可以使用对应的基本数据类型来传递。
- 自动拆箱：对于包装类对象可以赋值给基本数据类型
Integer i2 = new Integer("10");//并不能说明创建了一个Integer对象，只是运用了其自动拆箱的功能
String转int通过包装类来完成,Integer提供了valueOf（）方法可以将基本类型int转换为包装类型Integer，或者将String转换成Integer，String如果为Null或“”都会报错，intValue（）方法可以将Integer类型的值转换为int类型。
int intValue = Integer.valueOf("12").intValue();
System.out.println(Integer.valueOf("13"));
System.out.println(intValue);
System.out.println(Integer.valueOf("44").doubleValue());
Integer提供了parseInt（）方法将String类型的值强转成int类型
System.out.println(Integer.parseInt("11"));
int i3 = Integer.parseInt("90");
Random类
此类用于产生随机数
如果用相同的种子创建两个 Random 实例，则对每个实例进行相同的方法调用序列，它们将生成并返回相同的数字序列
Random random = new Random();
//这里的Random()里可以传入一个种子，以保证每次产生的随机数是一直的
int i = random.nextInt();
//这里的nextInt里可以传入一个参数，来限制产生的随机数的范围
int i1 = random.nextInt(20);
//例如传入20，则产生的随机数的范围是0-20
System类
System 类包含一些有用的类字段和方法，它不能被实例化。
-
System.gc(): 会手动触发一次垃圾回收，对JVM内存（堆内存）中 对象没有引用的进行清理。
-
System.currentTimeMillis(): 获取当前系统的时间-> 毫秒为单位的时间戳。
Date类
- 构造方法：
public Date()
public Date(long date)
- 成员方法：
public long getTime()
public void setTime(long time)
Date date = new Date();
//获取系统当前时间 -》Wed Jan 03 10:57:40 CST 2024
System.out.println(date);
//获取当前时间，以毫秒为单位的时间戳->1704250738225
System.out.println(date.getTime());
DateFormat类
DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。其子实现类SimpleDateFormat。
- 构造方法
（1）public SimpleDateFormat()
SimpleDateFormat simpleDateFormat = new SimpleDateFormat();
String dateStr1 = simpleDateFormat.format(date);
System.out.println(dateStr1);
输出>>>>
24-1-3 下午2:21
（2）public SimpleDateFormat(String pattern)：参数可以传入时间的格式
自定义开发常用标准时间格式：
SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String strDate = simpleDateFormat1.format(date);
System.out.println(strDate);
输出>>>>
2024-01-03 14:21:06
- 成员方法
public final String format(Date date)：把时间转换成自己想要格式的时间字符串
public Date parse(String source)：解析时间字符串，转换成系统格式的时间
SimpleDateFormat simpleDateFormat2 = new SimpleDateFormat("yyyy年MM月dd日'T'HH点mm分ss秒");
Date parse = simpleDateFormat2.parse("2023年12月25日T14点15分01秒");//解析成系统格式的时间——》Mon Dec 25 14:15:01 CST 2023
System.out.println(parse);
String formatted = simpleDateFormat1.format(parse);//转化自己想要时间格式
System.out.println(formatted);
输出>>>
2023-12-25 14:15:01
eDateFormat = new SimpleDateFormat();
String dateStr1 = simpleDateFormat.format(date);
System.out.println(dateStr1);
输出>>>>
24-1-3 下午2:21
（2）public SimpleDateFormat(String pattern)：参数可以传入时间的格式
自定义开发常用标准时间格式：
```java
SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String strDate = simpleDateFormat1.format(date);
System.out.println(strDate);
输出>>>>
2024-01-03 14:21:06
- 成员方法
public final String format(Date date)：把时间转换成自己想要格式的时间字符串
public Date parse(String source)：解析时间字符串，转换成系统格式的时间
SimpleDateFormat simpleDateFormat2 = new SimpleDateFormat("yyyy年MM月dd日'T'HH点mm分ss秒");
Date parse = simpleDateFormat2.parse("2023年12月25日T14点15分01秒");//解析成系统格式的时间——》Mon Dec 25 14:15:01 CST 2023
System.out.println(parse);
String formatted = simpleDateFormat1.format(parse);//转化自己想要时间格式
System.out.println(formatted);
输出>>>
2023-12-25 14:15:01
扫一扫
4654
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
