java之不同数据流应用举例

package anno;

import java.io.File;
 java.io.FileInputStream;
 java.io.FileNotFoundException;
 java.io.FileOutputStream;
 java.io.IOException;

public class Test2 {
    static void main(String[] args) {
        test1FileInputStream();
        test2FileInputStream();
        testFileOutputStream();
    }
    static   test1FileInputStream() {
        String path = "F:test.txt";
        try {
            FileInputStream fs = new FileInputStream(path);
            //设置一个数组接收文件的内容
            需要注意的是，如果数组设置的太小，那么可能出现读取的数据不完整或者乱码等情况
            byte[] b = new byte[30];
            文件输入流对象有一个返回值，返回的是读取数据的长度，如果读取到一个数据了，还会向后读一个，
            当读取完毕时会返回-1
            int len = 0;
            while((len=fs.read(b))!=-1) {
                参数1是缓冲数据数组，参数2是从哪个位置开始转换成字符串，参数3是总共转换的长度
                System.out.println(new String(b,0,len));
            }
            fs.close();
        } catch (FileNotFoundException e) {
             TODO Auto-generated catch block
            e.printStackTrace();
        }  (IOException e) {
                        e.printStackTrace();
        }
    }
     test2FileInputStream() {
        String path = "F:test.txt";
        File f = new File(path);
        int l = (int) f.length();
        byte[l];
            将读取的数据存入到b中
            fs.read(b);
            将b转换成字符串并输出
            System.out.println( String(b));
            fs.close();
        }  testFileOutputStream() {
        //如果不存在该文件，则系统会新建一个
        String path1 = "F:test2.txt" {
            FileOutputStream fo =  FileOutputStream(path1);
            String str = "这是我测试的输入";
            fo.write(str.getBytes());将数据写到byte中
            fo.flush();将内存中的数据写到文件中
            fo.close();关闭
        }             e.printStackTrace();
        }
    }
}

            2.使用字节流将一个文件复制到指定的文件夹下


 copyFile() {
        String path = "F:test.txt";
        String path2 = "F:test2.txt" {
            FileInputStream fi =  FileInputStream(path);
            FileOutputStream fo =  FileOutputStream(path2);
            File f =  File(path);
            int l = (int) f.length();
            [l];
            while((len=fi.read(b))!=-1) {
                fo.write(b,0            e.printStackTrace();
        }

综合使用之前读取的方式。
3.文件字符输入流、文件字符输出流

 testFileReader() {
        String path = "F:test.txt" {
            FileReader fr =  FileReader(path);
            //注意这里是char类型的数组了
            char[] c = char[20];
            while((len=fr.read(c))!=-1) {
                System.out.println(new String(c,len));
            }
            fr.close();
        }  testFileWriter() {
        String path1 = "F:test2.txt" {
            FileWriter fw =  FileWriter(path1);
            String str = "这是我测试的输入";
            //注意这里可以直接写入字符串
            fw.write(str);
            fw.flush();将内存中的数据写到文件中
            fw.close();            e.printStackTrace();
        }
    }

需要注意的是定义char数组时仍然是需要知道数据是有多少字符的，不然长度不够，显示不全或者写入不全。（这里暂时还未了解怎么处理）
4.使用字符流将一个文件复制到指定的文件夹下

     copyFile2() {
        String path = "F:test.txt" FileReader(path);
            FileWriter fw =  FileWriter(path2);
            char[30) {
                fw.write(c,len);
            }
            fw.flush();
            fw.close();
            fr.close();
        }             e.printStackTrace();
        }
        
    }

二、带缓冲的流
为了提高数据的读写速度，java API提供了带缓冲功能的流类，在使用这些流类时，会创建一个内部缓冲区数组。
根据数据操作单位可以把缓冲流分为：BufferedInputStream/BufferedOutputStream和BufferedReader/BufferedWriter。
缓冲流要“套接”在相应的节点流之上，对读写的数据提供了缓冲的功能，提高了读写的效率，同时增加了些新方法。对于输出的缓冲流，写出的数据都会先在内存中缓存，使用flush()会将在内存中的数据立即写出。
1.缓冲字节输入流、缓冲字节输出流

 java.io.BufferedInputStream;
 java.io.BufferedOutputStream;
 Test4 {
    void main(String[] args) throws IOException {
        testBufferedInputStream();
        testBufferedOutputStream();
        copyFile();
    }
    void testBufferedInputStream()  IOException {
        FileInputStream fi = new FileInputStream("F:test.txt");
        把文件字节输入流放入到缓冲输入流中
        BufferedInputStream bi =  BufferedInputStream(fi);
        byte[35];
        while((len=bi.read(b))!=-1) {
            System.out.println(void testBufferedOutputStream()  IOException {
        FileOutputStream fo = new FileOutputStream("F:test3.txt"把文件字节输入流放入到缓冲输入流中
        BufferedOutputStream bo =  BufferedOutputStream(fo);
        String str = "这是我测试的内容";
        bo.write(str.getBytes());
        bo.flush();
        bo.close();
        fo.close();
    }
    
     FileInputStream(path);
            BufferedInputStream bi =  BufferedInputStream(fi);
            FileOutputStream fo =  FileOutputStream(path2);
            BufferedOutputStream bo =  BufferedOutputStream(fo);
            File f = ) {
                bo.write(b,len);
            }
            bo.flush();
            bo.close();
            fo.close();
            bi.close();
            fi.close();
        }             e.printStackTrace();
        }
        
    }
}

2.缓冲字符输入流、缓冲字符输出流

 java.io.BufferedReader;
 java.io.BufferedWriter;
 java.io.FileReader;
 java.io.FileWriter;
 Test3 {
    
     main(String[] args) {
        testBufferedReader();
        testBufferedWriter();
        copyFile();
    }
    
     testBufferedReader() {
        String path = "F:test.txt" FileReader(path);
            BufferedReader br =  BufferedReader(fr);
            char[17while((len=br.read(c))!=-1 testBufferedWriter() {
        String path1 = "F:test2.txt" FileWriter(path1);
            BufferedWriter bw =  BufferedWriter(fw);
            String str = "这是我测试的输入";
            bw.write(str);将数据写到chars中
            bw.flush();将内存中的数据写到文件中
            bw.close();
            fw.close(); BufferedReader(fr);
            FileWriter fw =  FileWriter(path2);
            BufferedWriter bw =  BufferedWriter(fw);
            ) {
                bw.write(c,len);
            }
            bw.flush();
            bw.close();
            fw.close();
            br.close();
            fr.close();
        }             e.printStackTrace();
        }
        
    }

}

三、转换流：用于字节流和字符流之间的转换
java Api提供了两个转换流：InputStreamReader和OutputSreamWriter。
当字节流中的数据都是字符时，转换成字符流操作更高效

 java.io.IOException;
 java.io.InputStreamReader;
 java.io.OutputStreamWriter;

 Test5 {
     IOException {
        testInputStreamReader();
        testOutputStreamWriter();
    }
    void testInputStreamReader() 字节流转换成字符流
        注意转换成的编码要和读取的文件一致
        InputStreamReader ir = new InputStreamReader(fi,"utf-8"while((len=ir.read(c))!=-1void testOutputStreamWriter() 转换字节输出流为字符输出流
        OutputStreamWriter ow = new OutputStreamWriter(fo,1)">);
        String str = "这是我测试的内容";
        ow.write(str);
        ow.flush();
        ow.close();
        fo.close();
    }
    
                e.printStackTrace();
        }
        
    }
}

四、标准输入输出流

 java.io.InputStreamReader;

 Test6 {
     IOException {
        testSystemIn();
        testWriterToTxt();
    }
    void testSystemIn()  IOException {
        创建一个获取键盘输入的输入流
        InputStreamReader ir =  InputStreamReader(System.in);
        将输入流放在缓冲中
        BufferedReader br =  BufferedReader(ir);
        String str = ""while((str = br.readLine())!=null) {
            System.out.println(str);
        }
    }
    将控制台的输入写入到txt文件中
    void testWriterToTxt()  BufferedReader(ir);
        BufferedWriter bw = new BufferedWriter(new FileWriter("F:test5.txt"));
        String line = ""while((line = br.readLine())!=) {
            if (line.equals("over")) {
                break;
            }
            bw.write(line);
        }
        bw.flush();
        bw.close();
        br.close();
        ir.close();
    }
}

