JAVA学习记录（三）——Java 流(Stream)、文件(File)和IO

最新推荐文章于 2022-07-26 08:34:49 发布

小鬼头1111

最新推荐文章于 2022-07-26 08:34:49 发布

阅读量2.3k

点赞数

分类专栏： java 文章标签： java

java 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

学习：http://www.ziqiangxuetang.com/java/java-tutorial.html

简介

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

Java.io包中的流支持很多种格式，比如：基本类型、对象、本地化字符集等等。

一个流可以理解为一个数据的序列。输入流表示从一个源读取数据，输出流表示向一个目标写数据。

Java为I/O提供了强大的而灵活的支持，使其更广泛地应用到文件传输和网络编程中。

读取控制台输入

Java的控制台输入由Sysem.in完成。

为了获得一个绑定到控制台的字符流，你可以把System.in包装在一个BufferedReader 对象中来创建一个字符流。

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

Reader对象创建后，我们便可以使用read()方法从控制台读取一个字符，或者用readLine()方法读取一个字符串。

从控制台读取多字符输入

从BufferedReader对象读取一个字符要使用read()方法，它的语法如下：

int read( ) throws IOException

每次调用read()方法，它从输入流读取一个字符并把该字符作为整数值返回。当流结束的时候返回-1。该方法抛出IOException。

下面的程序示范了用read()方法从控制台不断读取字符直到用户输入”q”。

// 使用 BufferedReader 在控制台读取字符

import java.io.*;

public class BRRead {
   public static void main(String args[]) throws IOException
   {
      char c;
      // 使用 System.in 创建 BufferedReader
      BufferedReader br = new BufferedReader(new
                         InputStreamReader(System.in));
      System.out.println("Enter characters, 'q' to quit.");
      // 读取字符
      do {
         c = (char) br.read();
         System.out.println(c);
      } while(c != 'q');
   }
}

从控制台读取字符串

从标准输入读取一个字符串需要使用BufferedReader的readLine()方法。

String readLine( ) throws IOException

下面的程序读取和显示字符行直到你输入了单词”end”。

// 使用 BufferedReader 在控制台读取字符
import java.io.*;
public class BRReadLines {
   public static void main(String args[]) throws IOException
   {
      // 使用 System.in 创建 BufferedReader
      BufferedReader br = new BufferedReader(new
                              InputStreamReader(System.in));
      String str;
      System.out.println("Enter lines of text.");
      System.out.println("Enter 'end' to quit.");
      do {
         str = br.readLine();
         System.out.println(str);
      } while(!str.equals("end"));
   }
}

控制台输出

在此前已经介绍过，控制台的输出由 print( ) 和println( )完成。这些方法都由类PrintStream 定义，System.out是该类对象的一个引用。

PrintStream 继承了OutputStream类，并且实现了方法write()。这样，write()也可以用来往控制台写操作。

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

void write(int byteval)

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

下面的例子用write()把字符”A”和紧跟着的换行符输出到屏幕：

import java.io.*;

// 演示 System.out.write().
public class WriteDemo {
   public static void main(String args[]) {
      int b;
      b = 'A';
      System.out.write(b);
      System.out.write('\n');
   }
}

**注意：**write()方法不经常使用，因为print()和println()方法用起来更为方便。

读写文件

输入流和输出流的类层次图

这里写图片描述

FileInputStream

创建

该流用于从文件读取数据，它的对象可以用关键字new来创建。

有多种构造方法可用来创建对象。

（1）可以使用字符串类型的文件名来创建一个输入流对象来读取文件：

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

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

File f = new File("C:/java/hello");
InputStream f = new FileInputStream(f);

（3）方法
创建了InputStream对象，就可以使用下面的方法来读取流或者进行其他的流操作。

1   public void close() throws IOException{}
关闭此文件输入流并释放与此流有关的所有系统资源。抛出IOException异常。
2   protected void finalize()throws IOException {}
这个方法清除与该文件的连接。确保在不再引用文件输入流时调用其 close 方法。抛出IOException异常。
3   public int read(int r)throws IOException{}
这个方法从InputStream对象读取指定字节的数据。返回为整数值。返回下一字节数据，如果已经到结尾则返回-1。
4   public int read(byte[] r) throws IOException{}
这个方法从输入流读取r.length长度的字节。返回读取的字节数。如果是文件结尾则返回-1。
5   public int available() throws IOException{}
返回下一次对此输入流调用的方法可以不受阻塞地从此输入流读取的字节数。返回一个整数值。

