java io流

Posted 2023-03-24

inputStream f= new inputSream("de.txt");
File f=new File("de.txt") 有什么区别。。。新手自学，大神们多讲点这方面的吧。可以多加分

inputStream f= new inputSream("de.txt");
属于字节流，读取文件的时候是以字节的方式读取
File f=new File("de.txt")
是创建一个文件对象。无法读取或修改文件里边的内容，需要构建一个输入或输出流到该文件上才可以读取或修改内容,如：FileInputStream fis = new FileInputStream(f);fis.read();

字节流：以字节为单位读取或输出信息
字符流：以字符为单位读取或输出信息
带stream的都是字节式
输入流：读取信息到程序
输出流：从程序向外输出信息
比较常用的是下面的

InputStream 字节输入流
OutputStream 字节输出流
Reader 字符输入流
Writer 字符输出流

BufferedInputStream 带缓存的 字节输入流
BufferedOutputStream 带缓存的字节输出流
BufferedReader 带缓存的 字符输入流
BufferedWriter 带缓存的字符输出流

FileInputStream 文件 字节输入流
FileOutputStream 文件字节输出流
FileReader 文件字符输入流
FileWriter 文件字符输出流 参考技术A 在JAVA里 所有的IO操作都是流来实现的 而能产生流的叫源
第一句是为de.txt的源添加输入流 （这个“入”是对于内存来说的或者你认为是java程序也可以，对于数据源de.txt本身意味着它的数据要流出来，是不是很形象！很多初学者就卡在，以为你明明是输出啊为什么叫输入流？因为他们站在源的角度上而没有站在java程序的角度上。）就是说你可以通过这个输入流让“源”里面的数据流出来，流入到内存或者java程序里面也就是用java去读源里面的内容。
第二句话是为de.txt建立file对象，也就是重点是拿到这个源本身而不是这个源里面的数据。 参考技术B inputStream f= new inputSream("de.txt");
InputStream是不能直接实例化的，可以用FileInputStream

是创建一个输入流，你可以用输入流读取这个文件,
File f=new File("de.txt")就是创建一个文件咯，只能用File里面的相关方法本回答被提问者采纳 参考技术C 首先：InputStream f= new InputStream("de.txt");这个是错误的，InputStream 是抽象类 不能new实例

然后InputStream是字节流、File f=new File("de.txt") 是打开一个文件，实体文件的抽象形式
希望对你有帮助 参考技术D File 是对文件的操作 说白了 就是对外在的操作 比如说创建一个文件 删除一个文件
inputStream 是对文件内容的操作 比如File建了一个文件 它可以在文件里面写入或读取到文字，画图等
基本没什么冲突 一个主内一个主外

Java之IO流总结

    IO流
·Java流式输入/输出原理
·Java流类的分类
·输入/输出流类
·常见的节点流和处理流
·文件流
·缓冲流
·转换流
·数据流
·Print流
·Object流

①Java流式输入/输出原理
    
        00101...-->
    文件 ------------------ 程序

        <-- ...00101
    文件 ------------------ 程序
    
           00101...-->
    网络连接 ------------------ 程序

        00101...-->
    程序 ------------------ 程序

         00101...-->  “Hello”
    文件 -----------============== 程序 （从0101等转换为字符，一层包一层）

②流的分类
    java.io包中
        ·按数据流的方向不同可以分为输入流、输出流
        ·按处理数据单位不同可以分为字节流、字符流
        ·按照功能不同可以分为节点流、处理流

    所有流类型位于包java.io内都分别继承以下四种抽象流类型

            字节流        字符流
    ------------------------------------------
    输入流          InputStream      Reader
    输出流          OutputSteam      Writer


        字节流（8bit）

             |----FileInputStream(节点流)
             |
             |----PipedInputStream(节点流)     |---LineNumberInputStream(处理流)
             |                          |       
             |----FilterInputStream(处理流)-------|---DataInputStream(处理流)
             |                     |
    InputStream -|----ByteArrayInputStream(节点流)    |---BufferedInputStream(处理流)
             |                     |---PushbackInputStream(处理流)        
             |----SequenceInputStream(处理流)
             |
             |----StringBufferInputStream(节点流)
             |
             |----ObjectInputStream(处理流)

