一、File类

（一）、什么是file类？

在 Java 中，File 类是 java.io 包中唯一代表磁盘文件（夹）本身的对象。File 类定义了
一些与平台无关的方法来操作文件， 主要是用来获取或处理与磁盘文件相关的属性信息，
像文件名、 文件路径、访问权限和修改日期等，还可以浏览子目录层次结构。但是File 类不具
有能够从文件读取文件内容和向文件写入信息的功能，它仅描述文件本身的属性，也就是说File
 能新建、删除、重命名文件和目录，但 File 不能访问文件内容本身。如果需要访问文件内容
 本身，则需要使用输入/输出流。
File类的包名是java.io，且实现了Serializable, Comparable两大接口以便于其
对象可序列化和比较

（二）、常用的构造函数

注意：

1、构造函数创建的只是一个File实例，并没有以文件做读取等操作，因此即使路径是错误的，也可以创建实例不报异常

2、创建了一个File示例，代表了这个File实例指向了这个路径上的文件

3、这个路径使用两个斜杠\在Java中是转义的含义，实际上在Java中也可以用一个/来代替两个\。

1、    public File(String pathname) {}

说明：通过给定的字符串路径(一般是文件的绝对路径)转为抽象路径名来创建File实例，
当传入null时会抛出NullPointerException空指针异常。

2、    public File(String parent, String child) {}
说明：从父路径名字符串和子路径名字符串(一般是相对父类的相对路径)创建新的File实例
     2.1) 若子路径child为Null，会抛出NullPointerException空异常错误
     2.2) 当父路径为Null时，会以子路径child作为绝对路径创建实例，等同于调用第一个File(String child )效果一样
     2.3) 当父路径不为空时，会以父路径作为目录，子路径作为父路径下的目录或者文件名，最后得到的实例对象的路径就是父路径和子路径的组合
     
     
 

（三）、常用的方法

1、File类创建和删除功能

boolean createNewFile();指定路径不存在该文件时创建文件，返回true 否则false
boolean mkdir（） 当指定的单击文件夹不存在时创建文件夹并返回true 否则false
boolean mkdirs（） 但指定的多级文件夹在某一级文件夹不存在时，创建多级文件夹并返回true 否则false
boolean delete（） 删除文件或者删除单级文件夹，删除文件夹，这个文件夹下面不能有其他的文件和文件夹

2、File类的判断功能

boolean exists() 判断指定路径的文件或文件夹是否为空
boolean isAbsolute() 判断当前路径是否是绝对路径
boolean isDirectory() 判断当前的目录是否存在
boolean isFile() 判断当前的目录是否是一个文件
boolean isHidden() 判断当前路径是否是一隐藏文件

3、File类的获取功能和修改名字功能

File getAbsoluteFile() 获取文件的绝对路径，返回File对象
String getAbsolutePath() 获取文件的绝对路径，返回路径的字符串
String getParent() 获取当前路径的父级路径，以字符串形式返回该父级路径
String getName() 获取文件或文件夹的名称
String getPath() 获取File对象中封装的路径
long lastModified() 以毫秒值返回最后修改时间
long length() 返回文件的字节数
boolean renameTo(File dest) 将当前File对象所指向的路径修改为指定File所指向的路径

4、File 类的其他获取功能

String[] list(); 以字符串的形式返回当前路径下所有的文件和文件夹的名称
File[] listFile 以File对象的形式返回当前路径下的所有文件和文件夹名称
Static File[] listRoots() 获取计算机中的所有盘符

汇总：

1）public String getName()} 
     获取实例对象代表的文件名字(包含文件后缀)
2）public String getParent()
     获取实例对象代表的文件上级目录
-3）public File getParentFile()
     获取实例对象的父项的实例对象，如果此路径名未指定父目录，则返回null；也就是获取对象的上级目录然后再实例化一个对象
4） public String getPath()
获取实例对象代表的文件的实际路径
5）public boolean isAbsolute()
检测该实例对象代表的文件的路径是否是绝对路径(windows系统中路径是以驱动盘开始的就是绝对路径)
6）public String getAbsolutePath()
获取实例对象代表的文件的绝对路径
7）public boolean exists()
判断实例对象代表的文件是否存在
8）public boolean isFile()
检测实例对象代表的是否是文件.
9）public boolean isDirectory()
检测实例对象代表的是否是目录
10）public boolean createNewFile()  throws IOException
创建新文件--当且仅当实例对象代表的文件不存在时才可以创建新文件qie创建的XXX文件的目录地址是以编译器的工作空间为上级目录加上创建实例对象的时候的路径名形成最后的路径