这里写图片描述

FileOutputStream

该类用来创建一个文件并向文件中写数据。

如果该流在打开文件进行输出前，目标文件不存在，那么该流会创建该文件。

构建

有两个构造方法可以用来创建FileOutputStream 对象。
（1）使用字符串类型的文件名来创建一个输出流对象：

OutputStream f = new FileOutputStream("C:/java/hello")

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

File f = new File("C:/java/hello");
OutputStream f = new FileOutputStream(f);

（3）方法

1   public void close() throws IOException{}
关闭此文件输入流并释放与此流有关的所有系统资源。抛出IOException异常。
2   protected void finalize()throws IOException {}
这个方法清除与该文件的连接。确保在不再引用文件输入流时调用其 close 方法。抛出IOException异常。
3   public void write(int w)throws IOException{}
这个方法把指定的字节写到输出流中。
4   public void write(byte[] w)
把指定数组中w.length长度的字节写到OutputStream中。

这里写图片描述

实例

import java.io.*;

public class fileStreamTest{

   public static void main(String args[]){

   try{
      byte bWrite [] = {11,21,3,40,5};
      OutputStream os = new FileOutputStream("test.txt");
      for(int x=0; x < bWrite.length ; x++){
         os.write( bWrite[x] ); // writes the bytes
      }
      os.close();

      InputStream is = new FileInputStream("test.txt");
      int size = is.available();

      for(int i=0; i< size; i++){
         System.out.print((char)is.read() + "  ");
      }
      is.close();
   }catch(IOException e){
      System.out.print("Exception");
   }   
   }
}

上面的程序首先创建文件test.txt，并把给定的数字以二进制形式写进该文件，同时输出到控制台上。

扩展

ByteArrayInputStream类

字节数组输入流在内存中创建一个字节数组缓冲区，从输入流读取的数据保存在该字节数组缓冲区中。创建字节数组输入流对象有以下几种方式。
（1）创建

接收字节数组作为参数创建：

ByteArrayInputStream bArray = new ByteArrayInputStream(byte [] a);

另一种创建方式是接收一个字节数组，和两个整形变量 off、len，off表示第一个读取的字节，len表示读取字节的长度。

ByteArrayInputStream bArray = new ByteArrayInputStream(byte []a, int off, int len)

（2）方法

序号  方法描述
1   public int read()        
从此输入流中读取下一个数据字节。
2   public int read(byte[] r, int off, int len)
将最多 len 个数据字节从此输入流读入字节数组。
3   public int available()
返回可不发生阻塞地从此输入流读取的字节数。
4   public void mark(int read)
设置流中的当前标记位置。
5   public long skip(long n)
从此输入流中跳过 n 个输入字节。

ByteArrayOutputStream类

字节数组输出流在内存中创建一个字节数组缓冲区，所有发送到输出流的数据保存在该字节数组缓冲区中。创建字节数组输出流对象有以下几种方式。

（1）创建

下面的构造方法创建一个32字节（默认大小）的缓冲区。

OutputStream bOut = new ByteArrayOutputStream();

另一个构造方法创建一个大小为n字节的缓冲区。

OutputStream bOut = new ByteArrayOutputStream(int a)

（2）方法

序号  方法描述
1   public void reset()
将此字节数组输出流的 count 字段重置为零，从而丢弃输出流中目前已累积的所有数据输出。
2   public byte[] toByteArray()
创建一个新分配的字节数组。数组的大小和当前输出流的大小，内容是当前输出流的拷贝。
3   public String toString()
将缓冲区的内容转换为字符串，根据平台的默认字符编码将字节转换成字符。
4   public void write(int w)
 将指定的字节写入此字节数组输出流。
5   public void write(byte []b, int of, int len)
 将指定字节数组中从偏移量 off 开始的 len 个字节写入此字节数组输出流。
6   public void writeTo(OutputStream outSt)
将此字节数组输出流的全部内容写入到指定的输出流参数中。

实例——ByteArrayInputStream 和 ByteArrayOutputStream的使用

下面的例子演示了ByteArrayInputStream 和 ByteArrayOutputStream的使用：

