精华内容
下载资源
问答
  • 例子:往一个文件内写东西以前的写法,总是在处理的最后都需要finally关闭资源,这样多了就会觉得很麻烦private static void oldtest(String filePath) throws FileNotFoundException {OutputStream out = new ...

    例子:往一个文件内写东西

    以前的写法,总是在流处理的最后都需要finally关闭资源,这样多了就会觉得很麻烦

    private static void oldtest(String filePath) throws FileNotFoundException {

    OutputStream out = new FileOutputStream(filePath);

    try {

    out.write((filePath+"我就是测试下用Java写点东西进来").getBytes());

    }catch (Exception e){

    e.printStackTrace();

    }finally {

    try {

    out.close();

    }catch (Exception e){

    e.printStackTrace();

    }

    }

    }

    Java7 里的try...catch...resource 写法可以流会自动回收,只需在try()括号里写流对象,这样就不用老是finally了

    //自动关闭资源写法

    private static void newtest(String filePath) throws FileNotFoundException {

    try(OutputStream out = new FileOutputStream(filePath);){

    out.write("用try...catch..resource写法试试会不会自动关闭资源".getBytes());

    }catch (Exception e){

    e.printStackTrace();

    }

    }

    我们可以看下源代码:

    e7f1a5c71d173103d086f67087cf9f3b.png

    这个outputStream实现了Closeable这个类,看下Closeable源代码

    f1b868c2adf70ddeb7caedd99f91eaa6.png

    看下AutoCloseable源代码:

    75192138f3e9e9e6864886ba0ee00342.png

    注意:

    1、使用该写法,需要该类有有实现AutoCloseable类

    2、实现了AutoCloseable接⼝的类,在try()⾥声明该类实例的时候,try结束后⾃动调⽤的 close⽅法,这个动作会早于finally⾥调⽤的⽅法

    3、不管是否出现异常,try()⾥的实例都会被调⽤close⽅法

    4、try⾥⾯可以声明多个⾃动关闭的对象,越早声明的对象,会越晚被close掉

    展开全文
  • 从图片上可以看出字节输入流InputStream和字节输出流OutputStream都实现了Closeable接口,这个接口中提供了一个close()方法,用来释放资源,在我们创建输入输出流并且用完时,我们需要关闭输入输出流。在关闭输出流...

    什么是字节流和字符流
    在这里插入图片描述
    字节流类间的继承关系
    字节流间的继承关系
    从图片上可以看出字节输入流InputStream和字节输出流OutputStream都实现了Closeable接口,这个接口中提供了一个close()方法,用来释放资源,在我们创建输入输出流并且用完时,我们需要关闭输入输出流。在关闭输出流之前,我们需要用Flush()方法刷新一下输出流,用来将输出流中的元素全部刷新,防止输出流中留有剩余没输出的元素,然后在关闭。
    字符流类间的继承关系
    字符流间的继承关系
    FileInputStream类
    FileInputStream是抽象类InputStream的实现类
    我们想要读取某个文件,就需要先创建一个“输入流”,在创建流的时候会有异常,我们可以进行try catch 捕获处理也可以throws抛出,建议捕获处理。

    public static void main(String[] args) {
            FileInputStream fis=null;//创建字节输入流,先赋给它空值
            try {
                //要读取某个文件,先与这个文件创建一个“输入流”
    
                //文件路径,此处赋给的是绝对路径
                String FilePath="D:\\idea\\java code\\src\\learn\\IO\\temp01";//相对路径,相对当前而言,在当前路径下找
    
                fis=new FileInputStream(FilePath);//创建一个字节输入流对象,并将文件路径穿进去
                //开始读,read()方法,一次只能读取一个字节,并且输出该字节的时候会转换成Ascll码值
                int i1=fis.read();
                int i2=fis.read();
                int i3=fis.read();
                int i4=fis.read();
                int i5=fis.read();
                int i6=fis.read();
                //因为传入的文件中只有abcdef,所以在读到第7次的时候文件已经读完了
                int i7=fis.read();
                System.out.println(i1);//97 a
                System.out.println(i2);//98 b
                System.out.println(i3);//99 c
                System.out.println(i4);//100 d
                System.out.println(i5);//101 e
                System.out.println(i6);//102 f
                //如果已经读取到文件的末尾就会返回-1
                System.out.println(i7);//-1
            }catch (FileNotFoundException e){//处理文件找不到异常
                e.printStackTrace();//打印异常名称,基本信息,异常位置
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                //为了保证流一定会释放,所以在finally语句块中执行
                if(fis!=null){
                    try {
                        fis.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
    
        }
    

    我们可以使用循环读取文件,就可以不用使用单一的read()方法那么麻烦了

     public static void main(String[] args) {
            FileInputStream fis=null;
            try {
                //创建流
                 fis=new FileInputStream("D:\\idea\\java code\\src\\learn\\IO\\temp01");
                //读取
                /*
               while (true){
                   int temp=fis.read();
                   if(temp==-1){
                       break;
                   }
                   System.out.println(temp);
               }
                 */
                //升级循环
                int temp=0;//定义一个判定变量
                while ((temp=fis.read())!=-1){//当read()方法的返回值为-1时,就代表文件已经读取完了,我们让他退出循环即可,当返回值不是-1时,我们输出temp,也就是输出文件的内容
                    System.out.println(temp);
                }
    
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }finally {
                //关闭流
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    

    很显然一次读取一字节太慢了,用的久就会伤害硬盘,所以我们可以使用字节数组来进行高效读取

    /*
        int read(byte[] byte)
        读取之前在内存中准备一个byte数组,每次读取多个字节存储到byte数组中
        一次读取多个字节,不是单字节读取。
        该方法返回的int类型的值代表的是这次读取的多少个字节
        效率高
     */
    public class FileInputStreamTest03 {
        public static void main(String[] args) {
            //创建输入流
            FileInputStream fis=null;
            try {
                //创建输入流
                fis=new FileInputStream("D:\\idea\\java code\\src\\learn\\IO\\temp01");
                //读取数据
                //准备一个byte数组
                byte[] bytes=new byte[3];//每次最多读取三个字节
                int i=fis.read(bytes);//3
                //将byte数组转换成字符串,构造方法,多次的读取,后面读取会将之前读取的字节覆盖
                System.out.println(new String(bytes));//abc
                int i1=fis.read(bytes);//3
                System.out.println(new String(bytes));//def
                int i2=fis.read(bytes);//1
                System.out.println(new String(bytes));//gef,ef已经被读取了。
                System.out.println(new String(bytes,0,i2));//g String类的构造方法,可将byte数组的一部分转换成String类型
                int i3=fis.read(bytes);//-1 已经到达文件的末尾返回-1
                System.out.println(new String(bytes));//gef
                System.out.println(i);
                System.out.println(i1);
                System.out.println(i2);
                System.out.println(i3);
                /*
                 //将while循环升级,用循环可以减少代码,高效的读取
                int temp=0;
                while (((temp=fis.read(bytes))!=-1)){
                    System.out.println(new String(bytes,0,temp));
                }
                */
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }finally {
                try {
                    //关闭输入流
                    fis.close();
                }catch (IOException e){
                    e.printStackTrace();
                }
            }
        }
    }
    

    FileInputStream类的其他方法

     public static void main(String[] args) throws Exception {
            //创建流
            FileInputStream fis=new FileInputStream("D:\\idea\\java code\\src\\learn\\IO\\temp01");
            //available()方法返回此输入流下一个方法调用可以不受阻塞地从此输入流读取(或跳过)的估计字节数。可用来估计文件大概有多少字节
            System.out.println(fis.available());//7
    
            System.out.println(fis.read());//97
            System.out.println(fis.available());//6
            //将指针跳过两个字节
            fis.skip(2);
            System.out.println(fis.read());//100,因为跳过了98,99
            //关闭
            fis.close();
        }
    

    FileOutputStream类
    FileOutputStream类是抽象类OutputStream的子类,用来创建一个字节输出流。
    我们要将数据写入一个文件,就需要使用输出流来写入。
    有一点需要注意的是,使用输出流写入文件时,如果该文件路径不存在,会自动创建文件,如果该文件存在且原文件中有数据的话,那么写入的时候就要使用追加的方式写入,不然会覆盖掉原文件的数据。

     public static void main(String[] args) {
            FileOutputStream fis=null;
            try {
                //1、创建文件字节输出流
                //谨慎使用
                // fis=new FileOutputStream("D:\\idea\\java code\\src\\learn\\IO\\temp02");//该文件不存在会自动创建
                //以追加的方式写入文件(不会覆盖掉原文件内容)
                fis=new FileOutputStream("D:\\idea\\java code\\src\\learn\\IO\\temp02",true);//append:true表示追加,false表示不追加
                 //2、开始写
                String msg="HelloWorld";
                byte[] bytes=msg.getBytes();
                //将byte数组的所有数据全部写入
                fis.write(bytes);
                //将byte数组中的一部分数据写入
                fis.write(bytes,0,3);
    
    
    
                //推荐最后的时候为了保证数据完全写入硬盘,所以要刷新
                fis.flush();//强制写入
    
            }catch (FileNotFoundException e){
                e.printStackTrace();
            }catch (IOException e){
                e.printStackTrace();
            } finally {
                //关闭输出流
                try {
                    if(fis!=null){
                        fis.close();
                    }
                }catch (IOException e){
                    e.printStackTrace();
                }
            }
        }
    

    使用输入输出流复制文件

      public static void main(String[] args) {
            //创建输入流
            FileInputStream fis=null;
            try {
                fis=new FileInputStream("D:\\idea\\java code\\src\\learn\\IO\\temp01");
            }catch (FileNotFoundException e){
                e.printStackTrace();
            }
            //创建输出流
            FileOutputStream fos=null;
            try {
                fos=new FileOutputStream("D:\\idea\\java code\\src\\learn\\IO\\temp02");
            }catch (FileNotFoundException e){
                e.printStackTrace();
            }
            //一边读,一边写
            byte[] bytes=new byte[1024];//每次读写1KB
            try {
                int temp=0;
                while ((temp=fis.read(bytes))!=-1){
                    fos.write(bytes,0,temp);
                }
            }catch (IOException e){
                e.printStackTrace();
            }
        }
    

    FlieReader类
    FileReader类用来创建字符输入流,字符输入流只能读取纯文本文件。

     public static void main(String[] args) {
            FileReader fr=null;
            try {
                //创建文件字符流
                 fr=new FileReader("D:\\idea\\java code\\src\\learn\\IO\\temp01");
                 char[] chars=new char[512];//1KB
                int temp=0;
                while ((temp=fr.read(chars))!=-1){
                    //将char数组有效部分转换为字符串输出
                    System.out.println(new String(chars,0,temp));
                }
            }catch (FileNotFoundException e){
                e.printStackTrace();
            }catch (IOException e){
                e.printStackTrace();
            } finally {
                if(fr!=null);{
                    try {
                        fr.close();
                    }catch (IOException e){
                        e.printStackTrace();
                    }
                }
            }
    
        }
    

    FileWriter类
    FileWriter类用来创建字符输出流

      public static void main(String[] args) throws Exception {
            //创建文件字符输出流
            //FileWriter fw=new FileWriter("D:\\idea\\java code\\src\\learn\\IO\\temp01");//覆盖文件
            FileWriter fw1=new FileWriter("D:\\idea\\java code\\src\\learn\\IO\\temp01",true);//以追加的方式添加文件
            FileReader fr=new FileReader("D:\\idea\\java code\\src\\learn\\IO\\temp02");
            //一边读,一边写,只能复制纯文本文件
            char[] c=new char[512];
            int temp=0;
            //读
            if ((temp=fr.read(c))!=-1){
                //写
                fw1.write(c,0,temp);
            }
            /*
            fw1.write("李海波!!!");
            //将char数组的一部分写入
            char[] chars={'我','是','中','国','人','!',',','.',};
            fw1.write(chars,0,6);
             */
            //刷新
            fw1.flush();
            //关闭
            fw1.close();
            fr.close();
        }
    
    展开全文
  • 例子:往一个文件内写东西以前的写法,总是在处理的最后都需要finally关闭资源,这样多了就会觉得很麻烦private static void oldtest(String filePath) throws FileNotFoundException {OutputStream out = new ...

    例子:往一个文件内写东西

    以前的写法,总是在流处理的最后都需要finally关闭资源,这样多了就会觉得很麻烦

    private static void oldtest(String filePath) throws FileNotFoundException {

    OutputStream out = new FileOutputStream(filePath);

    try {

    out.write((filePath+"我就是测试下用Java写点东西进来").getBytes());

    }catch (Exception e){

    e.printStackTrace();

    }finally {

    try {

    out.close();

    }catch (Exception e){

    e.printStackTrace();

    }

    }

    }

    Java7 里的try...catch...resource 写法可以流会自动回收,只需在try()括号里写流对象,这样就不用老是finally了

    //自动关闭资源写法

    private static void newtest(String filePath) throws FileNotFoundException {

    try(OutputStream out = new FileOutputStream(filePath);){

    out.write("用try...catch..resource写法试试会不会自动关闭资源".getBytes());

    }catch (Exception e){

    e.printStackTrace();

    }

    }

    我们可以看下源代码:

    e7c563bc6577128490126e36b7b59717.png

    这个outputStream实现了Closeable这个类,看下Closeable源代码

    03e077baf9201443f600cd5c7167eb25.png

    看下AutoCloseable源代码:

    582d4398b92a6cf1129ac376912c8dba.png

    注意:

    1、使用该写法,需要该类有有实现AutoCloseable类

    2、实现了AutoCloseable接?的类,在try()?声明该类实例的时候,try结束后?动调?的 close?法,这个动作会早于finally?调?的?法

    3、不管是否出现异常,try()?的实例都会被调?close?法

    4、try??可以声明多个?动关闭的对象,越早声明的对象,会越晚被close掉

    原文:https://www.cnblogs.com/zexin/p/12275948.html

    展开全文
  • 一、输入流1、 InputStream类是字节输入流的抽象类,是所有字节...close()关闭输入流并且释放与该关联的所有系统资源;2、Reader类是字符输入流的抽象类,是所有字符输入流的父类;Reader类中的方法和InputStr...

    一、输入流

    1、 InputStream类是字节输入流的抽象类,是所有字节输入流的父类;以下是该类中的一些方法的简要说明;

    read()方法:从输入流中读取数据的下一个字节;

    read(byte[] b):从输入流中读入一定长度的字节;

    close()关闭此输入流并且释放与该流关联的所有系统资源;

    2、Reader类是字符输入流的抽象类,是所有字符输入流的父类;Reader类中的方法和InputStream中的方法相似;

    二、输出流

    1、OutputStream类是字节输出流的抽象类;以下为该类的方法均返回void;

    write(int b)方法:将指定的字节写入此输出流;

    write(byte[] b)方法:将b个字节从指定的byte数组中写入此输出流;

    flush()方法:彻底完成输出并清空缓存区;

    close()方法:关闭输出流;

    2、 Writer类是字符输出流的抽象类所有字符输出流的父类;方法与OutputStream相似;

    三、File类

    1、文件的创建与删除;--常用的创建方法:File(String pathname)

    该构造方法通过将给定路径名字符串转换为抽象路径名来创建一个新的File实例;

    --删除一个文件:delete() 删除一个文件或者删除一个空文件夹;

    --获取文件信息:

    getname() 返回值为:String 获取文件名称

    exits() 返回值为:boolean 判断文件是否存在

    size() 返回值为:long 获取文件的长度

    getParent() 返回值为:String 获取文件的父路径

    isFile() 返回值为:boolean 判断是否是文件

    isDirectory() 返回值为:boolean 判断是否是文件夹

    lastModified() 返回值为:long 判断文件最后修改的时间

    list() 返回值为:list 列出文件夹中的资源

    listFiles() 返回值为:list 列出文件夹中的文件

    mkdir() 返回值为:boolean 创建一级不存在路径

    mkdirs() 返回值为:boolean 创建多级不存在的目录

    createNewsFile() 返回值为:boolean 创建新文件

    四、文件输入输出流

    1、FileInputStream和FileOutputStreamFileInputStream类常用构造方法:FileInputStream(String name)参数为文件名name

    FileInputStream(File file)参数为File

    FileOutputStream类常用构造方法与FileInputStream相同;

    2、FileReader和FileWriterFileReader类常用的构造方法:FileReader(String name)、FileReader(File file)

    FileWriter类常用的构造方法与FileReader一样;

    3、 BufferedInputStream和BufferedOutputStreamBufferedInputStream类常用的构造方法:BufferedInputStream(InputStream in)

    例如:BufferedInputStream(new FileInputStream(String name))

    BufferedOutputStream类常用的构造方法BufferedOutputStream(OutputStream out)

    4、 BufferedReader和BufferedWriterBufferedReader类常用的构造方法BufferedReader(Reader r)

    例如:BufferedReader(new FileReader(String name))

    BufferedWriter类常用的构造方法BufferedWriter(Writer w)

    例如:BufferedWriter(new FileWriter(String name))

    本文链接:

    http://blog.ps-ef.cn/Java/22.html

    展开全文
  • 1.BufferedReader是Reader的一个子类,它具有缓冲的作用,避免了频繁的从物理设备中读取信息。它有以下两个构造函数:...它的基本方法:voidclose()//关闭流voidmark(int readAheadLimit)//标记当前位置b...
  • java中需要手动释放的资源bai常见的有以下两个:流相du关资zhi源流相关资源一般遵循:1)先开后关dao,先开的输入流,再开的输出流,通过读取输入流写入输出流中,那么应该先关输出流,再关输入流,但是一般关闭输入...
  • 在我编程中遇到了一个问题,就是客户端如果不关闭输入流的话,服务端与客户端之间的通讯就会卡住,只要一调用socket。shutdownInput关闭输入流就正常客户端代码public static void main(String[] args) {try {//1....
  • 在写Java输入输出流的时候很重要的一点就是在最后不要忘记调用close函数来关闭打开的流,因为打开文件是一种独占式的操作,打开后不关闭会导致其他程序不能再次打开这个文件。 为了避免程序员在写输入输出流时忘记...
  • Java输入输出流

    2020-11-23 13:49:06
    通过使用java.io包中的输入/输出流类就可以达到输入输出信息的目的 I/O流(Input/Output) 在Java中将信息的输入与输出过程抽象为I/O流 输入是指数据流入程序 输出是指数据从程序流出 一个流就是一个从源流向目的地的...
  • Java输入/输出流

    千次阅读 2021-01-01 19:21:49
    Java输入/输出流 一、流的概念 输入流只能读不能写,输出流只能写不能读。按照流中数据的处理单位不同,可将流分为字节流和字符流。在字节流中,数据的组织和操作的基本单位是字节;在字符流中,数据的组织和操作的...
  • //读取键盘录入的数据写到a.txt//方式一private static void method() throws IOException {//创建输入流对象InputStream is = System.in;...//创建输出流对象FileWriter fw = new FileWriter("a.txt");//读取数据...
  • 例子:往一个文件内写东西以前的写法,总是在处理的最后都需要finally关闭资源,这样多了就会觉得很麻烦private static void oldtest(String filePath) throws FileNotFoundException {OutputStream out = new ...
  • Java输入输出流

    2017-12-06 16:12:34
    Java语言将信息的输入/输出过程抽象为输入/输出流。也就是说,Java I/O流表现为声明并创建的java.io包中对应类的实例对象(流对象)。使用输入流/输出流的一般步骤如下: (1)使用java.io包中的类创建并打开一个流...
  • JAVA输入输出流关闭

    千次阅读 2015-02-01 11:24:03
    昨天写了一个读取配置文件的方法,打开了InputStream 输入 读取了配置文件信息。 在本地测试tomcat时,没发现问题 。 讲模块打包放到linux服务器上部署的Weblogic...修改代码,关闭输入流。。。 环境恢复正常。。。
  • JAVA文件读写输入输出流关闭问题、JAVA垃圾回收
  • java关于输入输出流

    2019-02-22 23:43:18
    程序必须打开两个文件,以可读的方式打开一个已有文件和以可写的方式打开一个新文件,后将已有文件中的内容,暂时存放在内存中,再写入新的文件,后关闭所有文件,程序结束。 根据题意,首先需要读入一个文件中的...
  • 输入输出流 想要了解更详细的输入输出流知识点可以看往期博客 Java File类/文件字节流/图形和图像(20.5.12) Java文件字符流/缓冲流/使用文件对话/动画和视频20.5.13 等等… 下面只是作简单的复习带过 相关知识点 ...
  • java高级输入输出流(3)–文件字节流 *** (1)文件字节流:实现文件复制 (2)FileInputStream FileOutputStream (3)使用FileInputStream建立通往文件的输入流时,可能会出现异常, 如:要打开的文件可能不存在,所以...
  • java中需要手动释放的资源bai常见的有以下两个:流相du关资zhi源流相关资源一般遵循:1)先开后关dao,先开的输入流,再开的输出流,通过读取输入流写入输出流中,那么应该先关输出流,再关输入流,但是一般关闭输入...
  • java中执行删除文件操作,要关闭输入输出流FileInputStream fis=null; FileOutputStream fos=null; try{ //复制文件 fis=new FileInputStream("D:/test.txt"); fos=new FileOutputStream("D:/test.txt1"); int ...
  • java中需要手动释放的资源bai常见的有以下两个:流相du关资zhi源流相关资源一般遵循:1)先开后关dao,先开的输入流,再开的输出流,通过读取输入流写入输出流中,那么应该先关输出流,再关输入流,但是一般关闭输入...
  • java 输入输出流

    2020-07-18 11:06:26
    关闭输入流 如果对文件读取需求比较简单,那么可以使用FileInputStream 类(文件字节输入),该类是InputStream类的子类(以字节为单位读取文件),该类的实例方法都是从InputStream类继承来的。 构造方法 可以使用...
  • 切记: 读写文件一定要及时关闭输入输出流项目中,用到将rtf文档上传后修改一个更新标记为0未更新,另外一个程序将文档上传到LED屏上面,LED程序检测到更新标记为未更新时将状态投到LED上面,并将状态更新为1已更新...
  • java中执行lunix命令的时候使用PrintWriter来输出命令,使用input.readLine()来获取命令执行结果的时候,需要先关闭OutputStreamWriter然后使用input.readLine()来获取执行结果。在这里提醒自己。 部分代码如下 ...
  • 文件操作的时候一定要记得关闭!!!!!!!!ASCII:美国标准信息交换码,用一个字节的7位可以表示一个字符ISO8859-1:拉丁码表,西欧标准字符集,用一个字节的8位表示GB2312:中文编码表,用两个字节来表示中文...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,210
精华内容 484
关键字:

java关闭输入输出流

java 订阅