参考：《Java编程思想》
IO属于java的基本知识，但是io的知识体系过于庞大，书中提到过“对程序语言的设计者来说，创建一个好的输入/输出系统是一项艰难的任务”，我觉得艰难在于，需要考虑太多的因素，因为文件有多种多样：文本格式，音视频格式，zip格式，网络等等，读取的方式也很多：顺序读取，随机读取，按行，按字符等等。这也就导致了Java io类库的庞大。

目录
一、io的分类
二、输入字节流InputStream
三、输出字节流OutputStream
四、输入字符流Reader
五、输出字符流Writer
六、高速缓冲字节流
七、高速缓冲字符流

一、io的分类
Java的io在总体抽象上分为两类：

堵塞式io（bio）
非堵塞式io（nio）

学过操作系统，我们都知道一个系统的瓶颈大程度上取决于io的速度，io所花费的时间相比cpu处理的时间多太多了，堵塞式io在read时会一直等待读取端口的的内容，导致堵塞，write方法也同样如此，后面再网络编程这一块会大量的去比较这两种io的区别，在单机环境下，总体还是使用bio，也就是这篇文章要说到的输入输出流
根据应用场景分类


流式io
流式io又分为


字符流


字节流
字符流处理的单元为2个字节的Unicode字符，分别操作字符、字符数组或字符串，而字节流处理单元为1个字节，操作字节和字节数组




非流失io，辅助流式io


文件读取时与安全相关的类


总体上来说，io下有5个类/接口：磁盘操作：File，字节操作：InputStream 和 OutputStream，字符操作：Reader 和 Writer，对象操作：Serializable
二、输入字节流InputStream

（图来自网络）


InputStream


ByteArrayInputStream


FileInputStream


FilterInputStream

BufferedInputStream
DataInputStream
LineNumberInputStream
PushbackInputStream



ObjectInputStream


PipedInputStream


StringBufferInputStream




①InputStream是所有输入流的父类，是一个抽象类
②ByteArrayInputStream、FileInputStream、StringBufferInputStream分别从字节数组，文件对象，String类中读取数据
③ObjectOutputStream和所有FilterOutputStream的子类都是装饰流。

装饰器模式：在不修改原先对象核心的功能的情况下，对功能进行增强。


三、输出字节流OutputStream

（图来自网络）

OutputStream

ByteArrayOutputStream
FileOutputStream
FilterOutputStream

BufferedOutputStream
DataOutputStream
PrintStream


ObjectOutputStream
PipedOutputStream



①OutputStream是所有输入流的父类，是一个抽象类
②ByteArrayOutputStream、FileOutputStream、分别从字节数组，文件对象，中写入数据
③ObjectOutputStream和所有FilterOutputStream的子类都是装饰流。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OrsLZATZ-1603796560491)(C:\Users\VSUS\Desktop\笔记\io\img\4.png)]
四、输入字符流Reader


Reader


CharArrayReader


BufferedReader

LineNumbeReader



FilterReader

PushbackReader



InputStreamReader

FileReader



PipeReader


StringReader




①Reader是所有类的基类
② InputStreamReader是一个连接字节流和字符流的桥梁，它将字节流转变为字符流。
五、输出字符流Writer

（图来自网络）

Writer


BufferedWriter


CharArrayWriter


FilterWriter


OutPutStreamWriter

FileWriter



PipedWriter


PrintWriter


StringWriter




①Writer是所有类的基类
②OutputStreamWriter是OutputStream到Writer转换的桥梁
六、高速缓冲字节流
当文件较大时，使用高速缓冲流能显著提高效率


写入数据到流中，字节缓冲输出流 BufferedOutputStream


读取流中的数据，字节缓冲输入流 BufferedInputStream
通过构造方法就可以明白如何去使用缓冲流，只需将输入/输出字节流作为参数传入字节缓冲输入/输出流


public BufferedOutputStream(OutputStream out) {
        this(out, 8192);
    }

    /**
     * Creates a new buffered output stream to write data to the
     * specified underlying output stream with the specified buffer
     * size.
     *
     * @param   out    the underlying output stream.
     * @param   size   the buffer size.
     * @exception IllegalArgumentException if size <= 0.
     */
    public BufferedOutputStream(OutputStream out, int size) {
        super(out);
        if (size <= 0) {
            throw new IllegalArgumentException("Buffer size <= 0");
        }
        buf = new byte[size];
    }

七、高速缓冲字符流


字符缓冲输入流 BufferedReader


字符缓冲输出流 BufferedWriter


使用方法也和缓冲字节流一致

