【JavaSE基础】------IO流【一】

最新推荐文章于 2023-02-10 14:34:52 发布
最新推荐文章于 2023-02-10 14:34:52 发布
阅读量355 收藏
点赞数 1
分类专栏： JavaSE基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_38053081/article/details/71331431
版权


JavaSE基础IO流【一】

一、java.io.File类
     1.凡是与输入、输出相关的类、接口等都定义在java.io包下
     2.File是一个类，可以由构造器创建其对象，此对象对应者一个文件（.txt    .mp3    .mp4    .doc等等）或一个文件 目录
   3.File类对象是与平台无关的。（即也可以在其他平台使用）
    4.File类中的方法，仅涉及到如何创建、删除、重命名等等。只要涉及文件内容的，File是无能为力的，必须由IO来完成。
   5.File类的对象常作为IO流的集体类的构造器的形参。
    


         这里写图片描述
 二、IO流的概述
    1.流的分类
          按照数据流向不同：输入流，输出流
        按照处理数据的单位不同：字节流、字符流（处理纯文本文件）
        按照角色的不同：节点流（直接作用与文件）、处理流（在节点流的基础上加以处理）
    
 
    
    2.IO的体系
        抽象基类            节点流（文件流）          缓冲流（处理流的一种，可以提升文件操作的效率）       
        InputStream       FileInputStream            BufferedInputStream
        OutputStream    FileOutputStream         BufferedOutputStream    （flush() ）
        Reader                FileReader                         BufferedReader        （readLine()）
        Writer                  FileWriter                            BufferedWriter    （flush() ）

         ①、FileInputStream 读取文件
           一个字节一个字节的读取（读取速度较慢，不推荐使用） 
   
   
  1. private static void FileInputStreamTest() throws Exception {
  2.         // TODO Auto-generated method stub
  3.      File file1=new File("hello.txt");
  4.       FileInputStream fis=new FileInputStream(file1);
  5.         //调用FileInputStream的方法 实现file文件的读取
  6.      /*
  7.           read() 读取文件的一个字节，当执行到文件结尾时，返回-1.
  8.       * int b = fis.read();
  9.           while(b!=-1){
  10.            System.out.print((char)b);
  11.           b=fis.read();
  12.        }
  13.         */
  14.      int b;
  15.        while((b=fis.read())!=-1){
  16.             System.out.print((char)b);
  17.         }
  18.       fis.close();
  19.  }
               使用数组控制每次读取字节的长度，可同时读取多个字节 速度大大提升。
             
    
    
  1. private static void FileInputStreamTest(){
  2.       FileInputStream fis=null;
  3.       //调用FileInputStream的方法 实现file文件的读取
  4.      try {
  5.             // TODO Auto-generated method stub
  6.          File file1 = new File("hello.txt");
  7.            fis = new FileInputStream(file1);
  8.            byte[] b = new byte[5]; //读取到的数据写到数组，  数组长度为同时读取的字节长度
  9.           int len;  //因为数组长度是固定的 这里要用len 来表示同一次读取到的字节长度 有可能并没有装满数组
  10.            while ((len = fis.read(b)) != -1) {
  11. //                for (int i = 0; i < len; i++) {  
  12. //                  System.out.print((char) b[i]);
  13. //                }
  14.                String str=new String(b, 0, len);
  15.              System.out.print( str);
  16.          }
  17.       } catch (Exception e) {
  18.            // TODO: handle exception
  19.       }finally{
  20.             try {
  21.                 if(fis!=null){
  22.                     fis.close();
  23.              }
  24.           } catch (IOException e) {
  25.              // TODO Auto-generated catch block
  26.              e.printStackTrace();
  27.          }
  28.       }
  29.   }
    
 
       ②
