java i/o操作

最新推荐文章于 2024-05-14 12:26:39 发布

灰太狼1号

最新推荐文章于 2024-05-14 12:26:39 发布

阅读量2.5k

点赞数 2

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/deram_boy/article/details/51191425

版权

Java 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

1. I/O介绍：

中I/O操作主要是指使用Java进行输入，输出操作. Java所有的I/O机制都是基于数据流进行输入输出，这些数据流表示了字符或者字节数据的流动序列。Java.io是大多数面向数据流的输入/输出类的主要软件包。此外，Java也对块传输提供支持，在核心库 java.nio中采用的便是块IO。流IO的好处是简单易用，缺点是效率较低。块IO效率很高，但编程比较复杂。 Java.io包中包含了流式I/O所需要的所有类。在java.io包中有四个基本类：InputStream、OutputStream及Reader、Writer。 Java的IO模型设计非常优秀，它使用Decorator模式，按功能划分Stream，您可以动态装配这些Stream，以便获得您需要的功能。例如，您需要一个具有缓冲的文件输入流，则应当组合使用FileInputStream和BufferedInputStream。
这里写图片描述

io流的四个基本类
java.io包中包含了流式I/O所需要的所有类。在java.io包中有四个基本类：InputStream、OutputStream及Reader、Writer类，它们分别处理字节流和字符流：
这里写图片描述

一、java io的开始：文件

public class Demo {

    public static void main(String[] args){

        File f = new File("e:\\file");

        if(f.isDirectory()){
            System.out.println(f.getPath());
        }
    }
}

代码中isDirectory()方法是判断文件是文件夹还是一个文件，getPath()方法是打印文件(这里指的是file文件夹)的路径。
文件删除

import java.io.File;

public class Demo11 {

    public static void main(String[] args) {

        File f = new File("f:\\demo.txt");

        f.delete();
        if(boo){
            System.out.println("成功删除文件");
        }
    }
}

import java.io.File;
/**
 * 获取一个目录下的所有子项
 * @author Administrator
 */
public class FileDemo {
    public static void main(String[] args){
        /*
         * 查看当前项目根目录下的所有子项
         */
        File dir = new File(".");
        //首先判断是否为一个目录
        if(dir.isDirectory()){
            //获取当前目录下的所有子项
            File[] subs = dir.listFiles();
            for(File sub : subs){
                String name = sub.getName();
                //目录是没有长度的
                long length = sub.length();
                System.out.println(name+":"+length);
            }
        }
    }
}

FileFilter类

import java.io.File;
import java.io.FileFilter;

/**
 * listFiles方法支持文件过滤器
 * 
 * FileFilter接口，实现该接口需要实现抽象方法: boolean accept(File f)该方法要求我们定义过滤条件
 * listFiles方法会将当前目录下满足accept方法的子项返回
 * @author Administrator
 */
public class FileDemo2 {
    public static void main(String[] args){
        File dir = new File(".");
        if(dir.isDirectory()){
            //创建过滤器实例
            FileFilter filter = new MyFilter();
            //使用过滤器过滤子项
            File[] subs  = dir.listFiles(filter);
            for(File sub : subs){
                System.out.println(
                                sub.getName());
            }
        }
    }
}
class MyFilter implements FileFilter{
    public boolean accept(File file) {
        System.out.println(
                    "正在过滤:"+file.getName());
        return file.getName().startsWith(".");
    }
}

创建多级目录下的一个文件

import java.io.File;
import java.io.IOException;

/**
 * 创建多级目录下的一个文件
 * @author Administrator
 *
 */
public class FileDemo3 {
    public static void main(String[] args) throws IOException{      
        File file = new File(
                "a"+File.separator+
                "b"+File.separator+
                "c"+File.separator+
                "d"+File.separator+
                "e"+File.separator+
                "f"+File.separator+
                "g"+File.separator+
                "h.txt"
                );
        /*
         * 创建文件时，应首先判断当前文件所在的
         * 目录是否存在，因为若不存在，会抛出
         * 异常的。
         */
        /*
         * File getParentFile()
         * 获取当前文件或目录所在的父目录
         */
        File parent = file.getParentFile();
        if(!parent.exists()){
            parent.mkdirs();
        }
        if(!file.exists()){
            file.createNewFile();
            System.out.println("文件创建完毕");
        }

    }
}

