JAVA IO基础概念相关总结

我不是女神ヾ 2022-05-31 07:56 246阅读 0赞

java.io包是负责整个IO编程的开发包，在这个开发包中包含有核心的5个类和1个接口  
IO学习的关键：同一个方法根据不同的子类可能有不同的实现

**一、File类**  
在整个java.io包里面File是唯一一个与文件本身有关的处理类。例如：文件的创建、重命名等操作都属于文件本身的操作，如果要想使用File类进行操作，那么必须设置一个操作的路径，所以如果要想设置File类的操作文件路径，则可以使用如下构造：  
。构造：public File(String pathname)，要设置完整路径；  
。构造：public File(File parent, String child)，设置父路径与子路径。  
如果要进行文件的基础操作，那么应该使用如下的处理办法：  
。创建新文件：public boolean createNewFile() throws IOException;  
。判断路径是否存在：public boolean exists()；  
。删除文件：public boolean delete()；

**范例：File类的基本操作**

package cn.file;
    
    import java.io.File;
    
    public class Test { 
    
        public static void main(String args[]) throws Exception{    
            File file = new File("E:"+ File.separator +"demo.txt") ;
            if(file.exists()){
                file.delete() ;
            }else{
                file.createNewFile() ;
            }
        }
    }

**范例：File类目录操作**  
如果说现在给定的路径中有相应的目录存在，那么这个时候靠createNewFile（）方法是无法正常创建文件的，那么要想在程序中进行目录的创建，则需要如下的方法支持：  
。取得父路径：public File getParentFile() ；  
。创建目录：public boolean mkdirs() ；

package cn.file;
    
    import java.io.File;
    
    public class Test { 
    
        public static void main(String args[]) throws Exception{
    
            File file = new File("E:" + File.separator + "test1" + File.separator + 
                    "test2" + File.separator + "demo.txt") ;
    
            if(!file.getParentFile().exists()){
                file.getParentFile().mkdirs() ;
            }   
    
            if(file.exists()){
                file.delete() ;
            }else{
                file.createNewFile() ;
            }
        }
    
    }

**FIle类取得文件信息**  
所有的文件本身都有一些自己的保留信息。例如：文件的创建时间、文件的大小等。可以使用如下的办法取得文件相关的信息。  
。取得文件的大小：public long length()，返回的单位是字节  
。取得的是否的路径：public boolean isDirectory()；  
。取得的是否是文件：public boolean isFile()；  
。重命名：public boolean renameTo(File dest)；  
。最后一次修改时间：public long lastModified()；

package cn.file;
    
    import java.io.File;
    import java.math.BigDecimal;
    import java.text.SimpleDateFormat;
    
    public class Test3 { 
        public static void main(String[] args) {
    
            File file = new File("E:" + File.separator + "pic.jpg");
            if (file.exists()) { //文件存在
                if (file.isFile()) { //如果是文件
                    System.out.println("文件大小" + file.length() + "字节、"
                            + (new BigDecimal(file.length() / (double) 1024 / 1024)
                                    .divide(new BigDecimal(1), 2,
                                            BigDecimal.ROUND_HALF_UP)) + "兆");
                    System.out.println("最后一次修改日期"+ new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS")
                                            .format(new java.util.Date(file
                                                    .lastModified())));
                }
            }
    
        }
    }

**二：字节流和字符流**  
如果需要针对文件的内容进行处理操作，则必须要使用两类数据流：  
。字节流：OutputStream InputStre；  
。字符流：Writer Read；  
字节流是直接进行操作，而字符流需要经过处理，所有保存在磁盘上或者网络传输的数据都是字节，而所有的字节重新在内存之中整合在一起，就是字符。  
但是不管使用的是字节流还是字符流，其中基本的操作流程都是类似的，以文件操作为例子：  
。通过File类设置一个要操作的文件路径；  
。通过字节流或字符流的子类为父类对象实例化；  
。进行数据的读写操作；  
。关闭流；  
**2.1、字节输出流：OutputStream**  
字节输出流采用的是byte数据进行的操作处理，主要可以进行二进制数据的操作。如果要进行字节数据的传输操作使用OutputStream类完成，这个类的定义如下：  
public abstract class OutputStream  
extends Object  
implements Closeable, Flushable  
可以发现OutputStream这个抽象类同时实现了 Closeable 和 Flushable接口；  
。 Closeable ：表示的所有需要被关闭的资源接口，里面只有一个close（）方法，从JDK1.5开始；  
|-从JDK1.7开始Closeable又多出了AutoCloseable接口；  
。Flushable：表示刷新处理，JDK1.5后添加  
![OutPutStream类继承结构][OutPutStream]  
在OutPutStream类里面提供有3个write（）方法，这3个方法定义如下：  
。输出整个字节数组的数据：public void write(byte\[\] b) throws IOException ；  
。输出部分字节数组的数据：public void write(byte\[\] b, int off, int len) throws IOException ；  
。输出单个字节：public abstract void write(int b) throws IOException ；  
OutPutStream是一个抽象类，所以如果是抽象类则需要通过子类进行对象的实例化处理，既然要进行文件的处理，所以可以使用FileOutputStream子类为OutputStream父类实例化构造方法：  
。构造方法（创建新的）：public FileOutputStream(File file) throws FileNotFoundException ；  
。构造方法（追加）：public FileOutputStream(File file, boolean append) throws FileNotFoundException ；  
范例：使用OutputStream

