Java文件与流

文件

文件管理通过java.io包下.file类

作用：

1、文件属性
2、文件检查
3、文件删除
4、不包含对其文件内容的处理

File类的构造

语法：

File f =new  File(String path)
path:选中文件路径

例如：
先在E盘中创建一 .txt文件,
创建FileDome类

File f =new File("E:/iodemo.txt");

方法


例如：
创建新文件

        File f =new File("E:/iodemo01.txt");
        
        try {
            boolean b=f.createNewFile();
            System.out.println(b);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

盘中对应路径查看：


常用方法：

f.exists()判断文件是否存在
f.delete()删除文件，不可恢复性删除

流

概念： 流（Stream）代表程序中数据的流通

数据流：是一串连续不断的数据的集合

java中分为

1、输入流：流入 到计算机内存数据
2、输出流：流出 计算机内存数据

1、按照处理单位分为：

1、字节流
2、字符流

2、按照功能分为：

1、节点流（低级流）
2、处理流（高级流）
   速度不同：低级流 < 高级流

文件读取

字节流

创建FileInput类,读取上面iodemo.txt文件
iodemo.txt内容

helo word!
my name is wangjilong 
tell: 210-455214

创建FileInput类

public static void main(String[] args) {
        read1();

}
    //通过java   io读取文件数据
    public static void read1() {
        //找到文件
        File f= new File("E:/iodemo.txt");
        //文件字节输入流
        FileInputStream fis=null;
        try {
            //搭建管道 
            fis = new FileInputStream(f);
             //读取数据
            System.out.print((char)fis.read());//char强行转换类型，不然读取的是accii表  h对应值104
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

输出：
h

读取了一次，所以只有 h

修改读取数据部分代码，循环读取

//读取数据
           for (int i = 0; i < f.length(); i++) {
               System.out.print((char)fis.read());
           }

或者：
           while (true) {
               int s=0;
               if ((s=fis.read())!=-1) {
                   System.out.print((char)s);
               } else {
                   break;
               }
           }

输出：
helo word!
my name is wangjilong 
tell: 210-455214

注意：

 该方法无法读取 汉字 ；

read()方法：

此方法输入流中读取一个数据字节，如果已经达到文件末尾，则返回-1（表示读取完成）
容器创建

为了减少内存处理负担，可以先将文件读取到缓存器内，然后一次性读出，避免单个字节的吞吐。

在上面的代码上添加read2方法

public static void read2() {
        File f= new File("E:/iodemo.txt");
        //文件字节输入流
        FileInputStream fis;
        
        try {
             fis=new FileInputStream(f);
             //创建容器
             byte[] b= new byte[1024];
             //读入容器
             int length=fis.read(b);
             
             System.out.println(length);//返回读取文件内容的个数
             System.out.println(new String(b,0,length));//string构造
             
             
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    }

输出
54
helo word!
my name is wangjilong 
tell: 210-455214

关于上述代码中的String构造解释：
public String(byte[] bytes,int offset,int length)

    byte[] bytes：原数组 字符的数字形式 需要转成字符串
    int offset：初始位置 在byte的那个下标位置开始截取
    int length：截取的长度

同理这时候可以对文件中的 汉字进行读取，在.txt文件中添加汉字试一试读取

当前代码读取量只有1024，面对更大 的文件需要去循环多次读取

修改后

public static void read2() {
        File f= new File("E:/iodemo.txt");
        //文件字节输入流
        FileInputStream fis;
        
        try {
             fis=new FileInputStream(f);
             //创建容器
             byte[] b= new byte[1024];
             while ((fis.read(b))!=-1) {
                //读完返回-1
                 System.out.println(new String(b));
            }   
 
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    }

注意：
如果汉字出现乱码，需要修改编码格式为ANSI格式

文件拷贝和复制

拷贝和文件需要用 流 来完成
（生动形象的图解一下）


创建俩个txt文件，一个为空文件即可

我这里创建了 少年闰土.txt（作源文件）和 少年闰土copy.txt（目标文件空文件）

public static void main(String[] args) {
        //文件拷贝
        File f1=new File("E:/少年闰土.txt");//源文件
        File f2=new File("D:/少年闰土copy.txt");//目标文件
        
        //字节输入流
        FileInputStream fis=null;
        //字节输出流
        FileOutputStream fos=null;  
        try {
             fis =new FileInputStream(f1);
             fos =new  FileOutputStream(f2);
             byte[] b=new byte[1024];
             int length=0;
             while ((length=fis.read(b))!=-1) {
                fos.write(b, 0,length);
            }
             System.out.println("拷贝成功");
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            
        } catch (IOException e) {
            // TODO Auto-generated catch block
            
        }finally {
            try {
                fos.close();//关闭流
            } catch (Exception e2) {
                // TODO: handle exception
            }
        }

运行，在目标文件中查看拷贝后的文件内容

注意：当 write 方式没有写入时无法完成，则强制写入

fos.flush()
向文件中添加内容

向iodemo01.txt文件中写入内容

File f= new File("E:/iodemo01.txt");
        FileOutputStream fos;
        try {
             fos=new FileOutputStream(f);
             byte[] b=new byte[100];
             //写入内容
             String str ="今年我想买个劳";
             //将字符串转换成byte数组
             b=str.getBytes();
             fos.write(b);
             System.out.println("输入完成");
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

运行，在路径中找到该文件查看。

如果需要继续添加内容，不覆盖以前的内容，在 f， 后加true就行

fos=new FileOutputStream(f,true);

字符流

2字节 ，字符输入流Reader, 字符输出流 writer

File f=new File("E:/iodemo02.txt");
        FileWriter fw = null ;
        try {
            fw =new FileWriter(f,true);
            String str = "我还想买个红旗";
            fw.write(str);
            System.out.println("完成");
            
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally {
            try {
                fw.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
字符流的拷贝

选定一个文件先完成读取，然后再写入到另一个文件，就完成了一个拷贝

        File f1=new File("E:/iodemo02.txt");
        File f2 =new File("E:/iodemo02copy.txt");
        
        
        FileWriter fw = null ;
        FileReader fr=null;
         
        try {
            fr =new FileReader(f1);
            fw =new FileWriter(f2);
            
            char[] c= new char[1024];
            int length=0;
            while ((length=fr.read(c))!=-1) {
                fw.write(c,0,length);
            }
            System.out.println("完成");
        }
        catch (FileNotFoundException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally {
            try {
                fw.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

关于高级流和处理流

高级流的使用需要先创建低级流，高级流可以更快的完成操作，节约时间

  public static void main(String[] args) {
        File f1=new File("E:/iodemo01.txt");//源文件
        File f2=new File("E:/iodemo011.txt");//目标文件
        //低级字节输入流
        FileInputStream fis=null;
        //高级字节输入流
        BufferedInputStream bis=null;
        
        //低级字节输出流
        FileOutputStream fos =null;
        //高级字节输出流
        BufferedOutputStream bos=null;
        
        try {
            fis = new FileInputStream(f1);
            bis =new BufferedInputStream(fis);
            fos =new FileOutputStream(f2);
            bos =new BufferedOutputStream(fos);
            
            byte[] b =new byte[2048];
            int length=0;
            while ((length=bis.read(b))!=-1) {
                bos.write(b,0,length);
                bos.flush();
            }
            System.out.println("ok!!!!!");
            
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally {
            
            try {
                bis.close();
                bos.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }   
    }

高级流和低级流放在同一类下，我们来作一个对比

public class BufferFileCopy {
    public static void main(String[] args) {
        
        //记录开始时间
        long begin =System.currentTimeMillis();
//      Files();
        buff();
        long end = System.currentTimeMillis();
        double time = (end-begin)/1000;
        System.out.println("执行过程时间为"+time);
    }
    //高级流文件拷贝
    public static void buff() {
        File f1=new File("E:/02.JavaSE核心技术/D-参考资料/01.zip");//源文件
        File f2=new File("E:/02.JavaSE核心技术/D-参考资料/01高级.zip");//目标文件
        //低级字节输入流
        FileInputStream fis=null;
        //高级字节输入流
        BufferedInputStream bis=null;
        
        //低级字节输出流
        FileOutputStream fos =null;
        //高级字节输出流
        BufferedOutputStream bos=null;
        
        try {
            fis = new FileInputStream(f1);
            bis =new BufferedInputStream(fis);
            fos =new FileOutputStream(f2);
            bos =new BufferedOutputStream(fos);
            
            byte[] b =new byte[2048];
            int length=0;
            while ((length=bis.read(b))!=-1) {
                bos.write(b,0,length);
                bos.flush();
            }
            System.out.println("ok!!!!!");
            
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally {
            
            try {
                bis.close();
                bos.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
    
    //低级流文件拷贝
    public static void Files() {
        File f1=new File("E:/02.JavaSE核心技术/D-参考资料/01.zip");//源文件
        File f2=new File("E:/02.JavaSE核心技术/D-参考资料/01低级.zip");//目标文件
        
        //字节输入流
        FileInputStream fis=null;
        //字节输出流
        FileOutputStream fos=null;  
        try {
             fis =new FileInputStream(f1);
             fos =new  FileOutputStream(f2);
             byte[] b=new byte[1024];
             int length=0;
             while ((length=fis.read(b))!=-1) {
                fos.write(b, 0,length);
            }
             System.out.println("拷贝成功");
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            
        } catch (IOException e) {
            // TODO Auto-generated catch block
            
        }finally {
            try {
                fos.close();//关闭流
            } catch (Exception e2) {
                // TODO: handle exception
            }
        }
    }

}

这里需要一个大一点的文件，我这里用的文件大小为389,952kb、

先执行低级流


再执行高级流



可以看出高级流的耗时明显小于低级流耗时

©著作权归作者所有,转载或内容合作请联系作者
【社区内容提示】社区部分内容疑似由AI辅助生成，浏览时请结合常识与多方信息审慎甄别。
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

相关阅读更多精彩内容

  • java（文件和流）
    前言 Java中使用IO(输入输出）来读取和写入，读写设备上的数据、硬盘文件、内存、网络......，根据数据的走...
    luckee阅读 6,828评论 0赞 0
  • Java文件流相关
    Java里面，将IO流体系按操作方式分类，可分为字节流和字符流。相关类结构图如下： 字节流相关的基类是InputS...
    zackyG阅读 6,533评论 0赞 1
  • Java 文件——流（Stream）的基本介绍
    1. 流 Stream Java中（绝大部分编程语言类似）文件一般不是单独处理，而是视为输入输出(I/O)设备的一...
    entro阅读 5,865评论 0赞 7
  • 第12章 文件与流
    目标 文件与目录管理 流 文件读写（字节流 字符流） 对象序列化 文件与目录管理 前置任务 前置需要了解的知识 1...
    A建飞_dedf阅读 1,423评论 0赞 0
  • 第12章 文件与流
    目标 文件与目录管理 流 文件读写（字节流 字符流） 对象序列化 文件与目录管理 前置任务 前置需要了解的知识1、...
    wqjcarnation阅读 3,725评论 0赞 2

友情链接更多精彩内容