11）public boolean delete() 
删除实例对象代表的文件或目录，当File类代表目录时，必须目录下为空才可以删除
12）public boolean mkdir()
根据实例对象的路径名创建目录(若目录已存在，则false;若路径是文件，则fasle;若路径的上级目录不存在则false)
13)public boolean mkdirs()
根据实例对象的路径创建目录，包括创建那些必须的且不存在的父级目录
14) public String[] list()
获取实例对象代表的文件下的各级文件名和目录名，返回一个字符串数组 
注意：   1.  当实例对象代表的是文件不是目录时，返回NUll对象

        2.  获取的是该目录下的文件名和目录名,并不包含该目录名称和其上级目录名称

        3.  字符串数组中都是文件名或目录名并不是路径名

        4.  字符串中的元素并不是按照实际系统中目录下的顺序排列的

15）public String[] list(FilenameFilter filter)
获取实例对象代表的文件下的各级文件名和目录名并指定过滤器进行过滤，返回一个字符串数组
注意  1. 过滤器是FilenameFilter类对象，当传入null时，效果和list()方法一样

     2. 过滤器是指过滤掉不符合名称的名字

     3. FilenameFilter 是一个接口，因此需要自己新建一个类来实现该接口作为参数传入进去
  

测试代码：

二、IO流

（一）、Java Io流的概念

 java的io是实现输入和输出的基础，可以方便的实现数据的输入和输出操作。在java中把不同
 的输入/输出源（键盘，文件，网络连接等）抽象表述为“流”(stream)。通过流的形式允许
 java程序使用相同的方式来访问不同的输入/输出源。

（二）、流的分类

1、 按照流的流向，可以分为输入流和输出流

    输入流input： ：读取外部数据（磁盘、光盘等存储设备的数据）到程序（内存）中。
    只能从中读取数据，而不能向其写入数据。
    输出流output： ：将程序（内存）数据输出到磁盘、光盘等存储设备中。只能向其写
    入数据，而不能向其读取数据。
    
    注意：java的输入流主要是InputStream和Reader作为基类，
    而输出流则是主要由outputStream和Writer作为基类。它们都是一些抽象基类，
    无法直接创建实例。

2、 按照操作单元可以划分为字节流和字符流。

 字节流和字符流的用法几乎完成全一样，区别在于字节流和字符流所操作的数据单元不同，
 字节流操作的单元是数据单元是8位的字节，字符流操作的是数据单元为16位的字符。
 
 注意：字节流主要是由InputStream和outPutStream作为基类，而字符流则主要有
 Reader和Writer作为基类。

3、 按照流的角色可以划分为节点流和处理流。

 可以从/向一个特定的IO设备（如磁盘，网络）读/写数据的流，称为节点流。节点流也被称为
 低级流。图15.3显示了节点流的示意图。 
    从图15.3中可以看出，当使用节点流进行输入和输出时，程序直接连接到实际的数据源
    ，和实际的输入/输出节点连接。 
处理流则用于对一个已存在的流进行连接和封装，通过封装后的流来实现数据的读/写功能。
处理流也被称为高级流。图15.4显示了处理流的示意图。

 从图15.4可以看出，当使用处理流进行输入/输出时，程序并不会直接连接到实际的数据源，
 没有和实际的输入和输出节点连接。使用处理流的一个明显的好处是，只要使用相同的处理流，
 程序就可以采用完全相同的输入/输出代码来访问不同的数据源，随着处理流所包装
 的节点流的变化，程序实际所访问的数据源也相应的发生变化。 

4、流的小节

虽然流的种类有许多，但是它们基本上都是基于这四个流衍生出来的：

字符流Writer和Reader、字节流InputStream和outPutStream

InputStream：字节输入流

outPutStream字节输出流

字符输入流

字符输出流

（三）、流的基本操作

前面我们学习了File类，它的作用是指明我们要操作的文件对象，但是它只能够获取文件的基本属性，不能够对文件的内容进行读取、修改。现在要学习的流，将它与File实例一起配合使用，就能够实现对文件的内容进行读取与修改

1、节点流（文件流的基本操作）

（1）、FileReader

