9.Java常用类
Object类
- 超类、基类,所有类的直接或间接父类,位于继承树的最顶层。
- 任何类,如没有书写extends显式继承某个类,都默认直接继承Object类,否则为间接继承。
- Object类中所定义的方法,是所有对象都具备的方法。
- Object类型可以存储任何对象。
- 作为参数,可接受任何对象。
- 作为返回值,可返回任何对象。
getClass()方法
-
public final native Class<?> getClass();
-
返回引用中存储的实际对象类型。
-
应用:通常用于判断两个引用中实际存储对象类型是否一致。
代码:
public class Demo {
public static void main(String[] args) {
Student student1 = new Student();
Student student2 = new Student();
//getClass()
System.out.println(student1.getClass());
//输出:class com.mlt.common.object.demo01.Student
System.out.println(student2.getClass());
//输出:class com.mlt.common.object.demo01.Student
if (student1.getClass() == student2.getClass()) {
System.out.println("两者类型相同");
} else {
System.out.println("两者类型不同");
}
//输出:两者类型相同
}
}
class Student {
String name;
int age;
}
hashCode()方法
-
public native int hashCode();
-
返回该对象的哈希码值。
-
哈希值是根据对象的地址或字符串或数字使用hash算法计算出来的int类型的值。
-
一般情况下相同对象返回相同哈希码,一般用来判断两个对象是否是同一个。
代码:
package com.mlt.common.object;
public class Demo01 {
public static void main(String[] args) {
Student student1 = new Student();
Student student2 = new Student();
//hashCode()
System.out.println(student1.hashCode()); //输出:1694819250
System.out.println(student2.hashCode()); //输出:1365202186
Student student3 = student2;
System.out.println(student3.hashCode()); //输出:1365202186。student2和student3的地址一样。
}
}
class Student {
String name;
int age;
}
toString()方法
-
public String toString() { return getClass().getName() + "@" + Integer.toHexString(hashCode()); }
-
返回该对象的字符串表示(表现形式)。
-
可以根据程序需求重写覆盖该方法,如:展示对象各个属性值。
代码:
public class Demo {
public static void main(String[] args) {
Student student1 = new Student();
Student student2 = new Student();
//toString()
System.out.println(student1.toString());
//输出:com.mlt.common.object.demo03.Student@6504e3b2
System.out.println(student2.toString());
//输出:com.mlt.common.object.demo03.Student@515f550a
Teacher teacher = new Teacher("麻辣烫", 18);
System.out.println(teacher.toString());
//输出:Teacher [name=麻辣烫, age=18]
}
}
class Student {
String name;
int age;
}
class Teacher {
String name;
int age;
//无参构造器
public Teacher() {
}
//有参构造器
public Teacher(String name, int age) {
this.name = name;
this.age = age;
}
//重写方法
@Override
public String toString() {
return "Teacher [name=" + name + ", age=" + age + "]";
}
}
equals()方法
-
public boolean equals(Object obj) { return (this == obj); }
-
比较两个对象地址是否相同。
-
可以进行重写覆盖,比较两个对象内容是否相同。
代码:
public class Demo {
public static void main(String[] args) {
Student student1 = new Student();
Student student2 = new Student();
Student student3 = student2;
//equals()
System.out.println(student1.equals(student2)); //输出:false
System.out.println(student2.equals(student3)); //输出:true
Teacher teacher1 = new Teacher("麻辣烫", 18);
Teacher teacher2 = new Teacher("麻辣烫", 18);
Teacher teacher3 = new Teacher("麻辣烫", 20);
System.out.println(teacher1.equals(teacher2)); //输出:true
System.out.println(teacher1.equals(student3)); //输出:false
}
}
class Student {
String name;
int age;
}
class Teacher {
String name;
int age;
//无参构造器
public Teacher() {
}
//有参构造器
public Teacher(String name, int age) {
this.name = name;
this.age = age;
}
// 重写 改变其比较内容
/*
步骤 1. 比较两个应用是否指向同一个对象
2. 判断obj是否为null
3. 判断两个引用只想的实际对象类型是否一致
4. 强制类型转换
5. 依次比较各个属性值是否相同
*/
@Override
public boolean equals(Object obj) {
//1. 比较两个应用是否指向同一个对象
if (this == obj) {
return true;
}
//2. 判断obj是否为null
if (obj == null) {
return false;
}
//3. 判断两个引用指向的实际对象类型是否一致
// if(this.getClass() == obj.getClass()){
//
// }
// instanceof 判断对象是否是某种类型
if (obj instanceof Teacher) {
//4. 强制类型转换
Teacher teacher = (Teacher) obj;
//5. 比较属性
if (this.name.equals(teacher.name) && this.age == teacher.age) {
return true;
}
}
return false;
}
}
finalize()方法
- 当对象被判定为垃圾对象时,由JVM自动调用此方法,用以标记垃圾对象,进入回收队列。
- 垃圾对象:没有有效引用指向此对象时,为垃圾对象。
- 垃圾回收:由gc销毁垃圾对象,释放数据存储空间。
- 自动回收机制:JVM的内存耗尽,一次性回收所有垃圾对象。
- 手动回收机制:使用
System.gc();
通知JVM执行垃圾回收。
代码:
public class Demo {
public static void main(String[] args) {
Student student = new Student("AAA",21);
new Student("BBB",21);
new Student("CCC",21);
new Student("DDD",21);
//finalize()
System.gc();
System.out.println("垃圾回收:");
/*
垃圾回收:
BBB被回收了!
DDD被回收了!
CCC被回收了!
*/
}
}
class Student {
String name;
int age;
//无参构造器
public Student() {}
//有参构造器
public Student(String name, int age) {
this.name = name;
this.age = age;
}
//重写方法
@Override
protected void finalize() throws Throwable {
System.out.println(this.name + "被回收了!");
}
}
包装类
-
基本数据类型所对应的引用数据类型。
-
Object 可统一所有数据,包装类的默认值是null。
基本数据类型 | 包装类型 |
---|---|
byte | Byte |
short | Short |
int | Integer |
long | Long |
float | Float |
double | Double |
boolean | Boolean |
char | Character |
类型转换与装箱、拆箱
- 装箱:把基本类型转换为引用类型。
- 拆箱:把引用类型转换为基本类型。
- 8种包装类提供不用类型间的转换方式。
- Number父类中提供的6个共性方法。
parseXXX( )
静态方法:String转换为XXX类型。XXX.valueOf(yyy)
:静态方法 yyy转换为XXX。
代码:
public class PackagingClass {
public static void main(String[] args) {
// 装箱:基本类型 → 引用类型
// 基本类型
int num1 = 18;
//使用Integer类创建对象
Integer integer1 = new Integer(num1);
Integer integer2 = Integer.valueOf(num1);
System.out.println("装箱:");
System.out.println(integer1); //输出:18
System.out.println(integer2); //输出:18
// 拆箱:引用类型 → 基本类型
Integer integer3 = new Integer(100);
int num2 = integer3.intValue();
System.out.println("拆箱:");
System.out.println(num2); //输出:100
//上述为jdk1.5之前方法,之后提供了自动装箱和拆箱
int num3 = 33;
//自动装箱
Integer integer4 = num3;
System.out.println("自动装箱:");
System.out.println(integer4); //输出:33
//自动拆箱
int num4 = integer4;
System.out.println("自动拆箱:");
System.out.println(num4); //输出:33
//基本类型和字符串之间转换
System.out.println("---------基本类型和字符串之间转换-----------");
//1.基本类型转成字符串
int number1 = 15;
//1.1 使用"+"
String string1 = number1 + "";
//1.2 使用Integer中的toString()方法
String string2 = Integer.toString(number1);
String string3 = Integer.toString(number1, 16); //第二个参数radix为进制要求
String string4 = Integer.toHexString(number1); //将一个整数转换为十六进制字符串
System.out.println(string1); //输出:15
System.out.println(string2); //输出:15
System.out.println(string3); //输出:f
System.out.println(string4); //输出:f
//2.字符串转换成基本类型
String string5 = "150";
//使用Integer.parseXXX();
int number2 = Integer.parseInt(string5);
System.out.println(number2); //输出:150
//3.boolean字符串形式转成基本类型
//"true" ———> true
//非"true"的任何 ———> false
String string6 = "true";
String string7 = "false";
String string8 = "study";
Boolean bool1 = Boolean.parseBoolean(string6);
Boolean bool2 = Boolean.parseBoolean(string7);
Boolean bool3 = Boolean.parseBoolean(string8);
System.out.println(bool1); //输出:ture
System.out.println(bool2); //输出:false
System.out.println(bool3); //输出:false
}
}
整数缓冲区
-
Java中的Integer缓冲区是在内部维护了一个缓存池,由其维护在范围-128到127之间所有的整数对象。当使用
valueOf
方法创建整数对象时,如果值在缓存池范围内,则直接从缓存池中返回该对象,否则创建新的对象。缓存池可以减少系统中创建的对象数量,节省了内存。 -
Java预先创建了256个常用的整数包装类型对象。
-
在实际应用当中,对已创建的对象进行复用。
代码:
public class IntegerBuffer {
public static void main(String[] args) {
//面试题
//面试题1:下面的输出结果为true还是为flase?
Integer integer1 = new Integer(100);
Integer integer2 = new Integer(100);
System.out.println(integer1 == integer2); //输出:false
//答案:integer1和integer2在栈空间,而它们的值存在堆空间;对比时比的是integer1和integer2在栈空间的地址,所以结果为false。
//面试题2:下面的输出结果为true还是为flase?
Integer integer3 = 100; //自动装箱
Integer integer4 = Integer.valueOf(100); //自动装箱,自动装箱其实就相当于调用了Integer.valueOf方法
System.out.println(integer3 == integer4); //输出:true
//答案:integer3和integer4都用了自动装箱的方式,Integer缓冲区的范围为-128-127之间,integer3和integer4定义的值为100,在这范围内,直接从缓存池中返回该对象,所以返回对象存储的地址一致,结果为true。
//面试题3:下面的输出结果为true还是为flase?
Integer integer5 = 200;//自动装箱
Integer integer6 = Integer.valueOf(200); //自动装箱,自动装箱其实就相当于调用了Integer.valueOf方法
System.out.println(integer5 == integer6); //输出:false
//答案:integer5和integer6都用了自动装箱的方式,Integer缓冲区的范围为-128-127之间,integer5和integer6定义的值为200,超出Integer缓冲区范围,需要创建新的对象,在堆中开辟一个新的空间(new Integer),integer5和integer6在栈中指向不同地址,所以返回对象存储的地址不一致,结果为flase。
//查看valueOf方法源码,缓存区范围为[-128, 127],在这之内对象复用,地址一样
}
}
String类
- 字符串是常量,创建之后不可改变。
- 字符串字面值存储在字符串池中,可以共享。
- 字符串创建两种方式:
String s = "Hello";
产生一个对象,字符串池中存储。String s = new String("Hello");
产生两个对象,堆、池各一个。
不可变性
字符串是常量,创建之后不可改变。
代码:
//String类 不可变性
public class Demo {
public static void main(String[] args) {
String name = "hello"; //"hello"常量存储在字符串池中
name = "zhangsan"; //将"zhangsan"赋值给name变量,给字符串赋值时,并没有修改数据,而是重新开辟一个空间储存新数据
String name2 = "zhangsan";
System.out.println(name == name2); //输出:true
}
}
代码内存分析:
⭐️这里的内存分析中,字符串池在方法区中,但是不同版本的jdk,字符串池的位置不唯一。
new创建String对象
String s = new String("Hello");
产生两个对象,堆、池各一个。
代码:
//String类 new创建String对象
public class Demo {
public static void main(String[] args) {
String str = new String("java");
String str2 = new String("java");
System.out.println(str == str2); //输出:false
System.out.println(str.equals(str2)); //输出:true
/*
在Java中,==和equals()都用于比较字符串是否相等,但它们有所不同。
1.==操作符用于比较引用地址是否相同。如果两个字符串变量指向同一个字符串常量或者new出来的同一个String对象,则==结果为true。
2.equals()方法用于比较字符串的内容是否相等。如果两个字符串的内容相同,不论是否是同一个对象,equals()都会返回true。
*/
}
}
代码内存分析:
常用方法
- length(); 返回字符串长度
- charAt(int index); 返回某个位置的字符
- contains(String str); 判断是否包含某个字符串
- toCharArray(); 返回字符串对应数组
- indexOf(); 返回子字符串首次出现的位置
- lastIndexOf(); 返回子字符串最后一次出现的位置
- trim(); 去掉字符串前后空格
- toUpperCase(); toLowerCase(); 转换大小写
- endsWith(str); startsWith(str); 判断是否以str 结尾、开头
- replace(char old, char new); 用新的字符或字符串替换旧的字符或字符串
- split(); 对字符串拆分
- equals/compareTo(); 比较大小
代码:
import java.util.Arrays;
//String类 常用方法
public class Demo03 {
public static void main(String[] args) {
//常用方法
String content = "java是最好的语言,java真香";
//1.length();返回字符串长度
System.out.println(content.length()); //输出:17
//2.charAt(int index);返回某个位置的字符
System.out.println(content.charAt(content.length() - 1)); //输出:香
//3.contains(String str);判断是否包含某个字符串
System.out.println(content.contains("java")); //输出:true
//4.toCharArray();返回字符串对应的数组
System.out.println(Arrays.toString(content.toCharArray())); //输出:[j, a, v, a, 是, 最, 好, 的, 语, 言, ,, j, a, v, a, 真, 香]
//5.indexOf();返回子字符串首次出现的位置
System.out.println(content.indexOf("java")); //输出:0
System.out.println(content.indexOf("java", 4)); //从索引4开始找。输出:11
//6.lastIndexOf();返回子字符串最后一次出现的位置
System.out.println(content.lastIndexOf("java")); //输出:11
//7.trim();去掉字符串前后的空格
String ct = " Hello World ";
System.out.println(ct.trim()); //输出:Hello World
//8.toUpperCase();toLowerCase();转换大小写
System.out.println(ct.toUpperCase()); //输出: HELLO WORLD
System.out.println(ct.toLowerCase()); // hello world
//9.endsWith(str);startsWith(str);判断是否以str结尾、开头
System.out.println(content.endsWith("java")); //输出false
System.out.println(content.startsWith("java")); //输出true
//10.replace(char old, char new);用新的字符或字符串替换旧的字符或字符串
System.out.println(content.replace("java", "php")); //输出:php是最好的语言,php真香
//11.split();对字符串拆分
String say = "java is the best language。。。java no.1";
String[] arr = say.split(" "); // "[ ,]+" 表示空格、逗号切分。+号表示切分可以多个,比如多个空格。
System.out.println(arr.length); //输出:6
System.out.println(Arrays.toString(arr)); //输出:[java, is, the, best, language。。。java, no.1]
String[] arr1 = say.split("[ 。]"); //用空格或句号分隔
System.out.println(Arrays.toString(arr1)); //输出:[java, is, the, best, language, , , java, no.1]
String[] arr2 = say.split("[ 。]+"); //用连续多个空格或句号分隔
System.out.println(Arrays.toString(arr2)); //输出:[java, is, the, best, language, java, no.1]
//12.equals/compareTo();比较大小
String s1 = "hello";
String s2 = "HELLO";
System.out.println(s1.equals(s2)); //输出:false
System.out.println(s1.equalsIgnoreCase(s2)); //忽略大小写比较。输出:true
//compareTo();
//两字符不同时顺序依次比较字符字典序的ascii码,返回差值
//字符相同时比较长度,返回差值
String s3 = "abc"; //a:97
String s4 = "xyz"; //x:120
System.out.println(s3.compareTo(s4)); //输出:-23
String s5 = "abc"; //b:98
String s6 = "aaa"; //a:97
System.out.println(s5.compareTo(s6)); //顺序依次比较。输出:1
String s7 = "abc";
String s8 = "abcdef";
System.out.println(s7.compareTo(s8)); //相同时比较长度。输出:-3
}
}
String类练习题
题目要求:
- 已知String str = “this is a text”;
- 将str中的单词单独获取
- 将str中的text替换成practice
- 在text前面插入一个easy
- 将每个单词的首字母改为大写
代码:
import java.util.Arrays;
//String类 练习题
public class Demo04 {
public static void main(String[] args) {
/*
题目要求:
1.已知String str = “this is a text”;
2.将str中的单词单独获取
3.将str中的text替换成practice
4.在text前面插入一个easy
5.将每个单词的首字母改为大写
*/
String str = "this is a text";
String[] words = str.split(" ");
System.out.println(Arrays.toString(words)); //输出:[this, is, a, text]
String strReplace = str.replace("text", "practice");
System.out.println(strReplace); //输出:this is a practice
String strInsert = str.replace("text", "easy text");
System.out.println(strInsert); //输出:this is a easy text
String newWords = "";
for (int i = 0; i < words.length; i++) {
String oldWord = words[i];
String newWord = oldWord.substring(0, 1).toUpperCase() + oldWord.substring(1);
if (i == 0) {
newWords += newWord;
} else {
newWords += " " + newWord;
}
}
System.out.println(newWords); //输出:This Is A Text
}
}
可变字符串
- StringBuffer : 可变长字符串,运行效率慢、线程安全。
- StringBuilder : 可变长字符串,运行效率快、线程不安全。
比String效率高且节省内存。
常用方法
//StringBuffer/StringBuilder类 可变字符串
public class Demo {
public static void main(String[] args) {
//StringBuffer和StringBuilder用法一致
StringBuffer sb = new StringBuffer();
//1.append();追加
sb.append("java 世界第一");
System.out.println(sb.toString()); //输出:java 世界第一
System.out.println(sb); //jdk1.8默认调用toString。输出:java 世界第一
//2.insert();添加、插入
sb.insert(0, "最前面");
System.out.println(sb); //输出:最前面java 世界第一
//3.replace();替换
sb.replace(0, 1, "hello"); //左闭右开
System.out.println(sb); //输出:hello前面java 世界第一
//4.delete();删除
sb.delete(0, 5); //左闭右开
System.out.println(sb); //输出:前面java 世界第一
//5.清空
sb.delete(0, sb.length());
System.out.println(sb.length()); //输出:0
}
}
StringBuffer/StringBuilder类与String类效率比较
//StringBuffer/StringBuilder类与String类效率比较
public class Demo {
public static void main(String[] args) {
String str = "";
long startTime = System.currentTimeMillis();
for (int i = 0; i < 99999; i++) {
str += i;
}
long endTime = System.currentTimeMillis();
System.out.println("String耗时:" + (endTime - startTime)); //输出:String耗时:18709
StringBuffer sb = new StringBuffer();
startTime = System.currentTimeMillis();
for (int i = 0; i < 99999; i++) {
sb.append(i);
}
endTime = System.currentTimeMillis();
System.out.println("StringBuffer耗时:" + (endTime - startTime)); //输出:StringBuffer耗时:13
}
}
BigDecimal
- 位置:
java.math
包中。 - 作用:精确计算浮点数。
- 创建方式:
BigDecimal bd = new BigDecimal("1.0");
代码:
import java.math.BigDecimal;
//BigDecimal类
public class Demo {
public static void main(String[] args) {
double d1 = 1.0;
double d2 = 0.9;
System.out.println(d1 - d2); //输出:0.09999999999999998
//注意使用字符串的参数
BigDecimal bigDecimal1 = new BigDecimal("1.0");
BigDecimal bigDecimal2 = new BigDecimal("0.9");
//1.减法
BigDecimal result1 = bigDecimal1.subtract(bigDecimal2);
System.out.println(result1); //输出:0.1
//2.加法
BigDecimal result2 = bigDecimal1.add(bigDecimal2);
System.out.println(result2); //输出:1.9
//3.乘法
BigDecimal result3 = bigDecimal1.multiply(bigDecimal2);
System.out.println(result3); //输出:0.90
//4.除法 (1.4-0.5)/0.9
BigDecimal result4 = new BigDecimal("1.4")
.subtract(new BigDecimal("0.5"))
.divide(new BigDecimal("0.9"));
System.out.println(result4); //输出:1
//注意:如果除不尽不会报错
// BigDecimal result5 = new BigDecimal("10").divide(new BigDecimal("3"));
BigDecimal result6 = new BigDecimal("10").divide(new BigDecimal("3"), 2, BigDecimal.ROUND_HALF_UP); //保留两位小数,四舍五入
System.out.println(result6); //输出:3.33
}
}
Date类
- Date表示特定的瞬间,精确到毫秒。
- Date类中的大部分方法都已经被Calendar类中的方法所取代。
- 时间单位:1s = 1,000ms = 1,000,000 μs = 1,000,000,000 = ns
代码:
import java.util.Date;
//Date类
public class Demo {
public static void main(String[] args) {
//1.创建Date对象
Date date1 = new Date();
System.out.println(date1); //jdk1.8默认调用toString。输出:Wed Sep 04 18:29:06 CST 2024
System.out.println(date1.toLocaleString()); //输出:04-Sep-2024 18:29:06
//创建昨天的
Date date2 = new Date(date1.getTime() - (60 * 60 * 24 * 1000)); //今天减去一天的毫秒数
System.out.println(date2); //输出:Tue Sep 03 18:29:06 CST 2024
//2.比较两个日期的先后顺序:after before
boolean b1 = date1.after(date2);
System.out.println(b1); //输出:true
boolean b2 = date1.before(date2);
System.out.println(b2); //输出:false
//比较compareTo();
//该方法接受一个Date对象作为参数,并返回一个整数值。如果调用该方法的Date对象在参数Date对象之前,则返回一个负数;如果调用该方法的Date对象在参数Date对象之后,则返回一个正数;如果两个Date对象相等,则返回0。
System.out.println(date1.compareTo(date2)); //输出:1
System.out.println(date2.compareTo(date1)); //输出:-1
System.out.println(date1.compareTo(date1)); //输出:0
//比较是否相等 equals
System.out.println(date1.equals(date2)); //输出:false
System.out.println(date1.equals(date1)); //输出:true
}
}
Calendar类
- Calendar提供了获取或设置各种日历字段的方法。
- 构造方法
protected Calendar();
由于是protected 所以无法直接创建。 - 其他方法。
方法名 | 说明 |
---|---|
static Calendar getInstance() | 使用默认时区和区域获取日历 |
void set(int year, int month, int date, int hourofday, int minute, int second) | 设置日历的年、月、日、时、分、秒 |
int get(int field) | 返回给定日历字段的值。字段比如年、月、日 |
void setTime(Date date) | 用给定的date设置此日历时间 |
Date getTime() | 返回一个date表示此日历的时间 |
void add(int field, int amount) | 按照日历的规则,给指定字段添加或减少时间量 |
long getTimeInMilles() | 毫秒为单位返回该日历的时间值 |
代码:
import java.util.Calendar;
//Calendar类
public class Demo01 {
public static void main(String[] args) {
//1.创建Calendar对象
Calendar calendar = Calendar.getInstance();
System.out.println(calendar.getTime().toString()); //输出:Fri Sep 06 21:40:01 CST 2024
//2.获取时间信息
//获取年
int year = calendar.get(Calendar.YEAR);
//获取月 从0到11
int month = calendar.get(Calendar.MONTH);
month += 1;
//获取日
int day = calendar.get(Calendar.DAY_OF_MONTH);
//获取小时
int hour = calendar.get(Calendar.HOUR_OF_DAY);
//获取分钟
int minute = calendar.get(Calendar.MINUTE);
//获取秒
int second = calendar.get(Calendar.SECOND);
//获取毫秒
int millisecond = calendar.get(Calendar.MILLISECOND);
//获取星期
//星期几的值是从1开始的,1代表星期日,2代表星期一,依次类推
int week = calendar.get(Calendar.DAY_OF_WEEK);
week = week == Calendar.SUNDAY ? Calendar.SATURDAY : week - 1 ;
System.out.println(year + "年" + month + "月" + day + "日" + "星期" + week + " " + hour + "时" + minute + "分" + second + "秒" + millisecond + "毫秒");
//输出:2024年9月6日星期5 22时5分28秒399毫秒
//3.设置时间
Calendar calendar1 = Calendar.getInstance();
calendar1.set(2022, 1, 10, 0, 0, 0);
System.out.println(calendar1.getTime().toString()); //输出:Sat Feb 12 00:00:00 CST 2022
//4.修改时间
calendar1.add(Calendar.DAY_OF_MONTH,1);
System.out.println(calendar1.getTime().toString()); //输出:Sun Feb 13 00:00:00 CST 2022
calendar1.add(Calendar.DAY_OF_MONTH,-3);
System.out.println(calendar1.getTime().toString()); //输出:Thu Feb 10 00:00:00 CST 2022
//5.补充方法
int max = calendar1.getActualMaximum(Calendar.DAY_OF_MONTH); //月数最大天数
System.out.println(max); //输出:28
int min = calendar1.getMinimum(Calendar.DAY_OF_MONTH); //月数最小天数
System.out.println(min); //输出:1
}
}
SimpleDateFormat类
- SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类。
- 进行格式化(日期→文本)、解析(文本→日期)。
- 常用的时间模式字母。
字母 | 日期或时间 | 示例 |
---|---|---|
y | 年 | 2019 |
M | 年中月份 | 08 |
d | 月中天数 | 10 |
H | 一天中小时(0-23) | 22 |
m | 分钟 | 16 |
s | 秒 | 59 |
S | 毫秒 | 356 |
代码:
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
//SimpleDateFormat类
public class Demo {
public static void main(String[] args) {
System.out.println("-----格式化-----");
//1.创建SimpleDateFormat对象
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//2.创建Date对象
Date date = new Date();
//3.格式化date
String formatDate = simpleDateFormat.format(date);
System.out.println(formatDate); //输出:2024-09-06 22:32:53
System.out.println("-----解析-----");
try {
Date date2 = simpleDateFormat.parse("2022-02-25 16:03:50"); //可能存在无法解析的异常,格式不符合 ParseException
System.out.println(date2); //输出:Fri Feb 25 16:03:50 CST 2022
} catch (ParseException e) {
e.printStackTrace();
}
}
}
System类
主要用于获取系统的属性数据和其他操作,构造方法私有的。
方法名 | 说明 |
---|---|
static void arraycopy(…); | 复制数组 |
static long currentTimeMillis(); | 获取当前系统时间,返回毫秒值 |
static void gc(); | 建议jvm赶快启动垃圾回收期器回收垃圾 |
static void exit(int status); | 退出jvm如果参数是0表示正常退出jvm 非0表示异常退出 |
代码:
import java.util.Arrays;
//System类
public class Demo {
public static void main(String[] args) {
//1.arraycopy复制
//scr-原数组 srcPos-从哪个位置开始复制0 dest-目标数组 destPos-目标数组的位置 length-复制的长度
int[] arr = {1, 2, 3, 4, 5};
int[] dest = new int[5];
System.arraycopy(arr, 0, dest, 0, arr.length);
System.out.println(Arrays.toString(dest)); //输出:[1, 2, 3, 4, 5]
//2.获取毫秒数
System.out.println(System.currentTimeMillis()); //1970.1.1到现在的毫秒数,常用来计时
//3.System.gc();告诉垃圾回收器回收垃圾
new Student("麻辣烫", 18);
System.gc(); //输出:麻辣烫被回收了!
//4.退出jvm
System.exit(0); //后面的代码不会执行
System.out.println("程序结束");
}
}
class Student {
String name;
int age;
//无参构造器
public Student() {
}
//有参构造器
public Student(String name, int age) {
this.name = name;
this.age = age;
}
//重写方法
@Override
protected void finalize() throws Throwable {
System.out.println(this.name + "被回收了!");
}
}
Math类
算数计算
Math.sqrt()
: 计算算术平方根Math.cbrt()
: 计算立方根Math.pow(a, b)
: 计算a的b次方Math.max(a, b)
: 计算最大值Math.min(a, b)
: 计算最小值Math.abs()
: 取绝对值
代码:
//Math类
//算数计算
public class Demo01 {
public static void main(String[] args) {
//1.Math.sqrt() 计算算数平方根
Double res1 = Math.sqrt(16);
System.out.println(res1); //输出:4.0
//2.Math.cbrt() 计算立方根
Double res2 = Math.cbrt(8);
System.out.println(res2); //输出:2.0
//3.Math.pow(a, b)计算a的b次方
Double res3 = Math.pow(2, 3);
System.out.println(res3); //输出:8.0
//4.Math.max(a, b) 计算最大值
int res4 = Math.max(2, -3);
System.out.println(res4); //输出:2
//5.Math.min(a, b) 计算最小值
int res5 = Math.min(2, -3);
System.out.println(res5); //输出:-3
//6.Math.abs() 取绝对值
int res6 = Math.abs(-3);
System.out.println(res6); //输出:3
}
}
进位
Math.ceil()
:天花板的意思,就是逢余进一,返回double值。
Math.floor()
:地板的意思,就是逢余舍一,返回double值。
Math.rint()
:四舍五入,返回double值。注意.5的时候会取偶数。
Math.round()
:四舍五入,float时返回int值,double时返回long值。
代码:
//Math类
//进位
public class Demo {
public static void main(String[] args) {
//ceil:天花板的意思,就是逢余进一,返回double值
System.out.println(Math.ceil(-10.1)); //输出:-10.0
System.out.println(Math.ceil(10.7)); //输出:11.0
System.out.println(Math.ceil(-0.7)); //输出:-0.0
System.out.println(Math.ceil(0.0)); //输出:0.0
System.out.println(Math.ceil(-0.0)); //输出:-0.0
System.out.println(Math.ceil(-1.7)); //输出:-1.0
System.out.println("-------------");
//floor:地板的意思,就是逢余舍一,返回double值
System.out.println(Math.floor(-10.1)); //输出:-11.0
System.out.println(Math.floor(10.7)); //输出:10.0
System.out.println(Math.floor(-0.7)); //输出:-1.0
System.out.println(Math.floor(0.0)); //输出:0.0
System.out.println(Math.floor(-0.0)); //输出:-0.0
System.out.println(Math.floor(-1.7)); //输出:-2.0
System.out.println("-------------");
//rint:四舍五入,返回double值。注意.5的时候会取偶数 异常的尴尬=。=
System.out.println(Math.rint(10.1)); //输出:10.0
System.out.println(Math.rint(10.7)); //输出:11.0
System.out.println(Math.rint(11.5)); //输出:12.0
System.out.println(Math.rint(10.5)); //输出:10.0
System.out.println(Math.rint(10.51)); //输出:11.0
System.out.println(Math.rint(-10.5)); //输出:-10.0
System.out.println(Math.rint(-11.5)); //输出:-12.0
System.out.println(Math.rint(-10.51)); //输出:-11.0
System.out.println(Math.rint(-10.6)); //输出:-11.0
System.out.println(Math.rint(-10.2)); //输出:-10.0
System.out.println("-------------");
//round:四舍五入,float时返回int值,double时返回long值
System.out.println(Math.round(10)); //输出:10
System.out.println(Math.round(10.1)); //输出:10
System.out.println(Math.round(10.7)); //输出:11
System.out.println(Math.round(10.5)); //输出:11
System.out.println(Math.round(10.51)); //输出:11
System.out.println(Math.round(-10.5)); //输出:-10
System.out.println(Math.round(-10.51)); //输出:-11
System.out.println(Math.round(-10.6)); //输出:-11
System.out.println(Math.round(-10.2)); //输出:-10
}
}
随机数
随机数产生有两种方式:
-
java.lang.Math.Random下的random方法,
Math.random()
只能产生 double 类型的 0~1 的随机数。 -
java.util.Random,Random 类提供了丰富的随机数生成方法,可以产生 boolean、int、long、float、byte 数组以及 double 类型的随机数,这是它与 random() 方法最大的不同之处。
- 构造方法有两种:
Random()
:该构造方法使用一个和当前系统时间对应的数字作为种子数,然后使用这个种子数构造 Random 对象。Random(long seed)
:使用单个 long 类型的参数创建一个新的随机数生成器。
-
⭐️伪随机数,都是根据seed进行计算所得。
方法 | 说明 |
---|---|
boolean nextBoolean() | 生成一个随机的 boolean 值,生成 true 和 false 的值概率相等。 |
double nextDouble() | 生成一个随机的 double 值,数值介于 [0,1.0),含 0 而不包含 1.0。 |
int nextlnt() | 生成一个随机的 int 值,该值介于 int 的区间,也就是 -231~231-1。如果需要生成指定区间的 int 值,则需要进行一定的数学变换。 |
int nextlnt(int n) | 生成一个随机的 int 值,该值介于 [0,n),包含 0 而不包含 n。如果想生成指定区间的 int 值,也需要进行一定的数学变换。 |
void setSeed(long seed) | 重新设置 Random 对象中的种子数。设置完种子数以后的 Random 对象 和相同种子数使用 new 关键字创建出的 Random 对象相同。 |
long nextLong() | 返回一个随机长整型数字。 |
boolean nextBoolean() | 返回一个随机布尔型值。 |
float nextFloat() | 返回一个随机浮点型数字。 |
double nextDouble() | 返回一个随机双精度值。 |
代码:
import java.util.Random;
//Math类
//随机数
public class Demo03 {
public static void main(String[] args) {
System.out.println("Math.random方法生成随机数");
System.out.println("生成的[0,1.0)区间的小数是" + Math.random());
System.out.println("Random类生成随机数");
Random random = new Random();
double randomDouble1 = random.nextDouble(); //生成[0,1.0)区间的小数
double randomDouble2 = random.nextDouble() * 7; //生成[0,7.0)区间的小数
int randomInt1 = random.nextInt(10); //生成[0,10)区间的整数
int randomInt2 = random.nextInt(18) - 3; //生成[-3,15)区间的整数
long randomLong1 = random.nextLong(); //生成一个随机长整型值
boolean randomBoolean1 = random.nextBoolean(); //生成一个随机布尔型值
float randomFloat1 = random.nextFloat(); //生成一个随机浮点型值
System.out.println("生成的[0,1.0)区间的小数是:" + randomDouble1);
System.out.println("生成的[0,7.0)区间的小数是:" + randomDouble2);
System.out.println("生成的[0,10)区间的整数是:" + randomInt1);
System.out.println("生成的[-3,15)区间的整数是:" + randomInt2);
System.out.println("生成一个随机长整型值:" + randomLong1);
System.out.println("生成一个随机布尔型值:" + randomBoolean1);
System.out.println("生成一个随机浮点型值:" + randomFloat1);
System.out.println("下期七星彩开奖号码预测:");
for (int i = 1; i < 8; i++) {
int num = random.nextInt(10); //生成[0,9]区间的整数
System.out.print(num);
}
System.out.println();
System.out.println("伪随机数证明");
//根据seed进行计算所得
Random random1 = new Random(100);
System.out.println(random1.nextDouble()); //输出:0.7220096548596434
Random random2 = new Random(100);
System.out.println(random2.nextDouble()); //输出:0.7220096548596434
}
}
UUID
UUID 是指在一台机器上生成的数字,它保证对在同一时空中的所有机器都是唯一的。通常平台会提供生成的API。按照开放软件基金会(OSF)制定的标准计算,用到了以太网卡地址、纳秒级时间、芯片ID码和许多可能的数字。
而标准的UUID格式为:xxxxxxxx-xxxx-xxxx-xxxxxx-xxxxxxxxxx (8-4-4-4-12),其中每个 x 是 0-9 或 a-f 范围内的一个十六进制的数字。
代码:
import java.util.UUID;
//Math类
//UUID
public class Demo04 {
public static void main(String[] args) {
System.out.println("唯一标识符UUID");
UUID uuid = UUID.fromString("46400000-8cc0-11bd-b43e-10d46e4ef14d");
UUID randomUUID = uuid.randomUUID();
System.out.println("uuid.toString():" + uuid.toString()); //通过String变量构造对象访问
System.out.println("uuid.randomUUID():" + randomUUID); //通过对象访问
System.out.println("UUID.randomUUID().toString():" + UUID.randomUUID().toString()); //通过类名访问
/*
运行结果:
唯一标识符UUID
uuid:46400000-8cc0-11bd-b43e-10d46e4ef14d
uuid.randomUUID():3da97690-807f-4eed-918b-9071cacfbfb9
UUID.randomUUID().toString():b7b415f3-4c8e-4951-8083-382030623708
*/
}
}
File类(操作文件)
构造方法
-
通过给定的父抽象路径名和子路径名字符串创建一个新的File实例。
File(File parent, String child);
-
通过将给定路径名字符串转换成抽象路径名来创建一个新File实例。
File(String pathname);
-
根据parent路径名字符串和child路径名字符串创建一个新File实例。
File(String parent, String child);
-
通过将给定的 file:URI 转换成一个抽象路径名来创建一个新的File实例。
File(URI uri);
相对路径表示方法
. | 表示当前目录,相对路径。 |
---|---|
… | 代表上一层目录,相对路径。 |
…/…/ | 上一层目录的上一层目录,相对路径。 |
/ | 根目录,绝对路径。 |
D:/New folder/ | 物理路径,绝对路径。 |
⭐️注意包和文件夹的区别,package是包的意思,不是文件夹路径。
1.创建
目录分割符:在Windows机器上的目录分隔符是\,在Linux机器上的目录分隔符是/
注意:在Windows上面\与/都可以作为目录分隔符。而且,如果写/的时候,只需要写1个正斜杠即可,而写\的时候,需要写2个反斜杠(转义字符)。
-
创建文件:
注意:需要进行异常处理。
createNewFile(); //成功返回true
-
创建文件夹:
mkdir(); //创建文件夹,如果父级路径不在,则文件夹创建失败 mkdirs(); //创建文件夹,如果父级路径不在,则自动创建父级路径,再创建子级路径
-
renameTo(File dest):重命名文件或文件夹。文件路径不同时,相当于文件的剪切+重命名,剪切的时候不能操作非空文件夹。移动/重命名成功返回true,失败返回false。
当目标文件路径有重名文件或文件夹,重命名失败。
代码:
import java.io.File;
import java.io.IOException;
//创建文件
public class Create {
public static void main(String[] args) {
//创建文件
System.out.println("-----createNewFile-----");
File file1 = new File("E:/java学习/textFile/1.txt");
try {
file1.createNewFile();
System.out.println("创建文件成功");
}catch (IOException e) {
e.printStackTrace();
System.out.println("创建文件失败");
}
//创建文件夹
System.out.println("-----mkdir()-----");
File file2 = new File("E:/java学习/textFile/folder1");
if(file2.mkdir()) {
System.out.println("父级路径存在,创建文件夹成功");
} else {
System.out.println("父级路径存在,创建文件夹失败");
}
File file3 = new File("E:/java学习/textFile/folder2/folder2.1");
if(file3.mkdir()) {
System.out.println("父级路径不存在,创建文件夹成功");
} else {
System.out.println("父级路径不存在,创建文件夹失败");
}
//创建文件夹
System.out.println("-----mkdirs()-----");
File file4 = new File("E:/java学习/textFile/folder2/folder2.1");
if(file4.mkdirs()) {
System.out.println("父级路径不存在,创建文件夹成功");
} else {
System.out.println("父级路径不存在,创建文件夹失败");
}
}
}
2.删除
- 方法名称:delete()
- 使用规范:既可以删除文件,也可以删除文件夹。
- 注意:
- 删除的时候不走回收站,直接删除。
- 不能删除非空文件夹。
- deleteOnExit():在虚拟机终止时,请求删除此抽象路径名的文件或者目录,保证文件异常时也可以删除文件。(注意:谨慎使用)
代码:
import java.io.File;
//删除文件
public class Delete {
public static void main(String[] args) {
//删除文件
System.out.println("-----文件delete-----");
File file1 = new File("E:/java学习/textFile/1.txt");
System.out.println(file1.getPath());
if (file1.delete()) {
System.out.println("文件删除成功");
} else {
System.out.println("文件删除失败");
}
System.out.println(file1.exists()); //查看文件是否存在,存在返回true,不存在返回false
//删除文件夹
System.out.println("-----文件夹delete-----");
File file2 = new File("E:/java学习/textFile/folder1");
System.out.println(file2.getPath());
if (file2.delete()) {
System.out.println("文件夹删除成功");
} else {
System.out.println("文件夹删除失败");
}
System.out.println(file2.exists()); //查看文件夹是否存在,存在返回true,不存在返回false
}
}
3.重命名
方法名称:renameTo(File dest)
注意:
- 方法的调用者是一个File对象,方法的参数是另外一个File对象。
- 调用者是当前修改之前的路径对象,参数是要修改为的路径对象。
- 如果改了父级路径,就是剪切+重命名,如果不改父级路径就是重命名。
代码:
import java.io.File;
//文件重命名
public class Rename {
public static void main(String[] args) {
//文件重命名
System.out.println("-----renameTo-----");
File fileOld = new File("E:/java学习/textFile/1.txt");
System.out.println(fileOld.getPath());
File fileNew = new File("E:/java学习/textFile/folder2/2.txt");
if (fileOld.renameTo(fileNew)) {
System.out.println("重命名成功");
System.out.println(fileOld.getPath());
System.out.println(fileNew.getPath());
} else {
System.out.println("重命名失败");
}
}
}
4.获取
- getName():获取文件或文件夹名称。
- getPath():返回的是绝对路径,可以是相对路径,但是目录要指定。
- getAbsolutePath():获取绝对路径。
- length():获取文件的大小(字节为单位)。
- getParent():获取文件的父路径。
- lastModified():获取文件最后一次修改的时间。
5.判断
- exists():判断指定的文件或者文件夹是否存在。
- isFile():判断是否是一个文件;如果不存在,则为false。
- isDirectory():判断是否是一个文件夹。
- isHidden():判断指定的文件是否是隐藏文件。
- isAbsolute():判断指定的文件或文件夹是否是在绝对路径下。
【推荐】编程新体验,更懂你的AI,立即体验豆包MarsCode编程助手
【推荐】凌霞软件回馈社区,博客园 & 1Panel & Halo 联合会员上线
【推荐】抖音旗下AI助手豆包,你的智能百科全书,全免费不限次数
【推荐】博客园社区专享云产品让利特惠,阿里云新客6.5折上折
【推荐】轻量又高性能的 SSH 工具 IShell:AI 加持,快人一步
· 微软正式发布.NET 10 Preview 1:开启下一代开发框架新篇章
· 没有源码,如何修改代码逻辑?
· DeepSeek R1 简明指南:架构、训练、本地部署及硬件要求
· NetPad:一个.NET开源、跨平台的C#编辑器
· 面试官:你是如何进行SQL调优的?