java 基础--IO 输入流

Posted 2020-10-11 周无极

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了java 基础--IO 输入流相关的知识，希望对你有一定的参考价值。

JAVA--IO流

（一） IO原理与概念

一、概念
流:流动、流向从一端移动到另一端源头与目的地
程序与文件|数组|网络连接|数据库，以程序为中心
二、IO流分类
流向: 输入流与输出流
数据:字节流:二进制，可以一切文件包括纯文本 doc 音频、视频等等
字符流:文本文件，只能处理纯文本
3、功能:节点:包裹源头
处理:增强功能，提供性能
三、字符流与字节流（重点）与文件
1、字节流
输入流:InputStream read(byte[] b) 、read(byte[] b, int off, int len) +close()
FileInputStream()
输出流:OutputStream write(byte[] b) write(byte[] b, int off, int len) +flush() +close()
FileOutputStream
2、字符流
输入流:Reader read(char[] cbuf) read(char[] cbuf, int off, int len) +close()
FileReader()
输出流:Writer write(char[] cbuf) write(char[] cbuf, int off, int len) +flush() +close()
write(String str, int off, int len)
FileWriter()
四、操作
1、举例:搬家 -->读取文件
1)、关联房子 --->建立与文件联系
2)、选择搬家 -->选择对应流
3)、搬家 -->读取|写出
a)、卡车大小 --->数组大小
b)、运输 -->读取、写出
4)、打发over -->释放资源
2、操作
1)建立联系
2)选择流
3)操作数组大小+read 、write
4)释放资源

（二）字节流

字节流:可以处理一切文件，包括二进制音频、视频、doc等
节点流: InputStream FileInputStream
OutputStream FileOutputStream

一、读取文件
1、建立联系 File对象源头
2、选择流文件输入流 InputStream FileInputStream
3、操作 : byte[] car =new byte[1024]; +read+读取大小
输出
4、释放资源 :关闭

5 类图

package com.bjsxt.io.byteIO;

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

/**
 * 文件的读取
 * 1、建立联系   File对象
    2、选择流     文件输入流  InputStream FileInputStream
    3、操作  : byte[] car =new byte[1024];  +read+读取大小
              输出
    4、释放资源 :关闭
 * @author Administrator
 *
 */
public class Demo01 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        //1、建立联系   File对象
        File src =new File("e:/xp/test/a.txt");
        //2、选择流
        InputStream is =null; //提升作用域
        try {
            is =new FileInputStream(src);
            //3、操作 不断读取 缓冲数组
            byte[] car =new byte[1024];
            int len =0; //接收 实际读取大小
            //循环读取
            StringBuilder sb =new StringBuilder();
            while(-1!=(len=is.read(car))){
                //输出  字节数组转成字符串
                String info =new String(car,0,len);
                sb.append(info);
            }
            System.out.println(sb.toString());
            
            
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            System.out.println("文件不存在");
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("读取文件失败");
        }finally{
            try {
                //4、释放资源
                if (null != is) {
                    is.close();
                }
            } catch (Exception e2) {
                System.out.println("关闭文件输入流失败");
            }
        }
    }

}

fileinputstream

二、写出文件
1、建立联系 File对象目的地
2、选择流文件输出流 OutputStream FileOutputStream
3、操作 : write() +flush
4、释放资源 :关闭

5 类图

package com.bjsxt.io.byteIO;

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

/**
 * 写出文件
1、建立联系   File对象  目的地
2、选择流     文件输出流  OutputStream FileOutputStream
3、操作  :  write() +flush
4、释放资源 :关闭
 * @author Administrator
 *
 */
public class Demo02 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        //1、建立联系   File对象  目的地
        File dest =new File("e:/xp/test/test.txt");
        //2、选择流   文件输出流  OutputStream FileOutputStream
        OutputStream os =null;
        //以追加形式 写出文件 必须为true 否则为覆盖
        try {
            os =new FileOutputStream(dest,true);
            //3、操作
            String str="bjsxt is very good \\r\\n";
            //字符串转字节数组
            byte[] data =str.getBytes();
            os.write(data,0,data.length);
            
            os.flush(); //强制刷新出去
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            System.out.println("文件未找到");
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("文件写出失败");
        }finally{
            //4、释放资源 :关闭
            try {
                if (null != os) {
                    os.close();
                }
            } catch (Exception e2) {
                System.out.println("关闭输出流失败");
            }
        }
    }

}

