Java中的I/O

输出流写文件

package Test10;

import java.io.FileWriter;
import java.io.IOException;

/*
 * FileWriter:
 *          FileWriter(String fileName):传递一个文件名称
 * 
 * 输出流写文件的步骤：
 *          1.创建输出流对象
 *          2.调用输出流写对象的方法
 *          3.释放资源
 * 
 * 相对路径：在项目的根目录下
 * 绝对路径：在指定盘中
 */
public class FileWriterDemo {
    public static void main(String[] args) throws IOException {
        //创建输出流对象
        FileWriter fw = new FileWriter("d:\\a.txt");//绝对路径
        FileWriter fw2 = new FileWriter("a.txt");//相对路径

        //调用输出流写对象的方法
        fw.write("hello");
        fw.flush();//刷新缓存区

        fw.write("world");
        fw.flush();//刷新缓存区

        //释放资源
        fw.close();//其实close在释放前也会刷新一次缓存区，适用于数据较少时

    }
}

写数据的五种方法

package Test10;

import java.io.FileWriter;
import java.io.IOException;

/*
 * 写数据的五种方法：
 *          1.void write(String str):写一个字符串数据
 *          2.void write(String str,int index,int len):写一个字符串中从索引index开始共len个字符
 *          3.void write(int chs):写一个字符数据，这里的int其实是既可以写char类型的字符，也可以写char对应的int的数值，例如：'a'-97
 *          4.void write(char[] chs,int index,int len):写一个字符数组中从索引index开始共len个字符
 * 
 * 数据的换行：
 *          1.Windows：\r\n
 *          2.linux:\n
 *          3.mac:\r
 * 
 * 数据的追加写入：
 *          FileWriter(String fileName,boolean append):不写true，则默认为flase，flase就是每次重新执行程序写数据就会把上次写的数据覆盖
 */
public class FileWriterDemo2 {
    public static void main(String[] args) throws IOException {
        //创建输出流对象
        FileWriter fw = new FileWriter("b.txt",true);

        //写一个字符串数据
        fw.write("hello");
        fw.write("\r\n");
        fw.flush();

        //写一个字符串中从索引index开始共len个字符
        fw.write("helloworld",2,5);
        fw.write("\r\n");
        fw.flush();

        //写一个字符数据，这里的int其实是既可以写char类型的字符，也可以写char对应的int的数值，例如：'a'-97
        fw.write('a');
        fw.write(97);
        fw.write("\r\n");
        fw.flush();

        //写一个字符数组中从索引index开始共len个字符
        char[] chs = {'h','e','l','l','o'};
        fw.write(chs,2,2);
        fw.write("\r\n");
        fw.flush();

        //释放资源
        fw.close();
    }
}

输入流读文件

package Test10;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

/*
 * FileReader:
 *          FileReader(String flieName):传递一个文件名称
 * 
 * 输入流读文件的步骤：
 *          1.创建输入流对象
 *          2.调用输入流对象读数据的方法
 *          3.释放资源
 * 
 * 读文件的方法：
 *          1.一次读一个字符
 *          2.一次读一个字符数组
 */
public class FileReaderDemo {
    public static void main(String[] args) throws IOException {
        //创建输入流对象
        FileReader fr = new FileReader("b.txt");

        //调用输入流对象读数据的方法:一次读一个字符
        int ch;
        while((ch=fr.read()) != -1){
            System.out.print((char)ch);//不用加ln，因为读的时候换行符也会被读
        }


        //调用输入流对象读数据的方法:一次读一个字符数组
        char[] chs = new char[1024];
        int len;
        while((len = fr.read(chs)) != -1){
            System.out.println(new String(chs,0,len));
        }

    }
}

复制文件的五种方式

package Test10;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/*
 * 复制文件的五种方式
 * 
 * 步骤：
 *      1.从b.txt文件中读取数据
 *      2.将数据写到copy,tet文件中
 */
public class CopyFileTest {
    public static void main(String[] args) throws IOException {
        String fileReadName = "b.txt";
        String fileWriteName = "copy.txt";

        method1(fileReadName,fileWriteName);
//      method2(fileReadName,fileWriteName);
//      method3(fileReadName,fileWriteName);
//      method4(fileReadName,fileWriteName);
//      method5(fileReadName,fileWriteName);

    }
    //基本流一次读写一个字符
    public static void method1(String fileReadName,String fileWriteName) throws IOException{
        //创建输入流对象
        FileReader fr = new FileReader(fileReadName);

        //创建输出流对象
        FileWriter fw = new FileWriter(fileWriteName);

        //基本流一次读写一个字符
        int ch;
        while((ch=fr.read()) != -1){
            fw.write(ch);
        }

        //释放资源
        fw.close();
        fr.close();
    }
    //基本流一次读写一个字符数组
    public static void method2(String fileReadName,String fileWriteName) throws IOException{
        //创建输入流对象
        FileReader fr = new FileReader(fileReadName);

        //创建输出流对象
        FileWriter fw = new FileWriter(fileWriteName);

        //基本流一次读写一个字符数组
        char[] chs = new char[1024];
        int len;
        while((len=fr.read(chs)) != -1){
            fw.write(chs, 0, len);
        }

        //释放资源
        fw.close();
        fr.close();
    }
    //缓冲流一次读写一个字符
    public static void method3(String fileReadName,String fileWriteName) throws IOException{
        //创建输入缓冲流对象
        FileReader fr = new FileReader(fileReadName);
        BufferedReader br = new BufferedReader(fr);

        //创建输出缓冲流对象
        FileWriter fw = new FileWriter(fileWriteName);
        BufferedWriter bw = new BufferedWriter(fw);

        int ch;
        while((ch=br.read()) != -1){
            bw.write(ch);
        }

        //释放资源
        bw.close();
        br.close();
    }
    //缓冲流一次读写一个字符数组
    public static void method4(String fileReadName,String fileWriteName) throws IOException{
        //创建输入缓冲流对象
        FileReader fr = new FileReader(fileReadName);
        BufferedReader br = new BufferedReader(fr);

        //创建输出缓冲流对象
        FileWriter fw = new FileWriter(fileWriteName);
        BufferedWriter bw = new BufferedWriter(fw);

        char[] chs = new char[1024];
        int len;
        while((len=br.read(chs)) != -1){
            bw.write(chs,0,len);
        }

        //释放资源
        bw.close();
        br.close();
    }
    //缓冲流一次读写一个字符串
    public static void method5(String fileReadName,String fileWriteName) throws IOException{
        //创建输入缓冲流对象
        FileReader fr = new FileReader(fileReadName);
        BufferedReader br = new BufferedReader(fr);

        //创建输出缓冲流对象
        FileWriter fw = new FileWriter(fileWriteName);
        BufferedWriter bw = new BufferedWriter(fw);

        //readLine():一次读取一行数据，但是不读取换行符
        String str;
        while((str=br.readLine()) != null){
            bw.write(str);
            bw.newLine(); //写一个换行符，由系统决定
        }

        //释放资源
        bw.close();
        br.close();
    }
}