Java文件读写

大家好，又见面了，我是你们的朋友全栈君。

1.%g用于输出科学计数法

2.用printf输出换行除了’\n’，还可以用’%n’

3.File类的几个构造方法：
1）File(String directoryPath)
2）File(String directoryPath,String filename)
3）File(File dirObj,String filename)
4）File(URI uri)
注意，这里的对象指的可能是一个我们通常所说的文件，也可能是一个目录（路径）；可以是个具体存在的文件，也可以是个尚未存在的文件。

4.所谓的数据流是指一组有顺序的、有起点和终点的字节集合

5.Java程序不能直接操纵I/O设备，而是在程序和设备之间加入了一个中间介质，这就是流。流是数据传输的抽象表达，与具体设备无关，程序一旦建立了流，就可以不用理会起点或终点是何种设备

6.输入流将数据从文件、标准输入或者其它外部设备输入加载到内存。

7.输入输出数据流：
1）以字节流传输的输入数据流都是抽象类InputStream的子类；以字符流传输的输入数据流都是抽象类Reader的子类。
2）以字节流传输的输出数据流都是抽象类OutputStream的子类；以字符流传输的输出数据流都是抽象类Writer的子类。

8.类File一般不涉及文件内部的具体内容，而是从整体上对文件进行处理，如获取各种各样的文件消息或者删除文件。类File不仅可以对文件进行操作，而且还可以对路径进行操作。

9.父目录：当前所在目录的上一层目录（文件夹）
子目录：当前所在目录的下一层目录（文件夹）

10.mark()通常与reset（）方法配合使用，可重复读取输入流所指定的字节数据。例如：若fis是一个输入流，如果想读取相同的字 节数据到字节数组b1和b2中，可通过以下语句实 现，先标记输入流中当前位置，读取数据后重置 读取位置。

fis.mark(5);
byte[] b1=new byte[5], byte[] b2=new byte[5],
 fis.read(b1,0,5);
fis.reset();
 Fis.read(b2,0,5);

11.mark(int readlimit)方法表示标记当前位置，并保证在mark以后最多可以读取readlimit字节数据。reset()方法表示重置移动读取指针到上一次mark的地方。

12.FileOutputStream用于向本地文件中写入数据，注意，是往本地文件中写入，不是向控制台输出。

13.FileInputStream不支持缓冲和做标记

14.InputStream和OutputStream都是抽象类，不能通过new OutputStream()的方法构造各自的实例。我们可以通过构造它们的子类的实例方式构造该类型的实例（类似于List和Arraylist的关系）。一个构造InputStreamReader实例的例子：

new InputStreamReader(new FileInputStream("data.txt"));

15.FilterInputStream:过滤器输入流是其它带过滤器的输入流的超类，它的方法和InputStream的方法完全一样，也就是说前者只是简单地重写了后者的所有方法。
1）它的构造方法是FilterInputStream(InputStream in)。过滤器输入流以一个InputStream为自己的数据。
2）成员变量：protected InputStream in。在构造方法里会对这个变量赋值，即this.in=in

16.当创建BufferedInputStream或者BufferedOutputStream的实例时，均会在内存中开辟一个字节数组的存储单元（一般称为缓存），默认为512字节，用来存放数据流中的数据。

17.通常情况下，缓冲区的大小应为内存页或者磁盘块等的整数倍，以避免页或块的浪费。

18.write(int b):将b转成二进制后，把b的低8位写到输出流。把所有32位都写到输出流的函数是writeInt(int b)。

19.使用对象流读取和写入对象时，要保证对象是串行化的。（串行化的概念：指对象通过把自己转化为一系列字节，记录字节的状态数据，以便再次利用的这个过程）

20.串行化（Serializable）是Java.io包中定义的一个接口。这个接口中没有定义任何方法，只是一个特殊的标记，用来告诉编译器，这个对象参加了串行化的协议，可以把它串行化。一个类要具有可串行化的特性就必须实现接口Java.io.Serializable。

21.有些对象不能串行化，例如Thread对象，FileInputStream对象以及FileOutputStream对象等，因为其状态是暂时的。

22.对不希望串行化的对象要用关键字transient修饰。

23.创建管道输入流对象(PipeInputStream)：

public PipeInputStream();
public PipeInputStream(PipeOutputStream src);

24.创建管道输出流对象（PipeOutputStream）:

public PipeOutputStream();
public PipeOutputStream(PipeInputStream src)

25.被连接的管道流必须没有与任何别的管道流连接，否则会抛出IOException异常，管t道输出流是往管道中写数据，管道输入流是往管道中读数据。（类似文件和文件流的关系）因为InputStream本来就是字节输入流，InputStream对应的字符流是Reader类。

26.InputStreamReader类继承自Reader类，通过其read方法从字节流中读取一个或者多个字节数据转换为字符数据。它可以接一个缓冲流来提高效率。OutputStreamWriter同理。

27.InputStream构造方法摘要 :出处

1）InputStreamReader (InputStream  in)  创建一个使用默认字符集的 InputStreamReader。 
2）InputStreamReader (InputStream  in, Charset  cs)  创建使用给定字符集的 InputStreamReader。 
3）InputStreamReader (InputStream  in, CharsetDecoder  dec)   创建使用给定字符集解码器的 InputStreamReader。 
4）InputStreamReader (InputStream  in, String  charsetName)  创建使用指定字符集的 InputStreamReader。

