文章目录
前言
学完Java的基础后需要再学习更多的实用的常用类来进阶学习。
一、常用类有哪些？
（1）Object类
（2）String类
（3）Math类
（4）File类
（5）Data类
（6）包装类
（7）Random类
二、常用类使用方法
1.Object类
注意：Object类主要包含的是：getClass方法，hasCod方法，toString方法，equals方法和finalize方法
0）所用的对象
public class Cat {
private String catName;
private Integer catAge;
public Cat(String catName, Integer catAge) {
this.catName = catName;
this.catAge = catAge;
}
public String getCatName() {
return catName;
}
public void setCatName(String catName) {
this.catName = catName;
}
public Integer getCatAge() {
return catAge;
}
public void setCatAge(Integer catAge) {
this.catAge = catAge;
}
@Override
public String toString(){
return this.catName+this.catAge;
}
}
1）getClass方法
getClass方法一般是用来比较两个类之间是否相同，所以这个方法返回的类型是一个类
代码如下（示例）：public class Test2 {
public static void main(String[] args) {
//getClass用法
Cat ya = new Cat("ya", 12);
Class class1 = ya.getClass();
Cat ma = new Cat("ma", 55);
Class class2 = ma.getClass();
System.out.println(class1==class2);
}
}
最后返回的结果是true
本质在使用getClass后ya 和ma 都会返回一个Cat对象，所以最后比对的时候才会得出true的结果
2）hasCode方法
hasCode方法在Java中是使用hash算法，通过计算对象在堆中的地址从而返回一个int类型的值，通过这个值的比较我们可以知道
代码如下（示例）：public class Test2 {
public static void main(String[] args) {
//hashCode方法
Cat ya = new Cat("ya", 12);
int i = ya.hashCode();
Cat ma = new Cat("ma", 55);
int j = ma.hashCode();
System.out.println(i == j);
System.out.println("hash值i:"+i+"\t"+"hash值j:"+j);
}
}
结果：
false
hash值i:764977973 hash值j:381259350
ya和ma这两个对象在创建的时候，会在堆中开辟出两个地方，而这两个地方的内存地址肯定不相同，所以通过hashCod计算出来的值也肯定不相同，所以最后得出的结果就是false。
3）toString方法
toString方法在Java中如果要使用最好是自己重写这个方法，不然返回的String类型就不是自己所需要的东西，就比如如下没有重写toString方法的时候
代码如下（示例）public class Test2 {
public static void main(String[] args) {
//toString
Cat ya = new Cat("ya", 12);
Cat ma = new Cat("ma", 55);
System.out.println(ya.toString());
System.out.println(ma.toString());
}
}
结果：
Cat@2d98a335
Cat@16b98e56
可以看到没有重写的时候是默认返回了对象类型和一串字符串
那么当我们重写toString方法后，就会返回我们想要的结果了
在对象类中重写代码如下（示例）@Override
public String toString(){
return "猫名字是："+this.catName+"\t"
+"猫年龄是："+this.catAge;
}
这时我们再运行就会发现
得出结果猫名字是：ya 猫年龄是：12
猫名字是：ma 猫年龄是：55
4）equals方法
equals方法在Java中如果要使用也是可以自己重写这个方法，如果不重写，那么在源码中就会是两个对象的地址比较
源代码如下 public boolean equals(Object obj) {
return this == obj;
}
我们可以通过下面的测试代码得出未重写得equals方法
public class Test2 {
public static void main(String[] args) {
//toString
Cat ya = new Cat("ya", 12);
Cat ma = new Cat("ma", 55);
System.out.println(ya.equals(ma));
}
}
得出得结果就是false
此时我们重新创建两个对象，但我们让这两个对象的值相同，此时再使用equals方法依然还会是显示false。所以我们此时在cat类中重写equals方法
重写equalsd的注意事项
(1)比较两个类是否相同
(2)比较obj类是否为空
(3)判断两个引用指向的实际对象是否为同一个
(4)类型强制转换
(5)依次比较属性值是否相同
重写代码如下
@Override
public boolean equals(Object obj){
//1、判断两个类是否相同
if(this.getClass() == obj.getClass()){
return true;
}
//2、判断obj是否为空
if (obj == null){
return false;
}
//3、判断引用指向的实际类型是否相同
if(obj instanceof Cat){
//4、类型强制转换
Cat cat = (Cat)obj;
//5、逐个比较属性值是否相同
if(this.getCatName().equals(cat.getCatName()) ||
this.getCatAge().equals(cat.getCatAge())){
return true;
}
}
return false;
}
在测试类中创建的对象如下
得出得结果就是true
public class Test2 {
public static void main(String[] args) {
//toString
Cat ya = new Cat("ya", 12);
Cat ma = new Cat("ya", 12);
System.out.println(ya.equals(ma));
}
}
5）finalize方法
finalize方法在Java中如果jvm虚拟机的内存不足便会自动释放垃圾对象从而腾出内存，但是我们也可以手动使用System.
当然有人可能会问什么是垃圾对象，垃圾对象就是指没有有效引用指向此对象时就是垃圾类
除此之外我们依旧可以在我们 的对象类中重写我们的finalize方法
@Override
protected void finalize() throws Throwable {
super.finalize();
}
但是当我们重写的时候，编译器会给我们的finalize划上一条横线并给我们这样的提示：
Overrides deprecated method in ‘java.lang.Object’ 覆盖“java.lang.Object”中不推荐使用的方法
2.包装类
1）包装类概述
在Java中有着8大数据类型，分别是byte、short、int、long、float、double、char、引用类型。其中byte、short、int、long、float、double、char各自所对应的引用类型就是包装类
各自的引用类型如下（示例）：
byte ->Byte
short ->Short
long -> Long
int ->Integer
float ->Float
double ->Double
2）装箱、拆箱
我们通常是把基本类型转换成引用类型的过程叫做装箱，反之将引用类型转换成基本类型的过程我们叫做拆箱
而我们可以通过Number类中的valueOf方法来装箱和.对应类型Value来拆箱
这里用int类型来进行演示public class Test2 {
public static void main(String[] args) {
//jdk<1.5
int i = 10;
Integer integer1 = Integer.valueOf(i);
int value = integer1.intValue();
System.out.println(value);
}
}
当然这个是jdk小于1.5的时候需要我们自动装箱和拆箱,当我们的jdk版本大于1.5的时候，就可以实现自动装箱和拆箱了
如下public class Test2 {
public static void main(String[] args) {
//jdk>1.5
int i = 10;
Integer integer1 = i;
int value = integer1;
System.out.println(value);
}
}
而自动装箱和拆箱的原理，当我们把程序的class文件编译回去后我们可以发现，是编译器自动帮我们使用了valueOf方法和intValue方法
3）基本类型转换成String类型，以及String类型转换成基本类型
当我们在做后端的时候时常会接收到前端传来的String类型的数据以及要把基本数据类型转换成String类型的时候，这时候我们就需要用到包装类自带的方法来解决
public class Test2 {
public static void main(String[] args) {
//基本数据类型转换成String类型
int i = 10;
String k = Integer.toString(i);
//String类型转换成基本数据类型
String s = "123";
int j = Integer.parseInt(s);
//parse后面的数据类型可以是任意的基本数据类型
}
}
4）integer的缓冲区
我们可以通过一些代码来深刻理解这个缓冲区
代码如下public class Test2 {
public static void main(String[] args) {
// 1
Integer i1 = new Integer(12);
Integer i2 = new Integer(12);
System.out.println(i1 == i2);
//2
Integer i3 = 100;//Integer.valueOf(100)
Integer i4 = 100;
System.out.println(i3 == i4);
//3
Integer i5 = 200;
Integer i6 = 200;
System.out.println(i5 == i6);
}
}
以上三个代码块的输出结果分别是：false true false.
我们可以看到第一种方法，创建i1 i2的时候都是通过Integer 的有参构造方法完成的所以其都创建一个实际对象，而 == 又比较的是对象的地址所以第一种的结果是false。
而第二、三种方法我们使用了自动装箱，此时省略了Integer.valueOf(100)这个代码，但是明明都是使用的同一种方法，为什么第二种方法得出的结果是true而第三种方法得出的结果是false？
我们可以去看一下valueOf的源代码
@HotSpotIntrinsicCandidate
public static Integer valueOf(int i) {
return i >= -128 && i <= Integer.IntegerCache.high ? Integer.IntegerCache.cache[i + 128] : new Integer(i);
}
这里源码使用了一个三元表达式，当传入的i大于-128且小于IntegerCache.high的结果如果为真则返回IntegerCache.cache数组中的数，但是如果超出这个范围则创建一个新的对象。当我们再点进IntegerCache的源码可以看到
private static class IntegerCache {
static final int low = -128;
static final int high;
static final Integer[] cache;
private IntegerCache() {
}
static {
int h = 127;
String integerCacheHighPropValue = VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
int i;
if (integerCacheHighPropValue != null) {
try {
i = Integer.parseInt(integerCacheHighPropValue);
i = Math.max(i, 127);
h = Math.min(i, 2147483518);
} catch (NumberFormatException var4) {
}
}
high = h;
cache = new Integer[high - -128 + 1];
i = -128;
for(int k = 0; k < cache.length; ++k) {
cache[k] = new Integer(i++);
}
assert high >= 127;
}
这个缓存的大小为一个cache大小为256的数组，最小是大于-128，最大是小于127
所以通过源码我们可以得出，当我们赋值的数在【-128-127】之间的时候，那么就会取这个数组中的元素，所以方法2的i3和i4所指向的是在堆中IntegerCache的100这个元素，所以地址是相同的，但是方法3的i5 和 i6因为已经超出了这个范围，所以三元运算直接判断为false，转而执行创建新对象的方法，而创建新对象后就和第一种方法一模一样了，从而导致了在堆中创建了两个不同的对象，进而在栈中的引用指向的地址也不相同所以才会出现false
3.String类
1)String在内存中的分配
首先在Java中String 的定义有两种方法，一种是直接等于赋值，另一种是对象赋值
示例如下public class Test2 {
public static void main(String[] args) {
String s = "abc";
String s1 = new String("abc");
System.out.println(s == s1);
}
}
这样比较的出的结果是false，因为当直接赋值的时候创建的abc是放在方法区的常量池中，而s则指向常量池中的abc
而当我们使用第二种方法后会在堆中创建一个s1的实际对象对象的内容是abc，而 == 比较的是对象的地址，所以两者得出的结果是false
但此时我们使用.equals后就会显示true的结果了，因为是直接比较值,具体的可以看上面的Object类中的equals方法
2）length方法
length方法一般就是用来判断String字符串的长度
代码如下（示例）public class Test2 {
public static void main(String[] args) {
String s = "abc";
System.out.println(s.length());
}
}
// 输出：3
3）replace方法
当你想要替换掉原字符串中的一个单词或者文字，就可以使用这个方法来实现
给定一个字符串“this is a text”，将text替换成Java 代码如下（示例）
public class Test2 {
public static void main(String[] args) {
String s = "this is a text";
String replace = s.replace("text", "java");
System.out.println(replace);
}
}
其中第一个位置是需要替换的原文本，第二个位置则是替换成的文本
4）charAt方法
通过输入字符串脚标，来获取输入脚标位置的字符串，值得注意的是脚标是从0开始，所以要获取字符串最后一个字符的时候需要length-1
代码如下（示例）public class Test2 {
public static void main(String[] args) {
String s = "this is a text";
System.out.println(s.charAt(2));
System.out.println(s.charAt(s.length()-1));
}
}
//输出：i
// t
5）contains方法
当你需要判断你的字符串中是否有你所需要的字符的时候，就可以使用这个方法，这个方法返回值是一个boolean类型的值
代码如下（示例）public class Test2 {
public static void main(String[] args) {
String s = "this is a text";
System.out.println(s.contains("a"));
}
}
//输出：true
6）toCharArrray方法
把你的字符串转换成一个字符串数组。这个地方可以使用Arrays类中的toString方法来进行字符串数组的打印
代码如下（示例）public class Test2 {
public static void main(String[] args) {
String s = "this is a text";
System.out.println(Arrays.toString(s.toCharArray()));
}
}
7）indexOf方法
寻找你所查找字符第一次出现的地方，而其提供了四种重载的方法
其中常用的就是，indexOf(“str")和indexOf("str",起始位置)
代码如下（示例）public class Test2 {
public static void main(String[] args) {
String s = "this is text a text of text";
System.out.println("第一次找到text的位置:"+s.indexOf("text"));
System.out.println("第二次找到text的位置:"+s.indexOf("text",13));
}
}
8）lastIndexOf方法
Java中为了方便，会提供）lastIndexOf方法来让你寻找你所查找字符最后一次出现的地方
代码如下（示例）public class Test2 {
public static void main(String[] args) {
String s = "this is text a text of text in the world";
System.out.println("text最后出现的位置:"+s.lastIndexOf("text"));
}
}
//输出：text最后出现的位置:23
9）trim方法
如果你的字符串中的开头和结尾有着大量的空格，那么trim方法就可以帮助你去掉这些空格
代码如下（示例）public class Test2 {
public static void main(String[] args) {
String s = " this is text a text of text in the world ";
System.out.println(s.trim());
}
}
//输出：this is text a text of text in the world
10）startsWith方法和endWith方法
这个方法可以检测你字符串的首字符和末尾字符是否是你想要鉴定的字符
代码如下（示例）public class Test2 {
public static void main(String[] args) {
String s = "this is text a text of text in the world";
System.out.println(s.startsWith("this"));
System.out.println(s.endsWith("world"));
}
}
//输出： true true
11）toUpperCase方法和toLowerCase
当你需要把你字符串中的字符全部变成大写或者全部变成小写的时候就可以使用这个方法
代码如下（示例）public class Test2 {
public static void main(String[] args) {
String s = "this is text a text of text in the world";
System.out.println(s.toUpperCase());
System.out.println(s.toLowerCase());
}
}
//输出：THIS IS TEXT A TEXT OF TEXT IN THE WORLD
//this is text a text of text in the world
12）split方法
可以拆分字符串，一般的会以空格为分隔起点，最后会返回一个String类型的数组
代码如下（示例）public class Test2 {
public static void main(String[] args) {
String s = "this is text a text of text in the world";
//仅适合于字符串标准
String[] split = s.split(" ");
for (String s1 : split) {
System.out.print(s1+"\t");
}
System.out.println();
System.out.println("==========================");
//当字符串不标准，字符与字符之间有多个空格和逗号的时候
String s1 = "this is text，under the desk";
String[] split1 = s1.split("[ ,]+");
for (String s2 : split1) {
System.out.print(s2+"\t");
}
}
}
输出：
this is text a text of text in the world
==========================
this is text，under the desk
13）String类自测题
需求：
1、已知String str = ” this is a text“；
2、将str中的单词单独提取出来
3、将str中的text替换成practice
4、在text前插入一个easy
5、将每个单词的首字母改为大写
代码如下（示例）public class Test2 {
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";
//将str中的单词单独提取出来
String[] s = str.split(" ");
for (String s1 : s) {
System.out.println(s1);
}
//将str中的text替换成practice
String replace = str.replace("text", "practice");
System.out.println(replace);
//在text前插入一个easy
String replace1 = str.replace("text", "easy text");
System.out.println(replace1);
//将每个单词的首字母改为大写
for (int i = 0; i < s.length; i++) {
char c = s[i].charAt(0);
char c1 = Character.toUpperCase(c);
String s1 = c1 + s[i].substring(1);
System.out.print(s1+"\t");
}
}
}
4.StringBuffer和StringBuilder
1）StringBuffer和StringBuilder的实现方法和两者的比较
（1）StringBuffer 可变字符串长度 运行效率较低 但是线程安全 可用于多线程
（2）StringBuilder 可变字符串长度 运行效率高 但是线程不安全 可用于单线程
2）append方法
不论是StringBuffer还是StringBuilder都有此方法。此方法的用途是在原本的字符串的末尾添加用户输入的字符串，但是这个类型是StringBuffer或StringBuilder类型的，如果在以后使用的接口需要传输的是String类型的时候，需要我们提前使用toString方法来转回Stirng类型
打印出的类型public class Test2 {
public static void main(String[] args) {
StringBuilder stringBuilder = new StringBuilder("hello");
System.out.println(stringBuilder.getClass());
}
}
输出：
class java.lang.StringBuilder
可以看到得出的结果是个StringBuilder类型的
append代码示例
public class Test2 {
public static void main(String[] args) {
StringBuilder stringBuilder = new StringBuilder("hello");
System.out.println("添加前: "+stringBuilder.toString());
System.out.println("添加后： "+stringBuilder.append(",Java").toString());
}
}
//输出：
添加前: hello
添加后： hello,Java
3）insert方法
不论是StringBuffer还是StringBuilder都有此方法。此方法的用途是当你输入你想插入的位置和所需插入的字符串后，就能将其插入到相应位置
源码展示public StringBuilder insert(int offset, String str) {
super.insert(offset, str);
return this;
}
代码示例
public class Test2 {
public static void main(String[] args) {
StringBuilder stringBuilder = new StringBuilder("hello");
System.out.println(stringBuilder.insert(0,"Good Morning,"));
}
}
4）replace方法
与之前String 的replace方法差不多相同，只不过这个的使用方法是 <起始位置，结束位置，替换字符>
源码展示public StringBuilder replace(int start, int end, String str) {
super.replace(start, end, str);
return this;
}
代码示例
public class Test2 {
public static void main(String[] args) {
StringBuilder stringBuilder = new StringBuilder("hello");
System.out.println(stringBuilder.replace(0,2,"pp"));
}
}
5）delete方法
当我们使用这个方法后我们可以删除指定长度的缓存中的内容，使用方法就是 <起始位置，结束位置>
代码示例public class Test2 {
public static void main(String[] args) {
StringBuilder stringBuilder = new StringBuilder("hello");
//删除缓存区的部分
StringBuilder delete = stringBuilder.delete(1, 3);
System.out.println("删除缓存区的部分后: "+delete.toString());
//清空整个缓存区
System.out.println("清空整个缓存区后:"+stringBuilder.delete(0,stringBuilder.length()));
}
}
输出：
删除缓存区的部分后: hlo
清空整个缓存区后:
6）StringBuffer和StringBuilder及String的效率比较
首先测试String的效率
代码示例public class Test2 {
public static void main(String[] args) {
String str = "";
//获取当前时间
long start = System.currentTimeMillis();
for (int i = 0; i <99999 ; i++) {
str+=i;
}
//获取当前结束时间
long end = System.currentTimeMillis();
System.out.println("所用时间:"+(end-start));
}
}
输出：
所用时间:4349
这里我们看到String的用时是43s
其次测试StringBuffer的效率
代码示例public class Test2 {
public static void main(String[] args) {
StringBuffer stringBuffer = new StringBuffer();
//获取当前时间
long start = System.currentTimeMillis();
for (int i = 0; i <99999 ; i++) {
stringBuffer.append(i);
}
System.out.println(stringBuffer.toString());
//获取当前结束时间
long end = System.currentTimeMillis();
System.out.println("所用时间:"+(end-start));
}
}
输出：
所用时间:42
这里我们看到String的用时是0.4s
最后测试StringBuilder的效率
代码示例public class Test2 {
public static void main(String[] args) {
StringBuilder stringBuilder = new StringBuilder();
//获取当前时间
long start = System.currentTimeMillis();
for (int i = 0; i <99999 ; i++) {
stringBuilder.append(i);
}
System.out.println(stringBuilder.toString());
//获取当前结束时间
long end = System.currentTimeMillis();
System.out.println("所用时间:"+(end-start));
}
}
输出：
所用时间:37
这里我们看到StringBuilder的用时是0.37s，所以我们不难看出StringBuilder的效率是最高的
5.BigDecimal类
0）注意事项
当我们使用double类型和float类型进行加减乘除的时候，我们往往会得到与我们心算所不一样的结果，这是因为这两个都是非高精度运算，所以当我们进行加减乘除的时候，总是会有一些误差，最后导致与我们心算的结果不一样
代码示例public class Test2 {
public static void main(String[] args) {
double d1 = 1.0;
double d2 = 0.9;
System.out.println(d1 - d2);
/*BigDecimal bigDecimal = new BigDecimal("0.845");
System.out.println(bigDecimal.add(new BigDecimal("0.14")).toString());*/
}
}
我们心算可以得出结果是0.1，但是程序执行完后得出的结果就是0.09999999999999998。所以，现在只是单纯的减法，但如果进行更复杂的运算后，可能会的到一个更大的误差，所以在银行的业务尽量使用BigDecimal高精度型。
1）add方法
因为使用了BigDecimal后是对象，所以不能再简单的使用+-*/来进行运算，所以此时我们则需要使用BigDecimal给我们提供的方法来进行计算，就比如此处的add
代码示例public class Test2 {
public static void main(String[] args) {
BigDecimal bigDecimal = new BigDecimal("0.845");
System.out.println(bigDecimal.add(new BigDecimal("0.14")).toString());
}
}
输出：
0.985
2）subtract方法
BigDecimal给我们提供的减法方法
代码示例public class Test2 {
public static void main(String[] args) {
BigDecimal bigDecimal = new BigDecimal("0.845");
System.out.println(bigDecimal.subtract(new BigDecimal("0.14")).toString());
}
}
输出：
0.705
3）mutiply方法
BigDecimal给我们提供的乘法方法
代码示例public class Test2 {
public static void main(String[] args) {
BigDecimal bigDecimal = new BigDecimal("0.845");
System.out.println(bigDecimal.multiply(new BigDecimal("0.14")).toString());
}
}
输出：
0.11830
4）divide方法
BigDecimal给我们提供的除法方法
代码示例public class Test2 {
public static void main(String[] args) {
BigDecimal bigDecimal = new BigDecimal("0.845");
System.out.println(bigDecimal.divide(new BigDecimal("0.14")).toString());
}
}
输出：
Exception in thread "main" java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result.
at java.base/java.math.BigDecimal.divide(BigDecimal.java:1722)
at Test2.main(Test2.java:10)
当我们测试到除法的时候，编译器就报错了，这时候我们就该在原始代码的基础上添加一点新的东西，也就是使用divide的重载方法来实现
代码示例public class Test2 {
public static void main(String[] args) {
BigDecimal bigDecimal = new BigDecimal("0.845");
System.out.println(bigDecimal.divide(new BigDecimal("0.14"),2,RoundingMode.HALF_UP).toString());
}
}
输出：
6.04
6.Date类
1）已经差不多全被calendar类取代了
7.Calendar类
1）Calendar类的创建
因为Calendar的构造方法是个被保护的方法，所以不能像其他普通的类那样直接使用new来创建Calendar 对象，转而是需要使用Calendar类中的一个静态方法getInstance来创建
代码示例public class Test2 {
public static void main(String[] args) {
Calendar calendar = Calendar.getInstance();
System.out.println(calendar.getTime().toString());
}
}
输出：
Thu Mar 10 20:15:32 CST 2022
2）get方法
用来获取当前年月日时分秒
代码示例public class Test2 {
public static void main(String[] args) {
Calendar calendar = Calendar.getInstance();
System.out.println(calendar.getTime());
//获取年份
int year = calendar.get(Calendar.YEAR);
//获取月份
int month = calendar.get(Calendar.MONTH);
//获取日
int day = calendar.get(Calendar.DAY_OF_MONTH);
//获取小时
int hour = calendar.get(Calendar.HOUR);
//获取分钟
int minute = calendar.get(Calendar.MINUTE);
//获取秒数
int second = calendar.get(Calendar.SECOND);
System.out.println(year+"年"+month+"月"+day+"日"+hour+"时"+minute+"分"+second+"秒");
}
}
输出：
Thu Mar 10 20:34:00 CST 2022
2022年2月10日8时34分0秒
3）set方法和add方法
用来修改当前所获取的年月日时分秒
仅修改年份代码示例public class Test2 {
public static void main(String[] args) {
Calendar calendar = Calendar.getInstance();
//未修改之前
System.out.println(calendar.getTime());
calendar.set(Calendar.YEAR,2003);
//修改之后
System.out.println(calendar.getTime());
}
}
输出：
Thu Mar 10 20:37:18 CST 2022
Mon Mar 10 20:37:18 CST 2003
4）获取当前月份的最大天数和最小天数
用来获取当前年的最大月数，或者当前月的最大天数
以获取当前月的最大天数代码示例public class Test2 {
public static void main(String[] args) {
Calendar calendar = Calendar.getInstance();
System.out.println(calendar.getTime());
//获取当前月份的最大天数
System.out.println(calendar.getActualMaximum(Calendar.DAY_OF_MONTH));
//获取当前月份的最小天数
System.out.println(calendar.getActualMinimum(Calendar.DAY_OF_MONTH));
}
}
输出：
31
1
8.SimpleDateFormat类
1）有参构造方法
SimpleDateFormat类提供了有参的构造方法和无参的构造方法，其中有参的构造方法则需要我们给定时间的格式
代码示例
public class Test2 {
public static void main(String[] args) throws ParseException {
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
}
}
这样就创建了一个标准的时间格式
### 2）format方法fomat方法是是SimpleDateFormat类提供的一个格式化的方法，因为现在Date类的一些方法已经被取代了所以给了这个方法让我们能把date获取到的时间以我们在有参构造中写的格式展示出来,并且能将date类型转换成String类型
代码示例public class Test2 {
public static void main(String[] args) throws ParseException {
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
Date date = new Date();
String format = simpleDateFormat.format(date);
System.out.println(format);
System.out.println(format.getClass());
}
}
输出：
2022/03/11 16:09:58
class java.lang.String
3）parse方法
fomat方法是是SimpleDateFormat类提供的一个解析的方法，能将String类型转换成Date类型
代码示例public class Test2 {
public static void main(String[] args) throws ParseException {
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
Date date = new Date();
String format = simpleDateFormat.format(date);
System.out.println(format);
System.out.println(format.getClass());
Date parse = simpleDateFormat.parse(format);
System.out.println(parse.getClass());
}
}
输出：
2022/03/11 16:09:58
class java.lang.String
class java.util.Date
## 9.System类 ### 1）arraycopy方法
arraycopy方法就是将一个数组的某个位置开始到某个结束位置内的内容全部复制到另外一个数组中去
代码示例
public class Test2 {
public static void main(String[] args) throws ParseException {
int[] a = {1,2,3,4,5};
int[] b = new int[a.length];
//一共有五个参数：Object var0, int var1, Object var2, int var3, int var4
//第一个是原始数组，第二个是目标数组的起始位置，第三个是目标数组，第四个是所需复制到目标数组的位置
//第五个是长度,你要复制几个参数
System.arraycopy(a,1,b,1,4);
for (int i : b) {
System.out.print(i+"\t");
}
}
}
输出：
0 2 3 4 5
2）arraycopy方法和Arrays类中的copyOf方法对比
其实本质Arrays中的copyOf方法使用的就是System中的arraycopy方法
原代码示例public static int[] copyOf(int[] original, int newLength) {
int[] copy = new int[newLength];
System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength));
return copy;
}
我们这里看到源码中依然调用的是 System.arraycopy方法
而我们可以继续往下查看System.arraycopy
@HotSpotIntrinsicCandidate
public static native void arraycopy(Object var0, int var1, Object var2, int var3, int var4);
看到的只是一个native 本地方法，只有参数而没有方法体，所以这个方法是由jvm底层所实现的
714
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