、FileOutputStream 写入文件
                    基本用法： 

   
   
  1. private static void FileOutputStreamTest() {
  2.         // TODO Auto-generated method stub
  3.      //1.创建File对象 指定hello2.txt 文件的位置   ★该文件不存在时，系统自动创建。如果已存在且存在内容时 此方法写入会覆盖其内容。
  4.      File file2=new File("hello2.txt");
  5.      //2.创建FileOutputStream 对象   将File对象作为形参 传递给FileOutputStream的构造中
  6.         FileOutputStream fos=null;
  7.      try {
  8.             fos=new FileOutputStream(file2);
  9.          //3.写入操作
  10.            fos.write(new String("hello world !").getBytes());
  11.            
  12.         } catch (IOException e) {
  13.          // TODO Auto-generated catch block
  14.          e.printStackTrace();
  15.      }finally{
  16.             //4.关闭流
  17.             if(fos!=null){
  18.                 try {
  19.                     fos.close();
  20.              } catch (IOException e) {
  21.                  // TODO Auto-generated catch block
  22.                  e.printStackTrace();
  23.              }
  24.           }
  25.       }
  26.   }
                    FileInputStream、File OutputStream 同时使用，实现从硬盘读取一个文件，并写入到另一个位置。（相当于文件的复制）： 

    
    
  1. private static void FileInputOutputStreamTest() {
  2.        // TODO Auto-generated method stub
  3.      //实现从硬盘读取一个文件，并写入到另一个位置。（相当于文件的复制）：
  4.         
  5.         //1.准备要读取和要写入的文件
  6.        File file1=new File("C:\Users\asusnb\Desktop\1.jpg");  //等会儿读取的文件   一定是存在的！！
  7.      File file2=new File("C:\Users\asusnb\Desktop\2.jpg");  //作为写入的文件 可以是不存在的
  8.      //2.准备相应的流
  9.      FileInputStream fis=null;
  10.       FileOutputStream fos=null;
  11.      //3.实现文件的复制    
  12.         try{
  13.           fis=new FileInputStream(file1);
  14.           fos=new FileOutputStream(file2);
  15.          //3.1 先从file1中 读取到文件的数据
  16.             byte[] b=new byte[5];
  17.          int len;
  18.          while((len=fis.read(b))!=-1){
  19.                //3.2 把file1中读取到的数据写入到file2中
  20.                fos.write(b, 0, len);
  21.          }
  22.       }catch(Exception e){
  23.           e.printStackTrace();
  24.      }finally{
  25.             //4.关闭流
  26.             if(fis!=null){
  27.                 try {
  28.                     fis.close();
  29.              } catch (IOException e) {
  30.                  // TODO Auto-generated catch block
  31.                  e.printStackTrace();
  32.              }
  33.           }
  34.           if(fos!=null){
  35.                 try {
  36.                     fos.close();
  37.              } catch (IOException e) {
  38.                  // TODO Auto-generated catch block
  39.                  e.printStackTrace();
  40.              }
  41.           }
  42.       }
  43.   }

③、FileReader读取文件
                跟上面的FileInputStream 几乎相同 不同的是 FileReader读取的是字符，而FileInputStream读取的是字节 

     
     
  1. private static void FileReaderTest() {
  2.       // TODO Auto-generated method stub
  3.      //1.创建File对象     准备要读取的文件
  4.       File file=new File("C:\Users\asusnb\Desktop\1.txt");
  5.        //2.创建FileReader 对象   将要读取的文件放入FileReader
  6.       FileReader reader=null;
  7.         //3.通过FileReader 的read方法 读取文件
  8.       try{
  9.           reader=new FileReader(file);
  10.          char c[]=new char[20];   //创建char数组 数组长度为一次同时读取的字符长度 
  11.             int len;
  12.          while((len=reader.read(c))!=-1){
  13.                 String str=new String(c, 0, len);
  14.              System.out.print(str);
  15.               
  16.             }
  17.       }catch(Exception e){
  18.           e.printStackTrace();
  19.      }finally{
  20.             if(reader!=null){
  21.              try {
  22.                     reader.close();
  23.               } catch (IOException e) {
  24.                  // TODO Auto-generated catch block
  25.                  e.printStackTrace();
  26.              }
  27.           }
  28.       }
  29.       
  30.     }