28.一种高效的写法：

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

29.与InputStreamReader是字节转字符不同，OutputStreamWriter是字符转字节。反正外界传进来是字节，往外界输出的也是字节。

30.BufferReader的两个构造方法：

BufferedReader(Reader in);
BufferedReader(Reader in,int size);

31.小结：
1)File,FileStream是处理本地文件的类
2）DataStream是一个过滤流的子类，借此可以读写各种基本数据。
3）BufferedStream的作用是在数据送到目的地之前先缓存，达到一定数量时再送到目的地，以提高程序的运行效率。
4）PipedStream适合于一个处理的输出作为另一个处理的输入的情况。

LAB11（文件读写）：
1.FileInputStream(文件输入流)是从系统的某个文件中获得输入字节
FileOutputStream(File file)是向File对象的文件写入数据

2.无参的read()方法返回int类型，返回值是数据下一个字节的字节码，如果已到达流的最后面了，就返回-1；带参数的read（）方法返回的是读取的字节数（到达数据的末端返回值为-1）

3.read（）源码：

//带参
    public int read(byte b[], int off, int len) throws IOException { 
   
    //这里是一些前期判断，我们的buffer[]数组不能为空，偏移量一开始不能比0小，要读取的字节长度也不能比0小
        if (b == null) { 
   
            throw new NullPointerException();
        } else if (off < 0 || len < 0 || len > b.length - off) { 
   
            throw new IndexOutOfBoundsException();
        } else if (len == 0) { 
   
            return 0;
        }

        int c = read();
        if (c == -1) { 
   
            return -1;
        }
        b[off] = (byte)c;

        int i = 1;
        try { 
   
            for (; i < len ; i++) { 
   
                c = read();
                if (c == -1) { 
   
                    break;
                }
                b[off + i] = (byte)c;
            }
        } catch (IOException ee) { 
   
        }
        return i;
    }
    //--------------------分割线--------------------------
    public int read(byte b[]) throws IOException { 
   
        return read(b, 0, b.length);
    }

//不带参
/** * Reads the next byte of data from the input stream. The value byte is * returned as an <code>int</code> in the range <code>0</code> to * <code>255</code>. If no byte is available because the end of the stream * has been reached, the value <code>-1</code> is returned. This method * blocks until input data is available, the end of the stream is detected, * or an exception is thrown. * * <p> A subclass must provide an implementation of this method. * * @return the next byte of data, or <code>-1</code> if the end of the * stream is reached. * @exception IOException if an I/O error occurs. */
    public abstract int read() throws IOException;

4.用FileInputStream向文件中写入内容的步骤：
1）建立File对象：File in=new File(String pathname)
2）构造字符串：String text=“XXXXX”
3）字符串转byte，并指定编码方式：byte[] a=text.getBytes(“UTF-8”)
4）建立文件输出流：FileOutputStream o=new FileOutputStream(File filename)
5)开始写入：o.write(a)
6)关闭输出流：o.close()

5.删除String中的特定字符串：用replace方法即可，把待删除字符串替换成""即可达到删除字符串的目的。

6.获取子字符串：String.subString(int beginindex,int endindex),endindex表示子字符串在原字符串中的结束位置，也就是’\0’的位置。这个方法还可以用来拼接字符串，从而实现删除特定位置字符串的目的。

7.FileReader介绍：
1）Reader类是定义Java的流式字符输入模式的抽象类。
2）writer类是定义流式字符输出的抽象类
3）FileReader类创建了一个可以读取文件内容的Reader类
4）FileWriter创建一个可以写文件的Writer类
用FileReader类写文件示例：

  import  java.io.*;

    class FileWriterDemo { 
   

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

            String source = "learn how to write to file";

            FileWriter  f1 = new FileWriter("file1.txt");

            for  (int i=0; i<buffer.length; i +=2) { 
   

                f1.write (buffer[i]);

             }

            fo.close();

             FileWriter f2 = new FileWriter("file2.txt");

            f2.write(buffer);

            f2.close();

            FileWriter  f3 = new FileWriter ("file3.txt");

            f2.write(buffer,buffer.length-buffer.length/4, buffer.length/4);

        }

}

8.用FileWriter.write(String)向文件中写入字符串时，如果字符串中有换行，那么构造这个字符串的时候你得在换行符\n前加一个\r，因为在Windows系统里面\r\n才是换行

9.解决读取文件时乱码问题：先FileInputStream,然后InputStreamReader,最后是BufferedReader,就是文件–》按字节读取–》按流读取

public static void copyFile (String sourceFile, String targetFile) throws IOException { 
   
        FileWriter fw_o=new FileWriter(targetFile);
        FileInputStream fis=new FileInputStream(sourceFile);
        InputStreamReader fr=new InputStreamReader(fis,"gbk");//重点是这个，我也不知道为什么用utf-8不行
        BufferedReader br=new BufferedReader(fr);
        BufferedWriter bw=new BufferedWriter(fw_o);
        String s=new String();
        int i=0;
        while ((s=br.readLine())!=null){ 
   
            System.out.println(s);
            bw.write(s);
            bw.newLine();
        }
        bw.close();
    }

原文件内容：

运行输出：