InputStream的基本方法
        //读取一个字节并以整数的形式返回（0-255）
        //如果返回-1已到输入流的末尾
    ·int read() throws IOExcetion

        //读取一系列字节并存储到一个数组buffer
        //返回实际读取的字节数，如果读取器前已到输入流的末尾返回-1
    ·int read(byre[] buffer) throws IOExcetion

        //读取length个字节
        //并存储到一个字节数组buffer，从length位置开始
        //返回实际读取的字节数，如果读取前已到输入流的末尾返回-1
        //buffer - 读入数据的缓冲区。
        //offset - 数组 buffer 中将写入数据的初始偏移量。
        //length - 要读取的最大字节数。
    ·int read(byte[] buffer, int offset, int length) throws IOExcetion

        //关闭流释放内存资源
    ·void close() throws IOExcetion

        //跳过n个字节不读，返回实际跳过的字节数
    ·long skip(long n) throws IOExcetion


        字节流（8bit）

             |----FileOutputStream(节点流)
             |
             |----PipedOutputStream(节点流)    
             |                          |       
             |----FilterOutputStream(处理流)-----|---DataOutputStream(处理流)
             |                     |
       OutputStream -|----ByteArrayOutputStream(节点流)  |---BufferedOutputStream(处理流)
             |                     |---PrintStream(处理流)        
             |
             |----ObjectOutputStream(处理流)

OutputStream的基本方法
        //向输出流中写入一个字节数据，该字节数据为参数b的低8位
    ·void write(int b) throws IOException
    
        //将一个字节类型的数组中的数据写入输出流
    ·void write(byre[] b) throws IOException

        //将一个字节类型的数组中的从指定位置（off）开始的len个字节写入到输出流
    ·void write(byre[] b, int off, int len) throws IOException

        //关闭流释放内存资源
    ·void close() throws IOException

        //将输出流中缓冲的数据全部写出到目的地
    ·void flush() throws IOException

    注意：先flush，在close



        字符流（16bit）

             |----BufferedReader(节点流)----LineNumberReader(处理流)
             |
             |----CharArrayReader(处理流)    
             |                              
             |----InputStreamReader(处理流)-----FileReader(节点流)
             |                    
             Reader -|----FilterReader(处理流)----PushbackReader(处理流)
             |                         
             |
             |----PipedReader(节点流)
             |
             |----StringReader(节点流)


Reader的基本方法
        //读取一个字符并以整数的形式返回（0-255）
        //如果返回-1已到输入流的末尾
    ·int read() throws IOExcetion

        //读取一系列字符并存储到一个数组buffer
        //返回实际读取的字符数，如果读取器前已到输入流的末尾返回-1
    ·int read(byre[] buffer) throws IOExcetion

        //读取length个字符
        //并存储到一个字符数组buffer，从length位置开始
        //返回实际读取的字符数，如果读取前已到输入流的末尾返回-1
        //buffer - 读入数据的缓冲区。
        //offset - 数组 buffer 中将写入数据的初始偏移量。
        //length - 要读取的最大字符数。
    ·int read(byte[] buffer, int offset, int length) throws IOExcetion

        //关闭流释放内存资源
    ·void close() throws IOExcetion

        //跳过n个字符不读，返回实际跳过的字节数
    ·long skip(long n) throws IOExcetion


        字符流（16bit）

             |----BufferedWriter(处理流)
             |
             |----CharArrayWriter(节点流)    
             |                              
             |----OutputStreamReader(处理流)-----FileWriter(节点流)
             |                    
             Writer -|----FilterWriter(处理流)
             |                         
             |
             |----PipedWriter(节点流)
             |
             |----StringWriter(节点流)

Writer的基本方法
        //向输出流中写入一个字符数据，该字节数据为参数b的低8位
    ·void write(int b) throws IOException
    
        //将一个字符类型的数组中的数据写入输出流
    ·void write(char[] cbuf) throws IOException

        //将一个字符类型的数组中的从指定位置（off）开始的len个字符写入到输出流
    ·void write(char[] cbuf, int off, int len) throws IOException

        //将一个字符串中的字符写入到输出流
    ·void write(String string) throws IOException

        //将一个字符串从offset开始的length个字符写入到输出流
    ·coid write(String string, int offset, int length) throws IOException

        //关闭流释放内存资源
    ·void close() throws IOException

        //将输出流中缓冲的数据全部写出到目的地
    ·void flush() throws IOException


