Java基础08——流（Stream）与文件（File）

1.Stream概述

（1）Java中所有的基本I/O操作都是流（Stream）为基础的。流代表数据的流动或一端的写入器与另一端的读取器相互通信的通道。

（2）在使用终端的输入和输出设备，正在读或写文件，或者在Java中通过套接字（Socket）进行通信时，我们就已经使用了某种类型的流。

（3）按流所处理的数据类型划分，可以分为：

字节流——用于处理字节数据；

字符流——用于处理Unicode字符数据。

（4）两种基本的流：

输入流——只能从中读取字节数据，而不能向其中写入数据；

输出流——只能向其写入字节数据，而不能从中读取数据。

2.字节流：（InputStream/OutputStream）

(1)常见的InputStream类：

FileInputStream

DataInputStream

BufferedInputStream

演示代码如下：

public void read(){
        FileInputStream fis=null;
        try {
            fis=new FileInputStream("C://1.txt");
            byte[] buffer=new byte[1024];//开缓存空间
            int n=-1;//循环每次都读缓存大小的数据，直到没有数据可以读
            while ((n=fis.read(buffer))!=-1)//把buffer中的有效数据个数送给n，当读到文件末尾时，n=-1（表示读完了）
            {
                System.out.println(new String(buffer,0,n));
            }
                fis.read(buffer);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }


public void write(){

        FileOutputStream fos=null;
        try {
            fos=new FileOutputStream("D://2.txt");
            fos.write("hello!".getBytes());//按默认格式转换为byte
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                fos.flush();//把内存中的数据刷新到指定的文件中
                fos.close();//关闭文件
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

边读边写——拷贝（Copy）代码演示：

public void copy(){
        try (FileInputStream fis=new FileInputStream("d://2.txt");
             FileOutputStream fos=new FileOutputStream("c://2.txt");){
            byte[] buffer=new byte[1024*4];
            int n=-1;
            while ((n=fis.read(buffer))!=-1){//读缓冲大小数据
                fos.write(buffer,0,n);//写这个大小的数据
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {

        }
    }

3.字符流：（Reader/Writer)

（1）Reader、Writter相关类

@Test
    public void read(){
        try(Reader r=new FileReader("d://2.txt")) {
            int n=-1;
            char[] buffer=new char[1024];
            while ((n=r.read(buffer))!=-1){
                System.out.println(new String(buffer,0,n));
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    @Test
    public void write(){
        try (Writer writer=new FileWriter("D;//2.txt")){
            writer.write("bye!!");
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    @Test
    public void copy(){
        try(Reader fr=new FileReader("d://2.txt");
            Writer fw=new FileWriter("d://3.txt");) {

            char[] buffer =new char[1024];
            int n=-1;
            while ((n=fr.read(buffer))!=-1) {
                fw.write(buffer,0,n);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }

4.缓冲流

BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedInoutWritter类在数据流动的路径上增加了一个特定大小的数据缓冲区（默认8k）。数据缓冲区通过减少与read（）和write（）方法调用相对应的读取和写入的物理操作， 从而提高了效率。

import org.junit.Test;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;

public class 缓冲流 {
    @Test
    public void copy(){//下行FileInputStream第二个参数不加size默认8k，可加可不加
        try (BufferedInputStream bis =new BufferedInputStream(new FileInputStream("c://2.txt"),4096);
             BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("d://4.txt"));
        ){
            byte[] buffer=new byte[1024];
            int n=-1;
            while ((n=bis.read(buffer))!=-1) {
                bis.read(buffer,0,n);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

5.转换流

一般操作输入输出内容的时候，就需要使用字节或字符流，但是，有些时候，需要将字符流变成字节流形式，或者字节流变成字符流形式。所以，就需要另一种转换流的操作类。

OutputStreamWriter：是Writer的子类。将输出的字符流变成字节流：即将字符流的输入对象变成字节流输入对象。

InputStreamReader:是Reader的子类。将输入的字节流变成字符流，即将一个字节流的输入对象变成字符流输入对象。

输入输出流体系里提供了两个转换流，这两个转换流用于实现将字节流转换成字符流，其中InputStreamReader将字节输入流转换成字符输入流，OutputStreamWritter将字节流转换成字符输出流。

public class A
{
	public static void main(String[] args) 
	{
		BufferedReader br = null;
		try
		{
			//将Sytem.in对象转换成Reader对象
			InputStreamReader reader = new InputStreamReader(System.in);
			//将普通Reader包装成BufferedReader
			br = new BufferedReader(reader);
			String buffer = null;
			//采用循环方式来一行一行的读取
			while ((buffer = br.readLine()) != null)
			{
				//如果读取的字符串为"exit"，程序退出
				if (buffer.equals("exit"))
				{
					System.exit(0);
				}
				//打印读取的内容
				System.out.println("输入内容为:" + buffer);
				
			}
		}
		catch (IOException ioe)
		{
			ioe.printStackTrace();
		}
		//关闭输入流
		finally
		{
			try
			{
				br.close();				
			}
			catch (IOException ioe)
			{
				ioe.printStackTrace();
			}
		}
	}
}

6.序列化（Serializable）

（1）对象序列化的目标是将对象保存在磁盘中，或允许在网络中直接传输对象，对象序列化机制允许把内存中的Java对象转换成平台无关的二进制流，从而允许把这种二进制流持久保存到磁盘中，通过网络将这种二进制流传输到另一个网络节点。

（2）该机制使得对象可以脱离程序的运行而独立存在。

（3）对象的序列化指将一个Java对象写入IO流中，与此对应的是。对象的反序列化则指从IO流中恢复该Java对象。

（4）如果让某个类可以支持序列化机制，必须让类是可序列化的，也就是要实现Serializable接口。

（5）注：a.被static修饰的属性不会被序列化。

b.对象的类名、属性都会被序列化，方法不会被序列化。

c.要保证序列化对象所在类的属性也是可以被序列化的。

d.当通过网络、文件进行序列化时，必须按照写入的顺序读取对象。

e.反序列化时必须有序列化对象时的class文件。

（6）常见序列化协议的对比：

XML序列化性能、简洁性都较差，Thrift与Protobuf相比在时空开销方面有一定劣势，Protobuf和Avro在两个方面都非常优越。

7.文件

Java文件类以抽象的方式代表文件名和目录路径名。该类主要用于文件和目录的创建、文件的查找和文件的删除等。

（1）File对象代表磁盘中实际存在的文件和目录。通过以下构造方法创建一个File对象。

通过给定的父抽象路径名和子路径名字符串创建一个新的File实例。

File(File parent, String child);

通过将给定路径名字符串转换成抽象路径名来创建一个新 File 实例。

File(String pathname) 

根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。

File(String parent, String child) 

通过将给定的 file: URI 转换成一个抽象路径名来创建一个新的 File 实例。

File(URI uri) 

创建File对象成功后，可以使用以下列表中的方法操作文件。

 （2）File类常用方法总结

a.创建：

createNewFile()在指定位置创建一个空文件，成功就返回true，如果已存在就不创建，然后返回false。
mkdir()  在指定位置创建一个单级文件夹。
mkdirs()  在指定位置创建一个多级文件夹。
renameTo(File dest)如果目标文件与源文件是在同一个路径下，那么renameTo的作用是重命名， 如果目标文件与源文件不是在同一个路径下，那么renameTo的作用就是剪切，而且还不能操作文件夹。 

b.删除：

delete()  删除文件或者一个空文件夹，不能删除非空文件夹，马上删除文件，返回一个布尔值。
deleteOnExit()jvm退出时删除文件或者文件夹，用于删除临时文件，无返回值。
 判断：
exists()  文件或文件夹是否存在。
isFile()  是否是一个文件，如果不存在，则始终为false。
isDirectory()  是否是一个目录，如果不存在，则始终为false。
isHidden()  是否是一个隐藏的文件或是否是隐藏的目录。
isAbsolute()  测试此抽象路径名是否为绝对路径名。

 c.获取：

getName()  获取文件或文件夹的名称，不包含上级路径。
getAbsolutePath()获取文件的绝对路径，与文件是否存在没关系
length()  获取文件的大小（字节数），如果文件不存在则返回0L，如果是文件夹也返回0L。
getParent()  返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回null。
lastModified()获取最后一次被修改的时间。

d.文件夹相关：

static File[] listRoots()列出所有的根目录（Window中就是所有系统的盘符）
list()  返回目录下的文件或者目录名，包含隐藏文件。对于文件这样操作会返回null。
listFiles()  返回目录下的文件或者目录对象（File类实例），包含隐藏文件。对于文件这样操作会返回null。
list(FilenameFilter filter)返回指定当前目录中符合过滤条件的子文件或子目录。对于文件这样操作会返回null。
listFiles(FilenameFilter filter)返回指定当前目录中符合过滤条件的子文件或子目录。对于文件这样操作会返回null。

今天的文章Java基础08——流（Stream）与文件（File）分享到此就结束了，感谢您的阅读。