Java笔记：Java 流(Stream)、文件(File)和IO

更新时间：2018-1-7 12:27:21

更多请查看在线文集：http://android.52fhy.com/java/index.html


java.io 包几乎包含了所有操作输入、输出需要的类。所有这些流类代表了输入源和输出目标。

输入输出流

简介

一个流被定义为一个数据序列。输入流用于从源读取数据，输出流用于向目标写数据。

下图是一个描述输入流和输出流的类层次图：

在java.io包中操作文件内容的主要有两大类：字节流、字符流，两类都分为输入和输出操作。

在字节流中输出数据主要是使用OutputStream完成，输入使的是InputStream；在字符流中输出主要是使用Writer类完成，输入流主要使用Reader类完成。这四个都是抽象类。

java中提供了专用于输入输出功能的包java.io, 其中包括：

  • InputStream, OutputStream, Reader, Writer。
  • InputStream和OutputStream, 两个是为字节流设计的,主要用来处理字节或二进制对象。
  • Reader和Writer, 两个是为字符流（1个字符占2个字节）设计的,主要用来处理字符或字符串。

常见的System.in其实就是InputStream对象。

字节流转换为字符流

为了方便处理字节流，我们经常会把字节流转换为字符流。例如：

Java 的控制台输入由 System.in 完成。为了获得一个绑定到控制台的字符流，我们可以把 System.in 包装在一个 BufferedReader对象中来创建一个字符流。

下面是创建 BufferedReader 的基本语法：

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

同理，从文件读取：

InputStream f = new FileInputStream("C:/java/hello");
BufferedReader br = new BufferedReader(new InputStreamReader(f));

使用BufferedReader是为了使用缓冲功能。

java.io.BufferedReader和java.io.BufferedWriter类各拥有8192字符的缓冲区。当BufferedReader在读取文本文件时，会先尽量从文件中读入字符数据并置入缓冲区，而之后若使用read()方法，会先从缓冲区中进行读取。如果缓冲区数据不足，才会再从文件中读取，使用BufferedWriter时，写入的数据并不会先输出到目的地，而是先存储至缓冲区中。如果缓冲区中的数据满了，才会一次对目的地进行写出。

针对上面示例的三个类进行简单说明：

  • InputStream：是所有字节输入流的超类，一般使用它的子类：FileInputStream等，它能输出字节流；
  • InputStreamReader：是字节流与字符流之间的桥梁，能将字节流输出为字符流，并且能为字节流指定字符集，可输出一个个的字符；
  • BufferedReader：提供通用的缓冲方式文本读取，readLine()读取一个文本行，从字符输入流中读取文本，缓冲各个字符，从而提供字符、数组和行的高效读取。

InputStream提供的read()方法支持从输入流中读取一个数据字节。常用原型：

public int read() throws IOException {}

从此输入流中读取一个数据字节。如果没有输入可用，则此方法将阻塞。
指定者：类 InputStream 中的 read
返回：下一个数据字节；如果已到达文件末尾，则返回 -1。

public int read(byte[] b) throws IOException{}

从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。在某些输入可用之前，此方法将阻塞。
覆盖：类 InputStream 中的 read
参数：存储读取数据的缓冲区。
返回：读入缓冲区的字节总数，如果因为已经到达文件末尾而没有更多的数据，则返回 -1。

示例

示例1：从控制台读取单字符输入

public static void main(String[] args) throws IOException{
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    char c;

    System.out.println("输入字符,按下 'q' 键退出:");

    do {
        c = (char) br.read();
        System.out.println(c);
    }while(c != 'q');
}

示例2：从控制台读取多字符输入

public static void main(String[] args) throws IOException{
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    String s;
    System.out.println("输入字符串,按下 'quit' 键退出:");

    do {
        s = br.readLine();
        System.out.println(s);
    }while(!s.equals("quit"));
}

示例3：使用 InputStream 中的 read读取字节流