五、数据流

 java.io.DataInputStream;
 java.io.DataOutputStream;
 Test7 {
     IOException {
        testDataOutputStream();
        testDataInputStream();
    }
    用数据输出流写到文件中的基本类型数据是乱码，不能辨认出来，需要数据输入流读取
    void testDataOutputStream()  IOException {
        DataOutputStream ds = new DataOutputStream(new FileOutputStream("F:test6.txt"));
        ds.writeDouble(1.35d);
        ds.flush();
        ds.close();
    }
    void testDataInputStream()  IOException {
        DataInputStream ds = new DataInputStream(new FileInputStream("F:test6.txt"));
        System.out.println(ds.readDouble());
        ds.close();
    }
}

六、对象流
用于存储和读取对象的处理流，它的强大之处就是可以把java中对象写入到数据源中，也能把对象从数据源中还原出来。
序列化：用ObjectOutputStream类将一个对象下入io流中；
反序列化：用ObjectInputStream类从io流中恢复对Java对象；

 java.io.Serializable;

class Person implements Serializable{
    用来标识的UID
    private final long serialVersionUID = 1L;
    String name;
     age;
}


 java.io.ObjectInputStream;
 java.io.ObjectOutputStream;

 Test8 {
     IOException,ClassNotFoundException {
        testSerializable();
        testDeSerializable();
    }
    序列化
    void testSerializable()  IOException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("F:test7.txt"));
        Person p =  Person();
        p.name = "tom";
        p.age = 12;
        oos.writeObject(p);
        oos.flush();
        oos.close();
    }
    反序列化
    void testDeSerializable() new ObjectInputStream(new FileInputStream("F:test7.txt";
        Object obj = ;
        obj = ois.readObject();
        p = (Person) obj;
        System.out.println(p.name);
        System.out.println(p.age);
        ois.close();
    }
}