FileReader简介

 FileReader类从InputStreamReader类继承而来，按字符方式读取流中数据，此类的构造函数
 假定默认字符编码和默认字节缓冲区大小是合适的。如果要自己指定这些值，那么需要通过FileInputStream流对象来构造InputStreamReader流对象即可 
 
与字节型文件流不同，字节型文件流读取和写入的都是一个又一个的字节。
而字符型文件流操作的单位是一个又一个的字符，字符型流认为一个字母是一个字符
，而一个汉字也是一个字符。字符型文件流一般只能够用来操作一些文本格式的文件，
即可以用记事本正常打开的文件。（如：.txt .java .c .properties .html .js .xml）
它的用法与字节型文件流（FileInputStream，FileOutputStream）基本一致，
只不过它每次读写的数组类型是char[]而不是byte[]。

优点：字符型文件流解决了使用字节型文件流读写纯文本(含中文)文件时可能发生的中文乱码
问题，所以读写纯文本文件是字符型文件流的强项。

扩展：对于文本文件（.txt，.java，.c，.cpp）使用字符流处理较好

​ 对于非文本文件（.jpg，.mp3，.mp4，.avi，.doc，.ppt…）使用字节流处理较好

FileReader流常用构造方法

1、 public FileReader(String fileName) throws FileNotFoundException {
        super(new FileInputStream(fileName));
    }
    说明：)根据给定的文件路径来创建FileReader流对象：本质为利用文件路径创建File对象后
    构建FileInputStream流对象后调用父类构造方法
 
2、public FileReader(File file) throws FileNotFoundException {
        super(new FileInputStream(file));
}
   说明：）根据给定的文件对象创建FileReader流对象：本质为利用File对象后构建FileInputStream流对象后调用父类构造方法
   
   
注意：两个构造方法本质并无区别，都是调用父类构造，因此需要深究那么需要研究父类方法，
另外其还有另一个构造方法，暂时不考虑理解

FileReader常用方法

*public int read() throws IOException 
    读取单个字符。 
    读取的字符，如果已到达流的末尾，则返回 -1 

*public int read(char[] cbuf) throws IOException 
每次读取一个字符数组 
读取的字符，如果已到达流的末尾，则返回 -1 
cbuf - 目标缓冲区 

*public void close() throws IOException
关闭该流并释放与之关联的所有资源。

（2）、FileWriter

简介

FileWriter是用来将字符数据写入文件的类，这个类的构造函数假设默认的字符编码方式和
缓冲区大小的可被接受的，如果要改变指定编码和缓冲区大小可以用FileOutputStream来
构造一个OutputStreamWriter来实现。 当指定的文件没有找到时，一般是可以自动创建文件，
但这也和平台有关，有的平台不允许创建文件。如果这个纯文本文件已经存在，
并且里面有内容，此时我们再添加内容，就会覆盖掉这个纯文本文件已有的内容。
选择特定的构造方法就可以追加而不是覆盖。

主要的构造函数：

FileWriter(File file) 
用File对象来构造FileWriter，写数据时，从文件开头开始写起，会覆盖以前的数据

FileWriter(File file, boolean append) 
还是用File对象构造，如果第二个参数为true的话，表示以追加的方式写数据，
从文件尾部开始写起

FileWriter(FileDescriptor fd) 
用文件描述符来构造FileWriter

FileWriter(FileDescriptor fd, boolean append) 
用文件描述符来构造，第二个参数为true的话，表示以追加的形式写入数据

FileWriter(String fileName) 
用文件的路径名来构造FileWriter

FileWriter(String fileName,boolean append) 
用文件路径名来构造FileWriter，第二个参数为true的话，表示以追加的形式写入文件

主要方法：

String getEncoding() 
查看编码方式，返回时编码范式

void write(char[] cbuf, int off, int len) 
将字符数组的一部分写入到流中。将cbuf[off],cbuf[off+1],…,cbuf[off+len-1]部分字符 
写入到流中，但能不能写len个字符取决于cbuf中是否有那么多
重载的5个write方法：
*write(char[] cbuf) 
    写入字符数组。
*write(char[] cbuf, int off, int len) 
    写入字符数组的某一部分第一个参数是字符数组，第二个是开始索引，
    第三个是从开始索引开始取得字符串的长度      
*write(int c) 
    写入单个字符。          
*write(String str) 
    写入字符串          
*write(String str, int off, int len) 
     写入字符串的某一部分，第一个字符串，第二个是开始索引，第三个是从
     开始索引开始取得字符串的长度         

