收藏闪存小组博问

Lz_蚂蚱

园龄：5年3个月粉丝：17关注：6

IO流

合集 - JavaBase(25)
1.BigInteger与BigDecimal类2.Java字符集3.枚举类4.Java比较器Comparable与Comparator5.Java中System类6.Java中Math类7.Java内部类8.Java关键字：this、super、final9.Java代码块10.Java中继承性、多态性11.Java接口12.子类对象实例化的全过程13.static关键字14.Java中的关键字transient15.double转String结果为指数问题16.Java注解17.日期时间API18.String字符串函数19.Excepton异常类
20.IO流
21.Java反射机制22.JDK与JRE区别23.Java位运算24.Java方法重载25.Java属性赋值的先后顺序与对象的实例化过程
收起

目录

File类

  • java.io.File类：文件和文件目录路径的抽象表示形式，与平台无关。

  • File 能新建、删除、重命名文件和目录，但 File不能访问文件内容本身。如果需要访问文件内容本身，则需要使用输入/输出流。

  • 想要在Java程序中表示一个真实存在的文件或目录，那么必须有一个File对象，但是Java程序中的一个File对象，可能没有一个真实存在的文件或目录。

  • File对象可以作为参数传递给流的构造器

File类常用构造器

构造器 说明
public File(String pathname) 以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
绝对路径：是一个固定的路径，从盘符开始
相对路径：是相对于某个位置开始
public File(String parent, String child) 以parent为父路径，child为子路径创建File对象。
public File(File parent, String child) 根据一个父File对象和子文件路径创建File对象

路径分隔符

路径中的每级目录之间用一个路径分隔符隔开。

路径分隔符和系统有关：

windows和DOS系统默认使用 " \ " 来表示

UNIX和URL使用 " / " 来表示

Java程序支持跨平台运行，因此路径分隔符要慎用。

为了解决这个隐患，File类提供了一个常量：

public static final String separator

根据操作系统，动态的提供分隔符。

File file1 = new File("d:\\hguo\\info.txt");
File file2 = new File("d:" + File.separator + "hguo" + File.separator + "info.txt");
File file3 = new File("d:/hguo");

🌰：

/**
 * File类的使用
 *
 * 1. File类的一个对象，代表一个文件或一个文件目录(俗称：文件夹)
 * 2. File类声明在java.io包下
 * 3. File类中涉及到关于文件或文件目录的创建、删除、重命名、修改时间、文件大小等方法，
 *    并未涉及到写入或读取文件内容的操作。如果需要读取或写入文件内容，必须使用IO流来完成。
 * 4. 后续File类的对象常会作为参数传递到流的构造器中，指明读取或写入的"终点".
 *
 */
@SpringBootTest
public class FileTest {
    /*
    1.如何创建File类的实例
        File(String filePath)
        File(String parentPath,String childPath)
        File(File parentFile,String childPath)
 
        相对路径：相较于某个路径下，指明的路径。
        绝对路径：包含盘符在内的文件或文件目录的路径
 
     2.路径分隔符
         windows: \\
         unix: /
     */
    @Test
    public void test1() {
        //构造器1
        File file1 = new File("hello.txt"); // 相对于当前module
        File file2 = new File("D:\\workspace_idea1\\JavaSenior\\day08\\he.txt");
 
        System.out.println(file1);
        System.out.println(file2);
 
        //构造器2：
        File file3 = new File("D:\\workspace_idea1", "JavaSenior");
        System.out.println(file3);
 
        //构造器3：
        File file4 = new File(file3, "hi.txt");
        System.out.println(file4);
    }
}

常用方法

File类的获取功能

  • 获取绝对路径
public String getAbsolutePath()
  • 获取路径
public String getPath()
  • 获取名称
public String getName()
  • 获取上层文件目录路径。若无，返回null。
public String getParent()
  • 获取文件长度（即：字节数）。不能获取目录的长度。
public long length()
  • 获取最后一次的修改时间，毫秒值。
public long lastModified()
  • 获取指定目录下的所有文件或者文件目录的名称数组
public String[] list()
  • 获取指定目录下的所有文件或者文件目录的File数组
public File[] listFiles()

File类的重命名功能

  • 把文件重命名为指定的文件路径
public boolean renameTo(File dest)

File类的判断功能

  • 判断是否是文件目录
public boolean isDirectory()
  • 判断是否是文件
public boolean isFile()
  • 判断是否存在
public boolean exists()
  • 判断是否可读
public boolean canRead()
  • 判断是否可写
public boolean canWrite()
  • 判断是否隐藏
public boolean isHidden()

File类的创建功能

  • 创建文件，若文件存在，则不创建，返回false
public boolean createNewFile()
  • 创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录上层目录不存在，也不创建。
public boolean mkdir()
  • 创建文件目录。如果上层文件目录不存在，一并创建
public boolean mkdirs()

注意事项：如果你创建文件或文件目录没有写盘符路径，那么，默认在项目路径下。

File类的删除功能

  • 删除文件或者文件夹