fileoutputstream

三、文件拷贝程序为桥梁
1、建立联系 File对象源头目的地
2、选择流
文件输入流 InputStream FileInputStream
文件输出流 OutputStream FileOutputStream
3、操作 : 拷贝
byte[] flush =new byte[1024];
int len =0;
while(-1!=(len=输入流.read(flush))){
输出流.write(flush,0,len)
}
输出流.flush

package com.bjsxt.io.byteIO;

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

/**
 1、建立联系   File对象   源头 目的地
2、选择流     
     文件输入流  InputStream FileInputStream
      文件输出流  OutputStream FileOutputStream
3、操作  :  拷贝
     byte[] flush =new byte[1024]; 
     int len =0;
      while(-1!=(len=输入流.read(flush))){  
         输出流.write(flush,0,len)
      }
             输出流.flush
4、释放资源 :关闭 两个流
 
 
 * @author Administrator
 *
 */
public class CopyFileDemo {

    /**
     * @param args
     * @throws FileNotFoundException 
     */
    public static void main(String[] args) {
        String src ="E:/xp/test";
        String dest="e:/xp/test/4.jpg";
        try {
            copyFile(src,dest);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            System.out.println("文件不存在");
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("拷贝文件失败|关闭流失败");
        }
    }
    /**
     * 文件的拷贝
     * @param  源文件路径
     * @param  目录文件路径
     * @throws FileNotFoundException,IOException
     * @return 
     */
        public static void copyFile(String srcPath,String destPath) throws FileNotFoundException,IOException {
            //1、建立联系 源(存在且为文件) +目的地(文件可以不存在)  
            File src =new File(srcPath);
            File dest =new File(destPath);
            if(! src.isFile()){ //不是文件或者为null
                System.out.println("只能拷贝文件");
                throw new IOException("只能拷贝文件");
            }
            //2、选择流
            InputStream is =new FileInputStream(src);
            OutputStream os =new FileOutputStream(dest);
            //3、文件拷贝   循环+读取+写出
            byte[] flush =new byte[1024];
            int len =0;
            //读取
            while(-1!=(len=is.read(flush))){
                //写出
                os.write(flush, 0, len);
            }
            os.flush(); //强制刷出
            
            //关闭流
            os.close();
            is.close();
        }

}

copyfile

4、释放资源 :关闭两个流
四、文件夹拷贝
1、递归查找子孙级文件|文件夹
2、文件复制(IO流复制)
文件夹创建
3、 A
/ \\
as.txt b
|
b.txt

AA
|
A
/ \\
a.txt b
|
b.txt
4、不能将父目录拷贝到子目录中
删除超长目录

package com.bjsxt.io.byteIO;

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

/**
 * 文件夹的拷贝
 * 1、文件 赋值  copyFile
 * 2、文件 创建 mkdirs()
 * 3、递归查找子孙级
 * 
 * @author Administrator
 *
 */
public class CopyDir {

