IO流

最新推荐文章于 2024-03-05 14:57:45 发布
最新推荐文章于 2024-03-05 14:57:45 发布
阅读量90 收藏
点赞数
分类专栏： 笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51626328/article/details/115841433
版权

I/O流

一、I/O的概念

  1. I是指input，输入
  2. O是指output，输出

二、流的分类方式

  1. 按照流的方向分：输入流和输出流
  2. 按照流的单位分：字节流和字符流
  3. 按照流的功能分：节点流和过滤流

三、字节输入流和字节输出流

  1. 流的使用基本结构：

    1. 创建流对象
    2. 使用流对象执行操作代码
    3. 关闭流对象(释放资源)

  2. 父类：

    1. 输入流：public abstract class InputStream
    2. 输出流：public abstract class OutputStream

  3. 子类：

    1. 字节输出流：FileOutputStream

      1. 构造方法：
        1. public FileOutputStream(String name):通过指定文件所在位置创建流对象
        2. public FileOutputStream(String name,boolean append):通过指定文件所在位置创建流对象并且指定是否在原有数据后进行追加（true表示追加）
      2. 成员方法：
        1. write(int b):一次写入一个字节
        2. write(byte[] b):一次写入一个字节数组
        3. write(byte[] b,int index,int length):写入数组的一部分，从index下标开始，总计length个元素
      3. 特点：
        1. 如果没有文件，则会创建文件
        2. 如果没有文件夹，不会创建文件夹
      package com.baizhi.testIO;

import java.io.FileOutputStream;
import java.io.OutputStream;

public class TestFileOutputStream {
	public static void main(String[] args) throws Exception {
//		创建流对象
		OutputStream fos = new FileOutputStream("a.txt");
//		当需要在文件末尾继续追加内容的时候        
//      OutputStream fos = new FileOutputStream("a.txt",true);
        
//		操作流对象
		fos.write(65);
//		关闭流对象
		fos.close();
    }
}

    2. 字节输入流：FileInputStream

      1. 构造方法：public FileInputStream(String name):通过指定文件所在位置创建流对象
      2. 成员方法：
        1. int read():一次读取一个字节，如果返回-1，则代表读取到文件的末尾
        2. int read(byte[] bs):一次读取一个数组，返回本次读取到的数量，如果返回-1，则代表读取到文件的末尾
      package com.baizhi.testIO;

import java.io.FileInputStream;
import java.io.InputStream;