③输入/输出流
    1、输出流跟输入流
    一切以程序为中心
        ·从文件到程序为输入流
        ·从程序到文件为输出流
    2、字节流和字符流
        ·字节（8bit）
        ·字符（16bit）
        ·一个字符等于2个字节
    3、节点流和处理流
        ·处理流是包在节点流的一层“管道”

④常见的节点流和处理流
    ·节点流为可以从一个特定的数据源（节点）读写数据（如：文件，内存）
            节点流
        数据源 -------------------- 程序
        
    ·处理流是连接在已存在的流（节点流或处理流）之上，通过对数据的处理为程序提供更为强大的读写功能

            -->
        数据源 -------======== 程序
            
            <--
        程序 ============-------- 数据源

⑤节点流----文件流
    字符流            字节流
---------------------------------------
输入流    FileReader    FileInputStream
输出流    FileWriter    FileOutputStream

访问文件
    从文件到程序，输入流
    ·使用FileInputStream

        public class Login{
    public static void main(String[] args){
        int b = 0;
        FileInputStream fis = null;
        try {
            //连接管道
            fis = new FileInputStream("G://Java2014Project//JavaDemo1//src//Demo01/Login.java");
        } catch (FileNotFoundException e) {
            System.out.println("error");
        }
        //读取数据
            try {
                while((b = fis.read())!= -1){
                    System.out.print((char)(b));
                    
                }
                fis.close();
            } catch (IOException e) {
                System.out.println("error");
            }
        
    }
}
    显示结果
    package Demo01;

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

public class Login{
    public static void main(String[] args){
        int b = 0;
        FileInputStream fis = null;
        try {
            //????????
            fis = new FileInputStream("G://Java2014Project//JavaDemo1//src//Demo01/Login.java");
        } catch (FileNotFoundException e) {
            System.out.println("error");
        }
        //????????
            try {
                int num = 0;
                while((b = fis.read())!= -1){
                    System.out.print((char)(b));
                }
                fis.close();
            } catch (IOException e) {
                System.out.println("error");
            }
        
    }
}

    发现出现？？？？？，问题是汉字是一个字符（两个字节），用的是字节流，一个字节一个字节读取，
所有中文翻译不出来，改为Reader可以
    
    从程序到文件
    ·使用FileOutputStream
    package Demo01;

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

public class Login{
    public static void main(String[] args){
        int b = 0;
        FileInputStream fis = null;
        FileOutputStream fot = null;
        try {
            //连接管道
            fis = new FileInputStream("G://Java2014Project//JavaDemo1//src//Demo01/Login.java");
            fot = new FileOutputStream("C://Users//woshishabi//Desktop//test.txt");
        } catch (FileNotFoundException e) {
            System.out.println("error");
        }
        //读取数据
            try {
                while((b = fis.read())!= -1){
                    fot.write(b);
                }
                fis.close();
                fot.close();
            } catch (IOException e) {
                System.out.println("error");
            }
        
    }
}

    桌面上多了一个Test.txt文本，


    ·使用FileReader：字符输入流，从文件到程序
        ......
    ·使用FileWriter：字符输出流，从程序到文件
        ......

⑥处理流----缓冲流
    ·缓冲流要“套接”在相应的节点流之上，对读写的数据提供了缓冲的功能，提高了读写的效率，
同时增加了一些新的方法
    ·J2SDK提供了四种缓存流，其常用的构造方法为：
            //字符输入缓冲流
        BufferedReader(Reader in)
        BufferedReader(Reader in, int sz) //sz为自定义缓存区的大小    
            
            //字符输出缓冲流
        BufferedWriter(Writer out)
        BufferedWriter(Writer out,int sz)
        
            //字节输入缓冲流
        BufferedInputStream(InputStream in)
        BufferedInputStream(InputStream in, int size)
    
            //字节输出缓冲流
        BufferedOutputStream(OutputStream out)
        BufferedOutputStream(OutputStream out, int size)

    ·缓冲输入流支持其父类的mark和reset方法    mark：直接从多少个字符开始读取  reset：回到刚才标记的点
    ·bufferedReader提供了readline方法用于读取一行字符串（以\r或\n分隔）
    ·bufferedWriter提供了newLine用于写入一个行分隔符
    ·对于输出的缓冲流，写出的数据会现在内存中缓存，使用flush方法将会使内存中的数据立刻写出