public static void main(String[] args) throws IOException{
    InputStream input = System.in;
    byte[] b = new byte[1024];
    int len = 0;
    StringBuffer sb = new StringBuffer("");

    while ((len = input.read(b)) != 2) {
        System.out.println(len);
        sb.append(new String(b, 0, len));
    }

    input.close();
    System.out.println(sb.toString());
}

其实该例子改成文件读取会更好：

public static void main(String[] args) throws IOException{
    InputStream input = new FileInputStream("src/test.txt");
    byte[] b = new byte[1024];
    int len = 0;
    StringBuffer sb = new StringBuffer("");

    while ((len = input.read(b)) > 0) {
        System.out.println(len);
        sb.append(new String(b, 0, len));
    }

    input.close();
    System.out.println(sb.toString());
}

也可以使用一个文件对象来创建一个输入流对象来读取文件。我们首先得使用 File() 方法来创建一个文件对象：

File f = new File("src/test.txt");
InputStream input = new FileInputStream(f);

必须先在src目录下建立文件test.txt，内容: hello world
运行结果：

11
hello world

示例4：控制台输出：

我们知道，控制台的输出由 print() 和 println() 完成。这些方法都由类 PrintStream 定义，System.out 是该类对象的一个引用。
PrintStream 继承了 OutputStream类，并且实现了方法 write()。这样，write() 也可以用来往控制台写操作。
但是write() 方法不经常使用，因为 print() 和 println() 方法用起来更为方便。

PrintStream 定义 write() 的最简单格式如下所示：

void write(int byteval){}

该方法将 byteval 的低八位字节写到流中。

public static void main(String[] args) {
    System.out.write('h');
    System.out.write('\n');
}

示例5：输出内容到文件

public static void main(String[] args) throws IOException{

    String str = "hello world";

    // 构建FileOutputStream对象,文件不存在会自动新建
    OutputStream out = new FileOutputStream("src/test2.txt");
    out.write(str.getBytes());
    out.close();
}

也可以使用一个文件对象来创建一个输出流来写文件。我们首先得使用File()方法来创建一个文件对象：

File f = new File("src/test2.txt");
OutputStream out = new FileOutputStream(f);

运行后，打开src目，就能看到test2.txt。

getBytes()用于把字符串转化为字节流（byte型）。方法原型：

public byte[] getBytes() {
    return StringCoding.encode(value, 0, value.length);
}

public byte[] getBytes(Charset charset) {
    if (charset == null) throw new NullPointerException();
    return StringCoding.encode(charset, value, 0, value.length);
}

示例6：借助BufferedWriter输出内容到文件

public static void main(String[] args) throws IOException{

    String str = "hello";

    // 构建FileOutputStream对象,文件不存在会自动新建
    OutputStream out = new FileOutputStream("src/test3.txt");
    BufferedWriter bWriter = new BufferedWriter(new OutputStreamWriter(out));
    bWriter.write(str);
    bWriter.close();//关闭缓冲区
}

我们还可以结合上述的BufferedReader进行从键盘输入，保存到文件：

public static void main(String[] args) throws IOException{

    String str = "";

    // 构建FileOutputStream对象,文件不存在会自动新建
    OutputStream out = new FileOutputStream("src/test3.txt");
    BufferedWriter bWriter = new BufferedWriter(new OutputStreamWriter(out, "utf-8"));//构建OutputStreamWriter对象,参数可以指定编码,默认为操作系统默认编码,windows上是gbk
//      bWriter.write(str);

    //读缓存区
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

    do {
        str = br.readLine();
        bWriter.write(str);
        System.out.println(str);
    }while(!str.equals("quit"));

    bWriter.close();//关闭缓冲区,同时会把缓冲区内容写入文件
    out.close();// 关闭输出流,释放系统资源
}

文件和I/O

主要有这些类：

  • File 文件类。
  • FileReader FileReader类从InputStreamReader类继承而来。该类按字符读取流中数据。
  • FileWriter FileWriter 类从 OutputStreamWriter类继承而来。该类按字符向流中写入数据。