public boolean delete()

删除注意事项：java中的删除不走回收站。要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。

举几个🌰：

1、利用File构造器，new一个文件目录file。在其中创建多个文件和目录。

public class FileDemo {
 
    @Test
    public void test1() throws IOException {
        File file = new File("D:\\io\\io1\\hello.txt");
        //创建一个与file同目录下的另外一个文件，文件名为：haha.txt
        File destFile = new File(file.getParent(), "haha.txt");
        boolean newFile = destFile.createNewFile();
        if(newFile){
            System.out.println("创建成功！");
        }
    }
}

2、判断指定目录下是否有后缀名为.jpg的文件，如果有，就输出该文件名称

public class FindJPGFileTest {
 
	@Test
	public void test1(){
		File srcFile = new File("d:\\code");
		
		String[] fileNames = srcFile.list();
		for(String fileName : fileNames){
			if(fileName.endsWith(".jpg")){
				System.out.println(fileName);
			}
		}
	}
	@Test
	public void test2(){
		File srcFile = new File("d:\\code");
		
		File[] listFiles = srcFile.listFiles();
		for(File file : listFiles){
			if(file.getName().endsWith(".jpg")){
				System.out.println(file.getAbsolutePath());
			}
		}
	}
	/*
	 * File类提供了两个文件过滤器方法
	 * public String[] list(FilenameFilter filter)
	 * public File[] listFiles(FileFilter filter)
	 */
	@Test
	public void test3(){
		File srcFile = new File("d:\\code");
		
		File[] subFiles = srcFile.listFiles(new FilenameFilter() {
			
			@Override
			public boolean accept(File dir, String name) {
				return name.endsWith(".jpg");
			}
		});
		
		for(File file : subFiles){
			System.out.println(file.getAbsolutePath());
		}
	}
}

3、遍历指定目录所有文件名称，包括子文件目录中的文件。

// 拓展1：求指定目录所在空间的大小
// 求任意一个目录的总大小
public long getDirectorySize(File file) {
    // file是文件，那么直接返回file.length()
    // file是目录，把它的下一级的所有大小加起来就是它的总大小
    long size = 0;
    if (file.isFile()) {
        size += file.length();
    } else {
        File[] all = file.listFiles();// 获取file的下一级
        // 累加all[i]的大小
        for (File f : all) {
            size += getDirectorySize(f);// f的大小;
        }
    }
    return size;
}
// 拓展2：删除指定的目录
public void deleteDirectory(File file) {
    // 如果file是文件，直接delete
    // 如果file是目录，先把它的下一级干掉，然后删除自己
    if (file.isDirectory()) {
        File[] all = file.listFiles();
        // 循环删除的是file的下一级
        for (File f : all) {// f代表file的每一个下级
            deleteDirectory(f);
        }
    }
    // 删除自己
    file.delete();
}
// 列出file目录的下级，如果它的下级还是目录，接着列出下级的下级，依次类推
// 建议使用File类的File[] listFiles()
public void listAllSubFiles(File file) {
    if (file.isFile()) {
        System.out.println(file);
    } else {
        File[] all = file.listFiles();
        // 如果all[i]是文件，直接打印
        // 如果all[i]是目录，接着再获取它的下一级
        for (File f : all) {
            listAllSubFiles(f);// 递归调用：自己调用自己就叫递归
        }
    }
}
// 列出file目录的下级内容，仅列出一级的话
// 使用File类的String[] list()比较简单
public void listSubFiles(File file) {
    if (file.isDirectory()) {
        String[] all = file.list();
        for (String s : all) {
            System.out.println(s);
        }
    } else {
        System.out.println(file + "是文件！");
    }
}

I/O流原理及分类

IO原理

I/O是Input/Output的缩写，I/O技术是非常实用的技术，用于处理设备之间的数据传输。如读/写文件，网络通讯等。

Java程序中，对于数据的输入/输出操作以"流(stream)"的方式进行。

java.io包下提供了各种"流"类和接口，用以获取不同种类的数据，并通过标准的方法输入或输出数据。

输入input：读取外部数据（磁盘、光盘等存储设备的数据）到程序（内存）中。

输出output：将程序（内存）数据输出到磁盘、光盘等存储设备中。

流的分类

  • 按操作数据单位不同分为：字节流（8bit），字符流（16bit）
  • 按数据流的流向不同分为：输入流、输出流
  • 按流的角色的不同分为：节点流、处理流
(抽象基类) 字节流 字符流
输入流 InputStream Reader
输出流 OutputStream Writer

Java的IO流共涉及40多个类，实际上非常规则，都是从如下4个抽象基类派生的。

有这四个类派生出来的子类名称都是以其父类名作为子类名后缀。

文本文件可以用字节流进行复制，只是在复制过程中不要在控制台显示输出，复制完成后查看，就不会出现乱码现象。只是推荐使用字符流进行文本文件复制，在控制台输出显示不会出现乱码，非文本文件不能使用字符流复制。

