Java基础学习（10）

一、JDK8时间类

JDK7:多线程环境下会导致数据安全的问题
JDK8:时间日期对象都是不可变的，解决了这个问题
在这里插入图片描述

1.1 Zoneld时区

import java.time.ZoneId;
import java.util.Set;

public class ZoneId获取1 {
    public static void main(String[] args) {
        //1.获取所有的时间名称
        Set<String> zoneIds =  ZoneId.getAvailableZoneIds();
        System.out.println(zoneIds.size());//600
        System.out.println(zoneIds);//600个名称时间   我国的Asia/Shanghai

        //2. 获取当前系统默认的时区
        ZoneId zoneId = ZoneId.systemDefault();
        System.out.println(zoneId);//Asia/Shanghai

        //3. 获取指定区域的时区
        ZoneId id = ZoneId.of("Asia/Shanghai");
        System.out.println(id);//Asia/Shanghai


    }
}

1.2 Instant时间戳

import java.time.Instant;
import java.time.ZoneId;
import java.time.ZonedDateTime;

public class Instant方法 {
    public static void main(String[] args) {
/*
        //1. 获取当前Instant对象（标准时间）
        Instant now =  Instant.now();
        System.out.println(now);//2023-04-18T00:18:32.623003300Z
    */

        //2. 根据（秒/毫秒/纳秒）获取Istant对象
        Instant instant1 = Instant.ofEpochMilli(0L);
        System.out.println(instant1);//1970-01-01T00:00:00Z

        Instant instant = Instant.ofEpochSecond(1L);
        System.out.println(instant);//1970-01-01T00:00:01Z

        Instant instant2 = Instant.ofEpochSecond(1L, 1000000000L);
        System.out.println(instant2);//1970-01-01T00:00:02Z

        //3. 指定时间
        ZonedDateTime zonedDateTime = Instant.now().atZone(ZoneId.of("Asia/Shanghai"));
        System.out.println(zonedDateTime);//2023-04-18T08:26:19.216394900+08:00[Asia/Shanghai]

        //4 .isXXX进行判断时间
        Instant instant3 = Instant.ofEpochSecond(0L);
        Instant instant4 = Instant.ofEpochSecond(10L);
        //isBefore判断调用者代表的时间是否在参数表示时间的前面
        //isAfter判断调用者代表的时间是否在参数表示时间的后面
        boolean result1 = instant3.isAfter(instant4);
        boolean result2 = instant3.isBefore(instant4);
        System.out.println(result1+"， "+result2); //false， true

        //5. 减少时间系列
        Instant instant5 = Instant.ofEpochSecond(10000L);
        Instant instant6 = instant5.minusMillis(1000L);
        System.out.println(instant5+"，"+instant6);//1970-01-01T02:46:40Z，1970-01-01T02:46:39Z
    }
}

1.3 ZonedDateTime

import java.time.ZoneId;
import java.time.ZonedDateTime;

public class zonedDateTime {
    public static void main(String[] args) {
        //1 .获取ZonedDateTime时间对象
        ZonedDateTime time = ZonedDateTime.now();
        System.out.println(time);//2023-04-18T08:49:50.154319+08:00[Asia/Shanghai]

        //2. 获取指定的时间对象（带时区）
        ZonedDateTime time1 = ZonedDateTime.of(2023, 5, 18, 8, 59, 12, 0, ZoneId.of("Asia/Shanghai"));
        System.out.println(time1);//2023-05-18T08:59:12+08:00[Asia/Shanghai]

        // 3. withXXX 修改时间系列（年/月/日/时/分/秒）都可以
        ZonedDateTime zonedDateTime = time1.withYear(2028);
        System.out.println(zonedDateTime);//2028-05-18T08:59:12+08:00[Asia/Shanghai]

    }
}

1.4 DateTimeFormatter

日期格式化

1.5 日历类时间表示

1.6 工具类

Period

import java.time.LocalDate;
import java.time.Period;

public class JDK时间工具类 {
    public static void main(String[] args) {
        //获取当前时间对象
        LocalDate now = LocalDate.now();

        //获取生日时间对象
        LocalDate birthday = LocalDate.of(2004,01,05);

        //获取到生日与现在的时间差
        Period period = Period.between(birthday, now);
        System.out.println(period);//P19Y3M13D

        System.out.println(period.getYears());//19
        System.out.println(period.getDays());//13
        System.out.println(period.getMonths());//3

        System.out.println(period.toTotalMonths());//获取到生日到现在的一共月份             ---231---
    }
}

ChronoUnit

//获取当前时间对象
        LocalDate now = LocalDate.now();

1.7 包装类

基本数据类型对应的引用类型 -----> 基本类型—>对象

