标签：输出常用 Java String int System println out

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，字符串池的位置不唯一。

String类不可变性内存分析

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。
         */
    }
}

代码内存分析：

new创建String对象内存分析

常用方法

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()：判断指定的文件或文件夹是否是在绝对路径下。

标签：输出,常用,Java,String,int,System,println,out
From： https://www.cnblogs.com/spicy-hot-pot/p/18436716

9.Java常用类