RandomAccessFile用于读写文件数据的类

mport java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;

public class RandomAccessFileDemo {
    public static void main(String[] args) throws IOException{
        /*
         *  对项目跟目录下一个名为demo.dat
         *  的文件内容进行读写 
         */
        RandomAccessFile raf
            = new RandomAccessFile("demo.dat","rw");        
//      File file = new File("demo.dat");
//      RandomAccessFile raf2= new RandomAccessFile(file,"rw");
        int num = 97;
        raf.write(num);     
        raf.close();// 使用IO后，一定要记得关闭
    }
}

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
public class RandomAccessFileDemo2 {
    public static void main(String[] args) throws IOException{
            RandomAccessFile raf= new RandomAccessFile("demo.dat","r");
            int i = raf.read();
            System.out.println(i);
            //再读取一个字节
            i = raf.read();
            System.out.println(i);
            //再读取一个字节
            i = raf.read();
            System.out.println(i);
            raf.close();
    }
}

使用RandomAccessFile完成复制操作

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
public class RandomAccessFileDemo3 {
    public static void main(String[] args) throws IOException{      
        /*
         * 1:创建一个RandomAccessFile用于读取待复制的文件
         * 2:创建一个RandomAccessFile用于将原文件的中数据写入该文件
         * 3:循环从原文件中读取每一个字节并写入目标文件中
         * 4:关闭两个RandomAccessFile      
         */
        long start = System.currentTimeMillis();
        RandomAccessFile src= new RandomAccessFile("src.jpg","r");  
        RandomAccessFile des= new RandomAccessFile("copy.jpg","rw");
        int d = -1;
        while( (d = src.read()) != -1 ){
            des.write(d);
        }
        System.out.println("拷贝完毕");
        src.close();
        des.close();
        long end = System.currentTimeMillis();
        System.out.println("耗时:"+(end-start)+"ms");
    }
}

使用RandomAccessFile批量写出一组字节

import java.io.IOException;
import java.io.RandomAccessFile;
public class RandomAccessFileDemo4 {
    public static void main(String[] args) throws IOException{
            RandomAccessFile raf= new RandomAccessFile("test.txt","rw");
            String str = "我爱北京天安门";
            /* String的getBytes()方法:将当前字符串按照当前系统默认的字符集转换为对应的字节。*/
            byte[] buf = str.getBytes("gbk");
            raf.write(buf);
            raf.close();
    }
}

使用RandomAccessFile读取一个字节数组的数据

import java.io.IOException;
import java.io.RandomAccessFile;
import java.util.Arrays;
public class RandomAccessFileDemo5 {
    public static void main(String[] args) throws IOException{
            RandomAccessFile raf= new RandomAccessFile("test.txt","r");
            /*int read(byte[] buf)一次尝试从文件中读取buf数组length个字节并从该数组的第一个位置处起存放实际读取到的字节。返回值为实际读取到的字节数*/
            byte[] buf = new byte[50];
            int len = raf.read(buf);
            System.out.println(len);
            System.out.println(Arrays.toString(buf));           
            /*从字节数组转换为对应的字符串*/
            String str = new String(buf,"GBK");
            System.out.println(str.trim());
            raf.close();
    }
}

使用RandomAccessFile基于缓存形式复制文件

import java.io.IOException;
import java.io.RandomAccessFile;
public class RandomAccessFileDemo6 {
    public static void main(String[] args) throws IOException{
            RandomAccessFile src= new RandomAccessFile("src.jpg","r");      
            RandomAccessFile des= new RandomAccessFile("copy.jpg","rw");
            long start = System.currentTimeMillis();
            byte[] buf = new byte[1024*10];
            int len = -1;
            /*int read(byte[] buf)若返回值为-1,表示没有数据可读了*/
            while((len = src.read(buf))!=-1){
                /*void write(byte[] b,int offset,int len)该方法的作用是将给定的字节数组中offset处开始，连续len个字节写出*/
                    des.write(buf,0,len);
            }
            long end = System.currentTimeMillis();
            System.out.println("耗时:"+(end-start));
            src.close();
            des.close();
    }
}