import java.io.*;
public class ByteStreamTest {
   public static void main(String args[])throws IOException {
      ByteArrayOutputStream bOutput = new ByteArrayOutputStream(12);
      while( bOutput.size()!= 10 ) {
         // 获取用户输入
         bOutput.write(System.in.read());
      }
      byte b [] = bOutput.toByteArray();
      System.out.println("Print the content");
      for(int x= 0 ; x < b.length; x++) {
         // 打印字符
         System.out.print((char)b[x]  + "   ");
      }
      System.out.println("   ");
      int c;
      ByteArrayOutputStream bInput = new ByteArrayOutputStream(b);
      System.out.println("Converting characters to Upper case " );
      for(int y = 0 ; y < 1; y++ ) {
         while(( c= bInput.read())!= -1) {
            System.out.println(Character.toUpperCase((char)c));
         }
         bInput.reset();
      }
   }
}

运行结果

asdfghjkly
Print the content
a   s   d   f   g   h   j   k   l   y
Converting characters to Upper case
A
S
D
F
G
H
J
K
L
Y

DataInputStream类

数据输入流允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型。
（1）创建

下面的构造方法用来创建数据输入流对象。

DataInputStream dis = DataInputStream(InputStream in);

另一种创建方式是接收一个字节数组，和两个整形变量 off、len，off表示第一个读取的字节，len表示读取字节的长度。

（2）方法

序号  方法描述
1   public final int read(byte[] r, int off, int len)throws IOException
从所包含的输入流中将 len 个字节读入一个字节数组中。如果len为-1，则返回已读字节数。
2   Public final int read(byte [] b)throws IOException
从所包含的输入流中读取一定数量的字节，并将它们存储到缓冲区数组 b 中。
3   
public final Boolean readBooolean()throws IOException,
public final byte readByte()throws IOException,
public final short readShort()throws IOException
public final Int readInt()throws IOException
从输入流中读取字节，返回输入流中两个字节作为对应的基本数据类型返回值。
4   public String readLine() throws IOException
从输入流中读取下一文本行。

DataOutputStream类

数据输出流允许应用程序以与机器无关方式将Java基本数据类型写到底层输出流。
（1）创建

下面的构造方法用来创建数据输出流对象。

DataOutputStream out = DataOutputStream(OutputStream  out);

（2）方法

序号  方法描述
1   public final void write(byte[] w, int off, int len)throws IOException
将指定字节数组中从偏移量 off 开始的 len 个字节写入此字节数组输出流。
2   Public final int write(byte [] b)throws IOException
将指定的字节写入此字节数组输出流。
3   
public final void writeBooolean()throws IOException,
public final void writeByte()throws IOException,
public final void writeShort()throws IOException,
public final void writeInt()throws IOException
这些方法将指定的基本数据类型以字节的方式写入到输出流。
4   Public void flush()throws IOException
  刷新此输出流并强制写出所有缓冲的输出字节。
5   public final void writeBytes(String s) throws IOException
将字符串以字节序列写入到底层的输出流，字符串中每个字符都按顺序写入，并丢弃其高八位。

实例

import java.io.*;

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

      DataInputStream d = new DataInputStream(new
                               FileInputStream("test.txt"));

      DataOutputStream out = new DataOutputStream(new
                               FileOutputStream("test1.txt"));

      String count;
      while((count = d.readLine()) != null){
          String u = count.toUpperCase();
          System.out.println(u);
          out.writeBytes(u + "  ,");
      }
      d.close();
      out.close();
   }
}

文件和I/O

还有一些关于文件和I/O的类，我们也需要知道：

File Class(类)
FileReader Class(类)
FileWriter Class(类)

File

Java文件类以抽象的方式代表文件名和目录路径名。该类主要用于文件和目录的创建、文件的查找和文件的删除等。
File对象代表磁盘中实际存在的文件和目录。

（1）创建

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

File(File parent, String child);

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

File(String pathname)

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

File(String parent, String child)

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

File(URI uri)

（2）方法
这里写图片描述

FileReader类

FileReader类从InputStreamReader类继承而来。该类按字符读取流中数据。
（1）创建

在给定从中读取数据的 File 的情况下创建一个新 FileReader。

FileReader(File file)

在给定从中读取数据的 FileDescriptor 的情况下创建一个新 FileReader。

FileReader(FileDescriptor fd)

在给定从中读取数据的文件名的情况下创建一个新 FileReader。

FileReader(String fileName)

（2）方法

序号  文件描述
1   public int read() throws IOException
读取单个字符，返回一个int型变量代表读取到的字符
2   public int read(char [] c, int offset, int len)
读取字符到c数组，返回读取到字符的个数

（3）实例