File 类至少有一个参数。File 类方法：

  • mkdir()方法创建一个文件夹，成功则返回true，失败则返回false。
    失败表明File对象指定的路径已经存在，或者由于整个路径还不存在，该文件夹不能被创建。
  • mkdirs()创建指定的目录，包括创建必需但不存在的父目录。创建多级目录使用该方法。
  • isDirectory()判断是否是一个目录。
  • isFile() 判断是否是一个标准文件。
  • list() 提取包含的文件和文件夹的列表。
  • delete()方法同于删除文件或空目录。
  • createNewFile() throws IOException
    当且仅当不存在具有此抽象路径名指定的名称的文件时，原子地创建由此抽象路径名指定的一个新的空文件。

示例1：目录操作

public static void main(String[] args) throws IOException {
    String dirname = "src/tmp";
    File file = new File(dirname);

    //创建目录
    if(!file.isDirectory()) {
        if(file.mkdirs()) {
            System.out.println("succ mkdirs");
        }
    }

    //创建文件
    File file2 = new File(dirname + "/test.txt");
    file2.createNewFile();//目录必须存在

    File file3 = new File(dirname + "/test/");
    file3.mkdir();

    //列出目录
    if(file.isDirectory()) {
        String[] lists = file.list();
        for (int i = 0; i < lists.length; i++) {
            File f = new File(dirname + "/" + lists[i]);
            if(f.isDirectory()) {
                System.out.println("[d]"+ lists[i]);
            }else {
                System.out.println("[f]"+ lists[i]);
            }
        }
    }else {
        System.out.println(dirname + " 不是一个目录");
    }

    //删除文件或目录
    if(file3.delete()) {
        System.out.println("删除成功");
    }
}

运行结果：

[d]test
[f]test.txt
删除成功

示例2：

