1.Object类

1.1 getClass()获取一个对象的类型class Class.Object.Student

1.2 hashCode方法，返回该对象的散列码值

如果两个对象的哈希码值不同，那这两个对象一定不等；

如果两个对象的哈希码值相同，不能确保这两个对象一定相等。

1.3 toString方法,返回该对象的字符串表示，默认返回运行时类名+@+对象的hashCode的16进制，一般需要被重写

1.4 equals方法，判断两个对象是否相，一般也需要重写

1.5 finalize() 当垃圾回收器确定不存在对该对象的更多引用时，对象的圾回收器调用该方，一般需要被重写。

//Student类
package Class.Object;
import java.util.Objects;
public class Student {
    private String name;
    private int age;
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", 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
    protected void finalize() throws Throwable {
        System.out.println(this.name+"对象被回收了");
    }
}

Object测试类测试代码：

 Student s1 = new Student("ming",25);
        Student s2 = new Student("uzi",23);
//        判断是s1和s2是不是一个类型
//        1.getClass方法
        Class  class1=s1.getClass();
        Class  class2=s2.getClass();
        if(class1==class2){
            System.out.println(class1);
            System.out.println("同一类型");
        }else {
            System.out.println("不是同一类型");
        }
        System.out.println("======================");
//        2.hashCode方法
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());
        Student s3=s1;
        System.out.println(s3.hashCode());
        System.out.println("======================");
        //3.toString方法,在Studeng中已经被重写
        System.out.println(s1.toString());
        System.out.println(s2.toString());
        System.out.println(s3.toString());
        System.out.println("======================");
//        4.equals方法，判断两个对象是否相等
        System.out.println(s1.equals(s2));
        System.out.println(s1.equals(s3));
        Student s4 = new Student("uzi",23);
        System.out.println(s2.equals(s4));
//        s2和s4不同，所以要重写equals方法
      Student s5 = new Student("ming",25);
        Student s6 = new Student("uzi",23);
        new Student("ming",25);
        new Student("uzi",23);
        System.gc();
        System.out.println("回收垃圾");

2.包装类

一般来说，java中有8大数据类型，被定义后存放在栈里边，而包装后，会有一些方法且存放在堆空间中。

引用类型转换为基本类型称之为拆箱，基本类型转换为引用类型称之为装箱。

1.Int与Integer类型的转换

//        自动装箱
        int age=20;
        Integer integer4=age;
//        自动拆箱
        int age2=integer4;

2.基本类型与字符串的转换

        int num = 18;
//        使用Integer类型
//        1.构造方法
        Integer integer1 = new Integer(num);
//        Integer integer2 = Integer.valueOf(num);
//        2.类型转换：拆箱
        Integer integer3 = new Integer(100);
//        int i = integer3.intValue();
//        自动装箱
        int age = 20;
        Integer integer4 = age;
//        自动拆箱
        int age2 = integer4;

1.基本类型转换为字符串

1.基本类型转换为字符串
        int n1 = 100;
//        1.1使用+号
        String s1 = n1 + "";
//        1.2 使用INtegar中的toString方法
        String s2 = Integer.toString(n1, 16);

2.字符串转换为基本类型

//        字符串转换为基本类型
        String str = "150";
//        使用Integer中的parseXXX();
        int n2 = Integer.parseInt(str);
//Integer缓冲区的范围是-128-12

3.boolean字符串形式转换为基本类型 “true”–>true 非"true"–>false

      String str2 = "true";
        String str = "ture";
        boolean b1 = Boolean.parseBoolean(str2);//true
        boolean b2 = Boolean.parseBoolean(str2);//false

3.String类

length()返回字符串长度

charAt( int index )返回某个位置的字符

contains(Strin str)判断是否包含某个字符串，返回值为true或false

toCharArray() 将字符串转换成数组

Indexof(Strin str,int index)查找str首次出现的下标，存在则返回改下标，不存在则返回-1,index为开始寻找的下标

castIndexOf(String str)查找字符串在当前字符串中最后一次出现的下标索引 trim()去掉字符串前后的空格

