作者的话

前言：这些都是很基本的，还有很多没有写出来，重点在于考试复习，包括后四章的内容

前面内容请参考JAVA阶段考内容知识点的梳理

一、集合、流

课堂总结1集合

集合概念：
保存和盛装数据的容器，将许多元素组合成一个单一单元的容器对象。
集合框架：
表示和操作集合的体系，包括接口、实现类，集合框架的结构图。

接口：Iterable、Iterator、Collection、List、Queue、Set、Map;
类：ArrayList,LinkedList,HashSet,TreeSet,HashMap,TreeMap,Stack;

具体实现：

java.lang.Iterable接口：实现了此接口类的对象，支持使用Iterable遍历元素及支持For Each循环语句；
boolean add()，向集合添加元素。如调用更改了集合返回true，下同
next()//向后移动游标，同时返回游标指向的元素；
remove()//移除当前游标未知的元素；
java.util.Collection接口：用于描述最具用通用性的集合，包含了最具有通用性的集合操作和方法；
boolean add()，向集合添加元素。如调用更改了集合返回true，下同
boolean addAll()，向集合添加一个集合
boolean remove()，从集合移除中指定元素
boolean removeAll()，从集合移除包含指定集合
void clear()，移除集合全部元素
boolean contains()，判断集合是否包含指定元素
boolean containsAll()，判断是否包含包含指定集合
boolean isEmpty()，判断集合是否包含元素
int size() ，集合长度
T[] toArray(，将集合转为指定类型的数组
Iterator<E> iterator()，获取迭代器;
java.util.List集合:有序的，允许包含重复的元素集合。除了从Collection继承的方法外，提供基于位置索引的操作方法：
add()，将指定位置元素后移，添加
set()，替换
get(int index)，获取
remove(int index)，移除
List集合接口基本实现类，即不同数据结构的实现
java.util.ArrayList，基于对象数组数据结构的实现，用的最多，整体性能好
java.util.LinkedList，基于双向链表数据结构的实现
List与数组的转换：
List to Array 用toArray()方法；

Array to List:Arrays工具类提供asList(T… a)方法：asList()方法为适配器模式方法，仅转换了类型，底层仍是数组。因此，执行任何修改集合长度方法(add/remove等)，将抛出异常

java.util.Map接口：用于存放键值对（key-value），通过Key值获取相应的value值
Map中key必须是唯一的，且每个key只能对应一个value；但不同key，可以对应同一个value；添加key-value时，如果key已经存在，则后一个覆盖前一个。
支持以任何类型（引用类型）对象为key/value
基本实现类：
java.util.HashMap，查询效率与内存占用最平衡，非线程安全；
java.util.TreeMap;
java.util.Table
常用操作方法：
put( key, value)，保存键值对
get( key)，基于key获取对应的value，如果value不存在，返回null
getOrDefault(key, VValue)，获取对应的value，没有则使用默认值
remove( key) ,去除对应的value值
containsKey(Object key)，键是否存在；
containsValue(Object value)，值是否存在；
size() ，长度；
isEmpty()，是否为空；

如何判断key相同?重写hashCode()和equals()方法

String重写了hashCode()/equals()方法，因此直接基于字符串值，而非对象的hash值比较（好像大致意思是判断key相等是用key的直接基于key的字符串值判断）

Set集合：不包含重复元素(数学中集合的抽象)扑克牌，不重复的关系，人，事物等

是否重复：根据hashCode()/equals()

Set接口：只包含继承自Collection方法，并添加禁止重复元素的限制，无基于索引的操作方法；

基本实现类：

java.util.HashSet<>，元素无序(底层基于HashMap确定元素是否重复)

java.util.LinkedHashSet<>，元素有序

java.util.TreeSet <>，元素有序

不可变集合，就是不可被修改的集合，定义完成后不可以修改，或者添加、删除。集合的数据项在创建的时候提供，并且在整个生命周期中都不可改变。

在Java 9中，可以使用静态工厂方法List.of、Set.of与Map.of来创建不可变列表、集合或映射

注意

课堂总结2流

函数式编程是一种程序设计思想

Stream操作的是集合中的元素，而非集合本身。因此，将创建新集合聚合Stream操作的结果，而不影响源集合结构
使用Stream的基本步骤包括：
创建Stream：通过stream()方法，取得集合对象的数据集。
Intermediate：通过一系列中间（Intermediate）方法，对数据集进行过滤、检索等数据集的再次处理。例如，使用filter()方法来对数据集进行过滤。
Terminal：通过最终（terminal）方法完成对数据集中元素的处理。例如，使用forEach()完成对过滤后元素的打印
中间操作
filter（）：过滤掉不和要求的元素、把表达式结果为真的元素放入新流中

map（）：把流中元素的类型映射为新类型，如，只要元素的某个属性

sorted（Comparator.**）：对流中元素排序。

Comparator.comparing()基于指定值排序、 reversed()倒序

终止操作

collect（Collectors.**）

Collectors的groupingBy()按指定类型分组返回Map、toList()、toSet()、toMap()转化为映射关系给出key和value

forEach()

jdk8以后map也有forEach（）方法，map提供的，不是继承的

forEach((k, v) -> { System.out.println(k + "/" + v.getColor()); });

元素删除Collection的removeIf（）方法，基于Iterator实现。

课堂总结3Optional容器

引入原因：解决空指针异常。
Optional单值容器、提供很多有用的方法，使用时不用显式进行空值检测
获得Optional对象

ofNullable（）元素不必为空
of（）元素必不为空//用的少
常见方法
ifPresent(Consumer consumer)不空执行参数操作，空什么也不做
中间操作filter（）过滤、map映射为新类型的容器。都可以返回空容器or（）jdk9的方法，为空时执行参数函数，且必须返回相同类型的容器
终止操作：orElse（）：得到元素类型，为空时返回参数创建对象
orEsleGet（）空时执行函数，返回元素对象
get（）、得到容器对象，空抛异常，不建议用，用orElse（）
isPresent（）判断是否为空

二、异常

课堂总结

异常的分类：

Throwable 是所有异常的祖先，Throwable有两个子类，Error和Exception;
Error是错误，表示运行应用程序中出现了严重错误，都是通过Error抛出的，一般程序无法处理；
Exception是异常，表示程序运行的时候，程序本身可以捕获并可以处理的错误；
常用异常：

异常处理的关键字：

捕获异常：
try:执行可能产生异常的代码；
catch：捕获异常；
finally:无论是否发生异常，代码总被执行；
抛出异常：
throw:异常生成阶段，手动抛出异常对象；
声明异常：
throws声明方法可能要抛出的各种异常类

定义新的异常：

Throwable类中的常用方法：

三、线程

课堂总结

程序、进程、线程

程序：是指含有指令和数据的文件，被存储在磁盘或其他的数据设备中，也就是说程序是静态的代码；
进程：是程序的一次执行过程，是代码在数据集合上的一次运行活动，是系统资源分配和调度的基本单位；
线程：线程是进程中的一个实体，是被系统独立调度和分派的基本单位，一个进程中至少有一个线程，进程中的多个线程共享进程的资源；

简而言之，一个程序至少有一个进程，一个进程至少有一个线程

线程的创建：

继承Thread类创建线程

实现Runnable接口创建线程

执行顺序

Thread类的常用方法：

start(): 启动一个新线程并执行 run() 方法中的代码。
run(): 定义线程要执行的代码。
sleep(long millis): 使当前线程暂停执行指定的时间。
join(): 等待该线程终止。
interrupt(): 中断该线程。

notify()和notifyAll()的作用，则是唤醒当前对象上的等待线程；notify()是唤醒单个线程，而notifyAll()是唤醒所有的线程。

wait()：的作用是让当前线程进入等待状态，同时，wait()也会让当前线程释放它所持有的锁。直到其他线程调用此对象的

线程的同步：

volatile关键字：

简单，保证数据的可见性。就是一个线程在对主内存的某一份数据进行更改时，改完之后会立刻刷新到主内存。并且会强制让缓存了该变量的线程中的数据清空，必须从主内存重新读取最新数据。

Volatile，可以保证变量的可见性，但，无法保证并发执行操作的原子性

synchronized 关键字

它用于修饰方法或代码块。当一个方法或代码块被声明为 synchronized 时，它表示这个方法或代码块是同步的，只能被一个线程同时访问。

synchronized 关键字可以保证线程安全，防止多个线程同时访问和修改共享数据。当一个线程进入 synchronized 方法或代码块时，它会获得一个锁；当这个线程离开 synchronized 方法或代码块时，它会释放这个锁。只有获得锁的线程才能进入 synchronized 方法或代码块，

构造函数不能同步，在构造函数中使用synchronized关键字是语法错误

synchronized无法修饰抽象方法

四、IO操作

课堂总结

IO流的概念：

IO流，将不同的输入输出，以相同的方式操作read(),write();创建不同类型的流，有不同的实现方式，不同类型的流，又有各自特有的操作方式。
无论内部如何工作，所有IO流呈现的都是相同的，简单的模式，程序中流入或流出的一系列数据。

Inputstream、Outputstream:

输入流，输出流的操作超类，支持子类以基本字节的方式操作二进制数据
java.io.InputStream抽象类：基本子类，ByteArrayInputStream,FileInputStream等；
int read() throws IOException,抽象方法由具体子类实现，返回流中下一字节（必然是0-255之间的整数表示），如果到达流末没有可读字节，返回-1.
java.io.OutputStream抽象类：基本子类，ByteArrayOutputStream,FileOutputStream等；
void write(int b) throws IOException 抽象方法。将十进制按字节写入输出流。
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.file.Paths;
 
public class TestIO {
    public static void main(String[] args) {
        try {
            getByteStreams();
        } catch (IOException e) {
            e.printStackTrace();
        }
 
    }
    public static void getByteStreams()throws IOException {
        FileInputStream in=new FileInputStream("C:/Users/yu/Desktop/a.txt");
        FileOutputStream out=new FileOutputStream("C:/Users/yu/Desktop/b.txt");
        int c;
        while((c=in.read())!=-1){
            System.out.println("读取字节的10进制整数："+c);
            out.write(c);
        }
        in.close();//有个问题就在于一旦异常了资源就无法关闭；
        out.close();
    }
 
}
资源文件的关闭：资源文件，比如IO流不会像其他对象，因失去引用而自动释放占用的资源，因此，必须被正确的关闭，否则会导致内存的溢出，以IO流为例，为确保无论是否出现异常，资源均被关闭，应在finally块中手动关闭资源，但这样会让程序中有大量的冗余；

try-with-resources语句，极大的简化了资源处理代码，使开发者无需关心资源状态，无需关心资源对象的创建顺序，无需关心资源对象的正确关闭方式
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
 
public class Main {
    public static void main(String[] args) {
        getByteStreams();
    }
 
    public static void getByteStreams() {
        // 使用try-with-resources语句来创建输入流和输出流
        try (FileInputStream in = new FileInputStream("D:/桌面/in.txt");
             FileOutputStream out = new FileOutputStream("D:/桌面/out.txt")) {
            int c;
            while ((c = in.read()) != -1) {
                System.out.println("读取字节的10进制整数：" + c);
                out.write(c);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
注意：

（1）资源的自动关闭，与异常无关。异常改怎么处理依然怎么处理。

（2）在try语句中声明使用资源后，执行顺序：

无异常，在try块执行后，自动关闭资源，finally块

有异常，自动关闭资源，catch块，finally块

路径：

绝对路径，始终包含根元素和查找文件所需的完整目录列表。例如，D:/test/a.txt。找到文件所需的所有信息都包含在路径声明中

相对路径，例如，a.txt。没有更多信息，程序将无法访问。即，相对路径，最终也必须基于绝对路径描述。‘

Path接口:Path代表一个不依赖于系统的文件路径。即运行在不同操作系统下，Path的具体实现不同(windows/linux)，但开发者仅需面向Path描述路径，不同系统，而无需关心操作系统差异。

Path getFileName()，返回文件名或名称元素序列的最后一个元素。即，最后一个路径描述，可能是文件名也可能是目录名

Path getParent()，返回父目录的路径

Path getRoot()，返回路径的根

Path resolve(Path other)方法，将路径拼接为一个新路径

boolean equals(Object obj):重写了equals判断路径是否相同

Files工具类：

java.nio.file.Files工具类，提供了丰富的基于Path操作的静态方法，读取/写入/操作，文件与目录。方法分类：

文件或目录的判断：

boolean exists(Path path)/notExists(Path path)，Path路径是否存在

Boolean isDirectory(Path path)，path是否为目录

文件或目录的创建：

Path createDirectory(Path dir) throws IOException。目录路径已存在则异常；目录路径为多级目录，异常

Path createDirectories(Path dir) throws IOException。自动创建多级不存在目录；目录已存在，无异常

Path createFile(path) throws IOException。基于指定路径，创建文件。文件存在，异常

文件或目录的复制：

Path copy(Path source, Path target, CopyOption... options) throws IOException，将文件复制到目标文件。默认，如果文件已经存在，异常

如果source为目录，不会复制里面的文件，仅相当于创建一个空目录

java.nio.file.StandardCopyOption枚举，实现了CopyOption接口，复制选项

文件或目录的移动：

Path move(Path source, Path target, CopyOption... options) throws IOException，将文件移动或重命名为目标文件。

默认，如果目标文件存在，则异常，可通过options参数声明移动选项

如果在本目录下移动，相当于文件改名

文件或目录的删除：

void delete(Path path) throws IOException。删除指定路径；路径不存在，异常

boolean deleteIfExists(Path path) throws IOException。路径不存在，不删除。返回是否删除成功

如果路径为目录，目录中包含文件(即不为空)，2种删除均异常

指定路径的遍历（Files的方法）：

Stream<Path> walk(Path start, int maxDepth) throws IOException：遍历，基于指定深度遍历path路径中的目录和文件

Stream<Path> walk(Path start) throws IOException：遍历path路径中的所有目录和文件，包括子目录的，观察遍历时的输出顺序，按层次输出的。注意返回值是流，后面可以用流的操作，比如过滤，排序等功能。可以借助于此方法删除非空目录