【无标题】

一.常见API

1. Object

Object类的作用:

Object类是Java中所有类的祖宗类，因此，Java中所有类的对象都可以直接使用Object类中提供的一些方法。

Object类的常见方法:

方法名	说明
public String toString()	返回对象的字符串表示形式。
public boolean equals(Object o)	判断两个对象是否相等。

toString:存在的意义:toString()方法存在的意义就是为了被子类重写,以便返回对象具体的内容.

equals:直接比较两个对象的地址值可以使用 “==” 代替equals, equals是为了被子类重写后,比较对象内容的.

2. Objects

Objects类的常见方法:

方法名	说明
public static boolean equals(Object a, Object b)	先做非空判断，再比较两个对象
public static boolean isNull(Object obj)	判断对象是否为null，为null返回true ,反之
public static boolean nonNull(Object obj)	判断对象是否不为null，不为null则返回true, 反之

Objects类提供的equals方法来比较两个对象: 会先做非空判断,不会出现空指针异常,所以更安全!!!

3. 包装类

自动装箱: 基本数据类型可以自动转换为包装类型。

自动拆箱: 包装类型可以自动转换为基本数据类型。

包装类常用方法:

可以调用toString方法,把基本类型转换成字符串 , 调用valueOf ,把字符串类型转换成真实数据类型.

4. StringBuilder和StringBuffer的区别

StringBuilder和StringBuffer用法一样,但是"StringBuffer"线程更安全

StringBuilder和StringBuffer:只是操作工具,最后需要调用toString方法转换回String类型.

5. StringJoiner

使用StringJoiner的方法

StringJoiner是用来拼接字符串的

StringJoiner 只支持String类型数据.

6. System工具类

currentTimeMillis方法:从1970.1.1日到当前时间的 时间毫秒值.

Runtime

****Runtime是对当前虚拟机做操作的方法.

7. BigDecimal 小数运算精度问题

用于解决浮点型小数运算时,出现精度问题.

1.应该如何把浮点型转换成BigDecimal的对象？

BigDecimal b3 = new BigDecimal(0.1+"");

BigDecimal b1 = new BigDecimal .valueOf(0.1);

BigDecimal b1 = new BigDecimal(Double.toString(0.1))

8. Java日期\时间

获取时间或指定时间

LocalDateTime常用API

获取时间示例代码

  //获取当前 年,月,日,时,分,秒
            LocalDateTime ldt = LocalDateTime.now();//获取当前时间
            System.out.println(ldt);
            //获取指定时间对象
           LocalDateTime ldt1 = LocalDateTime.
                    of(2023,11,13,12,02,51,999);
            System.out.println(ldt1);//2023-11-13T12:02:51.000000999
            System.out.println("当前对象的年:"+ldt1.getYear()+"年");//当前对象的年:2023年
            System.out.println("当前对象的月:"+ldt1.getMonthValue()+"月");//当前对象的月:11月
            System.out.println("当前对象的日:"+ldt1.getDayOfMonth()+"日");//当前对象的日:13日
            System.out.println("这一年的第:"+ldt1.getDayOfYear()+"天");//这一年的第:317天
            System.out.println("当前对象的小时:"+ldt1.getHour()+"时");//当前对象的小时12
            System.out.println("当前对象的分钟:" + ldt1.getMinute()+"分");//当前对象的分钟:2分
            System.out.println("当前对象的秒:" + ldt1.getSecond()+"秒");//当前对象的秒:51秒
            System.out.println("当前对象的毫秒:" + ldt1.getNano()+"毫秒");//当前对象的毫秒:999毫秒
            DayOfWeek dayOfWeek = ldt1.getDayOfWeek();//
            System.out.println("英文的星期:"+dayOfWeek.name());//英文的星期:MONDAY
            System.out.println("今天是星期:"+dayOfWeek.getValue());//今天是星期:1
            //  LocalDate  LocalTime  有相同的方法

修改时间信息示例代码

LocalDateTime localDateTime = LocalDateTime.of
        (2023,11,13,14,45,45,4500);