toUpperCase()字符串转换为大写toLowerCase()

endWith(String str)判断是否以str结尾startWith判断是否以str开头 replace(char oldChar,chanewChar)将旧字符串替换为新字符串

spilt(String str)根据str做拆分

equals(Strinstr);比较字符串是否相等

equalsIgnoreCase()忽略大小写的比较

compareTo(Strinstr);比较两个字符串的大小

subString(int index1,inindex2)从低index1的位置截取字符串到index2的位置

测试代码：

        String str="My name is Zhiyuan";
        System.out.println(str.length());
        System.out.println(Arrays.toString(str.toCharArray()));
        System.out.println(str.indexOf("name",2));
        String[] arr=str.split(" ");
        System.out.println(arr.length);
        for (String s : arr) {
            System.out.println(s);
        }

4.StringBuffer，StringBuilder 类

StringBuffer可变长字符串，运行效率慢、线程安全

StringBuilder可变长字符串，运行效率快、线程不安全

StringBuffer和StringBuilder 效果一样可以替换

java.lang.StringBuffer sb = new java.lang.StringBuffer()
 // 1.append();追加
        sb.append("java世界第一");
        System.out.println(sb.toString());
        sb.append("java真香");
        System.out.println(sb.toString());
//       2.insert();添加
        sb.insert(0, "你好");
        System.out.println(sb.toString());
 //      3.replace();替换
        sb.replace(0, 6, "php");
        System.out.println(sb.toString());
 //       4.delete();删除
        sb.delete(7, 11);
        System.out.println(sb.toString());
 //        5.reverse()反转
  System.out.println(sb.toString())
  StringBuffer sb2=new StringBuffer();
  StringBuilder sb3 = new StringBuilder();

5.BigDecimal类

BigDecimal打的浮点数精确计算

        double d1=1.0;
        double d2=0.9;
        System.out.println(d1-d2);
        double res=(1.4-0.5)/0.9;
        System.out.println(res);
//        BigDecimal打的浮点数精确计算
//        减法
        BigDecimal bd1=new BigDecimal("1.0");
        BigDecimal bd2=new BigDecimal("0.9");
        BigDecimal bd3=bd1.subtract(bd2);
        System.out.println(bd3);
//        加法
        BigDecimal bd4=bd1.add(bd2);
        System.out.println(bd4);
//        乘法
        BigDecimal bd5=bd1.multiply(bd2);
        System.out.println(bd5);
//        除法,除不尽的时候,可以用divide的重载,后边一位是保留的小数,在后边是取舍的方式,一般用BigDecimal.ROUND_HALF_UP,即四舍五入
        BigDecimal bd6 = new BigDecimal("1.4").subtract(new BigDecimal("0.5")).divide(new BigDecimal("0.9"));
        System.out.println(bd6);
        BigDecimal bd7=new BigDecimal("10").divide(new BigDecimal("3"),3,BigDecimal.ROUND_HALF_UP);
        System.out.println(bd7);.

6.Date类

Date表示特定的瞬间，精确到毫秒，Date的大部分类已经被Calendar类中的方法取代。

1.创建date对象
        //     今天的时刻
        Date date1=new Date();
        System.out.println(date1.toString());
        System.out.println(date1.toLocaleString());
//        昨天的时刻
        Date date2=new Date(date1.getTime()-60*60*24*1000);
        System.out.println(date2.toLocaleString());
//        方法after() before()
        boolean b1=date2.after(date1);
        System.out.println(b1);
        boolean b2=date2.before(date1);
        System.out.println(b2);
//        比较compareTo();
        int d=date1.compareTo(date2);
        System.out.println(d);
        int d2=date1.compareTo(date1);
        System.out.println(d2);
//        equals比较是否相等
        System.out.println(date1.equals(date2));

7.Calendar类

Calendar提供了获取或者设置各种日历字段的方法。

构造方法：peotected Calendar()：由于修饰符是protected，所以无法直接创建该对象

其他方法：

      Calendar calendar=Calendar.getInstance();
        System.out.println(calendar.getTime().toLocaleString());
        System.out.println(calendar.getTimeInMillis());