使用RandomAccessFile向文件中写入基本类型数据

import java.io.IOException;
import java.io.RandomAccessFile;
public class RandomAccessFileDemo7 {
    public static void main(String[] args) throws IOException{
            RandomAccessFile raf= new RandomAccessFile("raf.dat","rw");
            int num = Integer.MAX_VALUE;
            //连续写4个字节，将int值写出
            raf.writeInt(num);
            raf.writeDouble(1.4);
            raf.writeLong(1234l);
            raf.close();
    }
}

使用RandomAccessFile读取基本类型数据

import java.io.IOException;
import java.io.RandomAccessFile;
public class RandomAccessFileDemo8 {
    public static void main(String[] args) throws IOException{
        RandomAccessFile raf= new RandomAccessFile("raf.dat","r");
        int i = raf.readInt();
        System.out.println(i);
        double d = raf.readDouble();
        System.out.println(d);
        long l = raf.readLong();
        System.out.println(l);
        raf.close();
    }
}

查看RandomAccessFile的指针位置

import java.io.IOException;
import java.io.RandomAccessFile;
public class RandomAccessFileDemo {
    public static void main(String[] args) throws IOException{
        RandomAccessFile raf= new RandomAccessFile("raf.dat","rw");
        /*
         * long getFilePointer()
         * 获取当前RAF的指针位置
         */
        long p = raf.getFilePointer();
        System.out.println(p);//0
        raf.write(97);//写一个字节
        System.out.println(raf.getFilePointer());//1
        raf.writeInt(1);//连续写4个字节
        System.out.println(raf.getFilePointer());//5
        /*
         * 若想从文件的某个地方读取字节
         * 需要先将指针移动到这个位置
         * void seek(long position)
         */
        raf.seek(0);
        //通过raf读取一个字节
        int n = raf.read();
        System.out.println(n);
        System.out.println(raf.getFilePointer());//1
        raf.close();
    }
}

import java.io.IOException;
import java.io.RandomAccessFile;
/**
 * int skipBytes(int n)
 * 该方法会尝试跳过n个字节，返回值为实际
 * 跳过的字节数
 */
public class RandomAccessFileDemo2 {
    public static void main(String[] args) throws IOException{
        RandomAccessFile raf= new RandomAccessFile("raf.dat","r");//跳过1个字节
        raf.skipBytes(1);
        int i = raf.readInt();
        System.out.println(i);
        raf.close();
        }
}

字节流InputStream/OutputStream

1. InputStream抽象类

InputStream 为字节输入流，它本身为一个抽象类，必须依靠其子类实现各种功能，此抽象类是表示字节输入流的所有类的超类。继承自InputStream 的流都是向程序中输入数据的，且数据单位为字节（8bit）；

InputStream是输入字节数据用的类，所以InputStream类提供了3种重载的read方法.Inputstream类中的常用方法：
　　（1） public abstract int read( )：读取一个byte的数据，返回值是高位补0的int类型值。若返回值=-1说明没有读取到任何字节读取工作结束。
　　（2） public int read(byte b[ ])：读取b.length个字节的数据放到b数组中。返回值是读取的字节数。该方法实际上是调用下一个方法实现的
　　（3） public int read(byte b[ ], int off, int len)：从输入流中最多读取len个字节的数据，存放到偏移量为off的b数组中。
　　（4） public int available( )：返回输入流中可以读取的字节数。注意：若输入阻塞，当前线程将被挂起，如果InputStream对象调用这个方法的话，它只会返回0，这个方法必须由继承InputStream类的子类对象调用才有用，
　　（5） public long skip(long n)：忽略输入流中的n个字节，返回值是实际忽略的字节数, 跳过一些字节来读取
　　（6） public int close( ) ：我们在使用完后，必须对我们打开的流进行关闭.
　　这里写图片描述
- 1） FileInputStream把一个文件作为InputStream，实现对文件的读取操作
- 2） ByteArrayInputStream：把内存中的一个缓冲区作为InputStream使用
- 3） StringBufferInputStream：把一个String对象作为InputStream
- 4） PipedInputStream：实现了pipe的概念，主要在线程中使用
- 5） SequenceInputStream：把多个InputStream合并为一个InputStream

