Java--IO流

Java IO流

IO流用来处理设备之间的数据传输，文件复制，上传文件和下载文件，可以把数据存储到文件，也可以从文件中读取数据。

IO流分类

-输出流：FileWriter　　写数据

-输入流：FileReader　　读数据

FileWriter写数据

import java.io.FileWriter;
/*
 * 需求：往文件中写数据
 *         写数据使用输出流 --FileWriter
 * 构造方法：
 *         FileWriter(String filename):传递一个文件名称。
 * 输出流写数据的步骤：
 * 1.创建输出流对象；
 * 2.调用输出流写数据的方法；
 * 3.释放资源。
 * 
 * 成员方法：
 * -void write(String str) 
 * -void flush()
 * -void close()
 */
import java.io.IOException;

public class WriteTest {

    public static void main(String[] args) throws IOException {
        // 创建输出流对象；
        FileWriter fw = new FileWriter("d:\\text.txt");
        /*
         * 创建输出流对象做了哪些事情： 1.调用系统资源，创建了一个文件； 2.创建输出流对象； 3.把输出流对象指向文件。
         */
        // 调用输出流写数据的方法
        // 写一个字符串数据
        fw.write("Hello World!我喜欢猪猪");
        // 数据没有直接写到文件，其实是写到内存缓冲区
        fw.flush(); // 刷新缓冲区

        // 释放资源
        // 通知系统释放和该文件相关的资源；
        fw.close();
    }

}

View Code

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

/*
 *相对路径：相对当前项目而言的，在项目的根目录下
 *绝对路径：以盘符开始的路径。
 * 
 */
public class WriteTest01 {

    public static void main(String[] args) throws IOException {
        
        //FileWriter fw = new FileWriter("D:\\text1.txt");
        FileWriter fw = new FileWriter("text1.txt");
        fw.write("I love you,猪猪！");
        fw.flush();
        fw.write("我真的真的好喜欢猪猪");
        fw.flush();
        //fw.flush();
        /*
         * close()和flush()的区别
         * close() 刷新缓冲区，然后通知系统释放资源,流对象将不能再被使用。
         * flush() 刷新缓冲区，流对象将还能再被使用。
         */
        fw.close();

    }

}

View Code

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

/*
 * FileWriter写数据的5个方法
 * -void write(String str):写一个字符串数据
 * -void write(String str,int index,int len)：写一个字符串中的一部分数据；
 * -void write(int ch)：写一个字符数据，写int类型的好处：既可以写char类型的数据，也可以写char对应的int类型的值。
 * -void write(char[] chs)：写一个字符数组的数据；
 * -void write(char[] chs,int index,int len) ：写一个字符数组中的一部分数据
 */
public class WriteTest02 {
    public static void main(String[] args) throws IOException {
        FileWriter fw = new FileWriter("text2.txt");
        fw.write("猪猪，我喜欢你\n");
        fw.write("abcdefgh", 1, 5);
        fw.write("\n");
        fw.write(97);
        fw.write("\n");
        fw.write('a');
        fw.write("\n");
        char[] arr = { 's', 'd', 'v', 'f', 'b' };
        fw.write(arr);
        fw.write("\n");
        fw.write(arr, 1, 4);
        fw.write("\n");
        fw.close();
    }
}

View Code

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

/*
 * FileWriter写数据实现数据的换行，以及实现数据的追加写入
 * "\n"可以实现换行，win的换行符是"\r\n",mac识别的换行符是"\r";
 * FileWriter(String fileName, boolean append) 
 *    -构造一个FileWriter对象，给出一个带有布尔值的文件名，表示是否附加写入的数据。
 */
public class WriteTest03 {

    public static void main(String[] args) throws IOException {
        FileWriter fw = new FileWriter("test3.txt", true);

        // 写数据
        // for (int i = 0; i < 10; i++) {
        // fw.write("Hello" + i);
        // fw.write("\n");
        //
        // }
        // 追加写数据
        for (int i = 0; i < 10; i++) {
            fw.write("Hello" + i);
            fw.write("\n");

        }

        fw.close();
    }
}

View Code

FileReader读取数据

package demo;

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

/*
 * FileReader读数据
 * 构造方法：
 *         -FileReader(String fileName)
 * 成员方法：
 *         -int read();一次读取一个字符，
 *         -int read(char[] cbuf);
 */
public class ReadTest1 {

    public static void main(String[] args) throws IOException {
        FileReader fr = new FileReader("WriteTest02.java");
        // int ch = fr.read();
        // System.out.print((char)ch);
        // ch = fr.read();
        // System.out.print((char)ch);
        // ch = fr.read();
        // System.out.print((char)ch);
        // ch = fr.read();
        // System.out.print((char)ch);
        // ch = fr.read();
        // System.out.print((char)ch);
        // ch = fr.read();
        // System.out.print((char)ch);
        // ch = fr.read();
        // System.out.print((char)ch);

        // int ch;
        // do{
        // ch = fr.read();
        // System.out.print((char)ch);
        // }while(ch != -1);

        int ch;
        while ((ch = fr.read()) != -1) {
            System.out.print((char) ch);
        }
        fr.close();

    }
}

read()一次读取一个字符

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