//        获取时间信息
        int year=calendar.get(Calendar.YEAR);
//        int year=calendar.get(1);和上边相同
        int month=calendar.get(Calendar.MONTH);
        int day=calendar.get(Calendar.DAY_OF_MONTH);
        int hour=calendar.get(Calendar.HOUR_OF_DAY);//HOUR是12小时制
        int minute=calendar.get(Calendar.MINUTE);
        int second=calendar.get(Calendar.SECOND);
        System.out.println(year+"年"+(month+1)+"月"+day+"日"+hour+"时"+minute+"分"+second+"秒");
//        修改时间
        Calendar calendar2=Calendar.getInstance();
        calendar2.set(calendar.DAY_OF_MONTH,20);
        System.out.println(calendar2.getTime().toLocaleString());
//        add方法修改时间
        calendar2.add(Calendar.HOUR,1);//calendar2.add(Calendar.HOUR,-1);
        System.out.println(calendar2.getTime().toLocaleString());
//        补充方法
        int max=calendar2.getActualMaximum(Calendar.DAY_OF_MONTH);
        int min=calendar2.getActualMinimum(Calendar.DAY_OF_MONTH);
        System.out.println(max+"......"+min);

8.SimpleDateFormat类

SimpleDateFormat是一个以语言环境有关的方式来格式化和解析日期的具体类、

进行格式化（日期->文本）、解析(文本->日期 )

public static void main(String[] args) throws Exception{
//1.创建SimpleDateFormat对象 Y 年   M 月
       SimpleDateFormat sdf = new SimpleDateFormat("yyyy年mm月dd日 hh:mm:ss");
       SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy/mm/dd");
//      2. 创建Date
        Date date=new Date();
//        3.格式化date(把日期转换为字符串)
        String str=sdf.format(date);
        System.out.println(str);
//        解析:把字符串转换为日期
        Date date1 = sdf2.parse("1998/07/28");//必须符合上边定义的格式,否则报错
        System.out.println(date1);
}

9.System类

System系统类，主要用于获取系统的属性数据和其它操作，构造方法私有的

//       1. arraycopy数组的复制
//        src源数组,srcPos从哪个位置开始复制,dest目标数组,destPos目标数组位置,length复制的长度
        int[] arr1 = {1, 2, 3, 4, 5, 6};
        int[] arr2 = new int[6];
        System.arraycopy(arr1, 2, arr2, 2, 3);
        for (int i : arr2) {
            System.out.println(arr2[i]);
        }