2．OutputStream抽象类

　　OutputStream提供了3个write方法来做数据的输出，这个是和InputStream是相对应的。
　　1. public void write(byte b[ ])：将参数b中的字节写到输出流。
　　2. public void write(byte b[ ], int off, int len) ：将参数b的从偏移量off开始的len个字节写到输出流。
　　3. public abstract void write(int b) ：先将int转换为byte类型，把低字节写入到输出流中。
　　4. public void flush( ) : 将数据缓冲区中数据全部输出，并清空缓冲区。
　　5. public void close( ) : 关闭输出流并释放与流相关的系统资源。
　　这里写图片描述
　　
- 1) ByteArrayOutputStream：把信息存入内存中的一个缓冲区中
- 2) FileOutputStream：把信息存入文件中
- 3) PipedOutputStream：实现了pipe的概念，主要在线程中使用
- 4) SequenceOutputStream：把多个OutStream合并为一个
流结束的判断：方法read()的返回值为-1时；readLine()的返回值为null时。

3. 文件输入流： FileInputStream类

FileInputStream可以使用read()方法一次读入一个字节，并以int类型返回，或者是使用read()方法时读入至一个byte数组，byte数组的元素有多少个，就读入多少个字节。在将整个文件读取完成或写入完毕的过程中，这么一个byte数组通常被当作缓冲区，因为这么一个byte数组通常扮演承接数据的中间角色。
这里写图片描述
作用：打开文件，从文件读数据到内存的类。
使用方法(1)
File fin=new File(“d:/abc.txt”);
FileInputStream in=new FileInputStream( fin);
使用方法(2)
FileInputStream in=new FileInputStream(“d: /abc.txt”);
程序举例：将fos.dat程序的内容显示在显示器上
这里写图片描述

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

public class FisDemo {
    public static void main(String[] args) throws IOException{
        FileInputStream fis= new FileInputStream("fos.dat");        
        int i = fis.read();
        System.out.println(i);//97
        byte[] buf = new byte[21];
        int len = fis.read(buf);
        String str = new String(buf,"UTF-8");
        System.out.println(str);
        fis.close();
    }
}

4.文件输出流:FileOutputStream类

　作用：用来处理以文件作为数据输出目的数据流，或者说是从内存区读数据入文件
FileOutputStream类用来处理以文件作为数据输出目的数据流。
　　创建一个文件流对象有两种方法：
　　方式1：
　　 File f=new File (“d:/myjava/write.txt “);
FileOutputStream out= new FileOutputStream (f);
　　方式2：
　　FileOutputStream out=new FileOutputStream(“d:/myjava/write.txt “);
　　方式3：构造函数将 FileDescriptor()对象作为其参数。
　　FileDescriptor() fd=new FileDescriptor();
　　FileOutputStream f2=new FileOutputStream(fd);
　　方式4：构造函数将文件名作为其第一参数，将布尔值作为第二参数。
　　FileOutputStream f=new FileOutputStream(“d:/abc.txt”,true);
　　注意： （1）文件中写数据时，若文件已经存在，则覆盖存在的文件；
　　（2）的读/写操作结束时，应调用close方法关闭流。
程序举例：使用键盘输入一段文章，将文章保存在文件fos.dat中
这里写图片描述

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class FosDemo {
    public static void main(String[] args) throws IOException{
        FileOutputStream fos= new FileOutputStream("write.txt");
        fos.write(97);
        String str = "天安门上太阳升";
        byte[] buf = str.getBytes("UTF-8");
        fos.write(buf);
        fos.close();
    }
}

5. FileInputStream流和FileOutputStream的应用

package day02;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class CopyDemo {
    public static void main(String[] args) throws IOException{
        FileInputStream fis= new FileInputStream("src.jpg");        
        FileOutputStream fos= new FileOutputStream("copy2.jpg");        
        byte[] buf = new byte[10240];
        int len = -1;
        while((len=fis.read(buf))!=-1){
            fos.write(buf,0,len);
        }
        System.out.println("复制完毕");
        fis.close();
        fos.close();
    }
}

