Java:IO流与文件基础

说明：

　　本文所有内容包含图片均为MrSaber自己编写，转载请练习我哦。

　　本章内容将会持续更新，大家可以关注一下并给我提供建议，谢谢啦。

走进流

什么是流

　　流：从源到目的地的字节的有序序列。

　　在Java中，可以从其中读取一个字节序列的对象称作 输入流，可以向其中写入一个字节序列的对象称作 输出流。
　　　　? 这些字节序列的来源可以是：文件、网络连接、内存块等。
　　　　? 抽象类InputStream和OutputStream是构成输入/输出(I/O)的基础。
　　　　? 因为面向字节的流不便于处理以Unicode形式存储的信息(字符)，所以从抽象类Reader 和 Writer中继承出来一个专门处理字符流的类层次结构。
　　　　? 适配器类InputStreamReader将InputStream转换为Reader，OutputStreamWriter将OutputStream转换为Writer

IO流家族体系：

　　对流的分类

? 依据流相对于程序的另一个端点的不同：
　　? 节点流(全黄)：以特定源（如磁盘文件、内存某区域或线程之间的管道）为端点构造的输入/输出流
　　? 过滤流(半黄)：以其他已存在的流为端点构造的输入/输出流。
? 依据流中的数据单位不同：
　　? 字节流：流中的数据以8位字节为单位进行读写，以InputStream和OutputStream为共同父类
　　? 字符流：流中的数据以16位字符为单位进行读写，以Reader和Writer为共同父类

　　家族体系图(原创)：

家族体系的顶层方法

　说明：

　　　顶层方法不是很多，但是需要我们去记住，下面列出了所有的顶层方法，遇到问题是结合上图和下表可以清理思路。

　　A.abstract class OutputStream

　　B.abstract class InputStream

　　C.abstract class Reader

　　D.abstract class Writer　　

输出输入流的嵌套

说明：

　　单独使用节点流的情况在程序中较少出现。
　　一般常通过过滤流将多个流套接在一起，利用各种流的特性共同处理数据，套接的多个流构成了一个流链 　　

　　优点：

　　　　方便数据的处理并提高处理的效率。

着重介绍的几个过滤流：

　　? BufferedInputStream
　　　　? 在创建 BufferedInputStream 时，会创建一个内部缓冲区数组。
　　　　? 在读取或跳过流中的字节时，可根据需要从包含的输入流再次填充该内部缓冲区，一次填充多个字节。
　　? BufferedOuputStream
　　　　? 该类实现缓冲的输出流。通过设置这种输出流，应用程序就可以将各个字节写入底层输出流中，而不必针对每次字节写入调用底层系统。
　　? BufferedReader和BufferedWriter同样也是提供缓存区。
　　? DataInputStream
　　　　? 包含用于读取基本类型数据的全部接口

　　说明：所有的这些在下面我们都会重新强调并实现。

四大流—文件流

　　文件流包括：

　　　　? FileReader/FileWriter类
　　　　? FileInputStream/FileOutputStream类

　　创建文件流：

　　　　FileInputStream(File file) 
          　　通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定。
　　　　FileInputStream(String name) 
          　　通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定。

　　实例：　

　　复制文件内容：

public class FileCopy{
        public static void main(String[] args) throws IOException{
                FileInputStream in=new FileInputStream("FileCopy.java");
                FileOutputStream out=new FileOutputStream("FileCopy.txt");
                int c;
                while( (c=in.read())!=-1)
                        out.write(c);
                in.close();
                out.close();
        }
}

四大流—缓存流

　　说明：

　　　　缓存流是过滤流，以InputStream/OutputStream为前端流，并可指定缓冲区大小，如：
　　　　　　public BufferedInputStream(InputStream in)
　　　　　　public BufferedInputStream(InputStream in, int size)
　　　　BufferedReader增加readLine()
　　　　BufferedWriter增加newLine()：写入一个换行符。　　

　　演示：　　　　