public class TestFileInputStream {
	public static void main(String[] args) throws Exception {
//		创建流对象
		InputStream is = new FileInputStream("a.txt");
//		操作流对象
		while (true) {
			int i = is.read();
			if(i == -1) break;
			System.out.println((char)i);
		}
//		关闭流对象
		is.close();
	}
}

  4. 异常的积极处理

    package com.baizhi.testIO;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class TestFileOutputStream {
	public static void main(String[] args) {
//		将流对象的声明作用域扩大，以便于在finally中可以对该对象进行关闭
		OutputStream fos = null;
		try {
			fos = new FileOutputStream("a.txt",true);
			fos.write(65);
//			将创建流对象可能会抛出的异常进行处理
		}catch (FileNotFoundException e) {
			e.printStackTrace();
//			将文件写出操作可能会抛出的异常进行处理
		}catch (IOException e) {
			e.printStackTrace();
		}
		finally {
//			任何情况下都应该进行资源的释放
			if(fos != null) {
				try {
					fos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

  5. 文件的复制：通过输入流将文件进行读取，通过输出流对文件进行写出

    1. 一次写一个字节的方式进行复制

      package com.baizhi.testIO;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;

public class TestFileCopy {
	public static void main(String[] args) throws Exception {
//		创建输入和输出流，将a文件复制成b文件
		InputStream is = new FileInputStream("a.txt");
		OutputStream os = new FileOutputStream("b.txt");
//		输入之后，进行写出
		while (true) {
			int i = is.read();
			if(i == -1) break;
			os.write(i);
		}
//		关闭流对象
		is.close();
		os.close();
	}
}

    2. 一次写一个字节数组的方式进行复制

      package com.baizhi.testIO;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;

public class TestFileCopy {
	public static void main(String[] args) throws Exception {
//		创建输入和输出流，将a文件复制成b文件
		InputStream is = new FileInputStream("a.txt");
		OutputStream os = new FileOutputStream("b.txt");
//		输入之后，进行写出
		byte[] bs = new byte[1024];
		while (true) {
			int i = is.read(bs);
			if(i == -1) break;
			os.write(bs,0,i);
		}
//		关闭流对象
		is.close();
		os.close();
	}
}

四、字节过滤流

  1. 缓冲流

    1. 字节过滤输入流：BufferedInputStream

      1. 构造方法public BufferedInputStream(InputStream is)
      2. 成员方法：同FileInputStream
      3. 特点：具有缓冲区，读入更高效
      package com.baizhi.testIO;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.InputStream;

public class TestBufferedInputStream {
	public static void main(String[] args) throws Exception{
//		创建节点流
		InputStream is = new FileInputStream("a.txt");
//		包装过滤流
		BufferedInputStream bis = new BufferedInputStream(is);
//		操作流对象
		while (true) {
			int i = bis.read();
			if(i == -1) break;
			System.out.println((char)i);
		}
//		关闭过滤流
		bis.close();
	}
}

    2. 字节过滤输出流：BufferedOutputStream

      1. 构造方法public BufferedOutputStream(OutputStream os)
      2. 成员方法
        1. flush()：对缓冲区进行刷新
        2. 其他的同FileOutputStream
      3. 特点：具有缓冲区
      package com.baizhi.testIO;

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.OutputStream;

public class TestBufferedOutputStream {
	public static void main(String[] args) throws Exception{
//		创建节点流
		OutputStream os = new FileOutputStream("b.txt");
//		包装过滤流
		BufferedOutputStream bos = new BufferedOutputStream(os);
//		操作流对象
		bos.write(65);
//		关闭流对象
		bos.close();
	}
}

    3. 基于过滤流的文件复制

      package com.baizhi.testIO;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;

public class TestFileCopy {
	public static void main(String[] args) throws Exception {
//		创建节点流，将a文件复制成b文件
		InputStream is = new FileInputStream("a.txt");
		OutputStream os = new FileOutputStream("b.txt");
//		包装过滤流
		BufferedInputStream bis = new BufferedInputStream(is);
		BufferedOutputStream bos = new BufferedOutputStream(os);
//		输入之后，进行写出
		while (true) {
			int i = bis.read();
			if(i == -1) break;
			bos.write(i);
		}
//		关闭流对象
		bis.close();
		bos.close();
	}
}

  2. 缓冲流

    1. PrintStream
      1. 只有输出，没有对应的输入流
      2. 可以进行文件的写出，但是通常用于打印
      3. 打印语句使用的就是这个流
      4. 这个流具有缓冲区

  3. 对象流

    1. 对象输出流：ObjectOutputStream

      1. 构造方法：public ObjectOutputStream(OutputStream os)

      2. 成员方法：writeObject(Object o)

      3. 要求：需要实现序列化接口 Serializable

        package com.baizhi.testIO;

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.Serializable;

public class Test {
	public static void main(String[] args) throws Exception{
		OutputStream os = new FileOutputStream("a.txt");
		ObjectOutputStream oos = new ObjectOutputStream(os);
		
		Person p1 = new Person("zhangs", 30);
		Person p2 = new Person("guox", 29);
		
		oos.writeObject(p1);
		oos.writeObject(p2);
		
		oos.close();
	}
}
class Person implements Serializable{
	String name;
	int age;
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public Person() {
		super();
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	
}

      4. 对于不需要被序列化的属性，使用 transient 关键字修饰

        transient String name;

    2. 对象输入流：ObjectInputStream

      1. 构造方法：public ObjectInputStream(InputStream os)

      2. 成员方法：Object readObject()

      3. 要求：实现序列化接口

        package com.baizhi.testIO;

import java.io.EOFException;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.Serializable;

public class Test {
	public static void main(String[] args) throws Exception{
		
		InputStream is = new FileInputStream("a.txt");
		ObjectInputStream ois = new ObjectInputStream(is);
		try {
            while(true) {
                Object o = ois.readObject();
                System.out.println(o);
            }
		}catch (EOFException e) {
			System.out.println("文件读取结束");
		}
		ois.close();
	}
}
class Person implements Serializable{
	String name;
	int age;
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public Person() {
		super();
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	
}

五、编码与字符集

  1. 将十进制字符转换为二进制数字的过程称为编码
  2. 将二进制数字转换为十进制字符的过程称为解码
  3. 存储二进制数字与十进制字符之间映射关系的图表称为编码字符集
  4. 常见的编码字符集：
    1. ASCII：美国信息交换标准码
    2. ISO8859-1：西欧常用编码格式
    3. GB2312：早期的简体中文字符集
    4. GBK：现阶段常用的简体中文字符集
    5. Big5：繁体中文字符集，常见于台湾地区
    6. UTF-8：底层采用unicode的编码形式，世界通用的编码字符集
  5. 乱码的常见原因：编码和解码使用的字符集不一致

六、字符输入流和字符输出流

  1. 父类：
    1. 输入流：public abstract class Reader
    2. 输出流：public abstract class Writer
  2. 子类：

    1. 输入流：FileReader

      1. 构造方法：public FileReader(String path):通过指定文件所在位置创建流对象
      2. 成员方法：
        1. public int read():一次读取一个字符，如果返回-1，则代表读取到文件的末尾
        2. public int read(char[] cs):一次读取一个数组，返回本次读取到的数量，如果返回-1，则代表读取到文件的末尾
      package com.baizhi.testIO;

import java.io.FileReader;
import java.io.Reader;

public class TestFileReader {
	public static void main(String[] args) throws Exception{
//		创建流对象
		Reader r = new FileReader("a.txt");
//		操作流对象
		while (true) {
			int i = r.read();
			if(i == -1) break;
			System.out.println((char)i);
		}
//		关闭流对象
		r.close();
	}
}

    2. 输出流：FileWriter

      1. 构造方法：
        1. public FileWriter(Srting path):通过指定文件所在位置创建流对象
        2. public FileWriter(Srting path,boolean append):通过指定文件所在位置创建流对象并且指定是否在原有数据后进行追加（true表示追加）
      2. 成员方法：
        1. public void write(int c)：一次写入一个字符
        2. public void write(char[] cs)：一次写入一个字符数组
        3. public void write(char[] cs,int index,int length)：写入数组的一部分，从index下标开始，总计length个元素
      3. 特点：
        1. 如果没有文件，则会创建文件
        2. 如果没有文件夹，不会创建文件夹
      package com.baizhi.testIO;

import java.io.FileWriter;
import java.io.Writer;

public class TestFileWriter {
	public static void main(String[] args) throws Exception{
//		创建流对象
		Writer w = new FileWriter("b.txt");
//		当需要在文件末尾继续追加内容的时候
//      Writer w = new FileWriter("b.txt"，true);
        
//		操作流对象
		w.write('流');
//		关闭流对象
		w.close();
	}
}

七、字符过滤流

  1. 缓冲流：

    1. 字符过滤输入流：BufferedReader

      1. 构造方法：public BufferedReader(Reader in)
      2. 成员方法：
        1. public String readLine()：一次读取一整行，如果返回null，则代表读到文件尾
        2. 其他成员方法和FileReader一致
      package com.baizhi.testIO;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.Reader;

public class TestBufferedReader {
	public static void main(String[] args) throws Exception {
//		创建节点流
		Reader reader = new FileReader("a.txt");
//		创建过滤流
		BufferedReader br = new BufferedReader(reader);
//		一次读取一整行
		while (true) {
			String line = br.readLine();
			if(line == null) break;
			System.out.println(line);
		}
//		关闭流对象
		br.close();
	}
}

    2. 字符过滤输出流：BufferedWriter

      1. 构造方法：public BufferedWriter(Writer out)
      2. 成员方法：
        1. public void flush()：对缓冲区进行刷新
        2. public void newLine()：写换行符，适用于所有平台
        3. 其他成员方法和FileWriter一致
      package com.baizhi.testIO;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.Writer;

public class TestBufferedWriter {
	public static void main(String[] args) throws Exception {
//		创建节点流
		Writer writer = new FileWriter("b.txt");
//		包装过滤流
		BufferedWriter bw = new BufferedWriter(writer);
//		写完一行之后换行
		bw.write("zhangs");
		bw.newLine();
//		关闭流对象
		bw.close();
	}
}

  2. 缓冲流：

    1. 过滤流：PrintWriter
      1. 只有输出，没有对应的输入流
      2. 可以进行文件的写出
      3. 向浏览器输出字符
      4. 这个流具有缓冲区

八、桥转换流

  1. 可以将字节流转换为字符流的流称为桥转换流

  2. 类名：

    1. 输入流：InputStreamReader

      1. 构造方法：
        1. public InputStreamReader(InputStream in)：使用字节流作为参数构造桥转换流
        2. public InputStreamReader(InputStream in，String charsetName)：使用字节流作为参数构造桥转换流，并且指定读取时所使用的的编码字符集格式
      2. 成员方法：与字符流一致

    2. 输出流：OutputStreamWriter

      1. 构造方法：
        1. public OutputStreamWriter(OutputStream out)：使用字节流作为参数构造桥转换流
        2. public OutputStreamWriter(OutputStream out,String charsetName)：使用字节流作为参数构造桥转换流，并且指定写出时所使用的的编码字符集格式
      2. 成员方法：与字符流一致

    3. InputStreamReader和OutputStreamWriter本身也是过滤流，但是建议使用BufferedReader和BufferedWriter对文件进行操作

      package com.baizhi.testIO;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;

public class TestReaderAndWriter {
	public static void main(String[] args) throws Exception {
//		创建字节流
		InputStream is = new FileInputStream("a.txt");
		OutputStream fos = new FileOutputStream("b.txt");
//		创建桥转换流
		InputStreamReader isr = new InputStreamReader(is);
		OutputStreamWriter osw = new OutputStreamWriter(fos);
//		创建字符过滤流
		BufferedReader reader = new BufferedReader(isr);
		BufferedWriter writer = new BufferedWriter(osw);
//		文件复制
		while (true) {
			String line = reader.readLine();
			if(line == null) break;
			writer.write(line);
			writer.newLine();
		}
//		关闭流对象
		reader.close();
		writer.close();
	}
}

九、File类

  1. File类：用于操作硬盘上文件的类
  2. File对象和文件的关系：File对象是JVM堆内存中的对象，通过该对象的成员方法对硬盘上的文件进行操作
  3. 构造方法：public File(String pathname)：根据文件的路径创建File对象
  4. 成员方法：
    1. public boolean createNewFile()： 创建文件，创建成功返回true，如果文件存在返回值为false。
    2. public boolean mkdir()： 创建目录，创建成功返回true，如果文件存在返回值为false。
    3. public boolean delete(): 删除目录/文件,删除成功返回true,否则为false。
      1. 当删除目录时，只有当目录为空时，才可以删除；
      2. 而删除文件时，不管文件内容是否为空，都会被删除。
    4. public String getName()： 获取文件名(含扩展名)、目录名
    5. public boolean exists()： 判断一个文件或是目录是否存在，存在返回true，否则为false。
    6. public String getAbsolutePath ()： 获得绝对路径
    7. public File[] listFiles()： 获取当前目录下所有的文件和子目录
    8. public boolean isFile()： 判断File对象所对应的是否为文件
    9. public boolean isDirectory(): 判断File对象所对应的是否为目录
    10. 注意：isFile()和isDirectory()如果返回false，不能说明该File一定是目录或者文件，还有可能对应的文件不存在
编程小白(=_=)
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java高级编程——IO流
qq_61524266的博客
06-16 503
Java高级编程——IO流
Java IO流
m0_52514893的博客
12-10 480
程序中的基本数据类型，引用类型【数组，集合】存储的数据都是在内存中，当程序运行的时候存储在内存中，当程序执行完成后，数据就消失了，我们想要实现数据的持久化，那么我就得通过Java。缓冲流是处理流的一种，是建立在相应的节点流之上，对读写的数据提供了缓冲的功能，提高了读写的效率，同时还新增了一些方法。、计算修改名字后的文件的大小，文件的最后修改日 期、文件的名称及文件的父级目录，将这些信息打印到控制台。的子类，将输出的字符流装换为字节流，即：将一个字符流的输出对象变为字节流的输出对象。
JAVA编程思想进阶（二）IO流，网络编程，
hands_up_down的博客
11-06 501
程序就是对象的集合。
Java IO流详解（史上最全18个案例代码）
最新发布
Liugx的博客
03-05 1502
Java IO流是Java中用于输入和输出数据的机制，它提供了一种灵活且强大的方式来处理文件、网络连接和其他数据源。IO流主要分为字节流和字符流两种类型，其中字节流适用于处理二进制数据，而字符流则适用于处理文本数据。Java IO流的核心是输入流和输出流，输入流用于从数据源读取数据，输出流用于向数据源写入数据。
Java中的IO流
12-22
一、 什么是IO流 一般情况下是按照当前程序使用的内存为参照物来考虑数据的走向问题。 以文件操作为例 从内存中保存数据到硬盘 output 从硬盘中读取数据到内存 input 看视频，缓冲 使用缓冲可以让用户体验提高，相对...
Java IO流 文件传输基础
09-02
Java IO流是Java平台中用于处理输入输出的重要机制，它涉及到数据从源到目标的传输。文件传输基础是Java IO流应用的一个核心场景，通过IO流可以实现对文件的读写操作，包括创建、打开、修改和删除文件。在本文中，...
IO流自用模板
12-17
在Java编程中，IO流（Input/Output Stream）是用来处理数据输入和输出的重要工具。它允许程序与外部设备，如硬盘、网络、内存等进行数据交互。IO流分为两大类：字节流（处理字节数据）和字符流（处理字符数据）。...
java IO流文件的读写具体实例
09-04
Java IO流是Java平台中用于处理输入输出的重要机制，它允许程序与各种数据源和目的地进行交互，包括文件、网络连接、系统硬件等。在Java中，IO流分为四个主要类别，分别是字节流（处理二进制数据）、字符流（处理...
IO流的主要流
07-12
Java中的IO流主要负责在不同数据源之间进行数据的传输，包括从文件系统、网络、内存等地方读取数据，以及向这些地方写入数据。IO流被设计为双工通道，既可以进行输入操作，也可以进行输出操作。Java的IO流体系结构...
java IO流详细笔记
07-12
Java IO流详解
IO流宝典.pdf
06-19
Java IO流是Java平台核心特性之一，用于处理输入和输出数据。这个概念是Java编程中的基石，对于任何涉及数据传输或文件操作的应用程序都至关重要。《IO流宝典》这本书全面深入地探讨了这一主题，旨在帮助读者从基础...
map集合以及IO流
06-13
本文将深入探讨`Map`集合的特性和遍历方式，以及`Set`特性的排序，并介绍如何使用`IO流`，特别是字节流和字符流。 首先，我们来了解`Map`集合的基本概念。`Map`接口是Java集合框架的一部分，它不直接继承自`...
java核心编程——IO流
weixin_46048259的博客
10-22 458
一、File File:文件路径或文件对象，不描述文件本身！ 文件和目录路径名的抽象表示 import java.io.File; public class TestFile { public static void main(String[] args) { //1.构造方法 //-- File(String pathname) File file = new File("D:\\program\\A_hqyj\\ide...
Java IO流经典练习题
热门推荐
wenzhi的博客
09-19 4万+
本文对javaIO流的练习题做了比较详细的解答，其中有比较基础的，也有比较繁琐的，都是可以加深对javaIO流的全面的理解
JavaIO流编程总结
冒烟儿的专栏
03-21 1319
1.前言 在众多流行的编程语言中，Java对IO的处理应该是最特殊的，Java打着“尽量减少IO类的设计理念”，搞出了目前应该是最复杂的一套IO相关类，并称之为Java流。 对于新手来说，Java流包含的类众多，含义混杂，上手困难且其中暗藏的陷阱众多；但是对于熟悉了Java流的程序员来说，它的确称得上功能强大。 本文总结了一些Java流的使用指南，给出了一些实例代码，主要内容包括： Ja...
【Java学习笔记】IO编程
XiaoMai's Coding
07-08 1815
概述： IO的操作部分重点掌握两个代码模型： 五个类（File、outputstream、inputstream、writer、reader） 一个接口（Serializable） 在java.io包之中file类是唯一一个与文件本身操作（文件的创建、删除、取得文件信息等等） 1.File类的基本使用 Java.io.File是一个普通的类，所以直接实例化对象操作就好。实...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值