    /**
     * @param args
     */
    public static void main(String[] args) {
        //源目录
        String srcPath="E:/xp/test/a";     
        //目标目录
        String destPath="E:/xp/test/a/b";
        try {
            FileUtil.copyDir(srcPath,destPath);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        
    }
    /**
     * 拷贝文件夹
     * @param src 源路径
     * @param dest 目标路径
     */
    public static void copyDir(String  srcPath,String destPath){
        File src=new File(srcPath);
        File dest =new File(destPath);
        copyDir(src,dest);        
    }
    
    
    
    /**
     * 拷贝文件夹
     * @param src 源File对象
     * @param dest 目标File对象
     */
    public static void copyDir(File src,File dest){
        if(src.isDirectory()){ //文件夹
            dest =new File(dest,src.getName());            
        }        
        copyDirDetail(src,dest);
    }
    
    /**
     * 拷贝文件夹细节
     * @param src
     * @param dest
     */
    public static void copyDirDetail(File src,File dest){
        if(src.isFile()){ //文件
            try {
                FileUtil.copyFile(src, dest);
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }else if(src.isDirectory()){ //文件夹
            //确保目标文件夹存在
            dest.mkdirs();
            //获取下一级目录|文件
            for(File sub:src.listFiles()){
                copyDirDetail(sub,new File(dest,sub.getName()));
            }
        }
    }
    
    

}

copydir

package com.bjsxt.io.byteIO;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
/**
 * 文件操作
 * 1、文件拷贝
 * 2、文件夹拷贝  拒绝自己拷贝给自己
 * @author Administrator
 *
 */
public class FileUtil {
    /**
     * 拷贝文件夹
     * @param src 源路径
     * @param dest 目标路径
     * @throws IOException 
     * @throws FileNotFoundException 
     */
    public static void copyDir(String  srcPath,String destPath) throws FileNotFoundException, IOException{
        //拒绝自己拷贝给自己
        if(srcPath.equals(destPath)){
            return ;
        }
        File src=new File(srcPath);
        File dest =new File(destPath);
        copyDir(src,dest);        
    }
    
    
    
    /**
     * 拷贝文件夹
     * @param src 源File对象
     * @param dest 目标File对象
     * @throws IOException 
     * @throws FileNotFoundException 
     */
    public static void copyDir(File src,File dest) throws FileNotFoundException, IOException{
        if(src.isDirectory()){ //文件夹
            dest =new File(dest,src.getName());
            if(dest.getAbsolutePath().contains(src.getAbsolutePath())){
                System.out.println("父目录不能拷贝到子目录中");
                return;
            }
        }        
        copyDirDetail(src,dest);
    }
    
    /**
     * 拷贝文件夹细节
     * @param src
     * @param dest
     */
    public static void copyDirDetail(File src,File dest) throws FileNotFoundException,IOException{
        if(src.isFile()){ //文件
            try {
                FileUtil.copyFile(src, dest);
            } catch (FileNotFoundException e) {
                //e.printStackTrace();
                throw e;
            } catch (IOException e) {
                //e.printStackTrace();
                throw e;
            }
        }else if(src.isDirectory()){ //文件夹
            //确保目标文件夹存在
            dest.mkdirs();
            //获取下一级目录|文件
            for(File sub:src.listFiles()){
                copyDirDetail(sub,new File(dest,sub.getName()));
            }
        }
    }
    
    
    /**
     * 文件的拷贝
     * @param  源文件路径
     * @param  目录文件路径
     * @throws FileNotFoundException,IOException
     * @return 
     */
    public static void copyFile(String srcPath,String destPath) throws FileNotFoundException,IOException {
        //1、建立联系 源(存在且为文件) +目的地(文件可以不存在) 
        copyFile(new File(srcPath),new File(destPath));
    }
    /**
     * 文件的拷贝
     * @param  源文件File对象
     * @param  目录文件File对象
     * @throws FileNotFoundException,IOException
     * @return 
     */
    public static void copyFile(File src,File dest) throws FileNotFoundException,IOException {
        if(! src.isFile()){ //不是文件或者为null
            System.out.println("只能拷贝文件");
            throw new IOException("只能拷贝文件");
        }
        //dest为已经存在的文件夹，不能建立于文件夹同名的文件
        if(dest.isDirectory()){
            System.out.println(dest.getAbsolutePath()+"不能建立于文件夹同名的文件");
            throw new IOException(dest.getAbsolutePath()+"不能建立于文件夹同名的文件");
        }
        
        
        //2、选择流
        InputStream is =new BufferedInputStream(new FileInputStream(src));
        OutputStream os =new BufferedOutputStream(new FileOutputStream(dest));
        //3、文件拷贝   循环+读取+写出
        byte[] flush =new byte[1024];
        int len =0;
        //读取
        while(-1!=(len=is.read(flush))){
            //写出
            os.write(flush, 0, len);
        }
        os.flush(); //强制刷出
        
        //关闭流
        os.close();
        is.close();
    }
}

Fileutil

(三) 字符流

字符流:只能处理纯文本，全部为可见字符 .txt .html
节点流 Reader FileReader
Writer FileWriter
一、纯文本读取
1、建立联系
2、选择流 Reader FileReader
3、读取 char[] flush =new char[1024];
4、关闭

5 类图

package com.bjsxt.io.charIO;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

/**
 * 纯文本读取
 * @author Administrator
 *
 */
public class Demo01 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        //创建源
        File src =new File("E:/xp/test/a.txt");
        //选择流
        Reader reader =null;
        try {
            reader =new FileReader(src);
            //读取操作
            char[] flush =new char[1024];
            int len =0;
            while(-1!=(len=reader.read(flush))){
                //字符数组转成 字符串
                String str =new String(flush,0,len);
                System.out.println(str);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            System.out.println("源文件不存在");
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("文件读取失败");
        }finally{
            try {
                if (null != reader) {
                    reader.close();
                }
            } catch (Exception e2) {
            }
        }
    }

}

fileReader

二、纯文本写出
1、建立联系
2、选择流 Writer FileWriter
3、读取 write(字符数组,0,长度)+flush
write(字符串)
append(字符|字符串)
4、关闭

5 类图

package com.bjsxt.io.charIO;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

/**
 * 写出文件
 * @author Administrator
 *
 */
public class Demo02 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        //创建源
        File dest =new File("e:/xp/test/char.txt");
        //选择流
        Writer wr =null;
        try {
            //追加文件，而不是覆盖文件
            wr =new FileWriter(dest);
            //写出
            String msg ="追加.....锄禾日当午\\r\\n码农真辛苦\\r\\n一本小破书\\r\\n一读一上午";
            wr.write(msg);
            wr.append("倒萨发了看电视剧 ");
            
            wr.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                if (null != wr) {
                    wr.close();
                }
            } catch (Exception e2) {
            }
        }
    }

}