public class BufferedIO{
    public static void main(String[] args) throws IOException{
        BufferedReader in=new BufferedReader(
                new FileReader("BufferedIO.java"));
        PrintWriter out=new PrintWriter( new BufferedWriter(
                new FileWriter("BufferedIO.txt")));
        String s;
        int linecnt=1;
        StringBuilder sb=new StringBuilder();
        while((s=in.readLine())!=null){
            sb.append(linecnt+":"+s+"\n");
            out.println(linecnt+":"+s);
            linecnt++;
        }
        in.close();
        out.close();
        System.out.print(sb.toString());
    }
}

说明：

　　PrintWriter
　　向文本输出流打印对象的格式化表示形式，即在写入的同时可以对写入的数据进行格式化。

四大流—数据流

数据流包括：

　　DataInputStream/DataOutputStream类

读写基本数据类型的接口方法：

演示：

public class DataIO{
    public static void main(String[] args) throws IOException{
        DataOutputStream out=new DataOutputStream(
    new BufferedOutputStream(new FileOutputStream("data.txt")));
        out.writeBoolean(false); out.writeChar(‘c‘);
        out.writeByte(1); out.writeShort(2);
        out.writeInt(3); out.writeLong(4L);
        out.writeFloat(5.0f); out.writeDouble(6.0);
        out.writeUTF("hello world!"); out.close();

        DataInputStream in=new DataInputStream(
             new BufferedInputStream( new FileInputStream("data.txt")));
        System.out.println(in.readBoolean()+";"+in.readChar()+";");
        System.out.println(in.readByte()+";"+in.readShort()+";");
        System.out.println(+in.readInt()+";"+in.readLong());
        System.out.println(in.readFloat()+";"+in.readDouble()+";");
        System.out.println(in.readUTF()); in.close();
    }

　　说明：

　　　　?readUTF()与writeUTF()
　　　　　　writeBytes(String)和writeChars(String)方法在DataInputStream中没有对应的方法恢复出String
　　　　　　用DataOutputStream写字符串并使得DataInputStream能恢复出字符串的方法是使用writeUTF()和readUTF()
　　　　? UTF-8
　　　　　　ASCII字符→单字节形式；非ASCII字符→多字节形式
　　　　　　字符串长度→UTF-8字符串的前两字节中
　　　　　　Java中使用的是UTF-8的变体，UTF-8只是读写过程中的字符串形式，程序中Unicode

标准IO：

标准输入：键盘
标准输出：加载Java程序的命令窗口
　　Java在System类中定义了三个标准I/O流，是System类的三个静态变量：
　　　　System.in(public static final InputStream in)：标准输入流
　　　　System.out(public static final PrintStream out)：标准输出流
　　　　System.err(public static final PrintStream err)：标准错误输出流
　　
程序从键盘读入数据：
　　? int ch=System.in.read();
　　? System.in.read()从键盘缓冲区读入一个字节的数据，返回的是整型值（低位字节为输入数据，高位字节全为零）
　　? System.in.read()的执行使得整个程序被挂起，直到用户从键盘输入数据才继续运行
　　? 从键盘逐行读入：嵌套BufferedReader和InputStreamReader

实例：

public class StandardIO {
    public static void main(String[] args) {
        String s;
        BufferedReader in = new BufferedReader(
                       new InputStreamReader(System.in));
        System.out.println("Please input: ");
        try {
            s = in.readLine();
            while (!s.equals("exit")) {
                System.out.println(" read: " + s);
                s = in.readLine();
            }
            System.out.println("End of Inputting");
            in.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

java.util.Scanner类：从控制台读取输入

说明：
　　Scanner sc=new Scanner(System.in);
　　　　Scanner将控制台输入按照分隔符模式进行分割，分隔符模式默认为匹配空格
　　扫描结果通过各种next*()方法转化为不同类型的值
　　　　next() 获取一个字符串
　　　　nextByte() 获取一个byte类型的整数
　　　　nextShort() 获取一个short类型的整数
　　　　nextInt() 获取一个int类型的整数
　　　　nextLong() 获取一个long类型的整数
　　　　nextFloat() 获取一个float类型的数
　　　　nextDouble() 获取一个double类型的数
　　　　nextLine() 获取一行文本（即以回车键为结束标志）
输入输出的重定向：
　　System.setIn(InputStream)
　　System.setOut(PrintStream)
　　System.setErr(PrintStream)

随机存取文件

说明：

　　到目前为止所学习的Java流式输入/输出都是顺序访问流，即流中的数据必须按顺序进行读写当需要随机读写磁盘文件中的内容时，用RandomAccessFile类（既可对文件读，又可对文件写）

　　RandomAccessFile与其他顶层类的关系

构造方法：

操作：

文件指针操作
　　　　long getFilePointer() //返回当前文件指针
　　　　void seek(long pos) //文件指针定位到指定位置
　　　　long length() //返回文件长度
　　　　int skipBytes(int n) //从当前位置开始跳过n字节
读操作(实现了DataInput接口)
　　　　readBoolean(), readChar(), readInt(), readLong(), readFloat(), readDouble(), readLine(), readUTF()等
写操作(实现了DataOutput接口)
　　　　writeBoolean(), writeChar(), writeUTF(), writeInt(), writeLong(), writeFloat(), writeDouble()等

实例：

public class RandomAccessTest {
    public static void main(String[] args) throws IOException {
        long filePoint = 0;
        String s;
        RandomAccessFile file = new RandomAccessFile(
                    "RandomAccessTest.java", "r");
        long fileLength = file.length(); // 获取文件长度
        while (filePoint < fileLength) {
            s = file.readLine(); // 读一行字符，并移动文件指针
            System.out.println(s); // 输出显示读入的一行字符
            file.skipBytes(5);
            filePoint = file.getFilePointer(); // 获取当前文件指针
        }
        file.close();
    }
}

对象的串行化 

说明：
　　将对象保存到外存，称为对象的永久化。
　　对象永久化的关键是将对象的状态以一种串行格式表示出来，以便以后读取能够将该对象重构出来。
　　对Java对象的这一读写过程称为对象的串行化。
常在下列情况下使用：
　　1.Java远程方法调用(Remote Method Invocation)
　　2.Java Bean / EJB
　　3.对象永久化
实现串行化：
　　? 用ObjectOutputStream/ObjectInputStream实现对象的串行化
　　　　◇ 通过ObjectOutputStream的writeObject方法将一个对象写入到流中
　　　　　　? public final void writeObject(Object obj) throws IOException
　　　　◇ 通过ObjectInputStream的readObject方法将一个对象从对象流中读出
　　　　　　? public final Object readObject() throws IOException, ClassNotFoundException
　　　　◇ ObjectOutputStream实现了java.io.DataOutput接口
　　　　◇ ectInputStream实现了java.io.DataInput接口
实例：

/*输出对象*/
public class SerializeDate {
    SerializeDate( ){
        Date d = new Date( );
        try {
            ObjectOutputStream s= new ObjectOutputStream(
                    new FileOutputStream(“date.ser”));
            s.writeObject(d);
            s.close( );
        }catch( IOException e){
            e.printStackTrace( );
        }
    }
    public static void main(String args[]){
        SerializeDate b = new SerializeDate();
    }
}

/*输入对象*/
public class UnSerializeDate {
    Date d = null;
    UnSerializeDate() {
        try {
            ObjectInputStream s = new ObjectInputStream(
                    new FileInputStream("date.ser"));
            Object o=s.readObject();
            if(o instanceof Date)
                d = (Date) o; 
            s.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        UnSerializeDate us = new UnSerializeDate();
        System.out.println(us.d.toString());
    }
}

注意：
　　一个类只有实现了Serializable接口，其对象才是可串行化的

(未完待续.....)

Java:IO流与文件基础