使用write方法将写入文件时字符的换行：

只需要在调用 write() 方法的时候，写多两个字符 \r\n 
例如：fw.write("何以解忧\r\n唯有 Java!");

FileWriter 写入文件时出现中文乱码问题

可能出现乱码的代码：

 File file1 = new File("C:\\1.xml");
		 FileWriter fw = new FileWriter(file1);
		 fw.write("要输入的xml字符串");
		 fw.flush();
		 fw.close();

Java FileWriter 默认是用（ISO-8859-1 or US-ASCII）西方编码，不是UTF-8的，而FileWriter类有getEncoding方法，却没有setEncoding的方法。怎么解决呢？

File file1 = new File("C:\\1.xml");
			Writer writer = new BufferedWriter(
					new OutputStreamWriter(
							new FileOutputStream(file1), "UTF-8"));
			writer.write("要输入的xml字符串");
			writer.flush();
			writer.close();

注意：FileWriter 与FileReader是字符流，不能用来处理字节类型的数据（图片），会损坏文件

（3）、FileInputStream流

简介

FileInputStream流被称为文件字节输入流，意思指对文件数据以字节的形式进行读取操作。
如读取图片视频等

常用构造方法：

*public FileInputStream(File file) throws FileNotFoundException{}
      通过打开与File类对象代表的实际文件的链接来创建FileInputStream流对象.
      若File类对象的所代表的文件不存在;不是文件是目录;或者其他原因不能打开的话
      ，则会抛出FileNotFoundException
*public FileInputStream(String name) throws FileNotFoundException
      通过指定的字符串参数来创建File类对象，而后再与File对象所代表的
      实际路径建立链接创建FileInputStream流对象      

常用方法

*public int read() throws IOException
   从输入流中读取一个字节返回int型变量，若到达文件末尾，则返回-1
*public int read(byte[] b) throws IOException
从输入流中读取b.length个字节到字节数组中，返回读入缓冲区的总字节数，
若到达文件末尾，则返回-1。但是注意返回的是读入的总字节数而并不总是b.length，
说明有的时候实际读入的总字节数不一定等于数组的长度
*public int read(byte[] b,int off,int len) throws IOException
从输入流中读取最多len个字节到字节数组中(从数组的off位置开始存储字节)，
当len为0时则返回0，如果len不为零，则该方法将阻塞，直到某些输入可用为止
*public void close() throws IOException
关闭此输入流并释放与该流关联的所有系统资源---即释放与实际文件的连接
（查看源码可发现有同步锁锁住资源，因此关闭流释放锁

为什么返回值是int类型：

    1、方法解释中的-1相当于是数据字典告诉调用者文件已到底，可以结束读取了，
    这里的-1是Int型

     2、那么当文件未到底时，我们读取的是字节，若返回byte类型，那么势必造成同一方法返回类型不同的情况这是不允许的

     3、我们读取的字节实际是由8位二进制组成，二进制文件不利于直观查看，可以转成常用的十进制进行展示，因此需要把读取的字节从二进制转成十进制整数，故返回int型

（4）、 FileOutputStream

跟FileWriter差不多的用法

2、缓冲流(处理流)的基本操作

缓冲流是对4个基本的FileXxx流的增强，其作用大概是为了提高文件的读写效率，
因为我门不使用缓冲时， 每读一个字节就要写入一个字节，由于涉及磁盘的IO操作相
比内存的操作要慢很多，所以不带缓冲的流效率很低。带缓冲的流，可以一
次读很多字节，但不向磁盘中写入，只是先放到内存里。等凑够了缓冲区大小的
时候一次性写入磁盘，这种方式可以减少磁盘操作次数，速度就会提高很多！

所以缓冲流的基本原理,是创建流对象时候,会创建一个内置的默认大小的缓冲区数组,
通过缓冲区书写. 

同时正因为它们实现了缓冲功能，所以要注意在使用缓冲流如BufferedOutputStream
写完数据后，要调用flush()方法或close()方法，强行将缓冲区中的数据写出。
否则可能无法写出数据。与之相似还BufferedReader和BufferedWriter两个类。

关闭流的原则：先关闭外层的流，再关闭内层的流；但是因为关闭外层流的同时，内层的流也会自动关闭，所以关于内层流的关闭我门可以省略不写。

因为这几个流的操作以及涉及的方法差不多都是一样，所以只对其中一两个进行详细说明