④
、FileWriter  写入文件

        因为与上面的FileOutStream 相似 这里直接用了一个FileReader和FileWriter 结合的例子实现了字符流文件的复制

     
         
         
  1. private static void FileWriter() {
  2.         // TODO Auto-generated method stub
  3.      //注意 FileReader、FileWriter 只能读取和写入 字符流（文本文件），而FileInputStream、FileOutputStream 只能读取和写入 字节流（包括.mp3 视频等等）
  4.         //使用FileReader 和 FileWriter 把一个文本文件从硬盘复制到另一个地方
  5.      
  6.         //1.准备要读取和写入的文件
  7.         File file1=new File("C:\Users\asusnb\Desktop\1.txt");  //要读取的文件必须存在！！
  8.         File file2=new File("C:\Users\asusnb\Desktop\2.txt");  //此时是不存在的，若存在则覆盖该文件（写入可以不存在）
  9.       //2.准备相应的流
  10.      FileReader reader=null;
  11.         FileWriter writer=null;
  12.         //3.实现复制
  13.        try{
  14.           reader=new FileReader(file1);
  15.             writer=new FileWriter(file2);
  16.             char c[]=new char[24];
  17.          int len;
  18.          while((len=reader.read(c))!=-1){
  19.                 writer.write(c, 0, len);
  20.           }
  21.       }catch(Exception e){
  22.           e.printStackTrace();
  23.      }finally{
  24.             //4.关闭流
  25.             if(reader!=null){
  26.              try {
  27.                     reader.close();
  28.               } catch (IOException e) {
  29.                  // TODO Auto-generated catch block
  30.                  e.printStackTrace();
  31.              }
  32.           }
  33.           if(writer!=null){
  34.              try {
  35.                     writer.close();
  36.               } catch (IOException e) {
  37.                  // TODO Auto-generated catch block
  38.                  e.printStackTrace();
  39.              }
  40.           }
  41.       }
  42.   }


    