用一个对象把数据包起来

注意：

1. new Integer 是在堆区创建一个新的对象
2. Integer.ofvalue 是在-128~127之间是公用一个内存当中

Integer i6 = Integer .valueof(127);
Integer i7 = Integer.valueof(127);
System.out.println(i6 == i7);//true
Integer i8 = Integer .valueof(128);
Integer i9 = Integer.valueof(128);
System.out.println(i8 == i9);//false

JDK5提出的新特性

• 在JDK5的时候提出了一个机制:自动装箱和自动拆箱
• 自动装箱: 把基本数据类型会自动的变成其对应的包装类
• 自动拆箱:把包装类自动的变成其对象的基本数据类型

//自动装箱
Integer i1 = 10;

//创建对象与上方一致
Integer i2 = new Integer(10);

//自动拆箱
int i = i2;

在JDK5以后，int和Integer可以看做是同一个东西，因为在内部可以自动转化。

Integer成员方法

public class Interger类 {
    public static void main(String[] args) {
        //1.把整数转为二进制
        String str1 = Integer.toBinaryString(100);
        System.out.println(str1);//1100100
        //2. 把整数转为八进制
        String str2 = Integer.toOctalString(100);
        System.out.println(str2);//144
        //3. 把整数转为十六进制
        String str3 = Integer.toHexString(100);
        System.out.println(str3);//64

        //4.将字符串类型的整数转化为int类型的整数
        //强类型语言:每种数据在java中都有各自的数据类型
        // 在计算的时候，如果不是同一种数据类型，是无法直接计算的。
        int i = Integer.parseInt("123");
        System.out.println(i);//123
        System.out.println(i+1);//124--->数据转化成功
        
    }
}

二、集合进阶

2.1 集合的体系结构

• List系列集合:添加的元素是有序、可重复、有索引
• Set系列集合:添加的元素是无序不重复、无索引

2.1.1 Collection

Collection是单列集合的祖宗接口，它的功能是全部单列集合都可以继承使用的

添加对象

1 .细节：我们在添加元素的时候，如果为List 类，无论添加什么都是返回true（添加成功），因为List类可以重复； 但是如果为Set类，如果有重复的就会添加不成功，返回false，因为Set类不可以重复

 //2. 添加对象
        coll.add("aaa");
        coll.add("ccc");
        coll.add("bbb");
//        System.out.println(coll.add("bbb"));//true

删除对象

只有存在的元素才能删除，所以不存在就会返回一个false，反之true

        coll.remove("aaa");
        System.out.println(coll.remove("aaa"));//true

判断是否包含元素

底层原理：是依赖equals方法进行判断的

• 如果在集合当中存储的是自定义的对象，也想利用contains进行判断是否包含对象，就必须在自定义对象的地方进行JavaBean处理，重新来定义equals方法

coll.contains("bbb");
        System.out.println(coll.contains("bbb"));//true

判断集合是否为空，长度为多少

     //5. 判断集合是否为空
        coll.isEmpty();

        //6. 计算集合的长度
        coll.size();//2

2.2collection的遍历方式

• 迭代器遍历
• 增强for遍历
• Lambda表达式遍历

2.2.1 迭代器遍历

特点：不依赖索引

Collection集合获取迭代器

方法名称	说明
Iterator<E> iterator()	返回迭代器对象，默认指向当前集合的0索引

lterator中的常用方法:

方法名称	说明
boolean hasNext()	判断当前位置是否有元素，有元素返回true,没有元素返回false
E next()	获取当前位置的元素，并将迭代器对象移向下一个位置

遍历时的细节

• 1，报错NoSuchElementException
• 2，迭代器遍历完毕，指针不会复位
• 3，循环中只能用一次next方法
• 4，迭代器遍历时，不能用集合的方法进行增加或者删除
  若要删除可以使用Iterator里面的remove方法去除,增加元素

若要删除可以使用Iterator里面的remove方法去除：

Collection<String> coll  = new ArrayList<>();
   coll.add("aaa");
        coll.add("bbb");
        coll.add("ccc");
        coll.add("ddd");
Iterator<String> it = coll.iterator();
       //4. 利用循环，进行遍历集合
        while (it.hasNext()){
            String str = it.next();//这个方法实现了1. 获取元素 2. 指针后移一位
            if(str.equals("bbb")){
            	it.remove();
            }
        }
        System.out.println(coll);//aaa,ccc,ddd

2.2.2 增强for遍历

原理：

• 增强for的底层就是迭代器，为了简化迭代器的代码书写的。
• 它是JDK5之后出现的，其内部原理就是一个iterator迭代器
• 所有的单列集合和数组才能用增强for进行遍历

package 集合的进阶.ColectionDome;