jian（1）、BufferedInputStream

常用构造方法：

BufferedInputStream(InputStream in) //使用默认buf大小、底层字节输入流构建
bis 

BufferedInputStream(InputStream in, int size) //使用指定buf大小、底层字
节输入流构建bis 

常用方法：

int available();  //返回底层流对应的源中有效可供读取的字节数      
  
void close();  //关闭此流、释放与此流有关的所有资源  
  
boolean markSupport();  //查看此流是否支持mark
  
void mark(int readLimit); //标记当前buf中读取下一个字节的下标  
  
int read();  //读取buf中下一个字节  
  
int read(byte[] b, int off, int len);  //读取buf中下一个字节  
  
void reset();   //重置最后一次调用mark标记的buf中的位子  
  
long skip(long n);  //跳过n个字节、 不仅仅是buf中的有效字节、也包括in的源
中的字节 

（2）、BufferedOutputStream

常用构造函数

BufferedOutputStream(OutputStream out); //使用默认大小、底层字节输出流构造bos。
默认缓冲大小是 8192 字节( 8KB )
  
BufferedOutputStream(OutputStream out, int size);  //使用指定大小、底层字节输出流
构造bos 

常用方法：

//在这里提一句,`BufferedOutputStream`没有自己的`close`方法,当他调用父类
`FilterOutputStrem`的方法关闭时,会间接调用自己实现的`flush`方法将buf中残存
的字节flush到out中,再`out.flush()`到目的地中,DataOutputStream也是如此。 
  
void  flush();  将写入bos中的数据flush到out指定的目的地中、注意这里不是
flush到out中、因为其内部又调用了out.flush()  
  
write(byte b);      将一个字节写入到buf中  
  
write(byte[] b, int off, int len);      将b的一部分写入buf中

那么什么时候flush()才有效呢？

答案是：当OutputStream是BufferedOutputStream时。

当写文件需要flush()的效果时，需要
FileOutputStream fos = new FileOutputStream(“c:\a.txt”);
BufferedOutputStream bos = new BufferedOutputStream(fos);

也就是说，需要将FileOutputStream作为BufferedOutputStream构造函数的
参数传入，然后对BufferedOutputStream进行写入操作，才能利用缓冲及flush()。

查看BufferedOutputStream的源代码，发现所谓的buffer其实就是一个byte[]。
BufferedOutputStream的每一次write其实是将内容写入byte[]，当buffer容量到达上
限时，会触发真正的磁盘写入。而另一种触发磁盘写入的办法就是调用flush()了。

    1.BufferedOutputStream在close()时会自动flush
    2.BufferedOutputStream在不调用close()的情况下，缓冲区不满，又需要把缓
    冲区的内容写入到文件或通过网络发送到别的机器时，才需要调用flush.

（3）、BufferedWriter

构造方法：

BufferedWriter （Writer out）————创建一个使用默认大小输出缓
冲区的缓冲字符输出流。

BufferedWriter （Writer out,int sz）——创建一个使用给定大小输出缓
冲区的缓冲字符输出流。

常用方法：

public void write（int c）—————写入单个字符。

public void write（char[ ] cbuf）——写入字符数组。

abstract void write（char[ ] cbuf，int off,int len）——写入字符数组的某一部分，
off数组的开始索引，len写的字符个数。

void write（String str）——写入字符串。

void write（char[ ] cbuf，int off,int len）——写入字符数组的某一部分，
off字符串的开始索引，len写的字符个数。

void flush（）——刷新该流的缓冲。

public void close（）————————关闭此流，但要先刷新它。

void newLine()————写入一个行分隔符。会根据不同的操作系统，
获取不同的行分隔符。

使用步骤：

1.创建字符缓冲输出流对象，构造方法中传递字符输出流。
2.调用字符缓冲输出流对象的方法write，把数据写入到缓冲区中。
3.调用字符缓冲输出流对象的方法flush，把内存缓冲区中的数据，刷
新到文件中。
4.释放资源。

(4)、BufferedReader

构造方法：

BufferedReader （Reader in）————创建一个使用默认大小的输入缓
冲区的缓冲字符输入流。
BufferedReader （Reader in）————创建一个使用是定大小输入缓
冲区的缓冲字符输入流。

参数解释：——————读取文件的数据源
Reader in——字符输入流
我们可以传递FileReader,缓冲流会给FileReader增加一个缓冲区，提高
FileReader的读取效率。