System.out.println("将对象年份修改为"+localDateTime.withYear(2003));
System.out.println("将对象月份修改为"+localDateTime.withMonth(5));
System.out.println("将对象日修改为"+localDateTime.withDayOfMonth(3));
System.out.println("将对象时修改为"+localDateTime.withHour(8));
System.out.println("将对象分钟修改为"+localDateTime.withMinute(0));
System.out.println("将对象秒修改为"+localDateTime.withSecond(0));
System.out.println("将对象毫秒份修改为"+localDateTime.withNano(0));
System.out.println("将对象修改为当前年的第几天"+localDateTime.withDayOfYear(5));

LocalDateTime localDateTime1 = localDateTime.withYear(2003).withMonth(5).
        withDayOfMonth(3).withHour(11).withMinute(59).withSecond(0).withNano(0);
//创建一个日期格式化对象
DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH时mm分ss秒 EEE a");
//按照格式化器的规则转换为字符串
String format = dtf.format(localDateTime1);
System.out.println(format);
// 2003年05月03日 11时59分00秒 周六 上午

时间格式化器

 //创建一个日期格式化对象
        LocalDateTime ldt = LocalDateTime.now();//获取当前时间
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH时mm分ss秒 EEE a");
        //按照格式化器的规则转换为字符串
        String format = dtf.format(ldt);
        // 2003年05月03日 11时59分00秒 周六 上午
        System.out.println(format);

//输出结果
	2023年11月13日 16时09分03秒 周一 下午
	

============================================================================================================
//字符串类型 转时间
        LocalDateTime localDateTime = LocalDateTime.now();

        String str = "2024-05-03 08:30:00";
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        LocalDateTime parse = LocalDateTime.parse(str, formatter);  //parse 可以将字符串转化成时间格式
        System.out.println(parse);
        
        String format = formatter.format(parse); //时间格式器
        System.out.println(format);

        
        Duration between = Duration.between(localDateTime, parse);
        System.out.println(between.toDaysPart()+" 天 "+between.toHoursPart()+" 小时 "+between.toSecondsPart()+"秒");
        
//输出结果:
	2024-05-03T08:30
	2024-05-03 08:30:00
	171 天 16 小时 8秒

计算间隔时间

Period

Duration

LocalDateTime start = LocalDateTime.now();
LocalDateTime end = LocalDateTime.of(2024, 2, 10, 8, 00);

Duration between = Duration.between(start, end);
System.out.println(between.toDaysPart() + "天" + between.toHoursPart() + "小时"
+between.toMinutesPart()+"分"+ between.toSecondsPart() + "秒");

定时任务

Timer timer = new Timer();
timer.schedule(new Time(),0,1000); //每秒执行一次
============================================================================================================

package com.itheima.d6_localdatetimeapi;

import java.time.Duration;
import java.time.LocalDateTime;
import java.util.Timer;
import java.util.TimerTask;

public class Time extends TimerTask {


    @Override
    public void run() {
        LocalDateTime start = LocalDateTime.now();
        LocalDateTime end = LocalDateTime.of(2024, 2, 10, 8, 00);

        Duration between = Duration.between(start, end);
        System.out.println(between.toDaysPart() + "天" + between.toHoursPart() + "小时" +between.toMinutesPart()+"分"+ between.toSecondsPart() + "秒");
    }
}

二.Collection集合

集合的分类

Collection集合分为两大常用集合体系:

1.List系列集合

List集合:添加的元素是有序,可重复,有索引.

List接口:常用实现类ArrayList和LinkedList

2.常用方法

集合合并: 集合对象.addAll(集合对象2);

Object[] objects = list.toArray(); 
String string = Arrays.toString(objects);
System.out.println(string);  //可以转换成字符串

3.遍历方法

迭代器遍历

迭代器遍历 使用步骤

1.得到一个迭代器对象

集合 . iterator

2.使用while 遍历

while(集合.hasNext()){
it.next();
}

增强for循环遍历

for (String s : list) {
    System.out.println(s);
}

lambda表达式遍历

集合的并发修改问题

迭代器遍历机制，规定迭代器遍历集合的同时，不允许集合自己去增删元素，否则就会出现并发修改异常。

处理集合的并发修改问题 可以调用  迭代器.remove 方法

==========================================================================

for(i=0,i<集合.size,i++){

集合.remove

i--;

}

4.List集合特点和特有方法

5.List支持的遍历方式

6.ArrayList集合的底层原理

ArrayList底层:基于数组结构实现的

ArrayList特点:

根据索引查询才快,如果根据内容还是一样一个一个查.

ArrayList扩容机制

①利用无参构造器创建的集合，会在底层创建一个默认长度为0的数组

