JAVA期末考内容知识点的梳理

我就是我 2024-04-17 11:45 104阅读 0赞

## 作者的话 ##

> 前言：这些都是很基本的，还有很多没有写出来，重点在于考试复习，包括后四章的内容
> 
> 前面内容请参考[JAVA阶段考内容知识点的梳理][JAVA]

## 一、集合、流 ##

### 课堂总结1集合 ###

>  *  集合概念：
>     
>      *  保存和盛装数据的容器，将许多元素组合成一个单一单元的容器对象。
>  *  集合框架：
>     
>      *  表示和操作集合的体系，包括接口、实现类，集合框架的结构图。
> 
> ![4ede152b69a1475f945b23c974f34fbe.jpg][]
> 
> ![8d808922930e44928ab1da5f99b84bfa.png][]
> 
>  *  接口：Iterable、Iterator、Collection、List、Queue、Set、Map;
>  *  类：ArrayList,LinkedList,HashSet,TreeSet,HashMap,TreeMap,Stack;

> 具体实现：
> 
> 1.   **java.lang.Iterable接口：实现了此接口类的对象，支持使用Iterable遍历元素及支持For Each循环语句；**
> 2.  **boolean add()，向集合添加元素。如调用更改了集合返回true，下同**
>     
>     1.  **next()//向后移动游标，同时返回游标指向的元素；**
>     2.  **remove()//移除当前游标未知的元素；**
> 3.  **java.util.Collection接口：用于描述最具用通用性的集合，包含了最具有通用性的集合操作和方法；**
>     
>     1.  **boolean add()，向集合添加元素。如调用更改了集合返回true，下同**
>     2.  **boolean addAll()，向集合添加一个集合**
>     3.  **boolean remove()，从集合移除中指定元素**
>     4.  **boolean removeAll()，从集合移除包含指定集合**
>     5.  **void clear()，移除集合全部元素**
>     6.  **boolean contains()，判断集合是否包含指定元素**
>     7.  **boolean containsAll()，判断是否包含包含指定集合**
>     8.  **boolean isEmpty()，判断集合是否包含元素**
>     9.  **int size() ，集合长度**
>     10. **T\[\] toArray(，将集合转为指定类型的数组**
>     11. **Iterator<E> iterator()，获取迭代器;**
> 4.  **java.util.List集合:有序的，允许包含重复的元素集合。除了从Collection继承的方法外，提供基于位置索引的操作方法：**
>     
>     1.  **add()，将指定位置元素后移，添加**
>     2.  **set()，替换**
>     3.  **get(int index)，获取**
>     4.  **remove(int index)，移除**
> 5.  **List集合接口基本实现类，即不同数据结构的实现**
>     
>     1.  **java.util.ArrayList，基于对象数组数据结构的实现，用的最多，整体性能好**
>     2.  **java.util.LinkedList，基于双向链表数据结构的实现**
> 6.  **List与数组的转换：**
>     
>     1.  **List to Array 用toArray()方法；**
>     2.  **Array to List:Arrays工具类提供asList(T… a)方法 ：asList()方法为适配器模式方法，仅转换了类型，底层仍是数组。因此，执行任何修改集合长度方法(add/remove等)，将抛出异常**
> 7.  **java.util.Map接口：用于存放键值对（key-value），通过Key值获取相应的value值**
>     
>     1.  **Map中key必须是唯一的，且每个key只能对应一个value；但不同key，可以对应同一个value；添加key-value时，如果key已经存在，则后一个覆盖前一个。**
>     2.  **支持以任何类型（引用类型）对象为key/value**
>     3.  **基本实现类：**
>         
>         1.  **java.util.HashMap，查询效率与内存占用最平衡，非线程安全；**
>         2.  **java.util.TreeMap;**
>         3.  **java.util.Table**
>     4.  **常用操作方法：**
>         
>         1.  **put( key, value)，保存键值对**
>         2.  **get( key)，基于key获取对应的value，如果value不存在，返回null**
>         3.   **getOrDefault(key, VValue)，获取对应的value，没有则使用默认值**
>         4.  **remove( key) ,去除对应的value值**
>         5.  **containsKey(Object key)，键是否存在；**
>         6.  **containsValue(Object value)，值是否存在；**
>         7.  **size() ，长度；**
>         8.   **isEmpty()， 是否为空；**
>     5.  **如何判断key相同?重写hashCode()和equals()方法**
>         
>         **String重写了hashCode()/equals()方法，因此直接基于字符串值，而非对象的hash值比较（好像大致意思是判断key相等是用key的直接基于key的字符串值判断）**
> 8.  **Set集合：不包含重复元素(数学中集合的抽象)扑克牌，不重复的关系，人，事物等**
>     
>     **是否重复：根据hashCode()/equals()**
> 9.  **Set接口：只包含继承自Collection方法，并添加禁止重复元素的限制，无基于索引的操作方法；**
>     
>     1.  **基本实现类：**
>     2.  **java.util.HashSet<>，元素无序(底层基于HashMap确定元素是否重复)**
>     3.  **java.util.LinkedHashSet<>，元素有序**
>     4.  **java.util.TreeSet <>，元素有序**
> 10. 不可变集合，就是不可被修改的集合，定义完成后不可以修改，或者添加、删除。集合的数据项在创建的时候提供，并且在整个生命周期中都不可改变。
>     
>     在Java 9中，可以使用静态工厂方法List.of、Set.of与Map.of来创建不可变列表、集合或映射

注意

![c72343514a914a44b5ef11e4af059760.png][]

### 课堂总结2流 ###

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

> 1.  Stream操作的是集合中的元素，而非集合本身。因此，将创建新集合聚合Stream操作的结果，而不影响源集合结构
> 2.  使用Stream的基本步骤包括：
>     
>     1.  创建Stream：通过stream()方法，取得集合对象的数据集。
>     2.  Intermediate：通过一系列中间（Intermediate）方法，对数据集进行过滤、检索等数据集的再次处理。例如，使用filter()方法来对数据集进行过滤。
>     3.  Terminal：通过最终（terminal）方法完成对数据集中元素的处理。例如，使用forEach()完成对过滤后元素的打印
> 3.  中间操作
>     
>     1.  filter（）：过滤掉不和要求的元素、把表达式结果为真的元素放入新流中
>     2.  map（）：把流中元素的类型映射为新类型，如，只要元素的某个属性
>     3.  sorted（Comparator.\*\*）：对流中元素排序。
>     4.  Comparator.comparing()基于指定值排序、 reversed()倒序
> 4.  终止操作
>     
>     1.  collect（Collectors.\*\*）
>     2.  Collectors的groupingBy()按指定类型分组返回Map、toList()、toSet()、toMap()转化为映射关系给出key和value
>     3.  forEach()
> 5.  jdk8以后map也有forEach（）方法，map提供的，不是继承的
>     
>     forEach((k, v) -> \{ System.out.println(k + "/" + v.getColor()); \});
> 6.  元素删除Collection的removeIf（）方法，基于Iterator实现。

### 课堂总结3Optional容器 ###

> 1.  引入原因：解决空指针异常。
> 2.  Optional单值容器、提供很多有用的方法，使用时不用显式进行空值检测
> 3.  获得Optional对象
> 4.  1.  ofNullable（）元素不必为空
>     2.  of（）元素必不为空//用的少
> 5.  常见方法
>     
>     1.  ifPresent(Consumer consumer)不空执行参数操作，空什么也不做
>     2.  中间操作filter（）过滤、map映射为新类型的容器。都可以返回空容器or（）jdk9的方法，为空时执行参数函数，且必须返回相同类型的容器
>     3.  终止操作：orElse（）：得到元素类型，为空时返回参数创建对象  
>         orEsleGet（）空时执行函数，返回元素对象  
>         get（）、得到容器对象，空抛异常，不建议用，用orElse（）
>     4.  isPresent（）判断是否为空

### 相关习题 ###

1.Java集合框架的顶级接口是（C）

*  A. Iterable
 *  B. Iterator
 *  C. Collection
 *  D. List

> Collection接口是Java集合框架的根接口，它定义了一组对象的基本操作，如添加、删除、清空、遍历等。Iterable接口是一个功能接口，它只有一个抽象方法iterator()

2.正确声明一个整型集合变量（B）

*  A. List<int> list;
 *  B. List<Integer> list;
 *  C. List list<int>;
 *  D. List list<T>;

3.若类A继承自类B，变量List<A> list1集合中允许添加类B对象

*  A. 对
 *  B. 错

> 因为List<A>是List的子类，而List<B>也是List的子类，但是List<A>和List<B>之间并没有任何关系。所以，变量List<A> list1集合中只能添加A类型的对象，而不能添加B类型的对象

补充题

类B继承自类A，集合List<A>，当向集合添加B类型对象时( )

*  A. 编译时错误
 *  B. 运行时错误
 *  C. 警告
 *  D. 无错误

> 父类无法添加，子类能添加

4.LinkedList是继承自Collection接口的一种基于链表的集合类型

*  A. 对
 *  B. 错

> *答案解析：*
> 
> LinkedList不是集合类型，而是List集合类型的一种基于双向链表的实现

5.Map是一种用于存放键值对的集合类型

*  A. 对
 *  B. 错

> Map不是集合

6.欲构造ArrayList类的一个实例，下列哪个语句是正确的（B ）？

*  A. ArrayList myList=new Object ();
 *  B. List myList=new ArrayList ();
 *  C. ArrayList myList=new List ();
 *  D. List myList=new List ();

7.集合Stream是一种操作集合的容器

*  A. 对
 *  B. 错

8. (判断题)集合Stream可通过过滤操作移除源集合中的元素

*  A. 对
 *  B. 错

> stream的操作会产生新集合,不会影响源集合结构

9.Optional是一种集合类型，可以向里面添加多个同类型的对象。

*  A. 对
 *  B. 错

> Optional并不是一种集合类型，而是一种用于表示一个可能存在的值或者不存在的值的包装类型。它通常用于处理可能为空的情况，而不是用于存储多个对象。Optional类型要么包含一个非空的值，要么为空。如果要表示多个同类型的对象，通常会使用List、Set或者其他集合类型。

10.Optional的map()方法,允许改变容器中元素类型

*  A. 对
 *  B. 错

> Optional类提供了map()方法，它允许对Optional对象中的值进行转换，并返回一个包含转换结果的新的Optional对象。map()方法的作用是对Optional对象进行转换操作，可以改变容器中元素的类型。这在处理Optional对象时非常有用，可以将一个类型的Optional对象转换为另一个类型的Optional对象。

## 二、异常 ##

### 课堂总结 ###

> 异常的分类：
> 
> ![ed442b504efaabb577d76a5757ccb881.png][]
> 
> 1.  **Throwable 是所有异常的祖先，Throwable有两个子类，Error和Exception;**
> 2.  **Error是错误，表示运行应用程序中出现了严重错误，都是通过Error抛出的，一般程序无法处理；**
> 3.  **Exception是异常，表示程序运行的时候，程序本身可以捕获并可以处理的错误；**
> 4.  **常用异常：**![ff6c458c68f549b5b9125e3de00759f4.png][]
> 
> **异常处理的关键字：**
> 
> 1.  **捕获异常：**
>     
>     1.  **try:执行可能产生异常的代码；**
>     2.  **catch：捕获异常；**
>     3.  **finally:无论是否发生异常，代码总被执行；**
> 2.  **抛出异常：**
>     
>     1.  **throw:异常生成阶段，手动抛出异常对象；**
> 3.  **声明异常：**
>     
>     1.  **throws声明方法可能要抛出的各种异常类**
> 
> ![e2fc158dbe804f81be0ec59eb5e0bb61.png][]
> 
> ![70395d7f67304d389aa6194228170b77.png][]
> 
> **定义新的异常：**
> 
> Throwable类中的常用方法：
> 
> ![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5bCP5p2O5bCP5LqO_size_20_color_FFFFFF_t_70_g_se_x_16][]

### 相关习题 ###

1.基于以下代码，分析方法，未引发异常，的输出结果

private static void try() {
    
        try {
    
          System.out.println("A");
    
          method(); // 未引发异常
    
          System.out.println("B");
    
          return;
    
          System.out.println("C");
    
        } catch (Exception e) {
    
          System.out.println("D");
    
        } finally {
    
          System.out.println("E");
    
        }
    
        System.out.println("F");
    
        return;
    
      }

*  A. A B
 *  B. A B E
 *  C. A B E F
 *  D. A E B

2.基于以下代码，分析方法，引发异常，的输出结果

private static void try() {
    
        try {
    
          System.out.println("A");
    
          method(); // 引发异常
    
          System.out.println("B");
    
          return;
    
          System.out.println("C");
    
        } catch (Exception e) {
    
          System.out.println("D");
    
        } finally {
    
          System.out.println("E");
    
        }
    
        System.out.println("F");
    
        return;
    
      }

*  A. A D E B
 *  B. A D B E F
 *  C. A D E F
 *  D. A D E B C

3.仅支持自定义Unchecked类型异常，不支持自定义checked类型异常

*  A. 对
 *  B. 错

> Java中支持自定义checked类型异常和unchecked类型异常。checked异常是指在程序编译时必须处理的异常，而unchecked异常是指在程序运行时才会出现的异常。Java中的RuntimeException及其子类都是unchecked异常，其他的Exception及其子类都是checked异常

4.自定义异常类时，可以继承的类是（ ）

*  A. Error
 *  B. Applet
 *  C. Throwable、Exception及其子类
 *  D. AssertionError

5.对于catch子句中异常的排列，下列哪种是正确的(  )

*  A. 父类异常在先，子类异常在后
 *  B. 子类异常在先，父类异常在后
 *  C. 有继承关系的异常不能在同一个try程序段内
 *  D. 异常怎么排列都可以，和次序无关

> 这是因为如果父类异常在先，那么后面的子类异常就不会被捕获，因为父类异常已经包含了子类异常。而且通常子类异常的信息比父类异常更精确。所以为了正确处理不同类型的异常，应该按照从小到大的范围排列catch子句

6.父类中未声明抛出异常的方法，子类重写时允许增加抛出checked类型异常声明

*  A. 对
 *  B. 错

> 子类重写父类的方法时，对于checked异常，子类不能增加抛出异常的声明。子类只能抛出父类方法中声明的异常或者其子类型的异常，或者完全不抛出异常。这是为了保证子类的使用不会比父类更容易出错，遵循了Liskov替换原则。  
>   
> 如果父类的方法没有声明抛出任何checked异常，子类在重写该方法时也不能声明抛出任何checked异常。如果子类的方法抛出了checked异常，编译器会报错。只有unchecked异常可以在子类方法中抛出而不受限制。

7.出现异常时，java会沿方法调用栈寻找最近一个专门捕获处理与此异常类型相同的程序，而非能处理此异常类型的程序

*  A. 对
 *  B. 错

> 在Java中，当异常出现时，Java虚拟机会沿着方法调用栈向上寻找能够处理该异常的程序，直到找到合适的异常处理器。这个处理器可以是专门捕获并处理该异常类型的程序，也可以是能够处理该异常类型或其父类型的通用异常处理器。  
>   
> Java异常处理机制允许使用try-catch语句来捕获和处理异常。当异常发生时，程序会跳转到能够处理该异常的catch块，而不是继续向上查找最近一个专门捕获处理该异常类型的程序。因此，异常处理器不一定是专门为某个异常类型而设计的，而是能够处理该异常类型或其父类型的异常处理器。  
>   
> 所以，给定的陈述是错误的。正确的表述应该是：当异常出现时，Java会沿方法调用栈向上寻找能够处理该异常类型或其父类型的异常处理器。

8.可以不在出现异常的方法内捕获处理异常

*  A. 对
 *  B. 错

> 在Java中，可以在异常发生的方法外部捕获和处理异常。Java异常处理机制允许使用try-catch语句块来捕获异常，并在合适的地方进行处理。这意味着可以在调用异常可能发生的方法的地方使用try-catch语句来捕获和处理异常，而不一定需要在异常发生的方法内部处理异常。

9.方法声明抛出异常，会影响方法签名

*  A. 对
 *  B. 错

10.构造函数上禁止抛出异常

*  A. 对
 *  B. 错

> 在Java中，构造函数可以抛出异常。与其他方法一样，构造函数可以在其声明中包含抛出异常的声明。  
>   
> 构造函数可以抛出受检异常（checked exceptions）和未受检异常（unchecked exceptions）。受检异常是在方法声明中显式声明的异常，调用者必须处理或继续抛出。未受检异常是RuntimeException或其子类的异常，调用者可以选择性地处理或继续抛出。  
>   
> 当构造函数抛出受检异常时，调用者在创建对象实例时必须处理这些异常，可以通过try-catch块捕获异常或继续向上层抛出异常。

11.抽象方法无法声明抛出异常

*  A. 对
 *  B. 错

> 抽象方法是一种没有具体实现的方法，它只是在抽象类或接口中进行声明。在Java中，抽象方法可以声明抛出异常，就像普通方法一样。声明抛出异常的目的是让调用者知道该方法可能会产生特定类型的异常，并采取相应的处理措施。

12.与外部资源互交时，可能出现Unchecked类型异常

*  A. 对
 *  B. 错

> 与外部资源互动时，可能出现检查型异常，而不是非检查型异常（Unchecked Exception）。非检查型异常（如RuntimeException及其子类）通常表示程序错误或编程错误，而检查型异常（如IOException、SQLException等）通常表示外部资源操作的失败或异常情况。

## 三、线程 ##

### 课堂总结 ###

> 程序、进程、线程
> 
>  *  程序：是指含有指令和数据的文件，被存储在磁盘或其他的数据设备中，也就是说程序是静态的代码；
>  *  进程：是程序的一次执行过程，是代码在数据集合上的一次运行活动，是系统资源分配和调度的基本单位；
>  *  线程：线程是进程中的一个实体，是被系统独立调度和分派的基本单位，一个进程中至少有一个线程，进程中的多个线程共享进程的资源；
> 
> 简而言之，一个程序至少有一个进程，一个进程至少有一个线程
> 
> 线程的创建：
> 
> **继承Thread类****创建线程**
> 
> ![95017d1744e14ce5b27df97b58a82d9f.png][]
> 
> **实现Runnable接口创建线程**![edbc61f06fe04dd0b4f2fc4db3d844e7.png][]
> 
> 执行顺序
> 
> ![9ad8b0a4375f407ea36a8dbf875aa345.png][]
> 
> ![7bf8ee5d061e42608dde612b44fd8631.png][]
> 
> ![c49462ebcd4c46bfa2612b72c98d4d88.png][] **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无法修饰抽象方法

### 相关习题 ###

1.CountDownLatch类中要求执行线程阻塞直到计数器为零的方法是

*  A. trace()
 *  B. await()
 *  C. sleep()
 *  D. submit()

> CountDownLatch是Java中的一个同步辅助类，它可以用于控制一个或多个线程等待其他线程的操作完成。它通过一个计数器来实现，该计数器初始化为一个正整数，并且在计数器未达到零之前，调用线程将被阻塞。  
>   
> await()方法是CountDownLatch类中用于阻塞线程的方法。当调用await()方法时，当前线程会被阻塞，直到计数器的值变为零。当其他线程调用CountDownLatch的countDown()方法，计数器的值会减一，直到计数器的值为零时，被阻塞的线程才会被唤醒继续执行。

2.关于关键词volatile，下列叙述正确的是

*  A. 可以保证对修饰变量操作是同步的
 *  B. 修饰方法实现原子性操作
 *  C. 线程不保存变量副本，每次使用都去主内存读取
 *  D. 仅支持修饰基本数据类型

> 关键字volatile在Java中用于修饰变量，具有以下特性：  
>   
> A. 可以保证对修饰变量的操作是可见的，即当一个线程修改了volatile修饰的变量的值时，其他线程能够立即看到最新的值。但它并不能保证操作的原子性，因此不适用于保证对变量操作的同步性。  
>   
> B. 修饰方法并不能实现原子性操作。volatile关键字主要用于修饰变量，而不是方法。  
>   
> C. 线程不会保存volatile修饰变量的副本，每次使用变量时都会去主内存中读取最新的值。这是volatile的一个重要特性，可以确保线程获取到的是最新的值。  
>   
> D. volatile关键字不仅支持修饰基本数据类型，也支持修饰引用类型变量。因此，选项D是不正确的。

4.发出中断通知，会使线程停止运行

*  A. 对
 *  B. 错

> 发出中断通知不会直接使线程停止运行。在Java中，可以使用Thread类的interrupt()方法发出中断通知，但这只是一种通知机制，它会设置线程的中断状态，而不会直接停止线程的执行。

5.线程默认会反复循环执行任务直到被强制中断

*  A. 对
 *  B. 错

> 线程默认情况下不会反复循环执行任务直到被强制中断。线程的执行取决于线程所执行的任务和线程的逻辑。  
>   
> 在Java中，线程可以执行一次性任务，也可以执行循环任务，具体取决于线程的实现代码。线程可以在任务完成后自行结束，也可以在满足某个条件或收到中断通知时结束。

6.类中有2个要求执行同步的实例级方法，当1个线程调用其中一个同步方法时，其他线程无法调用另一同步方法

*  A. 对
 *  B. 错

7.类中有1个要求执行同步的实例级方法，1个普通方法。

当1个线程调用其中一个同步方法时，其他线程无法调用非同步方法

*  A. 对
 *  B. 错

8.下面程序的运行结果（）

public static void main(String[] args) {
    
    Thread t = new Thread() {
    
    public void run() {
    
    pong();
    
    }
    
    };
    
    t.run();
    
    System.out.print("ping");
    
    }
    
    
    
    static void pong() {
    
    System.out.print("pong");
    
    }

*  A. pingpong
 *  B. pongping
 *  C. pingpong和pongping都有可能
 *  D. 都不对

9.以下可以实现多线程下原子性执行操作的接口是( )

*  A. Lock
 *  B. Random
 *  C. Atomic
 *  D. Executor

10.Thread类的sleep()方法和wait()方法都可以让线程暂停执行。  
A. 对  
B. 错

> Thread类的sleep()方法和wait()方法都可以让线程暂停执行，但它们的使用方式和效果有所不同。  
>   
> sleep()方法是Thread类的静态方法，调用它会让当前线程暂停执行一段指定的时间。sleep()方法不会释放锁，并且线程在休眠期间不会被中断，直到休眠时间结束才会继续执行。  
>   
> wait()方法是Object类的实例方法，调用它会让当前线程暂停执行，并释放对象上的锁。wait()方法通常与synchronized关键字一起使用，以实现线程之间的协调和同步。当线程调用wait()方法时，它会进入等待状态，直到其他线程调用相同对象的notify()或notifyAll()方法来唤醒等待的线程。

## 四、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路径中的所有目录和文件，包括子目录的，观察遍历时的输出顺序，按层次输出的。注意返回值是流，后面可以用流的操作，比如过滤，排序等功能。可以借助于此方法删除非空目录**

### 相关习题 ###

1.以下能够正确描述，C:/a/b，路径的输出是

String p1 = **"C:/"**;  
String p2 = **"a"**;  
String p3 = **"b"**;

*  A. System.***out***.println(p1 + p2 + p3);
 *  B. System.***out***.println(Path.*of*(p1 + p2 + p3));
 *  C. System.***out***.println(Path.*of*(p1).resolve(p2).resolve(p3));
 *  D. System.***out***.println(Path.*of*(p3).resolve(p2).resolve(p1));

> 正确的输出是：  
>   
> C. System.out.println(Path.of(p1).resolve(p2).resolve(p3));  
>   
> 该代码会将路径组合为 "C:/a/b" 并输出。Path.of() 方法用于创建路径对象，resolve() 方法用于连接路径段。

2.如果在try-with-resources语句的try代码块内引发异常，先执行catch块处理异常以及finally块后，关闭资源

*  A. 对
 *  B. 错

3.InputStream的read(byte\[\] b)方法，当流中字节数多于字节数组缓冲区容量时，将抛出异常

*  A. 对
 *  B. 错

> 当使用 InputStream 的 read(byte\[\] b) 方法时，如果流中的字节数多于字节数组缓冲区的容量，该方法不会抛出异常。它会尽可能地将流中的数据读取到字节数组缓冲区中，并返回实际读取的字节数。如果流中的字节数超过了缓冲区的容量，它将只读取缓冲区大小的字节，并返回该数量。剩余的字节将保留在流中，可以通过后续的读取操作来获取。

4.OutputStream的write(byte\[\] b)方法，会将字节数组缓冲区中的全部字节写入输出流

*  A. 对
 *  B. 错

> 当使用 OutputStream 的 write(byte\[\] b) 方法时，会将字节数组缓冲区中的全部字节写入输出流。具体来说，该方法会将字节数组 b 中的所有字节写入到输出流中，以便将数据发送到目标位置。如果字节数组的长度大于输出流的缓冲区大小，该方法会将全部字节写入输出流的缓冲区，并尽可能地将缓冲区的内容发送到目标位置。

5.输入输出流默认均基于字符串完成文件的操作  
A. 对  
B. 错

> 输入输出流默认并不基于字符串完成文件的操作。输入输出流（InputStream 和 OutputStream）是用于字节级别的输入和输出操作的。它们用于处理字节数据而不是字符串数据。

[JAVA]: https://blog.csdn.net/qq_62377885/article/details/130174721
[4ede152b69a1475f945b23c974f34fbe.jpg]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/12/799ff9c74ae14d708f6b2fc223a35bf8.jpg
[8d808922930e44928ab1da5f99b84bfa.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/12/3dabbae4178c461fb37280f476091265.png
[c72343514a914a44b5ef11e4af059760.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/12/5479b27869b948549cdeaa2907ff7a8e.png
[ed442b504efaabb577d76a5757ccb881.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/12/ac00c9d4ac1a4dd99f5f7d923bbb0abf.png
[ff6c458c68f549b5b9125e3de00759f4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/12/fece896eb5b44af8b24ca35ac7c88314.png
[e2fc158dbe804f81be0ec59eb5e0bb61.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/12/32f2c79bc0cd4448a89cf87d1b004e13.png
[70395d7f67304d389aa6194228170b77.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/12/20473494266d41acaba494a531666b6f.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5bCP5p2O5bCP5LqO_size_20_color_FFFFFF_t_70_g_se_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/12/2454b9c0fa754aa985f18479f007fdf1.png
[95017d1744e14ce5b27df97b58a82d9f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/12/152bf448025a4cfabe660ce7aa774ba9.png
[edbc61f06fe04dd0b4f2fc4db3d844e7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/12/62181fb88d494f28ace7b12a174de1ba.png
[9ad8b0a4375f407ea36a8dbf875aa345.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/12/4a0ff0d82ca34f50b6ae330d2e0d2fef.png
[7bf8ee5d061e42608dde612b44fd8631.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/12/799e35c9c4a348d9b63bd1d9a84e6321.png
[c49462ebcd4c46bfa2612b72c98d4d88.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/12/1c3411c1d959457782783c5e9e49cf21.png