//        Arrays.copyOf();也是复制,不过是来自System方法实现的
//        2.currentTimeMillis(),可以计时
        System.out.println(System.currentTimeMillis());
        long start = System.currentTimeMillis();
        for (int i = 0; i < 999999; i++) {
            for (int i1 = 0; i1 < 99999; i1++) {
                int res = i + i1;
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("用时:" + (end - start));
//        3.System.gc();告诉垃圾回收器回收垃圾
        System.gc();
//        4.exit()退出jvm
        System.exit(0);
        System.out.println("程序已经结束了");//程序结束了,所以不会执行

10.Collections工具类

Collections提供以下方法对List进行排序操作

void reverse(List list)：反转

void shuffle(List list),随机排序

void sort(List list),按自然排序的升序排序

void sort(List list, Comparator c);定制排序，由Comparator控制排序逻辑

void swap(List list, int i , int j),交换两个索引位置的元素

void rotate(List list, int distance),旋转。当distance为正数时，将list后distance个元素整体移到前面。当distance为负数时，将 list的前distance个元素整体移到后面。

测试代码：

package Collections.Map;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
//Collections工具类
public class Demo04 {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(23);
        list.add(24);
        list.add(29);
        list.add(26);
        list.add(23);
//        sort排序
        System.out.println("排序之前" + list.toString());
        Collections.sort(list);
        System.out.println("排序之后" + list.toString());
//        binarySearch二分查找
        Collections.binarySearch(list, 24);
//        copy复制
        List<Integer> list2 = new ArrayList<>();
        for (int i = 0; i < list.size(); i++) {
            list2.add(0);
        }
        Collections.copy(list2, list);//要要求集合的元素个数相同,相当于给list2赋值
        System.out.println(list2.toString());
//        reverse反转
        Collections.reverse(list);
        System.out.println(list.toString());
//        shuffle将集合元素打乱
        Collections.shuffle(list);
        System.out.println(list);
//        补充：*****
//        list转换成数组
        Integer[] arr= list.toArray(new Integer[0]);
        System.out.println(arr.length);
        System.out.println(Arrays.toString(arr));
//        数组转换成集合
        String[] names={"张三","李四","王五"};
        Integer[] nums={1,2,4,8,9,7,12};
//        数组转换成的集合是一个受限集合，不能添加和删除,把基本数据类型转换为集合时,需要修改为包装类
        List<String> list3=Arrays.asList(names);
        List<Integer> list4=Arrays.asList(nums);
//        list3.add("高柳");
        System.out.println(list3);
        System.out.println(list4);
    }
}

11.Math类

static double PI 圆周率

static double E 自然数的底

static int abs(int a) 返回参数的绝对值

static double ceil(double d)返回大于或者等于参数的最小整数

static double floor(double d)返回小于或者等于参数的最大整数

static long round(double d)对参数四舍五入

static double pow(double a,double b ) a的b次幂

static double random() 返回随机数 0.0-1.0之间

static double sqrt(double d)参数的平方根

public static void main(String[] args) {
// System.out.println("Math.PI = " + Math.PI);
//  System.out.println("Math.E = " + Math.E);
//static int abs(int a) 返回参数的绝对值
System.out.println(Math.abs(-6));
//static double ceil(double d)返回大于或者等于参数的最小整数
System.out.println(Math.ceil(12.3)); //向上取整数
//static double floor(double d)返回小于或者等于参数的最大整数
System.out.println("Math.floor(5.5) = " + Math.floor(5.5));//向下取整数
//static long round(double d)对参数四舍五入
long round = Math.round(5.5); //取整数部分  参数+0.5
System.out.println("round = " + round);
//static double pow(double a,double b ) a的b次幂
System.out.println("Math.pow(2,3) = " + Math.pow(2, 3));
//static double sqrt(double d)参数的平方根
System.out.println("Math.sqrt(4) = " + Math.sqrt(3));
// static double random() 返回随机数 0.0-1.0之间
for(int x = 0 ; x < 10 ; x++){
System.out.println(Math.random()); //伪随机数
}
}

12.JDK8新的事件日期对象

获取该类的对象,静态方法

static LocalDate now() 获取LocalDate的对象,跟随操作系统

static LocalDate of() 获取LocalDate的对象,自己设置日期

of方法中传递年月日 of(int year,int month,int day)

/**
* LocalDate的静态方法获取对象
*/
public static void getInstance(){
   //静态方法now()
   LocalDate localDate = LocalDate.now();
   System.out.println("localDate = " + localDate);
   //静态方法of()设置日期
   LocalDate of =  LocalDate.of(2022,5,10);
   System.out.println("of = " + of);
}

获取日期字段的方法 : 名字是get开头

int getYear() 获取年份
int getDayOfMonth()返回月中的天数
int getMonthValue() 返回月份

/**
* LocalDate类的方法 getXXX()获取日期字段
*/
public static void get(){
    LocalDate localDate = LocalDate.now();
    //获取年份
    int year = localDate.getYear();
    //获取月份
    int monthValue = localDate.getMonthValue();
    //获取天数
    int dayOfMonth = localDate.getDayOfMonth();
    System.out.println("year = " + year);
    System.out.println("monthValue = " + monthValue);
    System.out.println("dayOfMonth = " + dayOfMonth);
}

设置日期字段的方法 : 名字是with开头

LocalDate withYear(int year)设置年份

LocalDate withMonth(int month)设置月份

LocalDate withDayOfMonth(int day)设置月中的天数

LocalDate对象是不可比对象,设置方法with开头,返回新的LocalDate对象

/**
     * LocalDate类的方法 withXXX()设置日期字段
     */
public static void with(){
    LocalDate localDate = LocalDate.now();
    System.out.println("localDate = " + localDate);
    //设置年,月,日
    //方法调用链
    LocalDate newLocal = localDate.withYear(2025).withMonth(10).withDayOfMonth(25);
    System.out.println("newLocal = " + newLocal);
}```
- 设置日期字段的偏移量, 方法名plus开头,向后偏移
- 设置日期字段的偏移量, 方法名minus开头,向前偏移
```java
 /**
     * LocalDate类的方法 minusXXX()设置日期字段的偏移量,向前
     */
    public static void minus() {
        LocalDate localDate = LocalDate.now();
        //月份偏移10个月
        LocalDate minusMonths = localDate.minusMonths(10);
        System.out.println("minusMonths = " + minusMonths);
    }
    /**
     * LocalDate类的方法 plusXXX()设置日期字段的偏移量,向后
     */
    public static void plus(){
        LocalDate localDate = LocalDate.now();
        //月份偏移10个月
        LocalDate plusMonths = localDate.plusMonths(10);
        System.out.println("plusMonths = " + plusMonths);
    }

13.File类

文件夹 Directory : 存储文件的容器,防止文件重名而设置,文件归类,文件夹本身不存储任何数据, 计算专业数据称为目录

文件 File : 存储数据的,同一个目录中的文件名不能相同

路径 Path : 一个目录或者文件在磁盘中的位置

c:\jdk8\jar 是目录的路径,是个文件夹的路径

c:\jdk8\bin\javac.exe 是文件的路径

File类,描述目录文件和路径的对象

平台无关性

13.1 File类的构造方法

File (String pathname)传递字符串的路径名

File(String parent,String child)传递字符串的父路径,字符串的子路径

File(File parent,String child)传递File类型的父路径,字符串的子路径

 public static void main(String[] args) {
        fileMethod03();
    }
    /**
     * File(File parent,String child)传递File类型的父路径,字符串的子路径
     */
    public static void fileMethod03(){
        File parent = new File("C:/Java/jdk1.8.0_221");
        String child = "bin";
        File file = new File(parent,child);
        System.out.println(file);
    }
    /**
     * File(String parent,String child)传递字符串的父路径,字符串的子路径
     * C:\Java\jdk1.8.0_221\bin
     * C:\Java\jdk1.8.0_221 是 C:\Java\jdk1.8.0_221\bin 的父路径
     */
    public static void fileMethod02(){
        String parent = "C:/Java/jdk1.8.0_221";
        String child = "bin";
        File file = new File(parent,child);
        System.out.println(file);
    }
    /**
     * File (String pathname)传递字符串的路径名
     */
    public static void fileMethod(){
        //字符串的路径,变成File对象
        File file = new File("C:\\Java\\jdk1.8.0_221\\bin");
        System.out.println(file);
    }

13.2 File类的创建方法

boolean createNewFile()创建一个文件,文件路径写在File的构造方法中
boolean mkdirs()创建目录,目录的位置和名字写在File的构造方法中

    //创建文件夹 boolean mkdirs()
    public static void fileMethod02(){
        File file = new File("C://Java//1.txt");
        boolean b = file.mkdirs();
        System.out.println("b = " + b);
    }
    //创建文件 boolean createNewFile()
    public static void fileMethod() throws IOException {
        File file = new File("C://Java//1.txt");
        boolean b = file.createNewFile();
        System.out.println("b = " + b);
    }

13.3 File类的删除方法

boolean delete() 删除指定的目录或者文件,路径写在File类的构造方法

不会进入回收站,直接从磁盘中删除了,有风险

    public static void fileMethod03(){
        File file = new File("C:/Java/aaa");
        boolean b = file.delete();
        System.out.println("b = " + b);
    }

13.4 File类判断方法

boolean exists() 判断构造方法中的路径是否存在

boolean isDirectory()判断构造方法中的路径是不是文件夹

boolean isFile()判断构造方法中的路径是不是文件

boolean isAbsolute() 判断构造方法中的路径是不是绝对路径

13.4.1 绝对路径与相对路径

绝对路径

在磁盘中的路径具有唯一性

Windows系统中,盘符开头 C:/Java/jdk1.8.0_221/bin/javac.exe

Linux或者Unix系统, /开头,磁盘根 /usr/local

互联网路径 :www.baidu.com

https://item.jd.com/100007300763.html

https://pro.jd.com/mall/active/3WA2zN8wkwc9fL9TxAJXHh5Nj79u/index.html

相对路径

必须有参照物

C:/Java/jdk1.8.0_221/bin/javac.exe

bin是参考点 : 父路径 C:/Java/jdk1.8.0_221

bin是参考点 : 子路径 javac.exe

bin参考点: 父路径使用 …/表示

    /**
     * boolean isAbsolute() 判断构造方法中的路径是不是绝对路径
     * 不写绝对形式的路径,写相对形式的,默认在当前的项目路径下
     */
    public static void fileMethod04(){
        File file = new File("C:/Java/jdk1.8.0_221/bin/javac.exe");
        boolean b = file.isAbsolute();
        System.out.println("b = " + b);
        File file2 = new File("javac.exe");
        b = file2.isAbsolute();
        System.out.println("b = " + b);
    }

13.5 File类获取的方法

File getAbsoluteFile() 获取绝对路径,返回值是File类型

File getParentFile() 获取父路径,返回值是File类型

String getName() 获取名字,File构造方法中的路径的名字

String getPath() 获取File构造方法中的路径,完整的路径转成String返回

long length()获取文件的字节数

/**
* File类的获取方法
* - File getAbsoluteFile() 获取绝对路径,返回值是File类型
* - File getParentFile() 获取父路径,返回值是File类型
*/
public static void fileMethod02(){
    File file = new File("C:\\Java\\jdk1.8.0_221\\bin\\java.exe");
    //获取绝对路径
    File absoluteFile = file.getAbsoluteFile();
    System.out.println("absoluteFile = " + absoluteFile);
    //获取父路径
    File parentFile = file.getParentFile().getParentFile();
    System.out.println("parentFile = " + parentFile);
    //文件的字节数
    long length = file.length();
    System.out.println("length = " + length);
}
/**
* File类获取方法
* - String getName() 获取名字,File构造方法中的路径的名字
* - String getPath() 获取File构造方法中的路径,完整的路径转成String返回
*/
public static void fileMethod(){
    File file = new File("C:\\Java\\jdk1.8.0_221\\bin\\java.exe");
    //getName()获取名字
    String name = file.getName();
    System.out.println("name = " + name);
    //getPath()构造方法参数,转成字符串
    String path = file.getPath();
    System.out.println("path = " + path);
}

13.6 File类的方法listFiles()

返回值是File[] 数组 , 存储了多个File对象, 方法的作用是遍历当前的文件夹

    public static void main(String[] args) {
        //fileMethod();
     foreachDir(new File("D:\\学习\\研究生\\研一\\自学\\Java学习\\MarkDown"));
        foreachDirs(new File("D:\\学习"));
    /**
     * 目录的递归遍历 : 传递参数,遍历哪个路径,传递过来
     */
    public static void foreachDir(File dir){
        System.out.println(dir);
        //listFiles()遍历目录  C:\Java\jdk1.8.0_221
        File[] files = dir.listFiles();
        //遍历数组,取出数组中的File对象
        //是遍历到的所有文件的全路径 (绝对路径)
        for(File f : files){
            //判断遍历到的路径是不是文件夹
            if(f.isDirectory()) //C:\Java\jdk1.8.0_221\jre  ,进入继续遍历
                //递归调用自己,传递路径
                foreachDir(f);
            else
                System.out.println(f);
        }
    }
    /**
     * 遍历目录
     */
   //    遍历目录
    public static void foreachDirs(File file){
        File[] files=file.listFiles();
        for (File file1 : files) {
            System.out.println(file1);
        }
    }
    //无参
    public static void foreachDirs(){
        File    file=new File("D:\\学习");
        File[] files=file.listFiles();
        for (File file1 : files) {
            System.out.println(file1);
        }
    }
}

Java常用类