IO之读写文件的整理

IO之读写文件的整理

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

1.FileInputStream 和 FileOutputStream(字节流） 1.1 FileInputStream 

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

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

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

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

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

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

 1.2 FileOutputStream

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

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

有两个构造方法可以用来创建 FileOutputStream 对象。

1.使用字符串类型的文件名来创建一个输出流对象：

OutputStream f = new FileOutputStream("E:/test/hello")

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

File f = new File("E:/test/hello");
OutputStream fOut = new FileOutputStream(f);

1.3 例子

1.

import java.io.*;
 
public class fileStreamTest {
    public static void main(String[] args) {
        try {
            byte bWrite[] = { 11, 21, 3, 40, 5 };
            //创建文件test.txt
            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");
        }
    }
}

 代码由于是二进制写入，可能存在乱码。

2.OutputStreamWriter，InputStreamReader解决乱码问题：

//文件名 :fileStreamTest2.java
import java.io.*;
 
public class fileStreamTest2 {
    public static void main(String[] args) throws IOException {
 
        File f = new File("a.txt");
        FileOutputStream fop = new FileOutputStream(f);
        // 构建FileOutputStream对象,文件不存在会自动新建
 
        OutputStreamWriter writer = new OutputStreamWriter(fop, "UTF-8");
        // 构建OutputStreamWriter对象,参数可以指定编码,默认为 *** 作系统默认编码,windows上是gbk
 
        writer.append("中文输入");
        // 写入到缓冲区
 
        writer.append("rn");
        // 换行
 
        writer.append("English");
        // 刷新缓存冲,写入到文件,如果下面已经没有写入的内容了,直接close也会写入
 
        writer.close();
        // 关闭写入流,同时会把缓冲区内容写入文件,所以上面的注释掉
 
        fop.close();
        // 关闭输出流,释放系统资源
 
        FileInputStream fip = new FileInputStream(f);
        // 构建FileInputStream对象
 
        InputStreamReader reader = new InputStreamReader(fip, "UTF-8");
        // 构建InputStreamReader对象,编码与写入相同
 
        StringBuffer sb = new StringBuffer();
        while (reader.ready()) {
            sb.append((char) reader.read());
            // 转成char加到StringBuffer对象中
        }
        System.out.println(sb.toString());
        reader.close();
        // 关闭读取流
 
        fip.close();
        // 关闭输入流,释放系统资源
 
    }
}

2 ByteArrayInputStream和 ByteArrayOutputStream（字节流） 2.1 ByteArrayInputStream

字节数组输入流在内存中创建一个字节数组缓冲区，从输入流读取的数据保存在该字节数组缓冲区中。

创建字节数组输入流对象有以下几种方式：

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

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

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

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

2.2 ByteArrayOutputStream

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

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

OutputStream bOut = new ByteArrayOutputStream();

2.构造方法创建一个大小为 a 字节的缓冲区

OutputStream bOut = new ByteArrayOutputStream(int a)

 

2.3  例子

import java.io.*;

public class ByteStreamTest {

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

      //创建一个大小为12字节的缓冲区
      ByteArrayOutputStream bOutput = new ByteArrayOutputStream(12);

      while( bOutput.size()!= 10 ) {
         // 获取用户输入值asdfghjkly
         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]  + "   ");
      }
        //输出结果：a   s   d   f   g   h   j   k   l   y
      System.out.println("   ");

      int c;

        //接收字节数组b作为参数创建
      ByteArrayInputStream bInput = new ByteArrayInputStream(b);

      System.out.println("Converting characters to Upper case " );
      for(int y = 0 ; y < 1; y++ ) {
        //bInput.read()从此输入流中读取下一个数据字节
         while(( c= bInput.read())!= -1) {
            System.out.println(Character.toUpperCase((char)c));
         }
         bInput.reset();
      }
   }
}

3.DataInputStream和DataOutputStream（字节流） 3.1 DataInputStream

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

构造方法用来创建数据输入流对象：

DataInputStream dis = new DataInputStream(InputStream in);

3.2 DataOutputStream

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

DataOutputStream out = new DataOutputStream(OutputStream  out);

3.3例子

import java.io.*;
 
public class Test{
   public static void main(String args[])throws IOException{
 
        //创建数据输入流对象
      DataInputStream in = new DataInputStream(new FileInputStream("test.txt"));
        //创建数据输出流对象
      DataOutputStream out = new DataOutputStream(new  FileOutputStream("test1.txt"));
        //字符流
      BufferedReader d  = new BufferedReader(new InputStreamReader(in));
     
      String count;
      while((count = d.readLine()) != null){
          String u = count.toUpperCase();
          System.out.println(u);
          out.writeBytes(u + "  ,");
      }
      d.close();
      out.close();
   }
}

test.txt 文件原本内容如下：

runoob1 runoob2 runoob3 runoob4 runoob5

执行结果 控制台打印的结果如下：

RUNOOB1
RUNOOB2
RUNOOB3
RUNOOB4
RUNOOB5

test1.txt

RUNOOB1 ,RUNOOB2 ,RUNOOB3 ,RUNOOB4 ,RUNOOB5

4.