bufferedReader和bufferedWriter使用

package Demo01;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class Login{
    public static void main(String[] args){
        try {
            //从文件写入数据
            BufferedReader br  = new BufferedReader(new FileReader("G://Java2014Project//JavaDemo1//src//Demo01//Login.java"));
            BufferedWriter bw = new BufferedWriter(new FileWriter("C://Users//woshishabi//Desktop//Test.txt"));
            //从文件读取数据
            String s = null;
            while((s = br.readLine()) != null){
                System.out.println(s);
                bw.write(s);
                bw.newLine();
            }
            bw.flush();
            br.close();
            bw.close();
        }
            catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    
    }
}


⑦处理流----转换流
    ·InputStreamReader和OutputStreamWriter用与字节数据到字符数据之间的转换
    ·InputStreamReader需要和InputStream“套接”
    ·OutputStream需要和OutputStream“套接”
    ·转换流在构造时可以指定其编码集合，例如
        InputStream isr = new InputStreamReader(System.in, "ISO8859_1");

范例：OutputStreamWriter

    package Demo01;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;

public class Login{
    public static void main(String[] args){
        try {
            //将输出字节流转换为字符流
            OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("C://Users//woshishabi//Desktop//Test.txt"));
            //向文件中输入字符串
            osw.write("sdfjaksldjflskdjflaskdjfsakjdf");
            //读取字符编码
            System.out.println(osw.getEncoding());
            osw.close();
            //在文本后面添加字符串，不覆盖，则true，否则写false， 后面可以自定义编码
            osw = new OutputStreamWriter(new FileOutputStream("C://Users//woshishabi//Desktop//Test.txt", true), "UTF-8");
            osw.write("qwqeqweqweqeq");
            System.out.println(osw.getEncoding());
            osw.close();
        }
            catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            
        }
    }

范例：InputStreamReader

    package Demo01;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class Login{
    public static void main(String[] args){
        //从键盘读取数据
        InputStreamReader isr = new InputStreamReader(System.in);
        //字符输入缓冲流
        BufferedReader br = new BufferedReader(isr);
        String s = null;
        try {
            //读取一行字符
            s = br.readLine();
            while(s != null){
            if(s.equalsIgnoreCase("exit")){     //将一个字符串与另一个字符串比较，不考虑大小写
                break;    
            }
            //将小写转换为大写
                System.out.println(s.toUpperCase());
                s = br.readLine();
            }
            br.close();
            
            }
         catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    }
}


⑧数据流----DataInputStream...
    ·DataInputStream 和 DataOutputStream 分别继承了InputStream 和 OutputStream，属于处理流，
需要分别套接在InputStream 和 OutputStream类型的节点流觞
    ·DataInputStream 和 DataOutputStream 提供了可以存取与机器无关的Java原始数据类型（int、double等）
的方法
    ·DataInputStream 和 DataOutputStream 的构造方法为：
        ·DataInputStream（InputStream in）
        ·DataOutputStream（OutputStream out）
    