import java.io.*;
public class FileRead{
   public static void main(String args[])throws IOException{
      File file = new File("Hello1.txt");
      // 创建文件
      file.createNewFile();
      // creates a FileWriter Object
      FileWriter writer = new FileWriter(file);
      // 向文件写入内容
      writer.write("This\n is\n an\n example\n");
      writer.flush();
      writer.close();
      // 创建 FileReader 对象
      FileReader fr = new FileReader(file);
      char [] a = new char[50];
      fr.read(a); // 读取数组中的内容
      for(char c : a)
          System.out.print(c); // 一个一个打印字符
      fr.close();
   }
}

FileWriter类

FileWriter类从OutputStreamReader类继承而来。该类按字符向流中写入数据。可以通过以下几种构造方法创建需要的对象。
（1）创建

在给出 File 对象的情况下构造一个 FileWriter 对象。

FileWriter(File file)

在给出 File 对象的情况下构造一个 FileWriter 对象。

FileWriter(File file, boolean append)

构造与某个文件描述符相关联的 FileWriter 对象。

FileWriter(FileDescriptor fd)

在给出文件名的情况下构造 FileWriter 对象，它具有指示是否挂起写入数据的 boolean 值。

FileWriter(String fileName, boolean append)

（2）方法

序号  方法描述
1   public void write(int c) throws IOException
写入单个字符c。
2   public void write(char [] c, int offset, int len)
写入字符数组中开始为offset长度为len的某一部分。
3   public void write(String s, int offset, int len)
写入字符串中开始为offset长度为len的某一部分。

（3）实例

import java.io.*;
public class FileRead{
   public static void main(String args[])throws IOException{
      File file = new File("Hello1.txt");
      // 创建文件
      file.createNewFile();
      // creates a FileWriter Object
      FileWriter writer = new FileWriter(file);
      // 向文件写入内容
      writer.write("This\n is\n an\n example\n");
      writer.flush();
      writer.close();
      //创建 FileReader 对象
      FileReader fr = new FileReader(file);
      char [] a = new char[50];
      fr.read(a); // 从数组中读取内容
      for(char c : a)
          System.out.print(c); // 一个个打印字符
      fr.close();
   }
}

Java中的目录

创建目录：

（1）File类中有两个方法可以用来创建文件夹：

mkdir( )方法创建一个文件夹，成功则返回true，失败则返回false。失败表明File对象指定的路径已经存在，或者由于整个路径还不存在，该文件夹不能被创建。
mkdirs()方法创建一个文件夹和它的所有父文件夹。可以在不存在的目录中创建文件夹。诸如：a\b,既可以创建多级目录。

（2）下面的例子创建 “/tmp/user/java/bin”文件夹：

import java.io.File;

public class CreateDir {
   public static void main(String args[]) {
      String dirname = "/tmp/user/java/bin";
      File d = new File(dirname);
      // 现在创建目录
      d.mkdirs();
  }
}

**注意：**Java在UNIX和Windows自动按约定分辨文件路径分隔符。如果你在Windows版本的Java中使用分隔符(/) ，路径依然能够被正确解析。

读取目录

（1）一个目录其实就是一个File对象，它包含其他文件和文件夹。

如果创建一个File对象并且它是一个目录，那么调用isDirectory( )方法会返回true。

可以通过调用该对象上的list()方法，来提取它包含的文件和文件夹的列表。

（2）下面展示的例子说明如何使用list()方法来检查一个文件夹中包含的内容：

import java.io.File;

public class DirList {
   public static void main(String args[]) {
      String dirname = "/tmp";
      File f1 = new File(dirname);
      if (f1.isDirectory()) {
         System.out.println( "Directory of " + dirname);
         String s[] = f1.list();
         for (int i=0; i < s.length; i++) {
            File f = new File(dirname + "/" + s[i]);
            if (f.isDirectory()) {
               System.out.println(s[i] + " is a directory");
            } else {
               System.out.println(s[i] + " is a file");
            }
         }
      } else {
         System.out.println(dirname + " is not a directory");
    }
  }
}

小鬼头1111

关注

0
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
JAVA学习记录（三）——Java 流(Stream)、文件(File)和IO

简介读取控制台输入从控制台读取多字符输入从控制台读取字符串控制台输出读写文件FileInputStream创建FileOutputStream构建实例扩展ByteArrayInputStream类ByteArrayOutputStream类实例ByteArrayInputStream 和 ByteArrayOutputStream的使用DataInputStream类
复制链接

扫一扫