import java.util.ArrayList;
import java.util.Collection;

public class ImportFor {
    public static void main(String[] args) {
        Collection<String> coll = new ArrayList<>();
        coll.add("aaa");
        coll.add("bbb");
        coll.add("ccc");

        //增强for遍历
        for (String s : coll) {
            System.out.println(s);
        }
    }
}

但是运用遍历的数据是第三方数据，所以通过改变第三方数据是不能改变原来数组/集合的数据的

2.2.3 lambda遍历

利用匿名内部类的形式 底层原理：就是自己利用for循环，遍历出每一个元素，把每一个元素，传递给accept s依次表示集合中的每一个元素

package 集合的进阶.ColectionDome;

import java.util.ArrayList;
import java.util.Collection;

public class lambda {
    public static void main(String[] args) {
        Collection<String> coll = new ArrayList<>();
        coll.add("aaa");
        coll.add("bbb");
        coll.add("ccc");

        
 /*       coll.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });*/

        //lambda表达式
        coll.forEach(s -> System.out.println(s));
    }
}

2.2.4 列表迭代器 ListIterator

ListIterator与Iterator的区别：

ListInterator可以添加元素

ListIterator<String> its = coll.listIterator();
        while (its.hasNext()){
            String next = its.next();
            if(next.equals("bbb")){
                its.remove();
                its.add("hhhh");
            }
            System.out.println(next);
        }
        System.out.println(coll);
    }

2.2.5 五种遍历方式对比

迭代器遍历:在遍历的过程中需要删除元素，请使用迭代器
列表迭代器: 在遍历的过程中需要添加元素，请使用列表迭代器
增强for遍历 \ Lambda表达式:仅仅想遍历，那么使用增强for或Lambda表达式
普通for: 如果遍历的时候想操作索引，可以用普通for.

2.3 List集合

• 有序:存和取的元素顺序一致有
• 索引:可以通过索引操作元素
• 可重复:存储的元素可以重复

List特有方法：

1. Collection的方法List都继承了
2. List集合因为有索引，所以多了很多索引操作的方法

方法名称	说明
void add(int index,E element)	在此集合中的指定位置插入指定的元素
E remove(int index)	删除指定索引处的元素，返回被删除的元素
E set(int index,E element)	修改指定索引处的元素、返回被修改的元素
E get(int index)	返回指定索引处的元素

package 集合的进阶.ListDome;

import java.util.ArrayList;
import java.util.List;

public class listDome1 {
    public static void main(String[] args) {
        //1. 创建List对象
        List<String> list = new ArrayList<>();

        //2. 添加对象
        list.add("aaa");
        list.add(1,"bbb");
        list.add("ccc");
        list.add(0,"dddd");
//        System.out.println(list);//[dddd, aaa, bbb, ccc]

        //3. 删除元素
        list.remove(1); //按照索引来删除元素
        list.remove("aaa");//按照元素来删除

        // 4. 修改元素
        list.set(1,"fff");
//        System.out.println(list);//[dddd, fff, ccc]

        //5. 查找元素
        System.out.println(list.get(1));//fff
    }
}

注意：在remove当中若出现删除元素与index（索引值）一样就得

2.4 数据结构

• 数据结构是计算机底层存储、组织数据的方式是指数据相互之间是以什么方式排列在一起的。
• 数据结构是为了更加方便的管理和使用数据，需要结合具体的业务场景来进行选择
• 一般情况下，精心选择的数据结构可以带来更高的运行或者存储效率

2.4.1 栈

特点：后进先出，先进后出

2.4.2 队列

特点： 先进先出，后进后出

2.4.3 数组

查询速度快: 查询数据通过地址值和索引定位，查询任意数据耗时相同。(元素在内存中是连续存储的)
删除效率低:要将原始数据删除，同时后面每个数据前移
添加效率极低:添加位置后的每个数据后移，再添加元素。

2.4.4 链表

• 结点：链表当中的每一个元素
  
  特点：

• 链表中的结点是独立的对象，在内存中是不连续的，每个结点包含数据值和下一个结点的地址。
• 链表查询慢，无论查询哪个数据都要从头开始找。
• 链表增删相对快

2.5 ArrayList

底层原理：

• 利用空参创建的集合，在底层创建一个默认长度为0的数组
• 添加第一个元素时，底层会创建一个新的长度为10的数组
• 存满时，会扩容1.5倍
• 如果一次添加多个元素，1.5倍还放不下，则新创建数组的长度以实际为准

当添加第一个元素的时候

当添加大于10的元素时候

2.6 LinkedList集合

• 底层数据结构是双链表，查询慢，增删快，但是如果操作的是首尾元素，速度也是极快的。
• LinkedList本身多了很多直接操作首尾元素的特有API