6. 缓冲输入输出流 BufferedInputStream/ BufferedOutputStream

这里写图片描述
计算机访问外部设备非常耗时。访问外存的频率越高，造成CPU闲置的概率就越大。为了减少访问外存的次数，应该在一次对外设的访问中，读写更多的数据。为此，除了程序和流节点间交换数据必需的读写机制外，还应该增加缓冲机制。缓冲流就是每一个数据流分配一个缓冲区，一个缓冲区就是一个临时存储数据的内存。这样可以减少访问硬盘的次数,提高传输效率。

BufferedInputStream:当向缓冲流写入数据时候，数据先写到缓冲区，待缓冲区写满后，系统一次性将数据发送给输出设备。

BufferedOutputStream :当从向缓冲流读取数据时候，系统先从缓冲区读出数据，待缓冲区为空时，系统再从输入设备读取数据到缓冲区。
1）将文件读入内存：
将BufferedInputStream与FileInputStream相接

FileInputStream in=new FileInputStream( “file1.txt ” );

BufferedInputStream bin=new BufferedInputStream( in);

2）将内存写入文件：
将BufferedOutputStream与 FileOutputStream相接

FileOutputStreamout=new FileOutputStream(“file1.txt”);

BufferedOutputStream bin=new BufferedInputStream(out);

3）键盘输入流读到内存
将BufferedReader与标准的数据流相接
InputStreamReader sin=new InputStreamReader (System.in) ；
BufferedReader bin=new BufferedReader(sin);
例子：
BufferedOutputStream

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class BosDemo {
    public static void main(String[] args) throws IOException{
        FileOutputStream fos= new FileOutputStream("bos.txt");
        BufferedOutputStream bos= new BufferedOutputStream(fos);                
        String str = "伟大领袖毛主席";
        byte[] buf = str.getBytes("UTF-8");
        bos.write(buf);
        /* 强制将当前缓冲流中的缓冲区中的数据全部写出，无论缓冲区是否被装满*/
        bos.flush();
        bos.close();//close时，也会自动调用一次flush
    }
}

BufferedInputStream/ BufferedOutputStream加速文件拷贝

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class CopyDemo2 {
    public static void main(String[] args)throws IOException {
        FileInputStream fis= new FileInputStream("src.AVI");
        BufferedInputStream bis= new BufferedInputStream(fis);
        FileOutputStream fos= new FileOutputStream("copy2.AVI");
        BufferedOutputStream bos= new BufferedOutputStream(fos);
        int d = -1;
        while ((d = bis.read()) != -1) {
            bos.write(d);
        }
        System.out.println("复制完毕");
        /* 关闭流时，只关闭最外层的高级流即可*/
        bis.close();
        bos.close();
    }
}

7. 字符流Writer/Reader

Java中字符是采用Unicode标准，一个字符是16位，即一个字符使用两个字节来表示。为此，JAVA中引入了处理字符的流。

1. Reader抽象类
用于读取字符流的抽象类。子类必须实现的方法只有 read(char[], int, int) 和 close()。但是，多数子类将重写此处定义的一些方法，以提供更高的效率和/或其他功能。
这里写图片描述
1) FileReader :与FileInputStream对应
主要用来读取字符文件，使用缺省的字符编码，有三种构造函数：
　　 (1）将文件名作为字符串：FileReader f=new FileReader(“c:/temp.txt”);
　　 (2）构造函数将File对象作为其参数。
　　 File f=new file(“c:/temp.txt”);
　　 FileReader f1=new FileReader(f);
　　 (3) 构造函数将FileDescriptor对象作为参数
　　 FileDescriptor() fd=new FileDescriptor()
　　 FileReader f2=new FileReader(fd);
2) CharArrayReader：与ByteArrayInputStream对应
　　3) StringReader : 与StringBufferInputStream对应
　　4) InputStreamReader
　　从输入流读取字节，在将它们转换成字符:Public inputstreamReader(inputstream is);
　　5) FilterReader: 允许过滤字符流 protected filterReader(Reader r);
　　6) BufferReader :接受Reader对象作为参数，并对其添加字符缓冲器，使用readline()方法可以读取一行。 Public BufferReader(Reader r);
2. Writer抽象类
写入字符流的抽象类。子类必须实现的方法仅有 write(char[], int, int)、flush() 和 close()。但是，多数子类将重写此处定义的一些方法，以提供更高的效率和/或其他功能。其子类如下：
这里写图片描述
3 .InputStream与Reader差别 OutputStream与Writer差别
InputStream和OutputStream类处理的是字节流，数据流中的最小单位是字节(8个bit)
Reader与Writer处理的是字符流，在处理字符流时涉及了字符编码的转换问题