/*
 * FileReader读取数据
 *     --int read(char[] cbuf); 一次读取一个字符数组，返回是实际读取的字符数组的长度,
 *         当长度是-1的时候表示没有数据了
 * 
 */
public class ReadTest2 {

    public static void main(String[] args) throws IOException {
        FileReader fr = new FileReader("WriteTest02.java");
        char[] chs = new char[1024];
        int len;
        while ((len = fr.read(chs)) != -1) {
            System.out.print(new String(chs, 0, len));
        }
        fr.close();
    }
}

View Code

IO流案例：复制文本文件

package demo;

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

/*
 * 复制文本文件：一次读取一个字符
 */
public class CopyFileTest {

    public static void main(String[] args) throws IOException {
        FileWriter fw = new FileWriter("Copy.java");
        FileReader fr = new FileReader("WriteTest02.java");
        
        int ch;
        while((ch = fr.read()) != -1){
            fw.write(ch);
        }
        fr.close();
        fw.close();

    }

}

复制文件

BufferedWriter，BufferedReader读写数据

BufferedWriter：高效字符缓冲流

将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入。

可以指定缓冲区大小，或者可以接受默认大小。默认值足够大，可用于大多数用途。

构造方法

BufferedWriter(Writer out) 创建使用默认大小的输出缓冲区的缓冲字符输出流。

常用方法:

1 void write(int c)：一次写一个字符
2 void write(char[] cbuf, int off, int len) ：写入字符数组的一部分。
3 void write(String s, int off, int len):写一个字符串的一部分。
4 void newLine()：写一行行分隔符。
5 void flush():刷新流。
6 void close():关闭流，先刷新。

BufferedReader：高效字符输入流

从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取。
可以指定缓冲区大小，或者可以使用默认大小。默认值足够大，可用于大多数用途。

构造方法：

BufferedReader(Reader in):创建使用默认大小的输入缓冲区的缓冲字符输入流。

BufferedReader(Reader in,int sz):创建使用指定大小的输入缓冲区的缓冲字符输入流。

常用方法：

void close():关闭流并释放与之相关联的任何系统资源。

int read():读一个字符。

int read(char[] cbuf,int off,int len):将字符读入数组的一部分。

String readline():读取一行文字。

package demo;

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

public class BufferedTest {

    public static void main(String[] args) throws IOException {
        //创建高效缓冲流
        BufferedReader br = new BufferedReader(new FileReader("Copy.java"));
        BufferedWriter bw = new BufferedWriter(new FileWriter("buffer.txt"));
        
        //一次读写一个字符
        int chs;
        while((chs = br.read()) != -1){
            bw.write(chs);
        }
        
        br.close();
        bw.close();

    }
}

缓冲流一次读写一个字符

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

public class BufferedTest01 {

    public static void main(String[] args) throws IOException {
        // 缓冲流一次读写一个字符数组
        BufferedReader br = new BufferedReader(new FileReader("Copy.java"));
        BufferedWriter bw = new BufferedWriter(new FileWriter("copy01.java"));

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

缓冲流一次读写一个字符数组

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

public class CopyFile {

    // 基本流一次读写一个字符
    public static void method1(String srcFile, String destFile)
            throws IOException {
        // 创建输入输出流对象
        FileReader fr = new FileReader(srcFile);
        FileWriter fw = new FileWriter(destFile);
        int i;
        while ((i = fr.read()) != -1) {
            fw.write((char) i);
        }
        fr.close();
        fw.close();
    }

    // 基本流一次读写一个字符数组
    public static void method2(String srcFile, String destFile)
            throws IOException {
        // 创建基本输入输出流对象
        FileReader fr = new FileReader(srcFile);
        FileWriter fw = new FileWriter(destFile);

        char[] chs = new char[1024];
        int len;
        while ((len = fr.read(chs)) != -1) {
            fw.write(new String(chs, 0, len));
        }
        fr.close();
        fw.close();
    }

    // 缓冲流一次读写一个字符
    public static void method3(String srcFile, String destFile)
            throws IOException {
        // 创建缓冲流对象
        BufferedReader br = new BufferedReader(new FileReader(srcFile));
        BufferedWriter bw = new BufferedWriter(new FileWriter(destFile));

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

    }

    // 缓冲流一次读写一个字符数组
    public static void method4(String srcFile, String destFile)
            throws IOException {
        BufferedReader br = new BufferedReader(new FileReader(srcFile));
        BufferedWriter bw = new BufferedWriter(new FileWriter(destFile));

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

    // 缓冲流使用特殊功能读写数据
    public static void method5(String srcFile, String destFile)
            throws IOException {
        BufferedReader br = new BufferedReader(new FileReader(srcFile));
        BufferedWriter bw = new BufferedWriter(new FileWriter(destFile));

        String line;
        while ((line = br.readLine()) != null) {
            bw.write(line);
            bw.newLine();
        }
        br.close();
        bw.close();
    }

    public static void main(String[] args) throws IOException {
        method1("WriteTest02.java", "copy1.java");
        method2("WriteTest02.java", "copy2.java");
        method3("WriteTest02.java", "copy3.java");
        method4("WriteTest02.java", "copy4.java");
        method5("WriteTest02.java", "copy5.java");

    }

}

五种读写数据方式

posted on 2019-03-21 23:51 野犬阅读(130) 评论(0) 编辑收藏举报