②添加第一个元素时，底层会创建一个新的长度为10的数组

③存满时，会扩容1.5倍

④如果一次添加多个元素，1.5倍还放不下，则新创建数组的长度以实际为准

ArrayList集合适用场景:

7.LinkedList

LinkedList集合的底层原理

LinkedList特有方法

Set系列集合

1.Set集合的特点

Set系列:添加的元素是无序,不重复,无索引.

Set接口:常用实现类

HashSet:无序,不重复,无索引

LinkedHashSet:有序,不重复,无索引

TreeSet:排序,不重复,无索引

代码实例

//Set<Integer> set = new HashSet<>();	//无序、无索引、不重复
//Set<Integer> set = new LinkedHashSet<>(); //有序、无索引、不重复
Set<Integer> set = new TreeSet<>(); //可排序(升序)、无索引、不重复
set.add(666);
set.add(555);
set.add(555);
set.add(888);
set.add(888);
set.add(777);
set.add(777);
System.out.println(set); //[555, 666, 777, 888]

2.HashSet集合底层原理

• JDK8之前: 哈希表=数组+链表
• JDK8之后:哈希表=数组+链表+红黑树
  

我们发现往HashSet集合中存储元素时，底层调用了元素的两个方法：一个是hashCode方法获取元素的hashCode值（哈希值）；另一个是调用了元素的equals方法，用来比较新添加的元素和集合中已有的元素是否相同。

新添加元素的hashCode值和集合中元素的hashCode值相同时不代表相同,调用equals方法比较两个元素的内容为true后才会认为相同(hashCode和equals必须重写,否则equals比较地址的结果不是不同需要注意)

在JDK8开始后，为了提高性能，当链表的长度超过8时，就会把链表转换为红黑树，如下图所示：

3.HashSet去重原理

前面我们学习了HashSet存储元素的原理，依赖于两个方法：一个是hashCode方法用来确定在底层数组中存储的位置，另一个是用equals方法判断新添加的元素是否和集合中已有的元素相同。

要想保证在HashSet集合中没有重复元素，我们需要重写元素类的hashCode和equals方法。比如以下面的Student类为例，假设把Student类的对象作为HashSet集合的元素，想要让学生的姓名和年龄相同，就认为元素重复。

public class Student{
    private String name; //姓名
    private int age; //年龄
    private double height; //身高
 
    //无参数构造方法
    public Student(){}
    //全参数构造方法
    public Student(String name, int age, double height){
        this.name=name;
        this.age=age;
        this.height=height;
    }
    //...get、set、toString()方法自己补上..
    
    //按快捷键生成hashCode和equals方法
    //alt+insert 选择 hashCode and equals
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Student student = (Student) o;

        if (age != student.age) return false;
        if (Double.compare(student.height, height) != 0) return false;
        return name != null ? name.equals(student.name) : student.name == null;
    }

    @Override
    public int hashCode() {
        int result;
        long temp;
        result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        temp = Double.doubleToLongBits(height);
        result = 31 * result + (int) (temp ^ (temp >>> 32));
        return result;
    }
}

接着，写一个测试类，往HashSet集合中存储Student对象。

public class Test{
    public static void main(String[] args){
        Set<Student> students = new HashSet<>();
        Student s1 = new Student("至尊宝",20, 169.6);
        Student s2 = new Student("蜘蛛精",23, 169.6);
        Student s3 = new Student("蜘蛛精",23, 169.6);
        Student s4 = new Student("牛魔王",48, 169.6);
        
        students.add(s1);
        students.add(s2);
        students.add(s3);
        students.add(s4);
        
        for(Student s : students){
            System.out.println(s);
        }
    }
}

//打印结果如下，我们发现存了两个蜘蛛精，当时实际打印出来只有一个，而且是无序的。 
//Student{name='牛魔王', age=48, height=169.6}
//Student{name='至尊宝', age=20, height=169.6}
//Student{name='蜘蛛精', age=23, height=169.6}

4.LinkedHashSet底层原理

每次添加元素，就和上一个元素用双向链表连接一下。第一个添加的元素是双向链表的头节点，最后一个添加的元素是双向链表的尾节点。

示例代码:

public class Test{
    public static void main(String[] args){
        Set<Student> students = new LinkedHashSet<>();
        Student s1 = new Student("至尊宝",20, 169.6);
        Student s2 = new Student("蜘蛛精",23, 169.6);
        Student s3 = new Student("蜘蛛精",23, 169.6);
        Student s4 = new Student("牛魔王",48, 169.6);
        
        students.add(s1);
        students.add(s2);
        students.add(s3);
        students.add(s4);
        
        for(Student s : students){
            System.out.println(s);
        }
    }
}
//打印结果
Student{name='至尊宝', age=20, height=169.6}
Student{name='蜘蛛精', age=23, height=169.6}
Student{name='牛魔王', age=48, height=169.6}

5.TreeSet集合

TreeSet集合特点:可以对元素进行排序，但是必须指定元素的排序规则。

如果我们往集合中添加Integer类型元素,String类型元素,元素本身具备了排序规则就可以直接排序.

Set<Integer> set1= new TreeSet<>();
set1.add(8);
set1.add(6);
set1.add(4);
set1.add(3);
set1.add(7);
set1.add(1);
set1.add(5);
set1.add(2);
System.out.println(set1); //[1,2,3,4,5,6,7,8]

Set<Integer> set2= new TreeSet<>();
set2.add("a");
set2.add("c");
set2.add("e");
set2.add("b");
set2.add("d");
set2.add("f");
set2.add("g");
System.out.println(set1); //[a,b,c,d,e,f,g]

如果往TreeSet集合中存储自定义类型的元素，比如说Student类型，则需要我们自己指定排序规则，否则会出现异常。

//创建TreeSet集合，元素为Student类型
Set<Student> students = new TreeSet<>();

//创建4个Student对象
Student s1 = new Student("至尊宝",20, 169.6);
Student s2 = new Student("紫霞",23, 169.8);
Student s3 = new Student("蜘蛛精",23, 169.6);
Student s4 = new Student("牛魔王",48, 169.6);

//添加Studnet对象到集合
students.add(s1);
students.add(s2);
students.add(s3);
students.add(s4);
System.out.println(students); 

运行代码发现报错,原因TreeSet不知道按照什么条件来给Student对象排序

编写TreeSet集合的排序规则有两种方法:

第一种：让元素的类实现Comparable接口，重写compareTo方法

第二种：在创建TreeSet集合时，通过构造方法传递Compartor比较器对象

第一种:

//第一步：先让Student类，实现Comparable接口
//注意：Student类的对象是作为TreeSet集合的元素的
public class Student implements Comparable<Student>{
    private String name;
    private int age;
    private double height;
	//无参数构造方法
    public Student(){}
    //全参数构造方法
    public Student(String name, int age, double height){
        this.name=name;
        this.age=age;
        this.height=height;
    }
    //...get、set、toString()方法自己补上..
    
    //第二步：重写compareTo方法
    //按照年龄进行比较，只需要在方法中让this.age和o.age相减就可以。
    /*
    原理：
    在往TreeSet集合中添加元素时，add方法底层会调用compareTo方法，根据该方法的
    结果是正数、负数、还是零，决定元素放在后面、前面还是不存。
    */
    @Override
    public int compareTo(Student o) {
        //this：表示将要添加进去的Student对象
        //o: 表示集合中已有的Student对象
        return this.age-o.age;
    }
}

//运行结果
//Student{name='至尊宝', age=20, height=169.6}
//Student{name='紫霞', age=20, height=169.8}
//Student{name='蜘蛛精', age=23, height=169.6}
//Student{name='牛魔王', age=48, height=169.6}

第二种:

//创建TreeSet集合时，传递比较器对象排序
/*
原理：当调用add方法时，底层会先用比较器，根据Comparator的compare方是正数、负数、还是零，决定谁在后，谁在前，谁不存。
*/
//下面代码中是按照学生的年龄升序排序
Set<Student> students = new TreeSet<>(new Comparator<Student>{
    @Override
    public int compare(Student o1, Student o2){
        //需求：按照学生的身高排序
        return Double.compare(o1,o2); 
    }
});

//创建4个Student对象
Student s1 = new Student("至尊宝",20, 169.6);
Student s2 = new Student("紫霞",23, 169.8);
Student s3 = new Student("蜘蛛精",23, 169.6);
Student s4 = new Student("牛魔王",48, 169.6);

//添加Studnet对象到集合
students.add(s1);
students.add(s2);
students.add(s3);
students.add(s4);
System.out.println(students);