import java.io.*;  
public class EncodeTest {  
    private static void readBuff(byte [] buff) throws IOException {  
       ByteArrayInputStream in =new ByteArrayInputStream(buff);  
        int data;  
        while((data=in.read())!=-1)   System.out.print(data+"  ");  
        System.out.println();     in.close();     }  

   public static void main(String args[]) throws IOException {  
       System.out.println("内存中采用unicode字符编码：" );  
       char   c='好';  
       int lowBit=c&0xFF;     int highBit=(c&0xFF00)>>8;  
       System.out.println(""+lowBit+"   "+highBit);  
       String s="好";  
       System.out.println("本地操作系统默认字符编码：");  
       readBuff(s.getBytes());  
       System.out.println("采用GBK字符编码：");  
       readBuff(s.getBytes("GBK"));  
       System.out.println("采用UTF-8字符编码：");        
       readBuff(s.getBytes("UTF-8"));      }  
}

这里写图片描述
Reader类能够将输入流中采用其他编码类型的字符转换为Unicode字符，然后在内存中为其分配内存
Writer类能够将内存中的Unicode字符转换为其他编码类型的字符，再写到输出流中。

BufferedReader缓冲字符输入流可以以行为单位读取字符串

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

public class BufferReaderDemo {
    public static void main(String[] args) throws IOException{
        FileInputStream fis= new FileInputStream("pw.txt");     
        InputStreamReader isr= new InputStreamReader(fis,"UTF-8");      
        BufferedReader br= new BufferedReader(isr);
        String str = null;
        while((str=br.readLine())!=null){
            System.out.println(str);
        }
        br.close();
    }
}

InputStreamReader字符输入流用于读取字符数据的流

package day03;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
public class ISRDemo {
    public static void main(String[] args)throws IOException{
        FileInputStream fis= new FileInputStream("osw.txt");

        InputStreamReader isr= new InputStreamReader(fis,"UTF-8");
        int d = -1;
        while((d = isr.read())!=-1){
            char c = (char)d;
            System.out.print(c);
        }
        isr.close();
    }
}

OutStream

FileInputStream和FileOutputStream

FileInputStream


import java.io.FileInputStream;
import java.io.IOException;
/**
 * FileInputStream 节点流用于从文件中读取字节的流
 */
public class FisDemo {
    public static void main(String[] args) throws IOException{
        FileInputStream fis= new FileInputStream("fos.dat");        
        int i = fis.read();
        System.out.println(i);//97

        byte[] buf = new byte[21];
        int len = fis.read(buf);
        String str = new String(buf,"UTF-8");
        System.out.println(str);

        fis.close();
    }
}

学习地址：http://blog.csdn.net/hguisu/article/details/7418161
http://blog.csdn.net/yczz/article/details/38761237

灰太狼1号

关注

2
点赞
踩
5

收藏

觉得还不错? 一键收藏
1
评论
java i/o操作

1. I/O介绍：中I/O操作主要是指使用Java进行输入，输出操作. Java所有的I/O机制都是基于数据流进行输入输出，这些数据流表示了字符或者字节数据的流动序列。Java.io是大多数面向数据流的输入/输出类的主要软件包。此外，Java也对块传输提供支持，在核心库 java.nio中采用的便是块IO。流IO的好处是简单易用，缺点是效率较低。块IO效率很高，但编程比较复杂。 Java.io包中包
复制链接

扫一扫