IO流体系

小结

  • 流是用来处理数据的。

  • 处理数据时，一定要先明确数据源，与数据目的地。

    数据源可以是文件，可以是键盘。

    数据的目的地可以是文件、显示器或其他设备。

  • 而流只是在帮助数据进行传输，并对传输的数据进行处理，比如过滤处理、转换处理等。

InputStream & Reader

InputStream 和 Reader是所有输入流的基类。

  • InputStream（典型实现：FileInputStream）
int read();
int read(byte[] b);
int read(byte[], int off, int len);
  • Reader（典型实现：FileReader）
int read();
int read(char[] c);
int read(char[] c, int off, int len);

程序中打开的文件IO资源不属于内存里的资源，垃圾回收机制无法回收该资源，所以应该显示关闭文件IO资源。

FileInputStream从文件系统中的某个文件中获得输入字节。FileInputStream用于读取非文本数据制类的原始字节流。要读取字符流，需要使用FileReader。

OutputStream & Writer

OutputStream 和 Writer也是所有输出流的基类。

void write(int c);
void write(char[] cbuf);
void write(char[] cbuf, int off, int len);
void flush();
void close(); // 需要先刷新，再关闭流

因为字符流直接以字符作为操作单位，所以Writer可以用字符串来替换字符数组，即以String对象作为参数。

void write(String str);
void write(String str, int off, int len);

FileOutputStream从文件系统中的某个文件中获得输出字节。FileOutputStream用于写出非文本数据之类的原始字节流。要写出字符流，需要使用FileWriter。

节点流(文件流)

节点流：直接从数据源或目的地读写数据。

  • 定义文件路径时，注意：可以用"/" 或者 "\"。
  • 在写入一个文件时，如果使用构造器 FileOutputStream(file)，则目录下有同名文件将被覆盖。
  • 如果使用构造器 FileOutputStream(file, true)，则目录下的同名文件不会被覆盖，在文件内容末尾追加内容。
  • 在读取文件时，必须保证该文件已存在，否则报异常。
  • 字节流操作字节，比如：.mp3、.avi、.rmvb、.mp4、.jpg、.doc、.ppt
  • 字符流操作字符，只能操作普通文本文件。最常见的文本文件：.txt、.java、.c、.cpp等语言的源代码。尤其注意.doc、excel、ppt这些不是文本文件。

读取文件

1、建立一个流对象，将已存在的一个文件加载进流。

FileReader fr = new FileReader(new File("Test.txt"));

2、创建一个临时存放数据的数组。

char[] ch = new char[1024];

3、调用流对象的读取方法将流中的数据读入到数组中。

fr.read(ch);

4、关闭资源。

fr.close();

🌰：

public class TestFile {
 