七、RandomAccessFile
支持随机访问的方式，程序可以直接跳转到文件的任意位置地方来进行读写。支持只访问文件的部分内容，可以向已存在的文件后追加内容。
RandomAccessFile对象包含一个记录指针，用以标记当前读写的位置。
RandomAccessFile类对象可以自由地移动和记录指针：

long getFilePoint()：获取文件记录指针的当前位置；
void seek(long pos)：将文件记录指针移动到指定位置；


 java.io.RandomAccessFile;

 Test9 {
            testRandomAccessFileRead();
        testRandomAccessFileWrite();
    }
    void testRandomAccessFileRead() 构造方法有两个参数，参数一为路径，参数二为访问方式
        r:只读
        rw:可写可读
        rwd:可写可读，同步内容跟新
        rws:可写可读，同步内容和元数据跟新；
        RandomAccessFile acf = new RandomAccessFile("F:test7.txt","r"设置文件起始的读取位置
        acf.seek(5while((len=acf.read(b))!=-1void testRandomAccessFileWrite() 设置文件起始的写入位置，0代表开头，acf.length代表文件末尾
        acf.seek(acf.length());
        acf.write("你好".getBytes());
        acf.close();
    }
}

总结：
流适用于处理数据的。
处理数据时，一定要明确数据源，与数据目的地：数据源可以是文件，也可以是键盘；数据目的地可以是文件、显示器或其它设备。
流只是帮助数据进行传输，并对传输的数据进行处理，比如过滤处理、转换处理等。
                        
（编辑：李大同）
【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!