范例：使用DataInputStream 和 DataOutputStream
package Demo01;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class Login{
    public static void main(String[] args){
        //一个字节数组输出流
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        //在字节数组输出流上套接一个数据流，能传递基本数据类型
        DataOutputStream dos = new DataOutputStream(baos);
        try {
            //向字节数组写入一个随机数
            dos.writeDouble(Math.random());
            dos.writeBoolean(true);
            //创建一个字节数组输入流
            ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
            //输出字节数组中有多少个字节
            System.out.println(bais.available());
            //将处理流包在字节数组输入流上，输出基本数据
            DataInputStream dis = new DataInputStream(bais);
            //输出double，先输入的先输出
            System.out.println(dis.readDouble());
            //输出boolean
            System.out.println(dis.readBoolean());
            dos.close();
            dis.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

    
⑨print流    PrintStream主要操作byte流，而PrintWriter用来操作字符流
    ·PrintWriter 和 PrintStream都属于输出流，分别针对与字符和字节
    ·PrintWriter 和 PrintStream提供了重载的print
    ·Println方法用于多种数据类型的输出
    ·PrintWriter 和 PrintStream的输出操作不会抛出异常，用户通过检测错误状态获取错误信息
    ·PrintWriter 和 PrintStream有自动flush功能
构造方法：
    ·PrintWriter(Writer out)
    ·PrintWriter(Writer out，boolean autoFlush)
    ·PrintWriter(OutputStream out， boolean autoFlush)
    ·PrintStream(OutputStream out)
    ·PrintStream(OutputStream out， boolean autoFlush)

范例：PrintStream
package Demo01;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintStream;

public class Login{
    public static void main(String[] args){
        PrintStream ps = null;
        try {
            //文件字节输出流
            FileOutputStream fos = new FileOutputStream("C://Users//woshishabi//Desktop//Test.txt");
            //输出流
            ps = new PrintStream(fos);
            if(ps != null){
                //使system.out指向了文件Test.txt
                System.setOut(ps);
            }
            for (int i = 0; i < 100; i++) {
                System.out.print(i + ",");
            }

        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}


范例：PrintWriter

    package Demo01;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.util.Date;

public class Login{
    public static void main(String[] args){
        String s = null;
        //从键盘输入，字节转字符的转换流上套接缓冲流
        BufferedReader bis = new BufferedReader(new InputStreamReader(System.in));
        try {
            //输出流，输出到文件，不覆盖
            FileWriter fw = new FileWriter("C://Users//woshishabi//Desktop//Test.txt",true);
            //输出流，套接在文件输出流上
            PrintWriter pw = new PrintWriter(fw);
            //接收键盘输入的一行数据，
            while((s = bis.readLine()) != null){
                //判断是否为exit，是则结束while
                if(s.equalsIgnoreCase("exit"))break;
                //小写转大写，在dos中输出
                System.out.println(s.toUpperCase());
                //在目标文件里面输出数据
                pw.println("------");
                pw.println(s.toLowerCase());
                pw.flush();
            }
            //在目标文件中输出日期
            pw.println("-----"+ new Date() + "------");
            pw.flush();
            pw.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}


⑩Object流
    ·直接将Object写入或读出
        ·transient关键字（透明的）：修饰属性， transient int k  = 15;   输出结果k = 0；在序列化的时候不考虑，不写入硬盘
        ·serializable接口：（标记性接口，里面什么都没有）
        ·extemalizable接口：
    注意：如果需要使用对象流，必须实现serializable接口

范例：
    package Demo01;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.Serializable;
import java.util.Date;

public class Login{
    public static void main(String[] args){
        T t = new T();
        t.k = 40;
        try {
            //文件输出流，
            FileOutputStream fos = new FileOutputStream("C://Users//woshishabi//Desktop//Test.txt");
            //在文件输出流上套接一个对象输出流，从程序传递一个对象到目标文件中
            ObjectOutputStream  oos = new ObjectOutputStream(fos);
            //写入对象
            oos.writeObject(t);
            //文件输入流，锁定目标文件
            FileInputStream fis = new FileInputStream("C://Users//woshishabi//Desktop//Test.txt");
            //在文件输入流上套接一个对象输入流，从目标文件中取出对象的通道
            ObjectInputStream ois = new ObjectInputStream(fis);

            //取出对象
            T t1 = (T) ois.readObject();
            //打印到屏幕上
            System.out.println(t1.i + " " + t1.j + " " + t1.k + " " + t1.z);
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
}

class T implements Serializable{
    int i = 1;
    int j = 2;
    double z = 9.0;
    int k = 14;

}




总结：
    ·InputStream/OutputStream

    ·Reader/Writer

    ·FileInputStream/FileoutputStream

    ·FileReader/FileWriter

    ·BufferedInputStream/BufferedOutoutStream

    ·BufferedTeader/BufferedWriter

    ·ByteArrayInputStream/ByteArrayOutputStream

    ·InputStreamReader/OutputStreamWriter

    ·DataInputStream/DataOutputStream

    ·PrintStream/PrintWriter

    ·ObjectInputStream/ObjectOutputStream