main 方法是 Java Application 程序执行的入口点，以下描述哪项是合法的（）。



基本数据类型不可任意互相转换。

小能转大，但是大转小需要强转，会丢失数据。
Java Applet在被浏览器加载的时候首先被执行且在applet整个生命周期中被运行一次的方法是（）


java.io.inputStreamReader用于字符流输入

java.io.inputStream用于字节流输入
Java程序中的类名称必须与存放该类的文件名相同。
G1不属于jdk1.6的垃圾收集器，应该是1.7之后的版本





ResultSet中记录行的第一列索引为1.

ResultSet结果集读取数据的方法主要是getXXX() ，他的参数可以使整型表示第几列（是从1开始的），还可以是列名。


此题的考点在于

1、静态代码块中的x 为局部变量。

2、x++先运算后赋值，++x先赋值后运算。即y=-1+1=0；

3、因为x++改变了x自身的值，所以此时的x为1，根据规则相当于：1+0+2=3。

即 结果为3
一个类可以实现多个接口。抽象类不必须有抽象方法。（即单继承，多实现）

选项：





通过super可以调用父类的构造函数。

final修饰的方法只是不能重写，static修饰的方法只能访问类的成员变量。

string是不可修改的，且java运行环境中对string对象有一个对象池保存。
算法：

有这样一道智力题：“某商店规定：三个空汽水瓶可以换一瓶汽水。小张手上有十个空汽水瓶，她最多可以换多少瓶汽水喝？”答案是5瓶，方法如下：先用9个空瓶子换3瓶汽水，喝掉3瓶满的，喝完以后4个空瓶子，用3个再换一瓶，喝掉这瓶满的，这时候剩2个空瓶子。然后你让老板先借给你一瓶汽水，喝掉这瓶满的，喝完以后用3个空瓶子换一瓶满的还给老板。如果小张手上有n个空汽水瓶，最多可以换多少瓶汽水喝？

我写的憨批算法：
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Scanner;
 
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = 0;
        List<Integer> list = new ArrayList();
        while (scanner.hasNext()) {
            int x =scanner.nextInt();
            if (x!=0){
            list.add(x);
            }else {
                break;
            }
        }
        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()) {
            n=iterator.next();
            if (n == 1) {
                System.out.println("0");
            } else {
                change(n, 0);
            }
        }
    }
 
 
 
    public  static  void change(int n,int sum){
        if (n<=1){
            System.out.println(sum);
            return ;
        }
 
        if (n/3==0&&n%3==2){
             n=0;
             sum++;
             change(n, sum);
        }else {
            sum+=n/3;
            n=n/3+n%3;
 
            change(n,sum);
        }
    }
}

链接：https://www.nowcoder.com/questionTerminal/3245215fffb84b7b81285493eae92ff0

来源：牛客网
明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性，他先用计算机生成了N个1到1000之间的随机整数（N≤1000），对于其中重复的数字，只保留一个，把其余相同的数去掉，不同的数对应着不同的学生的学号。然后再把这些数从小到大排序，按照排好的顺序去找同学做调查。请你协助明明完成“去重”与“排序”的工作(同一个测试用例里可能会有多组数据，希望大家能正确处理)。
Input Param
n               输入随机数的个数
inputArray      n个随机整数组成的数组
Return Value
OutputArray    输出处理后的随机整数
注：测试用例保证输入参数的正确性，答题者无需验证。测试用例不止一组。
样例输入解释：

样例有两组测试

第一组是3个数字，分别是：2，2，1。

第二组是11个数字，分别是：10，20，40，32，67，40，20，89，300，400，15。

import java.util.*;

public class SearchId {
    public static void main(String[] args) {
        Scanner scanner =new Scanner(System.in);
        while (scanner.hasNext()) {

            int n = scanner.nextInt();
            List<Integer> list = new ArrayList();
            for (int i = 0; i < n; i++) {
                int x=scanner.nextInt();
                if (!list.contains(x)){
                list.add(x);
                }
            }

            Collections.sort(list);
            Iterator<Integer> iterator = list.iterator();
            while (iterator.hasNext()) {
                Integer next = iterator.next();
                System.out.println(next);
            }


        }
    }
}


写出一个程序，接受一个十六进制的数，输出该数值的十进制表示。（多组同时输入 ）

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
          Scanner scanner =new Scanner(System.in);
        while (scanner.hasNext()) {
            String s = scanner.nextLine().replace("0x", "");
            int i = Integer.parseInt(s, 16);
            System.out.println(i);
        }
    
    }
}