Pee__wee
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java基础视频（传智播客刘意）
03-13
传智播客刘意老师的 java基础视频，包含视频，代码，笔记，PPT等
Javase基础——IO流
涛涛的个人博客
07-15 279
Javase基础——IO流
JavaSe之IO流
qq_54227829的博客
02-10 428
JavaSe之IO流
刘意JavaSE视频+源码（27天）（百度云）
04-09
传智播客刘意-风清扬的JavaSE学习资料，共有27天，视频和源码都有，下载后打开记事本复制链接密码，下载即可
java io流_Java——IO流超详细总结
weixin_39838362的博客
02-12 1868
该系列博文会告诉你如何从入门到进阶，一步步地学习Java基础知识，并上手进行实战，接着了解每个Java知识点背后的实现原理，更完整地了解整个Java技术体系，形成自己的知识框架。在初学Java时，IO流是我遇到的一个很头疼的东西，Java IO 体系看起来类很多，感觉很复杂，但其实是 IO 涉及的因素太多了。在设计 IO 相关的类时，编写者也不是从同一个方面考虑的，所以会给人一种很乱的感觉，并且还...
JavaSE基础篇 -- IO流的详细操作
07-28
本资源内详尽描述了Java基础的IO操作，包括基本的文件读取、写入、复制、分割、合并等动作，详情另可参见我的博客http://blog.csdn.net/zhongkelee/article/details/47061013
javaSE阶段学习项目--图书馆管理系统
01-02
适用于java初学者，通过三层架构思想进行开发设计，主要功能有增删改查，预约续借积分管理等功能。通过io流进行数据存储，涉及的知识点有多线程，io,网络编程等。
2020老杜最新Java零基础进阶视频教程-IO流课件
12-10
本Java视频教程适合有一定编程语言基础的学员观看，在本Java视频教程中讲解了Java面向对象、异常、数组、常用类、集合、IO流、线程、反射机制。该视频教程基于Java13进行讲解，Java13是目前Java最新版本。视频中讲师...
java I/O流总结
06-13
这是一篇关于javaSe的基础班关于IO流的全套总结，希望能对你的基础学习有所帮助。
JavaSE基础代码总结
06-07
JavaSE基础代码总结
传智播客 2015 刘意 Java基础-视频-笔记day27(完结)(2016年5月1日12:42:20)
weixin_30918415的博客
05-01 362
day27 1.类的加载概述和加载时机 2.类加载器的概述和分类 类加载器 负责将.class文件加载到内存中，并为之生成对应的Class对象。 虽然我们不需要关心类加载机制，但是了解这个机制我们就能更好的理解程序的运行。 类加载器的组成 BootstrapClassLoader根类加载器 ExtensionClassLoader扩展类加载器 Syset...
JavaSE基础：IO流
qq_43265673的博客
07-27 312
基础流（节点流） FileInputStream FileOutputStream FileReader FileWriter 包装流（处理流） BufferedInputStream BufferedOutputStream BufferedReader BufferedWriter ObjectInputStream ObjectOutputStream 其他小流 打印流 标准输入输出流 File类的特点和使用
JavaSE——IO流
weixin_56341892的博客
12-29 251
IO流 一、IO流概述 什么是IO？ I : Input O : Output 通过IO可以完成硬盘文件的读和写。 IO的分类 （1）一种方式是按照流的方向进行分类： ​ 以内存作为参照物， ​ 往内存中去，叫做输入(Input)。或者叫做读(Read)。 ​ 从内存中出来，叫做输出(Output)。或者叫做写(Write)。 （2）另一种方式是按照读取数据方式不同进行分类： 有的流是按照字节的方式读取数据，一次读取1个字节byte，等同于一次读取8个二进制位。这种流是万能的，什么类
JavaSE学习之IO流使用技巧
Jaybo
04-25 499
学习过java的小伙伴和将要学习java的小伙伴，都会遇到java中很重要的一块内容，即IO流。翻开java工具书可以发现IO流中有很多类，那么问题来了，就是，开发时该用哪个对象合适呢？或者如何选择使用对象呢？下面笔者根据自己的经验跟各位小伙伴分享下。第一步，首先，明确IO流中有两个主要的体系，即字节输入流（InputStream）、输出流（OutputStream）和字符输入流（Reader）、输
JavaSE IO流(节点流)
weixin_44717746的博客
07-04 219
目录字符：一.读：FileReader1.说明点：2.使用read()的重载方法2.1第三步中for循环的两种错误写法：二.写：FileWriter：1.说明：三.读写操作总结：字节：一.读：FileInputStream二.写：FileOutputStream三.结论： 字符： 一.读：FileReader 读取当前module下的hello.txt文件。 将字符一个一个的读取，然后再输出。即：一次循环读取一个字符。 1.说明点： read()的理解：返回读入一个字符。如果达到文件末尾，返回-1 异
【JavaSE】IO流总结
Java
05-14 416
文章目录一、File类File类概述和方法构造方法创建文件夹或文件判断功能获取功能高级获取删除功能重命名练习：输出指定目录下指定后缀名的文件名批量修改文件名案例二、字节流字节流 FileInputStream && FileOutputStream字节缓冲流BufferedInputStream && BufferedOutputStream三、字符流InputStreamReader && OutputStreamWriter文件缓冲流 FileWrite
传智播客 刘意_2015年Java基础视频-深入浅出精华版 笔记(day11~day17)(2016年2月28日17:44:38)
阿滔-juliantem
11-17 7243
day11 1.Eclipse的基本使用 编译： 自动编译，在保存的那一刻(ctrl+s)帮你做好了(class文件出现在bin目录下)
javase之IO流常用方法
Richard_666的博客
03-10 189
javase篇-第07讲--面向对象1
最新发布
09-08
通过继承，子类可以继承父类的属性和方法，并可以在此基础上进行扩展和修改。继承提供了一种代码复用的机制，可以减少重复编码的工作量。 多态是面向对象编程的又一个重要概念，它指的是同一类型的对象在不同的情况...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值