filewriter

package com.bjsxt.io.charIO;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;

/**
 * 纯文本拷贝
 * @author Administrator
 *
 */
public class CopyFileDemo {

    /**
     * @param args
     */
    public static void main(String[] args) {
        //创建源 仅限于 字符的纯文本
        File src =new File("E:/xp/test/Demo03.java");
        File dest =new File("e:/xp/test/char.txt");
        //选择流
        Reader reader =null;        
        Writer wr =null;
        try {
            reader =new FileReader(src);
            wr =new FileWriter(dest);
            //读取操作
            char[] flush =new char[1024];
            int len =0;
            while(-1!=(len=reader.read(flush))){
                wr.write(flush, 0, len);
            }
            wr.flush();//强制刷出
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            System.out.println("源文件不存在");
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("文件读取失败");
        }finally{
            try {
                if (null != wr) {
                    wr.close();
                }
            } catch (Exception e2) {
            }
            try {
                if (null != reader) {
                    reader.close();
                }
            } catch (Exception e2) {
            }
        }
    
    }

}

filrcopy

(四) 处理流

处理流:增强功能、提供性能，节点流之上
一、缓冲流
1)、字节缓冲流
BufferedInputStream
BufferedOutputStream

package com.bjsxt.io.buffered;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
/**
 * 字节流文件拷贝+缓冲流 ，提高性能
 * 缓冲流(节点流)
 * @author Administrator
 *
 */
public class BufferedByteDemo {

    /**
     * @param args
     */
    public static void main(String[] args) {
        
    }
    /**
     * 文件的拷贝
     * @param  源文件路径
     * @param  目录文件路径
     * @throws FileNotFoundException,IOException
     * @return 
     */
        public static void copyFile(String srcPath,String destPath) throws FileNotFoundException,IOException {
            //1、建立联系 源(存在且为文件) +目的地(文件可以不存在)  
            File src =new File(srcPath);
            File dest =new File(destPath);
            if(! src.isFile()){ //以上是关于java 基础--IO  输入流的主要内容，如果未能解决你的问题，请参考以下文章 
 java基础之 IO 流（输入/出字符流）
 Java : java基础 IO流
 Java编程基础之IO流
 Java基础IO流
 IO输入输出流——Java面向对象基础(29)
 java 基础--IO  输入流