package cn.file;
    
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.OutputStream;
    
    public class Test4 { 
        public static void main(String[] args) throws Exception{
            //通过File类设置要输出的文件路径
            File file = new File("E:" + File.separator + "test1" + File.separator + 
                    "test2" + File.separator + "demo.txt") ;
            //判断父目录是否存在，不存在则创建
            if(!file.getParentFile().exists()){ //不存在
                file.getParentFile().mkdirs() ; //创建
            }
            //通过OutputStream为子类FileOutputStream类实例化
            OutputStream output = new FileOutputStream(file) ;
            //定义要输出的数据并且将其输出
            String msg = "Hello World!" ;
            //将字符串变成字符数组
            byte data[] = msg.getBytes() ;
            //输出
            output.write(data) ;
            //关闭流
            output.close() ;
        }
    }

**2.2字节输入流：InputStrea**  
既然可以使用OutputStream实现了数据的输出操作，那么也同样可以实现数据读取操作，读取的操作可以使用InputStream类完成，先来看看InputStream类的定义：  
public abstract class InputStream  
extends Object  
implements Closeable  
在InputStream类中提供3个读取的操作方法：  
。读取数据：public int read(byte\[\] b) throws IOException ；  
。。 |-向字节数组中读取，返回读取的个数，如果没有数据了返回-1 ；  
。读取数据：public int read(byte\[\] b, int off, int len) throws IOException ；  
。。|-向字节数组中读取部分数据，返回的是读取的数据数，如果没有数据了返回-1 ；  
。读取数据：public abstract int read() throws IOException ；  
。。|-读取单个字节数据， 如果没有数据了返回-1 ；  
既然是通过文件读取，那么肯定是使用FileInputStream；  
。构造：public FileInputStream(File file) throws FileNotFoundException ；  
**范例：实现数据的读取：**

package cn.file;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.InputStream;
    
    public class Test5 { 
        public static void main(String[] args) throws Exception{
            //通过File类设置要输出的文件路径
            File file = new File("E:" + File.separator + "test1" + File.separator + 
                    "test2" + File.separator + "demo.txt") ;
            //判断文件是否存在
            //文件存在并且是一个文件
            if(file.exists() && file.isFile()){
                InputStream input = new FileInputStream(file) ;
                byte data[] = new byte[1024] ;
                //读取到字节数组中
                int len = input.read(data) ;
                System.out.println(" " + new String(data, 0, len) + " ") ;
                input.close() ;
            }
        }
    }

**2.3、字符输出流**  
Writer是专门负责（char,String）输出的操作，首先这个类定义如下：  
public abstract class Writer  
extends Object  
implements Appendable, Closeable, Flushable  
writer本身依旧是一个抽象类，所以如果要操作文件一定要使用FileWriter子类，而后在writer类里面也提供有一组的输出方法，其中最为重要的一个是：public void write(String str) throws IOException ；

package cn.file;
    
    import java.io.File;
    import java.io.FileWriter;
    import java.io.Writer;
    
    public class Test6 {
        public static void main(String[] args)throws Exception {
            File file = new File("E:" + File.separator + "test1" + File.separator + 
                    "test2" + File.separator + "demo.txt") ;
    
            if(!file.getParentFile().exists()){
                file.getParentFile().mkdirs() ;
            }   
            Writer out = new FileWriter(file) ;
            out.write("Hello World!") ;
            out.close() ;
        }
    }

**2.4、字符输入流**  
Reader属于字符输入流的抽象类，可以使用FileReader实现文件的读取操作，在Reader里面如果要进行数据的读取使用如下方法完成：public int read(char\[\] cbuf) throws IOException ；  
范例：使用Reader实现数据读取：

package cn.file;
    
    import java.io.File;
    import java.io.FileReader;
    import java.io.Reader;
    
    public class Test7 {
        public static void main(String[] args)throws Exception {
            File file = new File("E:" + File.separator + "test1" + File.separator + 
                    "test2" + File.separator + "demo.txt") ;
            if(file.exists() && file.isFile()){
                char data[] = new char[1024] ;
                Reader in = new FileReader(file) ;
                int len = in.read(data) ;
                System.out.println(new String(data,0,len));
                in.close() ;
            }
        }
    }

所有的流程和之前的inputStream一样，除了数据类型不同。

**2.5、字节流与字符流的区别**  
清楚了字节流和字符流的概念之后必须面对的问题在于：开发之中使用哪种数据流，以及2种数据流的区别是什么？

**一句话总结：如果描述中文的处理一定使用字符流，如果处理数据传输，那么使用字节流。**

在使用字节流进行处理的时候不会使用到内存处理，而是直接与原始数据产生交互。在使用字符流处理的时候如果没有进行关闭处理，那么所有的数据都只是会保存在缓冲区之中，而当进行关闭处理之后会强制性的将缓冲区的数据清空。如果现在使用字符流的时候不希望关闭，那么也可以使用flush()强制清空：public abstract void flush() throws IOException ；

字符流的所有操作都需要经过内存处理后得来，正因为如此，所以字符适合保存中文。像图片，音乐，电影，文字都是字节描述的，所以如果要传递的图片是二进制数据，必须使用字节流。

[OutPutStream]: /images/20220531/634f38d6665b491498f0b26072993b4d.png