public static void main(String[] args) throws IOException {
    String filename = "src/tmp/test.txt";
    File file = new File(filename);
    file.createNewFile();// 创建文件
    FileWriter fWriter = new FileWriter(file);//创建FileWriter对象
    fWriter.write('i');
    fWriter.write(' ');
    char[] cs = {'l', 'o', 'v', 'e', ' '};
    fWriter.write(cs);
    fWriter.write("java");
    fWriter.flush();//将输入流和输出流中的缓冲进行刷新，使缓冲区中的元素即时做输入和输出，而不必等缓冲区满
    fWriter.close();//关闭FileWriter对象

    //读取文件
    FileReader fReader = new FileReader(file);
    char[] cs2 = new char[15];
    fReader.read(cs2);//这里因为知道长度不会大于15，所以没有用while循环读取
    for(char c : cs2) {//遍历输出
        System.out.print(c);
    }
    fReader.close();

运行结果：

i love java

参考

1、Java 流(Stream)、文件(File)和IO | 菜鸟教程
http://www.runoob.com/java/java-files-io.html
2、java中char和byte的转换 - CSDN博客
http://blog.csdn.net/feixiazhitian/article/details/49511963
3、字节流与字符流的区别及相互转换 - 杰-维斯布鲁克 - 博客园
https://www.cnblogs.com/sjjsh/p/5269781.html
4、Java中，BufferedReader类的介绍及作用 - CSDN博客
http://blog.csdn.net/wiebin36/article/details/51912794

原文地址：https://www.cnblogs.com/52fhy/p/8232825.html

时间： 2024-08-27 00:22:55

Java笔记：Java 流(Stream)、文件(File)和IO的相关文章

Java学习记录(补充八:Date类;Java流(Stream),文件(File)和IO)

Date类,Calendar类package Box1; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Calendar; import java.util.Date; import java.util.Random; //Date类 public class DateTest { public static void main(String[] args) { Date

流Stream 文件File 流IO

Java 流(Stream).文件(File)和IO Java.io 包几乎包含了所有操作输入.输出需要的类.所有这些流类代表了输入源和输出目标. Java.io 包中的流支持很多种格式,比如:基本类型.对象.本地化字符集等等. 一个流可以理解为一个数据的序列.输入流表示从一个源读取数据,输出流表示向一个目标写数据. Java 为 I/O 提供了强大的而灵活的支持,使其更广泛地应用到文件传输和网络编程中. 但本节讲述最基本的和流与 I/O 相关的功能.我们将通过一个个例子来学习这些功能. 读取控

Java流(Stream)、文件(File)和IO

Java流(Stream).文件(File)和IO Java.io包几乎包含了所有操作输入.输出需要的类.所有这些流类代表了输入源和输出目标. Java.io包中的流支持很多种格式,比如:基本类型.对象.本地化字符集等等. 一个流可以理解为一个数据的序列.输入流表示从一个源读取数据,输出流表示向一个目标写数据. Java为I/O提供了强大的而灵活的支持,使其更广泛地应用到文件传输和网络编程中. 但本节讲述最基本的和流与I/O相关的功能.我们将通过一个个例子来学习这些功能. 读取控制台输入 Jav

java 学习笔记之 流、文件的操作

ava 学习笔记之 流.文件的操作 对于一些基础的知识,这里不再过多的解释, 简单的文件查询过滤操作 package com.wfu.ch08; import java.io.File; import java.io.FilenameFilter; public class Test1 { public static void main(String[] args) { File file=new File("F:\\2017-2018-1\\javase"); // //获取该目录下

深入理解 Java中的 流 (Stream)

首先,流是什么? 流是个抽象的概念,是对输入输出设备的抽象,Java程序中,对于数据的输入/输出操作都是以"流"的方式进行.设备可以是文件,网络,内存等. 流具有方向性,至于是输入流还是输出流则是一个相对的概念,一般以程序为参考,如果数据的流向是程序至设备,我们成为输出流,反之我们称为输入流. 可以将流想象成一个"水流管道",水流就在这管道中形成了,自然就出现了方向的概念. 当程序需要从某个数据源读入数据的时候,就会开启一个输入流,数据源可以是文件.内存或网络等等.

10.4-全栈Java笔记:常用流详解（二）

上节我们讲到「Java中常用流:文件字节流和字节数组流」,本节我们继续走起~  缓冲流 BufferedInputStream和BufferedOutputStream这两个流是处理流,通过内部缓存数组来提高操作流的效率. [示例1]使用缓冲流实现文件的高效率复制操作 public class Demo06 { public static void main(String[] args) { new Demo06().copyFile("d:/a.txt", "d:/b.tx

Java 流(Stream)、文件(File)和IO

Java.io包几乎包含了所有操作输入.输出需要的类.所有这些流类代表了输入源和输出目标. Java.io包中的流支持很多种格式,比如:基本类型.对象.本地化字符集等等. 一个流可以理解为一个数据的序列.输入流表示从一个源读取数据,输出流表示向一个目标写数据. Java为I/O提供了强大的而灵活的支持,使其更广泛地应用到文件传输和网络编程中. 但本文讲述最基本的和流与I/O相关的功能.我们将通过一个个例子来学习这些功能. 读取控制台输入 Java的控制台输入由System.in完成. 为了获得一

吴裕雄--天生自然 JAVA开发学习：流(Stream)、文件(File)和IO

BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); //使用 BufferedReader 在控制台读取字符 import java.io.*; public class BRRead { public static void main(String args[]) throws IOException { char c; // 使用 System.in 创建 BufferedReader Buffe

Java ——流(Stream)、文件(File)和IO

本节重点思维导图 示例:将指定的字符写到文件中 public static void main(String[] args) { try { //1.创建一个空的文件 File file = new File("abc.txt"); if (!file.exists()) { file.createNewFile(); } //2.准备数据 StringBuffer data = new StringBuffer(); for(int i = 0;i<8000;i++) { da