特有方法	说明
public void addFirst(E e)	在该列表开头插入指定的元素
public void addLast(E e)	将指定的元素追加到此列表的末尾
public E getFirst()	返回此列表中的第一个元素
public E getLast()	返回此列表中的最后一个元素
public E removeFirst()	从此列表中删除并返回第一个元素
public E removeLast()	从此列表中删除并返回最后一个元素

底层源码：

iterator底层原理解析

2.7 泛型深入

1. 泛型:是]DK5中引入的特性，可以在编译阶段约束操作的数据类型，并进行检查
2. 泛型的格式:<数据类型>
3. 注意:泛型只能支持引用数据类型

泛型的好处:

• 统一数据类型。
• 把运行时期的问题提前到了编译期间，避免了强制类型转换可能出现的异常，因为在编译阶段类型就能确定下来

结论：

1. 如果没有给集合指定的类型，默认所有的数据类型都是Object类型
2. 这个时候可以往集合里面添加任意的数据类型
3. 带来的坏处是：我们在获取数据的时候，无法使用他的特有行为

泛型的细节：

• 泛型中不能写基本数据类型
• 指定泛型的具体类型后，传递数据时，可以传入该类类型或者
• 子类类型如果不写泛型，类型默认是object

2.7.1 泛型类

使用场景:当一个类中，某个变量的数据类型不确定时，就可以定义带有泛型的类

此处E可以理解为变量，但是不是用来记录数据的，而是记录数据的类型，可以写成:T、E、K、V等

书写的方法

package 集合的进阶.MyArrayList;

import java.util.Arrays;

public class MyArrayList<E> {
    //创建一个Object数组
    Object[] obj = new Object[10];
    int size;//数组长度

    //E表示不确定要添加的数据类型，e表示添加的数据
    public boolean add(E e){
        obj[size] = e;//将数据存入
        size++;
        return true;
    }
    public E get(int index) {
        return (E)obj[index];
    }

    //方法重写，使得打印出来的list为String
    @Override
    public String toString(){
    return Arrays.toString(obj);
    }
}

调用的方法：

package 集合的进阶.MyArrayList;

public class Test {
    public static void main(String[] args) {
        //创建自己搭建的MyArrayList
        MyArrayList<String> list = new MyArrayList<>();
        list.add("sada");
        list.add("sada123");
        list.add("sadsada");
        System.out.println(list);
        System.out.println(list.get(1));
    }
}

2.7.2 泛型方法

方法中形参类型不确定时：
方案1:使用类名后面定义的泛型 所有方法都能用
方案2:在方法申明上定义自己的泛型 只有本方法能用

package 集合的进阶.LIstUtil;

import java.util.ArrayList;

public class listUtil {
    private listUtil(){

    }

    private static <E> void addAll(ArrayList list ,E e1,E e2){
        list.add(e1);
        list.add(e2);
    }
}

2.7.3 泛型接口

重点:如何使用一个带泛型的接口
方式1:实现类给出具体类型
方式2:实现类延续泛型，创建对象时再确定

接口泛型

public class MyArrayList2<E> implements List<E> {
	//接所有方法的重写
}

测试：

package 集合的进阶.MyArrayList;

public class Test2 {
    public static void main(String[] args) {
        MyArrayList2<String> list2 = new MyArrayList2<String>();
        list2.add("sadsad");//因为创建的是字符串类型，所以只能添加字符串
    }
}

2.7.4 泛型的继承和通配符

• 泛型不具备继承性，但是数据具备继承性

? extends E: 表示可以传递E或者E所有的子类类型
? super E:表示可以传递E或者E所有的父类类型

package 集合的进阶.MyArrayList;

import java.util.ArrayList;

public class MyArrayList4 {
    public static void main(String[] args) {
        //创建对象
        ArrayList<Ye> list1 = new ArrayList<>();
        ArrayList<Fu> list2 = new ArrayList<>();
        ArrayList<Zi> list3 = new ArrayList<>();
        ArrayList<Students> list4 = new ArrayList<>();

        methods(list1);
        methods(list2);
        methods(list3);
//        methods(list4); //报错

        method2(list1);
    }

    private static void method2(ArrayList<? super Zi> list) {
        //创建表示可以传递Zi或者Zi所有的父类类型
    }

    private static void methods(ArrayList<? extends Ye> list) {
        //创建的是一个表示可以传递Ye或者Ye所有的子类类型
    }

}
class Fu extends Ye{}
class Ye{}
class Zi extends  Fu{}
class Students{}

但是数据具备继承性:

ArrayList<Ye> list1 = new ArrayList<>(); list1.add(new Ye());
list1.add(new Fu());
list1.add(new Zi());