常用方法：

int read（）——读取单个字符并返回。
int read（char[ ] cbuf）——一次读取多个字符，将字符读入数组。
void close（）——关闭该流并释放与之关联的所有资源。
String readLine( )——————读取一个文本行。读取一行数据。
行的终止符号—————————通过下列字符即可认为某行已终止————换行（‘\n’）、回车（‘\r’）或者回车后直接跟着换行（\n\r）。
返回值
包含改行内容的字符串，不包含任何终止符，如果已达流末尾，则放回null。

使用步骤

1.创建一个字符缓冲输入流对象，构造方法中传递符缓冲输入流。
2.使用符缓冲输入流对象中的方法read/readLine读取文本。
3.释放资源。 

3、转换流（处理流、字符流）的基本操作

转换流 提供了两种用于将字节流转换为字符流的转换流。  其中InputStreamReader用
于将字节输入流转换为字符输入流，其中OutputStreamWriter用于将字节输出流转
换为字符输出流。
使用转换流可以在一定程度上避免乱码，还可以指定输入输出所使用的字符集 

注意：这些流都是继承了他们的父类的，因此他们的父类的方法也可以
使用，所以这两个流的使用方法跟之前的差不多。

（1）、InputStreamReader类

InputStreamReader类是Reader的子类，可以将一个字节输入流转变成字符输入流，
在转换时默认使用本地操作系统的字符编码或者指定其他字符编码

常用方法 :

InputStreamReader(InputStream in)	                                            创建一个使用默认字符集的InputStreamReader对象
InputStreamReader(InputStream in,Charset cs)                                    创建一个使用指定字符集的InputStreamReader对象
InputStreamReader(InputStream in,CharsetDecoder dec)	                        创建一个使用指定字符解码器的InputStreamReader对象
InputStreamReader(InputStream in,String str)	                                创建一个使用指定字符集的InputStreamReader对象
getEncoding()	       
   返回当前流使用的字符编码名称

（2）、OutputStreamWriter类

OutputStreamWriter类是Writer的子类，可以将一个字节输出流转变成字符输出流，
在转换时默认使用本地操作系统的字符编码或者指定其他字符编码。

常用方法：

OutputStreamWrider(OutputStream out)	
   创建一个使用默认字符集的OutputStreamWrider对象
OutputStreamWrider((OutputStream out,Charset cs)	
   创建一个使用指定字符集的OutputStreamWrider对象
OutputStreamWrider((OutputStream out,CharsetDecoder dec)	
   创建一个使用指定字符解码器的OutputStreamWrider对象
OutputStreamWrider((OutputStream out,String str)	
   创建一个使用指定字符集的OutputStreamWrider对象
getEncoding()	
   返回当前流使用的字符编码名称

4、标准的输入输出错误流

标准的输入输出流简单了解一下就可以了，实际开发时一般用不着。

java系统自带的标准数据流：java.lang.System:

java.lang.System 
public final class System  extends Object{ 
   static  PrintStream  err;//标准错误流（输出）
   static  InputStream  in;//标准输入(键盘输入流)
   static  PrintStream  out;//标准输出流(显示器输出流)

}

注意：
（1）System类不能创建对象，只能直接使用它的三个静态成员。
（2）每当main方法被执行时,就自动生成上述三个对象。

（1）、标准的输入流

System.in表示标准的输入流，用来从读取从键盘录入的数据，本质上
就是一个InputStream.
Java的API中提供了Scanner类已经对System.in进行了封装，读取键盘录入
的数据更加方便。所以不需要我们自己使用System.in来读取键盘录入的数据

public class SystemInDemo{
    public static void main(String[] args){
        //System.in的数据源是控制台键盘录入的数据
        InputStream in=System.in;
        //读取一个字节
        int by=in.read(); //阻塞，等待用户录入
        System.out.println(by);
        //释放资源
        in.close();
    }
}

（2）、标准的输出流

System.out表示装的输出流，用来往控制台输出数据，本质上就是一个OutputStream。
我们经常用的System.out.println("hello");其实就是用的标准的输出流，往控制台输出数据。

public class SystemOutDemo{
    public static void main(String[] args){
        //System.out的输出目的是控制台
        OutputStream out=System.out;
        //写一个字节
        out.write(97);
        //写多个字节
        byte[] bs={97,98,99,100};
        out.write(bs);
        //释放资源
        out.close();
    }
}