    @Test
    public void testFileReader() {
        FileReader fileReader = null;
        try {
            // 1.创建流对象，读取文件
            fileReader = new FileReader(new File("F:\\code\\demo\\temp\\Test.txt"));
            // 2.创建临时存放数据的数组
            char[] buf = new char[1024];
            // 3.调用流对象读取方法，将读取到的文件保存到数组中
            int len;
            while ((len = fileReader.read(buf)) != -1) {
                System.out.println(new String(buf, 0, len)); // 这是一个测试文本文件
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 4.关闭流资源
            if (null != fileReader) {
                try {
                    fileReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

写入文件

1、创建流对象，建立数据存放文件

FileWrite fw = new FileWriter(new File("Test.txt"));

2、调用流对象的写入方法，将数据写入流

fw.write("tempTest");

3、关闭流资源，并将流中的数据清空到文件中

fw.close();

🌰：

public class TestFile {
 
    @Test
    public void testFileWriter() {
        FileWriter fileWriter = null;
        try {
            // 1.创建写入流
            fileWriter = new FileWriter("F:\\code\\demo\\temp\\Test.txt");
            // 2.调用流对象的写入方法，将数据写入流
            fileWriter.write("Hello World");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (null != fileWriter) {
                try {
                    fileWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

字节输入输出流

FileInputStream

方法名 说明
int read() 从输入流中读取数据的下一个字节。返回0~255范围内的int字节值。如果因为已经到达流末尾而没有可用的字节，则返回值-1。
int read(byte[] b) 从此输入流中将最多 b.length个字节的数据读入一个byte数组中。如果因为已经到达流末尾没有可用的字节，则返回值 -1。否则以整数形式返回实际读取的字节数。
int read(byte[] b，int off，int len) 将输入流中最多len个数据字节读入byte数组。尝试读取len个字节，但读取的字节也可能小于该值。以整数形式返回实际读取的字节数。如果因为流位于文件末尾而没有可用的字节，则返回值 -1。
public void close() throws IOException 关闭此输入流并释放与该流关联的所有系统资源

🌰：

@Test
public void testFileInputStream() {
    FileInputStream fis = null;
    try {
        //1. 造文件
        File file = new File("F:\\code\\demo\\temp\\Test.txt");
 
        //2.创建字节输入流对象
        fis = new FileInputStream(file);
 
        //3.数据存储临时区域
        byte[] buffer = new byte[5];
 
        //记录每次读取的字节的个数
        int len;
 
        // 读取一次比较是否已经到达数据末尾，到达末尾返回-1退出循环打印
        while ((len = fis.read(buffer)) != -1) {
            String str = new String(buffer, 0, len);
            System.out.print(str);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (fis != null) {
            //4.关闭资源
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
 
}

FileOutputStream

方法名 说明
void write(int b) 将指定的字节写入此输出流。write的常规协定是：向输出流写入一个字节。要写入的字节是参数b的八个低位。b的24个高位将被忽略。即写入0~255范围的。
void write(byte[] b) 将b.length个字节从指定的byte数组写入此输出流。write(b)的常规协定是：应该与调用write(b, 0, b.length)的效果完全相同。
void write(byte[] b，int off，int len) 将指定byte数组中从偏移量off开始的len个字节写入此输出流。
public void flush() throws IOException 刷新此输出流并强制写出所有缓冲的输出字节，调用此方法指示应将这些字节立即写入它们预期的目标。
public void close() throws IOException 关闭此输出流并释放与该流关联的所有系统资源。

🌰：

/*
实现对图片的复制操作
*/
@Test
public void testFileInputOutputStream()  {
    FileInputStream fis = null;
    FileOutputStream fos = null;
    try {
        //
        File srcFile = new File("爱情与友情.jpg");
        File destFile = new File("爱情与友情2.jpg");
 
        //
        fis = new FileInputStream(srcFile);
        fos = new FileOutputStream(destFile);
 
        //复制的过程
        byte[] buffer = new byte[5];
        int len;
        while((len = fis.read(buffer)) != -1){
            fos.write(buffer,0,len);
        }
 
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if(fos != null){
            //
            try {
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if(fis != null){
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
 
        }
    }
}

字符输入输出流

FileReader

方法名 说明
int read() 读取单个字符。作为整数读取的字符，范围在0~65535之间（0x00-0xffff）(2个字节的Unicode码)，如果已到达流的末尾，则返回 -1。
int read(char[] cbuf) 将字符读入数组。如果已经到达流的末尾，则返回 -1。否则返回本次读取的字符数。
int read(char[] cbuf，int off，int len) 将字符读入数组的某一部分。存到数组cbuf中，从off处开始存储，最多读len个字符。如果已到达流的末尾，则返回 -1。否则返回本次读取的字符数。
public void close() throws IOException 关闭此输入流并释放与该流关联的所有系统资源。

FileWriter

File对应的硬盘中的文件如果不存在，在输出的过程中，会自动创建此文件。
File对应的硬盘中的文件如果存在：

如果流使用的构造器是：

FileWriter(file，false)

FileWriter(file)：对原有文件的覆盖

如果流使用的构造器是：FileWriter(file，true)：不会对原有文件覆盖，而是在原有文件基础上追加内容。

方法名 说明
void write(int c) 写入单个字符。要写入的字符包含在给定整数值的16个低位中，16个高位被忽略。即写入0~65535之间的Unicode码。
void write(char[] cbuf) 写入字符数组。
void write(char[] cbuf，int off，int len) 写入字符数组的某一部分。从off开始，写入len个字符。
void write(String str) 写入字符串。
void write(String str，int off，int len) 写入字符串的某一部分。
void flush() 刷新该流的缓冲，则立即将它们写入预期目标。
public void close() throws IOException 关闭此输出流并释放与该流关联的所有系统资源。

🌰：

@Test
public void testFileReader(){
    FileReader fr = null;
    try {
        //1.实例化File类的对象，指明要操作的文件
        File file = new File("hello.txt");//相较于当前Module
        //2.提供具体的流
        fr = new FileReader(file);
 
        //3.数据的读入
        //read():返回读入的一个字符。如果达到文件末尾，返回-1
        //方式一：
        //        int data = fr.read();
        //        while(data != -1){
        //            System.out.print((char)data);
        //            data = fr.read();
        //        }
 
        //方式二：语法上针对于方式一的修改
        int data;
        while((data = fr.read()) != -1){
            System.out.print((char)data);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        //4.流的关闭操作
        //            try {
        //                if(fr != null)
        //                    fr.close();
        //            } catch (IOException e) {
        //                e.printStackTrace();
        //            }
        //或
        if(fr != null){
            try {
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
 
}
 
//对read()操作升级：使用read的重载方法
@Test
public void testFileReader1()  {
    FileReader fr = null;
    try {
        //1.File类的实例化
        File file = new File("hello.txt");
 
        //2.FileReader流的实例化
        fr = new FileReader(file);
 
        //3.读入的操作
        //read(char[] cbuf):返回每次读入cbuf数组中的字符的个数。如果达到文件末尾，返回-1
        char[] cbuf = new char[5];
        int len;
        while((len = fr.read(cbuf)) != -1){
            //方式一：
            //错误的写法
            //                for(int i = 0;i < cbuf.length;i++){
            //                    System.out.print(cbuf[i]);
            //                }
            //正确的写法
            //                for(int i = 0;i < len;i++){
            //                    System.out.print(cbuf[i]);
            //                }
            //方式二：
            //错误的写法,对应着方式一的错误的写法
            //                String str = new String(cbuf);
            //                System.out.print(str);
            //正确的写法
            String str = new String(cbuf,0,len);
            System.out.print(str);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if(fr != null){
            //4.资源的关闭
            try {
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
 
        }
    }
}

处理流

处理流：不直接连接到数据源或目的地，而是"连接"在已存在的流（节点流或处理流）之上，通过对数据的处理为程序提供更为强大的读写功能。

缓冲流

为了提高数据读写的速度，Java API提供了带缓冲功能的流类，在使用这些流类时，会创建一个内部缓冲区数组，缺省使用8192个字节（8KB）的缓冲区。

BufferedInputStream源码：

public
class BufferedInputStream extends FilterInputStream {
 
    private static int DEFAULT_BUFFER_SIZE = 8192;
}
  • 缓冲流要 "套接" 在相应的节点流之上，根据数据操作单位可以把缓冲流分为：

BufferedInputStream 和 BufferedOutputStream

BufferedReader 和 BufferedWriter

  • 当读取数据时，数据按块读入缓冲区，其后的读操作则直接访问缓冲区。

  • 当使用BufferedInputStream 读取字节文件时，BufferedInputStream 会一次性从文件中读取8192个（8KB），直到缓冲区装满了，才重新从文件中读取下一个8192个字节数组

  • 向流中写入字节时，不会直接写到文件，先写到缓冲区中直到缓冲区写满，BufferedOutputStream才会把缓冲区中的数据一次性写到文件里。使用方法 flush()可以强制将缓冲区的内容全部写入输出流。

  • 关闭流的顺序和打开流的顺序相反。只要关闭最外层流即可，关闭最外层流也会相应关闭内层节点流。先关闭外层的流，再关闭内层的流

  • flush()方法的使用：手动将buffer中内容写入文件。

  • 如果是带缓冲区的流对象的close()方法，不但会关闭流，还会在关闭流之前刷新缓冲区，关闭后不能再写出。

🌰：

@Test
public void testBufferedInputStream() {
    BufferedReader bufferedReader = null;
    try {
        File inFile = new File("F:\\code\\demo\\temp\\Test.txt");
        // 1.创建节点流
        FileReader fileReader = new FileReader(inFile);
        // 2.创建缓冲流
        bufferedReader = new BufferedReader(fileReader);
        // 3.读取文件
        String temp;
        while ((temp = bufferedReader.readLine()) != null) {
            System.out.println(temp);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (null != bufferedReader) {
            try {
                bufferedReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
 
}
public class BufferedTest {
 
    /*
    实现非文本文件的复制
     */
    @Test
    public void BufferedStreamTest() throws FileNotFoundException {
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
 
        try {
            //1.造文件
            File srcFile = new File("爱情与友情.jpg");
            File destFile = new File("爱情与友情3.jpg");
            //2.造流
            //2.1 造节点流
            FileInputStream fis = new FileInputStream((srcFile));
            FileOutputStream fos = new FileOutputStream(destFile);
            //2.2 造缓冲流
            bis = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);
 
            //3.复制的细节：读取、写入
            byte[] buffer = new byte[10];
            int len;
            while((len = bis.read(buffer)) != -1){
                bos.write(buffer,0,len);
 
                // bos.flush();//刷新缓冲区
 
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.资源关闭
            //要求：先关闭外层的流，再关闭内层的流
            if(bos != null){
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
 
            }
            if(bis != null){
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
 
            }
            //说明：关闭外层流的同时，内层流也会自动的进行关闭。关于内层流的关闭，我们可以省略.
            //        fos.close();
            //        fis.close();
        }
    }
}

转换流

转换流提供了在字节流和字符流之间的转换。

Java API提供了两个转换流：

api 说明
InputStreamReader 将InputStream 转换为Reader。将一个字节的输入流转换为字符的输入流。
OutputStreamWriter 将Writer转换为OutputStream。将一个字符的输出流转换为字节的输出流。

  • 字节流中的数据都是字符时，转成字符流操作更高效。

  • 很多时候我们使用转换流来处理文件乱码问题。实现编码和解码的功能。

解码：字节、字节数组  --->字符数组、字符串
编码：字符数组、字符串 ---> 字节、字节数组

InputStreamReader

  • 实现将字节的输入流按指定字符集转换为字符的输入流。
  • 需要和InputStream "套接"。
构造器 说明
public InputStreamReader(InputStream in)
public InputStreamReader(InputStream in，String charsetName) charsetName代表字符集，如：utf-8、gbk

OutputStreamWriter

  • 实现将字符的输出流按指定字符集转换为字节的输出流。
  • 需要和OutputStream "套接"。
构造器 说明
public OutputStreamWriter(OutputStream out)
public OutputStreamWriter(OutputStream out，String charsetName) charsetName代表字符集，如：utf-8、gbk

🌰：

public class InputStreamReaderTest {
 
    /*
    此时处理异常的话，仍然应该使用try-catch-finally
    InputStreamReader的使用，实现字节的输入流到字符的输入流的转换
     */
    @Test
    public void test1() throws IOException {
 
        FileInputStream fis = new FileInputStream("dbcp.txt");
//        InputStreamReader isr = new InputStreamReader(fis);//使用系统默认的字符集
        //参数2指明了字符集，具体使用哪个字符集，取决于文件dbcp.txt保存时使用的字符集
        InputStreamReader isr = new InputStreamReader(fis,"UTF-8");//使用系统默认的字符集
 
        char[] cbuf = new char[20];
        int len;
        while((len = isr.read(cbuf)) != -1){
            String str = new String(cbuf,0,len);
            System.out.print(str);
        }
        isr.close();
    }
 
    /*
    此时处理异常的话，仍然应该使用try-catch-finally
 
    综合使用InputStreamReader和OutputStreamWriter
     */
    @Test
    public void test2() throws Exception {
        //1.造文件、造流
        File file1 = new File("dbcp.txt");
        File file2 = new File("dbcp_gbk.txt");
 
        FileInputStream fis = new FileInputStream(file1);
        FileOutputStream fos = new FileOutputStream(file2);
 
        InputStreamReader isr = new InputStreamReader(fis,"utf-8");
        OutputStreamWriter osw = new OutputStreamWriter(fos,"gbk");
 
        //2.读写过程
        char[] cbuf = new char[20];
        int len;
        while((len = isr.read(cbuf)) != -1){
            osw.write(cbuf,0,len);
        }
 
        //3.关闭资源
        isr.close();
        osw.close();
    }
}

标准的输入、输出流

System.in和System.out分别代表了系统标准的输入和输出设备默认输入设备是：键盘，输出设备是：显示器

System.in的类型是InputStream

System.out的类型是PrintStream，其是OutputStream的子类FilterOutputStream的子类

重定向：通过System类的setIn，setOut方法对默认设备进行改变。

public static void setIn(InputStream in)

public static void setOut(PrintStream out)

打印流、数据流

打印流

实现将基本数据类型的数据格式化转化为字符串输出

  • PrintStream和PrintWriter

提供了一系列重载的print()和println()方法，用于多种数据类型的输出

PrintStream和PrintWriter的输出不会抛出IOException异常

PrintStream和PrintWriter有自动flush功能

PrintStream打印的所有字符都使用平台的默认字符编码转换为字节。在需要写入字符而不是写入字节的情况下，应该使用PrintWriter类。

System.out返回的是PrintStream的实例

数据流

为了方便地操作Java语言的基本数据类型和String的数据，可以使用数据流。数据流有两个类：(用于读取和写出基本数据类型、String类的数据)。作用：用于读取或写出基本数据类型的变量或字符串

  • DatalnputStream和 DataOutputStream

分别"套接"在InputStream 和 OutputStream子类的流上

DatalnputStream中的方法：

boolean readBoolean()
byte readByte()
char readChar()
float readFloat()
double readDouble()
short readShort()
long readLong()
int readInt()
String readUTF()
void readFully(byte[] b)

DataOutputStream中的方法：

将上述的方法的read改为相应的write即可。

对象流

  • ObjectlnputStream和OjbectOutputSteam

    用于存储和读取基本数据类型数据或对象的处理流。它的强大之处就是可以把Java中的对象写入到数据源中，也能把对象从数据源中还原回来。

  • 序列化：用ObjectOutputStream类保存基本类型数据或对象的机制

  • 反序列化：用ObjectlnputStream类读取基本类型数据或对象的机制

  • ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量

对象的序列化

对象序列化机制允许把内存中的Java对象转换成平台无关的二进制流，从而允许把这种二进制流持久地保存在磁盘上，或通过网络将这种二进制流传输到另一个网络节点。当其它程序获取了这种二进制流，就可以恢复成原来的Java对象

序列化的好处在于可将任何实现了Serializable接口的对象转化为字节数据，使其在保存和传输时可被还原

序列化是RMI(Remote Method Invoke-远程方法调用）过程的参数和返回值都必须实现的机制，而RMI是 JavaEE的基础。因此序列化机制是JavaEE平台的基础。

如果需要让某个对象支持序列化机制，则必须让对象所属的类及其属性是可序列化的，为了让某个类是可序列化的，该类必须实现如下两个接口之一。否则，会抛出NotSerializableException异常

Serializable

Externalizable

凡是实现Serializable接口的类都有一个表示序列化版本标识符的静态变量：

private static final long serialVersionUID;

serialVersionUID用来表明类的不同版本间的兼容性。简言之，其目的是以序列化对象进行版本控制，有关各版本反序列化时是否兼容。

如果类没有显示定义这个静态常量，它的值是Java运行时环境根据类的内部细节自动生成的。若类的实例变量做了修改，serialVersionUID可能发生变化。故建议，显式声明。

简单来说，Java的序列化机制是通过在运行时判断类的serialVersionUID来验证版本一致性的。在进行反序列化时，JVM会把传来的字节流中的
serialVersionUID与本地相应实体类的serialVersionUID进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常。(InvalidCastException)

对象流序列化对象

若某个类实现了Serializable接口，该类的对象就是可序列化的。

  • 序列化

创建一个ObjectOutputStream

调用ObjectOutputStream 对象的 writeObject（对象）方法输出可序列化对象

注意写出一次，操作flush()方法一次

  • 反序列化

    创建一个 ObjectInputStream

    调用 readObject()方法读取流中的对象

如果某个类的属性不是基本数据类型或String类型，而是另一个引用类型，那么这个引用类型必须是可序列化的，否则拥有该类型的Field的类也不能序列化。

// 序列化：将对象写入到磁盘或者进行网络传输。
// 要求对象必须实现序列化
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("data.txt"));
Person p = new Person("韩梅梅", 18, "中华大街", new Pet());
oos.writeObject(p);
oos.flush();
oos.close();
// 反序列化：将磁盘中的对象数据源读出。
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("data.txt"));
Person p1 = (Person)ois.readObject();
System.out.Println(p1.toString);
ois.close();

实现了Serializable接口的对象，可将它们转换成一系列字节，并可在以后完全恢复回原来的样子。这一过程亦可通过网络进行。这意味着序列化机制能自动补偿操作系统间的差异。换句话说，可以先在Windows机器上创建一个对象，对其序列化，然后通过网络发给一台Unix机器，然后在那里准确无误地重新"装配"。不必关心数据在不同机器上如何表示，也不必关心字节的顺序或者其他任何细节。

由于大部分作为参数的类如：String、Integer等都实现了java.io.Serializable的接口，也可以利用多态的性质，作为参数使接口更灵活。

🌰：

public class ObjectInputOutputStreamTest {
 
    /*
    序列化过程：将内存中的java对象保存到磁盘中或通过网络传输出去
    使用ObjectOutputStream实现
     */
    @Test
    public void testObjectOutputStream(){
        ObjectOutputStream oos = null;
 
        try {
            //1.
            oos = new ObjectOutputStream(new FileOutputStream("object.dat"));
            //2.
            oos.writeObject(new String("我爱北京天安门"));
            oos.flush();//刷新操作
 
            oos.writeObject(new Person("王铭",23));
            oos.flush();
 
            oos.writeObject(new Person("张学良",23,1001,new Account(5000)));
            oos.flush();
 
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(oos != null){
                //3.
                try {
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
 
    /*
    反序列化：将磁盘文件中的对象还原为内存中的一个java对象
    使用ObjectInputStream来实现
     */
    @Test
    public void testObjectInputStream(){
        ObjectInputStream ois = null;
        try {
            ois = new ObjectInputStream(new FileInputStream("object.dat"));
 
            Object obj = ois.readObject();
            String str = (String) obj;
 
            Person p = (Person) ois.readObject();
            Person p1 = (Person) ois.readObject();
 
            System.out.println(str);
            System.out.println(p);
            System.out.println(p1);
 
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            if(ois != null){
                try {
                    ois.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
import java.io.Serializable;
 
/**
 * Person需要满足如下的要求，方可序列化
 * 1.需要实现接口：Serializable --> (标识接口，内部没有任何成员)
 * 2.当前类提供一个全局常量：serialVersionUID   常量必须显示声明创建，否则当此类有修改时反序列化会出现问题
 * 3.除了当前Person类需要实现Serializable接口之外，还必须保证其内部所有属性
 *   也必须是可序列化的。（默认情况下，基本数据类型可序列化）
 *
 * 补充：ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量
 *
 */
public class Person implements Serializable{
 
    public static final long serialVersionUID = 475463534532L;
 
    private String name;
    private int age;
    private int id;
    private Account acct;
 
    public Person(String name, int age, int id) {
        this.name = name;
        this.age = age;
        this.id = id;
    }
 
    public Person(String name, int age, int id, Account acct) {
        this.name = name;
        this.age = age;
        this.id = id;
        this.acct = acct;
    }
 
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", id=" + id +
                ", acct=" + acct +
                '}';
    }
 
    public Person(String name, int age) {
 
        this.name = name;
        this.age = age;
    }
 
    public Person() {
 
    }
}
 
class Account implements Serializable{
    public static final long serialVersionUID = 4754534532L;
    private double balance;
 
    @Override
    public String toString() {
        return "Account{" +
                "balance=" + balance +
                '}';
    }
 
    public double getBalance() {
        return balance;
    }
 
    public void setBalance(double balance) {
        this.balance = balance;
    }
 
    public Account(double balance) {
 
        this.balance = balance;
    }
}

RandomAccessFile随机存取文件流

RandomAccessFile声明在java.io包下，但直接继承于java.lang.Object类。并且它实现了Datalnput、DataOutput这两个接口，也就意味着这个类既可以读也可以写。

RandomAccessFile类支持"随机访问"的方式，程序可以直接跳到文件的任意地方来读、写文件

支持只访问文件的部分内容

可以向已存在的文件后追加内容

RandomAccessFile对象包含一个记录指针，用以标示当前读写处的位置

RandomAccessFile类对象可以自由移动记录指针：

方法名 说明
long getFilePointer() 获取文件记录指针的当前位置
void seek(long pos) 将文件记录指针定位到pos位置
构造器
public RandomAccessFile(File file，String mode)
public RandomAccessFile(String name，String mode)

创建RandomAccessFile类实例需要指定一个mode参数，该参数指定RandomAccessFile的访问模式：

r：以只读方式打开

rw：打开以便读取和写入

rwd：打开以便读取和写入；同步文件内容的更新

rws：打开以便读取和写入；同步文件内容和元数据的更新

如果模式为只读 r 。则不会创建文件，而是会去读取一个已经存在的文件，如果读取的文件不存在则会出现异常。如果模式为 rw 读写。如果文件不存在则会取创建文件，如果存在则不会创建。

我们可以用RandomAccessFile这个类，来实现一个多线程断点下载的功能，用过下载工具的朋友们都知道，下载前都会建立两个临时文件，一个是与被下载文件大小相同的空文件，另一个是记录文件指针的位置文件，每次暂停的时候，都会保存上一次的指针，然后断点下载的时候，会继续从上一次的地方下载，从而实现断点下载或上传的功能。

🌰：

/**
 * RandomAccessFile的使用
 * 1.RandomAccessFile直接继承于java.lang.Object类，实现了DataInput和DataOutput接口
 * 2.RandomAccessFile既可以作为一个输入流，又可以作为一个输出流  (如果作为输入流，则输出流需要再创建对象，不能既当输入流又当输出流)
 *
 * 3.如果RandomAccessFile作为输出流时，写出到的文件如果不存在，则在执行过程中自动创建。
 *   如果写出到的文件存在，则会对原有文件内容进行覆盖。（默认情况下，从头覆盖）不是完全覆盖原有文件内容，是看写入的内容是否比原有内容多，如果没有原有文件内容多，则只从头覆盖写入的内容。
 *
 * 4. 可以通过相关的操作，实现RandomAccessFile“插入”数据的效果
 
流中的方法seek()可以指定文件内容位置
 */
public class RandomAccessFileTest {
 
    @Test
    public void test1() {
 
        RandomAccessFile raf1 = null;
        RandomAccessFile raf2 = null;
        try {
            //1.
            raf1 = new RandomAccessFile(new File("爱情与友情.jpg"),"r");   没有使用节点流承装文件对象，是直接将文件对象作为参数传入
            raf2 = new RandomAccessFile(new File("爱情与友情1.jpg"),"rw");
            //2.
            byte[] buffer = new byte[1024];
            int len;
            while((len = raf1.read(buffer)) != -1){
                raf2.write(buffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //3.
            if(raf1 != null){
                try {
                    raf1.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
 
            }
            if(raf2 != null){
                try {
                    raf2.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
 
            }
        }
    }
 
    @Test
    public void test2() throws IOException {
 
        RandomAccessFile raf1 = new RandomAccessFile("hello.txt","rw");
 
        raf1.seek(3);//将指针调到角标为3的位置
        raf1.write("xyz".getBytes());//
 
        raf1.close();
 
    }
    /*
    使用RandomAccessFile实现数据的插入效果
     */
    @Test
    public void test3() throws IOException {
 
        RandomAccessFile raf1 = new RandomAccessFile("hello.txt","rw");
 
        raf1.seek(3);//将指针调到角标为3的位置
        //保存指针3后面的所有数据到StringBuilder中
        StringBuilder builder = new StringBuilder((int) new File("hello.txt").length());
        byte[] buffer = new byte[20];
        int len;
        while((len = raf1.read(buffer)) != -1){
            builder.append(new String(buffer,0,len)) ;
        }
        //调回指针，写入“xyz”
        raf1.seek(3);
        raf1.write("xyz".getBytes());
 
        //将StringBuilder中的数据写入到文件中
        raf1.write(builder.toString().getBytes());
 
        raf1.close();
 
        //思考：将StringBuilder替换为ByteArrayOutputStream
		// 方式三：避免出现乱码
		// ByteArrayOutputStream baos = new ByteArrayOutputStream();
		// byte[] buffer = new byte[10];
		// int len;
		// while ((len = fis.read(buffer)) != -1) {
		// baos.write(buffer, 0, len);
		// }
		//
		// return baos.toString();
    }
}
posted @   Lz_蚂蚱  阅读(34)  评论(0)  编辑  收藏  举报
（评论功能已被禁用）
点击右上角即可分享
微信分享提示
评论
收藏
关注
推荐
深色
回顶
收起