精华内容
下载资源
问答
  • java IO流操作,包括文件的读取,写入,上传和下载,支持文本数据和音频等文件
  • Java IO用法详解

    千次阅读 多人点赞 2018-03-19 10:10:36
    一、java io 概述1.1 相关概念Java IOJava IOJava 输入输出系统。不管我们编写何种应用,都难免和各种输入输出相关的媒介打交道,其实和媒介进行IO的过程是十分复杂的,这要考虑的因素特别多,比如我们要考虑和哪...

    一、java io 概述

    1.1 相关概念

    Java IO

    Java IO即Java 输入输出系统。不管我们编写何种应用,都难免和各种输入输出相关的媒介打交道,其实和媒介进行IO的过程是十分复杂的,这要考虑的因素特别多,比如我们要考虑和哪种媒介进行IO(文件、控制台、网络),我们还要考虑具体和它们的通信方式(顺序、随机、二进制、按字符、按字、按行等等)。Java类库的设计者通过设计大量的类来攻克这些难题,这些类就位于java.io包中。

    在JDK1.4之后,为了提高Java IO的效率,Java又提供了一套新的IO,Java New IO简称Java NIO。它在标准java代码中提供了高速的面向块的IO操作。本篇文章重点介绍Java IO,关于Java NIO请参考我的另两篇文章: 
    Java NIO详解(一) 
    Java NIO详解(二)

    在Java IO中,流是一个核心的概念。流从概念上来说是一个连续的数据流。你既可以从流中读取数据,也可以往流中写数据。流与数据源或者数据流向的媒介相关联。在Java IO中流既可以是字节流(以字节为单位进行读写),也可以是字符流(以字符为单位进行读写)。

    IO相关的媒介

    Java的IO包主要关注的是从原始数据源的读取以及输出原始数据到目标媒介。以下是最典型的数据源和目标媒介:

    • 文件
    • 管道
    • 网络连接
    • 内存缓存
    • System.in, System.out, System.error(注:Java标准输入、输出、错误输出)

    二、Java IO类库的框架

    2.1 Java IO的类型

    虽然java IO类库庞大,但总体来说其框架还是很清楚的。从是读媒介还是写媒介的维度看,Java IO可以分为:

    1. 输入流:InputStream和Reader
    2. 输出流:OutputStream和Writer

    而从其处理流的类型的维度上看,Java IO又可以分为:

    1. 字节流:InputStream和OutputStream
    2. 字符流:Reader和Writer

    下面这幅图就清晰的描述了JavaIO的分类:

    -字节流字符流
    输入流InputStreamReader
    输出流OutputStreamWriter

    我们的程序需要通过InputStream或Reader从数据源读取数据,然后用OutputStream或者Writer将数据写入到目标媒介中。其中,InputStream和Reader与数据源相关联,OutputStream和writer与目标媒介相关联。 以下的图说明了这一点:

    这里写图片描述

    2.2 IO 类库

    上面我们介绍了Java IO中的四各类:InputStream、OutputStream、Reader、Writer,其实在我们的实际应用中,我们用到的一般是它们的子类,之所以设计这么多子类,目的就是让每一个类都负责不同的功能,以方便我们开发各种应用。各类用途汇总如下:

    • 文件访问
    • 网络访问
    • 内存缓存访问
    • 线程内部通信(管道)
    • 缓冲
    • 过滤
    • 解析
    • 读写文本 (Readers / Writers)
    • 读写基本类型数据 (long, int etc.)
    • 读写对象

    下面我们就通过两张图来大体了解一下这些类的继承关系及其作用

    图1:java io 类的集成关系

    这里写图片描述

    图2:java io中各个类所负责的媒介

    这里写图片描述

    三、Java IO的基本用法

    3.1 Java IO :字节流

    通过上面的介绍我们已经知道,字节流对应的类应该是InputStreamOutputStream,而在我们实际开发中,我们应该根据不同的媒介类型选用相应的子类来处理。下面我们就用字节流来操作文件媒介:

    例1,用字节流写文件

      public static void writeByteToFile() throws IOException{
            String hello= new String( "hello word!");
             byte[] byteArray= hello.getBytes();
            File file= new File( "d:/test.txt");
             //因为是用字节流来写媒介,所以对应的是OutputStream 
             //又因为媒介对象是文件,所以用到子类是FileOutputStream
            OutputStream os= new FileOutputStream( file);
             os.write( byteArray);
             os.close();
      }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    例2,用字节流读文件

    public static void readByteFromFile() throws IOException{
            File file= new File( "d:/test.txt");
             byte[] byteArray= new byte[( int) file.length()];
             //因为是用字节流来读媒介,所以对应的是InputStream
             //又因为媒介对象是文件,所以用到子类是FileInputStream
            InputStream is= new FileInputStream( file);
             int size= is.read( byteArray);
            System. out.println( "大小:"+size +";内容:" +new String(byteArray));
             is.close();
      }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    3.2 Java IO :字符流

    同样,字符流对应的类应该是ReaderWriter。下面我们就用字符流来操作文件媒介:

    例3,用字符流读文件

    public static void writeCharToFile() throws IOException{
            String hello= new String( "hello word!");
            File file= new File( "d:/test.txt");
             //因为是用字符流来读媒介,所以对应的是Writer,又因为媒介对象是文件,所以用到子类是FileWriter
            Writer os= new FileWriter( file);
             os.write( hello);
             os.close();
      }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    例4,用字符流写文件

      public static void readCharFromFile() throws IOException{
            File file= new File( "d:/test.txt");
             //因为是用字符流来读媒介,所以对应的是Reader
             //又因为媒介对象是文件,所以用到子类是FileReader
            Reader reader= new FileReader( file);
             char [] byteArray= new char[( int) file.length()];
             int size= reader.read( byteArray);
            System. out.println( "大小:"+size +";内容:" +new String(byteArray));
             reader.close();
      }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    3.3 Java IO :字节流转换为字符流

    字节流可以转换成字符流,java.io包中提供的InputStreamReader类就可以实现,当然从其命名上就可以看出它的作用。其实这涉及到另一个概念,IO流的组合,后面我们详细介绍。下面看一个简单的例子:

    例5 ,字节流转换为字符流

    public static void convertByteToChar() throws IOException{
            File file= new File( "d:/test.txt");
             //获得一个字节流
            InputStream is= new FileInputStream( file);
             //把字节流转换为字符流,其实就是把字符流和字节流组合的结果。
            Reader reader= new InputStreamReader( is);
             char [] byteArray= new char[( int) file.length()];
             int size= reader.read( byteArray);
            System. out.println( "大小:"+size +";内容:" +new String(byteArray));
             is.close();
             reader.close();
      }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    3.4 Java IO :IO类的组合

    从上面字节流转换成字符流的例子中我们知道了IO流之间可以组合(或称嵌套),其实组合的目的很简单,就是把多种类的特性融合在一起以实现更多的功能。组合使用的方式很简单,通过把一个流放入另一个流的构造器中即可实现,两个流之间可以组合,三个或者更多流之间也可组合到一起。当然,并不是任意流之间都可以组合。关于组合就不过多介绍了,后面的例子中有很多都用到了组合,大家好好体会即可。

    3.5 Java IO:文件媒介操作

    File是Java IO中最常用的读写媒介,那么我们在这里就对文件再做进一步介绍。

    3.5.1 File媒介

    例6 ,File操作

    public class FileDemo {
      public static void main(String[] args) {
             //检查文件是否存在
            File file = new File( "d:/test.txt");
             boolean fileExists = file.exists();
            System. out.println( fileExists);
             //创建文件目录,若父目录不存在则返回false
            File file2 = new File( "d:/fatherDir/subDir");
             boolean dirCreated = file2.mkdir();
            System. out.println( dirCreated);
             //创建文件目录,若父目录不存则连同父目录一起创建
            File file3 = new File( "d:/fatherDir/subDir2");
             boolean dirCreated2 = file3.mkdirs();
            System. out.println( dirCreated2);
            File file4= new File( "d:/test.txt");
             //判断长度
             long length = file4.length();
             //重命名文件
             boolean isRenamed = file4.renameTo( new File("d:/test2.txt"));
             //删除文件
             boolean isDeleted = file4.delete();
            File file5= new File( "d:/fatherDir/subDir");
             //是否是目录
             boolean isDirectory = file5.isDirectory();
             //列出文件名
            String[] fileNames = file5.list();
             //列出目录
            File[]   files = file4.listFiles();
      }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30

    }

    3.5.3 随机读取File文件

    通过上面的例子我们已经知道,我们可以用FileInputStream(文件字符流)或FileReader(文件字节流)来读文件,这两个类可以让我们分别以字符和字节的方式来读取文件内容,但是它们都有一个不足之处,就是只能从文件头开始读,然后读到文件结束。

    但是有时候我们只希望读取文件的一部分,或者是说随机的读取文件,那么我们就可以利用RandomAccessFile。RandomAccessFile提供了seek()方法,用来定位将要读写文件的指针位置,我们也可以通过调用getFilePointer()方法来获取当前指针的位置,具体看下面的例子:

    例7,随机读取文件

      public static void randomAccessFileRead() throws IOException {
             // 创建一个RandomAccessFile对象
            RandomAccessFile file = new RandomAccessFile( "d:/test.txt", "rw");
             // 通过seek方法来移动读写位置的指针
             file.seek(10);
             // 获取当前指针
             long pointerBegin = file.getFilePointer();
             // 从当前指针开始读
             byte[] contents = new byte[1024];
             file.read( contents);
             long pointerEnd = file.getFilePointer();
            System. out.println( "pointerBegin:" + pointerBegin + "\n" + "pointerEnd:" + pointerEnd + "\n" + new String(contents));
             file.close();
      }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    例8,随机写入文件

      public static void randomAccessFileWrite() throws IOException {
             // 创建一个RandomAccessFile对象
            RandomAccessFile file = new RandomAccessFile( "d:/test.txt", "rw");
             // 通过seek方法来移动读写位置的指针
             file.seek(10);
             // 获取当前指针
             long pointerBegin = file.getFilePointer();
             // 从当前指针位置开始写
             file.write( "HELLO WORD".getBytes());
             long pointerEnd = file.getFilePointer();
            System. out.println( "pointerBegin:" + pointerBegin + "\n" + "pointerEnd:" + pointerEnd + "\n" );
             file.close();
      }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    3.6 Java IO:管道媒介

    管道主要用来实现同一个虚拟机中的两个线程进行交流。因此,一个管道既可以作为数据源媒介也可作为目标媒介。

    需要注意的是java中的管道和Unix/Linux中的管道含义并不一样,在Unix/Linux中管道可以作为两个位于不同空间进程通信的媒介,而在java中,管道只能为同一个JVM进程中的不同线程进行通信。和管道相关的IO类为:PipedInputStreamPipedOutputStream,下面我们来看一个例子:

    例9,读写管道

    public class PipeExample {
       public static void main(String[] args) throws IOException {
              final PipedOutputStream output = new PipedOutputStream();
              final PipedInputStream  input  = new PipedInputStream(output);
              Thread thread1 = new Thread( new Runnable() {
                  @Override
                  public void run() {
                      try {
                          output.write( "Hello world, pipe!".getBytes());
                      } catch (IOException e) {
                      }
                  }
              });
              Thread thread2 = new Thread( new Runnable() {
                  @Override
                  public void run() {
                      try {
                          int data = input.read();
                          while( data != -1){
                              System. out.print(( char) data);
                              data = input.read();
                          }
                      } catch (IOException e) {
                      } finally{
                         try {
                                           input.close();
                                    } catch (IOException e) {
                                           e.printStackTrace();
                                    }
                      }
                  }
              });
              thread1.start();
              thread2.start();
          }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36

    }

    3.7 Java IO:网络媒介

    关于Java IO面向网络媒介的操作即Java 网络编程,其核心是Socket,同磁盘操作一样,java网络编程对应着两套API,即Java IO和Java NIO,关于这部分我会准备专门的文章进行介绍。

    3.8 Java IO:BufferedInputStream和BufferedOutputStream

    BufferedInputStream顾名思义,就是在对流进行写入时提供一个buffer来提高IO效率。在进行磁盘或网络IO时,原始的InputStream对数据读取的过程都是一个字节一个字节操作的,而BufferedInputStream在其内部提供了一个buffer,在读数据时,会一次读取一大块数据到buffer中,这样比单字节的操作效率要高的多,特别是进程磁盘IO和对大量数据进行读写的时候。

    使用BufferedInputStream十分简单,只要把普通的输入流和BufferedInputStream组合到一起即可。我们把上面的例2改造成用BufferedInputStream进行读文件,请看下面例子:

    例10 ,用缓冲流读文件

      public static void readByBufferedInputStream() throws IOException {
            File file = new File( "d:/test.txt");
             byte[] byteArray = new byte[( int) file.length()];
             //可以在构造参数中传入buffer大小
            InputStream is = new BufferedInputStream( new FileInputStream(file),2*1024);
             int size = is.read( byteArray);
            System. out.println( "大小:" + size + ";内容:" + new String(byteArray));
             is.close();
      }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    关于如何设置buffer的大小,我们应根据我们的硬件状况来确定。对于磁盘IO来说,如果硬盘每次读取4KB大小的文件块,那么我们最好设置成这个大小的整数倍。因为磁盘对于顺序读的效率是特别高的,所以如果buffer再设置的大写可能会带来更好的效率,比如设置成4*4KB或8*4KB。

    还需要注意一点的就是磁盘本身就会有缓存,在这种情况下,BufferedInputStream会一次读取磁盘缓存大小的数据,而不是分多次的去读。所以要想得到一个最优的buffer值,我们必须得知道磁盘每次读的块大小和其缓存大小,然后根据多次试验的结果来得到最佳的buffer大小。

    BufferedOutputStream的情况和BufferedInputStream一致,在这里就不多做描述了。

    3.9 Java IO:BufferedReader和BufferedWriter

    BufferedReader、BufferedWriter 的作用基本和BufferedInputStream、BufferedOutputStream一致,具体用法和原理都差不多 ,只不过一个是面向字符流一个是面向字节流。同样,我们将改造字符流中的例4,给其加上buffer功能,看例子:

     public static void readByBufferedReader() throws IOException {
            File file = new File( "d:/test.txt");
             // 在字符流基础上用buffer流包装,也可以指定buffer的大小
            Reader reader = new BufferedReader( new FileReader(file),2*1024);
             char[] byteArray = new char[( int) file.length()];
             int size = reader.read( byteArray);
            System. out.println( "大小:" + size + ";内容:" + new String(byteArray));
             reader.close();
      }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    转载请说明出处,原文链接: http://blog.csdn.net/suifeng3051/article/details/48344587

    展开全文
  • Java io流文件读取和写入

    千次阅读 2020-07-10 17:16:29
    Java io 流操作demo类 1.读取操作 /** *@author lxw *@date 2020/6/24 *@desc 获取文件输入流,这里读入内存中 *@param [fileName] *@return byte[] **/ public byte[] readPdfFile(String fileName) ...

    Java io 流操作demo类

    1.读取操作

     /**
         *@author lxw
         *@date 2020/6/24
         *@desc 获取文件输入流,这里读入内存中
         *@param [fileName]
         *@return byte[]
        **/
        public byte[] readPdfFile(String fileName) throws Exception{
            InputStream in = null;
            byte[] bytesRel;
            try {
                //读取Constants.PDF_CREATE_AND_SIGN.PDF_FILE_PATH路径下文件名位fileName的文件
                File f = new File(Constants.PDF_CREATE_AND_SIGN.PDF_FILE_PATH+fileName);
                in = new FileInputStream(f);
                //in.available 只适合于读取本地文件时判断流中字节数,不适合网络中的流数据大小判定
                bytesRel = new byte[ in.available()];
                in.read(bytesRel);
            } catch (IOException e) {
              log.error("读取文件{}失败!"+Constants.PDF_CREATE_AND_SIGN.PDF_FILE_PATH+fileName);
              throw new BizException(IfspRespCode.RESP_ERROR,"读取pdf文件失败!");
            }finally {
                if (in != null){
                    try {
                        in.close();
                    } catch (IOException e) {
                        log.error("输入流关闭失败!原因:{}",e.getMessage());
                    }
                }
            }
            return  bytesRel;
        }

    2.写文件

     /**
         *@author lxw
         *@date 2020/6/24
         *@desc 写文件 如果想提高效率,可以使用缓冲流
         *@param [pdfByte, fileName]
         *@return void
        **/
        public void writePdfFile(byte[] pdfByte,String fileName) throws Exception{
            //检查文件是否已经存在,存在删除
            checkFIleExit(fileName,Constants.PDF_CREATE_AND_SIGN.PDF_FILE_PATH);
            OutputStream os = null;
            try {
                os = new FileOutputStream(Constants.PDF_CREATE_AND_SIGN.PDF_FILE_PATH+fileName);
                os.write( pdfByte ) ;
                os.flush() ;
            } catch (IOException e) {
                log.error("写入文件{}失败!"+Constants.PDF_CREATE_AND_SIGN.PDF_FILE_PATH+fileName);
            }finally {
                try {
                    if (os!=null)  os.close();
                } catch (IOException e) {
                    log.error("输入流关闭失败!原因:{}",e.getMessage());
                }
            }
        }
    
    
     /**
         *@author lxw
         *@date 2020/6/23
         *@desc 检查文件是否存在,存在就删除掉
         *@param [fileName, path]
         *@return void
        **/
        public void checkFIleExit(String fileName,String path){
            log.info("checkFIleExit方法入参:fileName:{},path:{}",fileName,path);
            File file = new File(path+fileName);
            if (file.exists()){
                file.delete();
            }
        }

     

    展开全文
  • Java IO

    万次阅读 多人点赞 2015-09-10 15:55:28
    一、java io 概述1.1 相关概念Java IOJava IOJava 输入输出系统。不管我们编写何种应用,都难免和各种输入输出相关的媒介打交道,其实和媒介进行IO的过程是十分复杂的,这要考虑的因素特别多,比如我们要考虑和哪...

    一、java io 概述

    1.1 相关概念

    Java IO

    Java IO即Java 输入输出系统。不管我们编写何种应用,都难免和各种输入输出相关的媒介打交道,其实和媒介进行IO的过程是十分复杂的,这要考虑的因素特别多,比如我们要考虑和哪种媒介进行IO(文件、控制台、网络),我们还要考虑具体和它们的通信方式(顺序、随机、二进制、按字符、按字、按行等等)。Java类库的设计者通过设计大量的类来攻克这些难题,这些类就位于java.io包中。

    在JDK1.4之后,为了提高Java IO的效率,Java又提供了一套新的IO,Java New IO简称Java NIO。它在标准java代码中提供了高速的面向块的IO操作。本篇文章重点介绍Java IO,关于Java NIO请参考我的另两篇文章:
    Java NIO详解(一)
    Java NIO详解(二)

    在Java IO中,流是一个核心的概念。流从概念上来说是一个连续的数据流。你既可以从流中读取数据,也可以往流中写数据。流与数据源或者数据流向的媒介相关联。在Java IO中流既可以是字节流(以字节为单位进行读写),也可以是字符流(以字符为单位进行读写)。

    IO相关的媒介

    Java的IO包主要关注的是从原始数据源的读取以及输出原始数据到目标媒介。以下是最典型的数据源和目标媒介:

    • 文件
    • 管道
    • 网络连接
    • 内存缓存
    • System.in, System.out, System.error(注:Java标准输入、输出、错误输出)

    二、Java IO类库的框架

    2.1 Java IO的类型

    虽然java IO类库庞大,但总体来说其框架还是很清楚的。从是读媒介还是写媒介的维度看,Java IO可以分为:

    1. 输入流:InputStream和Reader
    2. 输出流:OutputStream和Writer

    而从其处理流的类型的维度上看,Java IO又可以分为:

    1. 字节流:InputStream和OutputStream
    2. 字符流:Reader和Writer

    下面这幅图就清晰的描述了JavaIO的分类:

    -字节流字符流
    输入流InputStreamReader
    输出流OutputStreamWriter

    我们的程序需要通过InputStream或Reader从数据源读取数据,然后用OutputStream或者Writer将数据写入到目标媒介中。其中,InputStream和Reader与数据源相关联,OutputStream和writer与目标媒介相关联。 以下的图说明了这一点:

    这里写图片描述

    2.2 IO 类库

    上面我们介绍了Java IO中的四各类:InputStream、OutputStream、Reader、Writer,其实在我们的实际应用中,我们用到的一般是它们的子类,之所以设计这么多子类,目的就是让每一个类都负责不同的功能,以方便我们开发各种应用。各类用途汇总如下:

    • 文件访问
    • 网络访问
    • 内存缓存访问
    • 线程内部通信(管道)
    • 缓冲
    • 过滤
    • 解析
    • 读写文本 (Readers / Writers)
    • 读写基本类型数据 (long, int etc.)
    • 读写对象

    下面我们就通过两张图来大体了解一下这些类的继承关系及其作用

    图1:java io 类的集成关系

    这里写图片描述

    图2:java io中各个类所负责的媒介

    这里写图片描述

    三、Java IO的基本用法

    3.1 Java IO :字节流

    通过上面的介绍我们已经知道,字节流对应的类应该是InputStreamOutputStream,而在我们实际开发中,我们应该根据不同的媒介类型选用相应的子类来处理。下面我们就用字节流来操作文件媒介:

    例1,用字节流写文件

      public static void writeByteToFile() throws IOException{
            String hello= new String( "hello word!");
             byte[] byteArray= hello.getBytes();
            File file= new File( "d:/test.txt");
             //因为是用字节流来写媒介,所以对应的是OutputStream 
             //又因为媒介对象是文件,所以用到子类是FileOutputStream
            OutputStream os= new FileOutputStream( file);
             os.write( byteArray);
             os.close();
      }
    

    例2,用字节流读文件

    public static void readByteFromFile() throws IOException{
            File file= new File( "d:/test.txt");
             byte[] byteArray= new byte[( int) file.length()];
             //因为是用字节流来读媒介,所以对应的是InputStream
             //又因为媒介对象是文件,所以用到子类是FileInputStream
            InputStream is= new FileInputStream( file);
             int size= is.read( byteArray);
            System. out.println( "大小:"+size +";内容:" +new String(byteArray));
             is.close();
      }
    

    3.2 Java IO :字符流

    同样,字符流对应的类应该是ReaderWriter。下面我们就用字符流来操作文件媒介:

    例3,用字符流读文件

    public static void writeCharToFile() throws IOException{
            String hello= new String( "hello word!");
            File file= new File( "d:/test.txt");
             //因为是用字符流来读媒介,所以对应的是Writer,又因为媒介对象是文件,所以用到子类是FileWriter
            Writer os= new FileWriter( file);
             os.write( hello);
             os.close();
      }
    

    例4,用字符流写文件

      public static void readCharFromFile() throws IOException{
            File file= new File( "d:/test.txt");
             //因为是用字符流来读媒介,所以对应的是Reader
             //又因为媒介对象是文件,所以用到子类是FileReader
            Reader reader= new FileReader( file);
             char [] byteArray= new char[( int) file.length()];
             int size= reader.read( byteArray);
            System. out.println( "大小:"+size +";内容:" +new String(byteArray));
             reader.close();
      }
    

    3.3 Java IO :字节流转换为字符流

    字节流可以转换成字符流,java.io包中提供的InputStreamReader类就可以实现,当然从其命名上就可以看出它的作用。其实这涉及到另一个概念,IO流的组合,后面我们详细介绍。下面看一个简单的例子:

    例5 ,字节流转换为字符流

    public static void convertByteToChar() throws IOException{
            File file= new File( "d:/test.txt");
             //获得一个字节流
            InputStream is= new FileInputStream( file);
             //把字节流转换为字符流,其实就是把字符流和字节流组合的结果。
            Reader reader= new InputStreamReader( is);
             char [] byteArray= new char[( int) file.length()];
             int size= reader.read( byteArray);
            System. out.println( "大小:"+size +";内容:" +new String(byteArray));
             is.close();
             reader.close();
      }
    

    3.4 Java IO :IO类的组合

    从上面字节流转换成字符流的例子中我们知道了IO流之间可以组合(或称嵌套),其实组合的目的很简单,就是把多种类的特性融合在一起以实现更多的功能。组合使用的方式很简单,通过把一个流放入另一个流的构造器中即可实现,两个流之间可以组合,三个或者更多流之间也可组合到一起。当然,并不是任意流之间都可以组合。关于组合就不过多介绍了,后面的例子中有很多都用到了组合,大家好好体会即可。

    3.5 Java IO:文件媒介操作

    File是Java IO中最常用的读写媒介,那么我们在这里就对文件再做进一步介绍。

    3.5.1 File媒介

    例6 ,File操作

    public class FileDemo {
      public static void main(String[] args) {
             //检查文件是否存在
            File file = new File( "d:/test.txt");
             boolean fileExists = file.exists();
            System. out.println( fileExists);
             //创建文件目录,若父目录不存在则返回false
            File file2 = new File( "d:/fatherDir/subDir");
             boolean dirCreated = file2.mkdir();
            System. out.println( dirCreated);
             //创建文件目录,若父目录不存则连同父目录一起创建
            File file3 = new File( "d:/fatherDir/subDir2");
             boolean dirCreated2 = file3.mkdirs();
            System. out.println( dirCreated2);
            File file4= new File( "d:/test.txt");
             //判断长度
             long length = file4.length();
             //重命名文件
             boolean isRenamed = file4.renameTo( new File("d:/test2.txt"));
             //删除文件
             boolean isDeleted = file4.delete();
            File file5= new File( "d:/fatherDir/subDir");
             //是否是目录
             boolean isDirectory = file5.isDirectory();
             //列出文件名
            String[] fileNames = file5.list();
             //列出目录
            File[]   files = file4.listFiles();
      }
    

    }

    3.5.3 随机读取File文件

    通过上面的例子我们已经知道,我们可以用FileInputStream(文件字符流)或FileReader(文件字节流)来读文件,这两个类可以让我们分别以字符和字节的方式来读取文件内容,但是它们都有一个不足之处,就是只能从文件头开始读,然后读到文件结束。

    但是有时候我们只希望读取文件的一部分,或者是说随机的读取文件,那么我们就可以利用RandomAccessFile。RandomAccessFile提供了seek()方法,用来定位将要读写文件的指针位置,我们也可以通过调用getFilePointer()方法来获取当前指针的位置,具体看下面的例子:

    例7,随机读取文件

      public static void randomAccessFileRead() throws IOException {
             // 创建一个RandomAccessFile对象
            RandomAccessFile file = new RandomAccessFile( "d:/test.txt", "rw");
             // 通过seek方法来移动读写位置的指针
             file.seek(10);
             // 获取当前指针
             long pointerBegin = file.getFilePointer();
             // 从当前指针开始读
             byte[] contents = new byte[1024];
             file.read( contents);
             long pointerEnd = file.getFilePointer();
            System. out.println( "pointerBegin:" + pointerBegin + "\n" + "pointerEnd:" + pointerEnd + "\n" + new String(contents));
             file.close();
      }
    

    例8,随机写入文件

      public static void randomAccessFileWrite() throws IOException {
             // 创建一个RandomAccessFile对象
            RandomAccessFile file = new RandomAccessFile( "d:/test.txt", "rw");
             // 通过seek方法来移动读写位置的指针
             file.seek(10);
             // 获取当前指针
             long pointerBegin = file.getFilePointer();
             // 从当前指针位置开始写
             file.write( "HELLO WORD".getBytes());
             long pointerEnd = file.getFilePointer();
            System. out.println( "pointerBegin:" + pointerBegin + "\n" + "pointerEnd:" + pointerEnd + "\n" );
             file.close();
      }
    

    3.6 Java IO:管道媒介

    管道主要用来实现同一个虚拟机中的两个线程进行交流。因此,一个管道既可以作为数据源媒介也可作为目标媒介。

    需要注意的是java中的管道和Unix/Linux中的管道含义并不一样,在Unix/Linux中管道可以作为两个位于不同空间进程通信的媒介,而在java中,管道只能为同一个JVM进程中的不同线程进行通信。和管道相关的IO类为:PipedInputStreamPipedOutputStream,下面我们来看一个例子:

    例9,读写管道

    public class PipeExample {
       public static void main(String[] args) throws IOException {
              final PipedOutputStream output = new PipedOutputStream();
              final PipedInputStream  input  = new PipedInputStream(output);
              Thread thread1 = new Thread( new Runnable() {
                  @Override
                  public void run() {
                      try {
                          output.write( "Hello world, pipe!".getBytes());
                      } catch (IOException e) {
                      }
                  }
              });
              Thread thread2 = new Thread( new Runnable() {
                  @Override
                  public void run() {
                      try {
                          int data = input.read();
                          while( data != -1){
                              System. out.print(( char) data);
                              data = input.read();
                          }
                      } catch (IOException e) {
                      } finally{
                         try {
                                           input.close();
                                    } catch (IOException e) {
                                           e.printStackTrace();
                                    }
                      }
                  }
              });
              thread1.start();
              thread2.start();
          }
    

    }

    3.7 Java IO:网络媒介

    关于Java IO面向网络媒介的操作即Java 网络编程,其核心是Socket,同磁盘操作一样,java网络编程对应着两套API,即Java IO和Java NIO,关于这部分我会准备专门的文章进行介绍。

    3.8 Java IO:BufferedInputStream和BufferedOutputStream

    BufferedInputStream顾名思义,就是在对流进行写入时提供一个buffer来提高IO效率。在进行磁盘或网络IO时,原始的InputStream对数据读取的过程都是一个字节一个字节操作的,而BufferedInputStream在其内部提供了一个buffer,在读数据时,会一次读取一大块数据到buffer中,这样比单字节的操作效率要高的多,特别是进程磁盘IO和对大量数据进行读写的时候。

    使用BufferedInputStream十分简单,只要把普通的输入流和BufferedInputStream组合到一起即可。我们把上面的例2改造成用BufferedInputStream进行读文件,请看下面例子:

    例10 ,用缓冲流读文件

      public static void readByBufferedInputStream() throws IOException {
            File file = new File( "d:/test.txt");
             byte[] byteArray = new byte[( int) file.length()];
             //可以在构造参数中传入buffer大小
            InputStream is = new BufferedInputStream( new FileInputStream(file),2*1024);
             int size = is.read( byteArray);
            System. out.println( "大小:" + size + ";内容:" + new String(byteArray));
             is.close();
      }
    

    关于如何设置buffer的大小,我们应根据我们的硬件状况来确定。对于磁盘IO来说,如果硬盘每次读取4KB大小的文件块,那么我们最好设置成这个大小的整数倍。因为磁盘对于顺序读的效率是特别高的,所以如果buffer再设置的大写可能会带来更好的效率,比如设置成4*4KB或8*4KB。

    还需要注意一点的就是磁盘本身就会有缓存,在这种情况下,BufferedInputStream会一次读取磁盘缓存大小的数据,而不是分多次的去读。所以要想得到一个最优的buffer值,我们必须得知道磁盘每次读的块大小和其缓存大小,然后根据多次试验的结果来得到最佳的buffer大小。

    BufferedOutputStream的情况和BufferedInputStream一致,在这里就不多做描述了。

    3.9 Java IO:BufferedReader和BufferedWriter

    BufferedReader、BufferedWriter 的作用基本和BufferedInputStream、BufferedOutputStream一致,具体用法和原理都差不多 ,只不过一个是面向字符流一个是面向字节流。同样,我们将改造字符流中的例4,给其加上buffer功能,看例子:

     public static void readByBufferedReader() throws IOException {
            File file = new File( "d:/test.txt");
             // 在字符流基础上用buffer流包装,也可以指定buffer的大小
            Reader reader = new BufferedReader( new FileReader(file),2*1024);
             char[] byteArray = new char[( int) file.length()];
             int size = reader.read( byteArray);
            System. out.println( "大小:" + size + ";内容:" + new String(byteArray));
             reader.close();
      }
    

    转载请说明出处,原文链接: http://blog.csdn.net/suifeng3051/article/details/48344587

    展开全文
  • java io常用类总结

    千次阅读 2018-06-12 20:52:22
    读写数据是java开发过程中经常需要做的,本篇文章将我们平时常用的java io处理类做个总结,同时给出相关demo。可以看得出来,JAVA IO主要有这四个类InputStream、OutputStream、Reader、Writer来处理,要处理字节流...

    读写数据是java开发过程中经常需要做的,本篇文章将我们平时常用的java io处理类做个总结,同时给出相关demo。

    可以看得出来,JAVA IO主要有这四个类InputStream、OutputStream、Reader、Writer来处理,要处理字节流的就用InputStream、OutputStream,要处理字符流,就用Reader、Writer,现实中根据需要,我们选择他们的相关子类进行数据的读写。给出类图:


    根据处理媒介的不同进行划分


    下面给出常用的IO处理demo

    /**

     * 项目名称(中文)

     * 项目名称(英文)

     * Copyright (c) 2018 ChinaPay Ltd. All Rights Reserved.

     */

    package com.figo.study.test;


    import java.io.BufferedReader;

    import java.io.BufferedWriter;

    import java.io.DataInputStream;

    import java.io.File;

    import java.io.FileInputStream;

    import java.io.FileOutputStream;

    import java.io.FileReader;

    import java.io.FileWriter;

    import java.io.InputStream;

    import java.io.ObjectInputStream;

    import java.io.ObjectOutputStream;

    import java.io.OutputStream;

    import java.io.Reader;

    import java.io.Serializable;

    import java.io.StringWriter;

    import java.io.Writer;


    /**

     * IO操作总结 IO按读写划分可以分为输入流和输出流 IO,

     * 按处理媒介来划分可以分为字节流和字符流 

     * 另外为了处理不同的数据类型,输入输出流可以层层包装

     * 比如处理文件数据的FileInputStream,FileOutputStream.

     * 另外处理网络的IO一般使用Socket,jdk1.4及以上版本又推出了NIO, NIO non-blocking

     * io非阻塞的开源项目比如MINA,NETTY,本demo讨论io

     * 

     * @author figo

     * @version 1.0 2018-6-12 改订

     * @since 1.0

     */

    public class TestIO {


        /**

         * .

         * 

         * @param args

         */

        public static void main(String[] args) {

            // testInputStreamAndOutputStream();

            // testReaderAndWriter();

    //        testBufferReaderAndWriter();

            testObjectInputStreamAndObjectOutputStream();

        }


        /**

         * 字节流输入FileInputStream输出FileOutputStream 文件超大有可能会OOM

         */

        public static void testInputStreamAndOutputStream() {

            try {

                // 写入数据

                String hello = new String("hello world!");

                byte[] byteArray = hello.getBytes();

                File file = new File("E:\\学习资料\\java学习\\testIO\\iostream.txt");

                // 因为是用字节流来写媒介,所以对应的是OutputStream

                // 又因为媒介对象是文件,所以用到子类是FileOutputStream

                OutputStream os = new FileOutputStream(file);

                os.write(byteArray);

                os.close();


                // 读取数据

                byte[] byteArrayNew = new byte[(int) file.length()];

                // 因为是用字节流来读媒介,所以对应的是InputStream

                // 又因为媒介对象是文件,所以用到子类是FileInputStream

                InputStream is = new FileInputStream(file);

                int size = is.read(byteArrayNew);

                System.out.println("大小:" + size + ";内容:" + new String(byteArray));

                is.close();

            } catch (Exception ex) {

                ex.printStackTrace();

            }

        }


        /**

         * 字符流输入FileReader输出FileWriter 文件超大有可能会OOM

         */

        public static void testReaderAndWriter() {

            try {

                // 写入数据

                String hello = new String("hello worLd!");

                File file = new File(

                        "E:\\学习资料\\java学习\\testIO\\readerAndwriter.txt");

                // 因为是用字符流来读媒介,所以对应的是Writer,又因为媒介对象是文件,所以用到子类是FileWriter

                Writer os = new FileWriter(file);

                os.write(hello);

                os.close();


                // 读取数据

                // 因为是用字符流来读媒介,所以对应的是Reader

                // 又因为媒介对象是文件,所以用到子类是FileReader

                Reader reader = new FileReader(file);

                char[] byteArray = new char[(int) file.length()];

                int size = reader.read(byteArray);

                System.out.println("大小:" + size + ";内容:" + new String(byteArray));

                reader.close();

            } catch (Exception ex) {

                ex.printStackTrace();

            }

        }


        /**

         * 缓存字符输入BufferedReader和输出BufferedWriter 缓存一定大小字符流后再一次性输入输出

         * 每次一个字符一个字符的读写肯定影响性能的 每次读写缓存大小的数据量,一般不会OOM,批量读写明显会提高效率

         */

        public static void testBufferReaderAndWriter() {

            try {

                // 写入数据

                String hello = new String("hello worLd!");

                File file = new File(

                        "E:\\学习资料\\java学习\\testIO\\bufferReaderAndWriter.txt");

                // 因为是用字符流来读媒介,所以对应的是Writer,又因为媒介对象是文件,所以用到子类是FileWriter

                Writer os = new FileWriter(file);

                // 外部再包装一层buffer 不设置缓冲大小,默认8k,也可以自己通过这个构造函数指定

                // BufferedWriter(Writer paramWriter, int paramInt)

                BufferedWriter bw = new BufferedWriter(os);

                bw.write(hello);

                // 写一行换一行

                bw.newLine();

                bw.close();

                os.close();


                // 读取数据

                // 因为是用字符流来读媒介,所以对应的是Reader

                // 又因为媒介对象是文件,所以用到子类是FileReader

                Reader reader = new FileReader(file);

                // 外部再包装一层buffer 不设置缓冲大小,默认8k,也可以自己通过这个构造函数指定

                // BufferedReader(Reader paramReader, int paramInt)

                BufferedReader bufferReader = new BufferedReader(reader);

                String tempString = null;

                while ((tempString = bufferReader.readLine()) != null) {

                    // 显示行号

                    System.out.println(tempString);

                }

                bufferReader.close();

                reader.close();

            } catch (Exception ex) {

                ex.printStackTrace();

            }

        }


        /**

         * 对象读写到文件ObjectInputStream和ObjectOutputStream .

         */

        public static void testObjectInputStreamAndObjectOutputStream() {

            try {

                //定义一个对象

                Student student=new Student();

                student.setName("abc");

                student.setSex("男");

                student.setGrade("一年级");

                student.setAddress("上海");

                student.setMobile("15812345678");

                //对象写入文件

                FileOutputStream fos=new FileOutputStream("E:\\学习资料\\java学习\\testIO\\Student.txt");

                ObjectOutputStream oos=new ObjectOutputStream(fos);

                oos.writeObject(student);

                oos.flush();

                oos.close();

                //从文件读取对象

                FileInputStream fis=new FileInputStream("E:\\学习资料\\java学习\\testIO\\Student.txt");

                ObjectInputStream ois=new ObjectInputStream(fis);

                Student studentNew=(Student)ois.readObject();

                System.out.println(studentNew.toString());

                

            } catch (Exception ex) {

                ex.printStackTrace();

            }

        }

        /**

         * 一定记得实现Serializable,否则无法序列化成字节流

         * @author figo

         * .

         */

        public static class Student implements Serializable{

            /**

             * .

             */

            private static final long serialVersionUID = 1L;

            String name;

            String sex;

            String grade;

            String address;

            String mobile;


            public String getName() {

                return name;

            }


            public void setName(String name) {

                this.name = name;

            }


            public String getSex() {

                return sex;

            }


            public void setSex(String sex) {

                this.sex = sex;

            }


            public String getGrade() {

                return grade;

            }


            public void setGrade(String grade) {

                this.grade = grade;

            }


            public String getAddress() {

                return address;

            }


            public void setAddress(String address) {

                this.address = address;

            }


            public String getMobile() {

                return mobile;

            }


            public void setMobile(String mobile) {

                this.mobile = mobile;

            }


            @Override

            public String toString() {

                return "Student [name=" + name + ", sex=" + sex + ", grade="

                        + grade + ", address=" + address + ", mobile=" + mobile

                        + "]";

            }


        }

    }



     /**
         * 
         * 字符转字节流InputStreamReader和OutputStreamWriter . 
         * 这两个类的好处是可以指定读取和写入的字符编码
         */
        public static void testInputStreamReaderAndOutputStreamWriter() {


            try {
                //写文件
                String filePathAndName = "E:\\学习资料\\java学习\\testIO\\InputStreamReaderWriter.txt";
                File fileWrite = new File(filePathAndName);
                if (!fileWrite.exists()) {
                    fileWrite.createNewFile();
                }
                OutputStreamWriter write = new OutputStreamWriter(new FileOutputStream(fileWrite), "UTF-8");
                BufferedWriter writer = new BufferedWriter(write);
                String fileContent = "hello,world,你好世界!";
                writer.write(fileContent);
                writer.close();
                //读文件
                File fileRead = new File(filePathAndName);
                if (fileRead.isFile() && fileRead.exists()) {
                    InputStreamReader read = new InputStreamReader(
                            new FileInputStream(fileRead), "UTF-8");
                    BufferedReader reader = new BufferedReader(read);
                    String line;
                    StringBuffer sringBuffer=new StringBuffer();
                    while ((line = reader.readLine()) != null) {
                        //这样也可以指定编码,但是会new很多的String对象
    //                  String newLine=new String(line.getBytes("UTF-8"));
                        sringBuffer.append(line);
                    }
                    System.out.println(fileContent);
                    read.close();
                }


            } catch (Exception ex) {
                ex.printStackTrace();
            }
        }


    另外我们在处理文件读写经常用到java.io.File,这个类比较简单,给出常用方法大家看看就会了:



    好了,大家可以自己动手试一下。


    参考文章

    Java IO

    https://blog.csdn.net/suifeng3051/article/details/48344587


    Java的IO操作---File类

    https://www.cnblogs.com/alsf/p/5746480.html


    展开全文
  • Java IO多路复用机制详解

    千次阅读 2020-04-03 18:03:42
    1、在Java中,常见的IO模型有4种, 同步阻塞IO(BlockingIO):即传统的IO模型。 同步非阻塞IO(Non-blockingIO):默认创建的socket都是阻塞的,非阻塞IO要求socket被设置为NONBLOCK。注意这里所说的NIO并非Java...
  • 浅析javaIO的原理过程

    万次阅读 2019-01-26 06:51:27
    IO流用来处理设备之间的数据...java.io包下提供了各种“流”类和接口,用以获取不同种类的数据,并通过标准的方法输入或输出数据。 输入input:读取外部数据(磁盘、光盘等存储设备的数据)到程序(内存)中。 输...
  • java IO流传输图片

    千次阅读 2019-09-25 22:59:19
    本次传输是基于TCP协议进行传输,其实传输图片的写法和传输文件的...import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.FileInputStream; import java.io.IOException; imp...
  • java IO流学习总结

    万次阅读 多人点赞 2018-09-09 13:24:22
    学习了几天的java IO流,下面我来谈谈对java 输入输出流IO的个人见解吧! 转载自:https://blog.csdn.net/zhaoyanjun6/article/details/54292148/ java流类结构图 一.流的概念: 流是一组有顺序的,有起点和...
  • JavaIO——IO概述

    万次阅读 多人点赞 2018-08-23 10:36:55
    Java Io原理 IO流用来处理设备之间的数据传输,Java程序中,对于数据的输入/输出操作 都是以“流”的方式进行的。java.io包下提供了各种“流”类的接口,用以获取不同种类的数据,并...
  • Java IO流精讲下

    2019-12-10 13:46:14
    本门课程深入浅出的讲解了JavaIO流中的高级部分内容,主要内容有: l  LineNumberReader流 l  数据输入输出流(DataInputStream和DataOutputStream) l  内存操作流   &...
  • java IO流的概念理解

    万次阅读 多人点赞 2018-04-26 19:07:01
    1.Java Io流的概念,分类,类图。 1.1 Java Io流的概念     javaio是实现输入和输出的基础,可以方便的实现数据的输入和输出操作。在java中把不同的输入/输出源(键盘,文件,网络连接等)抽象表述为“流”...
  • Java IO层次体系结构

    千次阅读 多人点赞 2018-10-10 16:29:12
    在整个Java.io包中最重要的就是5个类和一个接口。5个类指的是File、OutputStream、InputStream、Writer、Reader;一个接口指的是Serializable.掌握了这些IO的核心操作那么对于Java中的IO体系也就有了一个初步的认识...
  • 原理:从已有文件中读取字节,将该字节写出到另一个文件中 代码如下: public class Main { public static void main(String[] args) throws IOException { FileInputStream fis = new FileInputStream("a.flac");...
  • Java IO流处理 面试题汇总

    万次阅读 多人点赞 2018-01-27 22:17:36
    说明:本节内容来源于网络汇总 输入输出流是相对于内存而言的! ...(1)java中有几种类型的流?...字节流继承inputStream...(2)谈谈Java IO里面的常见类,字节流,字符流、接口、实现类、方法阻塞 答:输入流就...
  • Java IO流学习总结一:输入输出流

    万次阅读 多人点赞 2017-01-09 19:49:50
    Java IO流学习总结一:输入输出流 转载请标明出处:http://blog.csdn.net/zhaoyanjun6/article/details/53761199 本文出自【赵彦军的博客】 Java流类图结构:流的概念和作用流是一组有顺序的,有起点和终点的字节...
  • Java io流使用相对路径读取文件

    千次阅读 2019-12-08 11:46:05
    前言: 在大多数时候我们会需要Java程序读取某个文件,不采用绝对路径读取文件,而采用相对路径读取。方法如下: 在工程目录下读取文件: 文件目录: /** * 工程目录下的相对路径读取文件数据 */ public ...
  • Java IO流经典练习题

    万次阅读 多人点赞 2016-09-19 09:10:05
    本文对javaIO流的练习题做了比较详细的解答,其中有比较基础的,也有比较繁琐的,都是可以加深对javaIO流的全面的理解
  • Java IO 和 NIO的区别

    万次阅读 多人点赞 2018-07-08 20:49:46
    主要区别IONIO面向字节流面向缓冲区阻塞基于Selector的非阻塞Java IO 和 NIO的主要区别体现在以上两个方面,以下详细说明这些区别的具体含义。面向流和面向缓冲区这个概念和编程方法中的面向过程、面向对象类似。...
  • Java IO流知识点总结

    千次阅读 多人点赞 2016-09-18 13:55:40
    本主要对javaIO流知识点做比较全面的总结,但是没有很深入阐述。
  • 新手小白学JAVA IO流 File 字节流 字符流

    万次阅读 多人点赞 2021-05-17 22:23:59
    IO简介 1 流Stream 在学习IO流之前,我们首先需要学习的概念就是Stream流 为了方便理解,我们可以把数据的读写...在java中,根据处理的数据单位不同,可以把流分为字节流和字符流 字节流 : 针对二进制文件 字符流 : 针对
  • Java IO流实现下载文件

    千次阅读 2018-03-15 09:59:49
    @RequestMapping(value = "download") public String download(HttpServletResponse response, Model model) { //通过文件名找出文件的所在目录 String URL = "D:/one/two.txt"...
  • Java IO之文件读取

    千次阅读 2018-07-25 19:41:05
    同步阻塞IOJAVA BIO):   服务器实现模式为一个连接一个线程,每当客户端 有连接请求时服务器端就需要启动一个线程进行处理 。而且服务器需要一直处于等待状态,一直在 accept();。如果这个连接不做任何事...
  • JavaIO流之创建文件

    千次阅读 2019-06-28 14:42:05
    import java.io.File; public class Test { public static void main(String[] args) throws Exception { // TODO Auto-generated method stub // File(String pathname):将一个字符串路径封装成Fi...
  • Java IO流的关闭顺序

    千次阅读 2018-10-24 20:05:57
    做后台开发跑批任务开发时(需要每天生成一个文件) IO流操作注意以下几点: 编码格式utf-8 在finally中对流进行...关闭流时需要遵循先开后关的原则,否则会异常“java.io.IOException:Stream Closed” ...
  • java IO流——创建文件并修改文件名

    千次阅读 2019-05-16 11:00:07
    package ... import java.io.File; import java.io.IOException; public class RenameTo { public static void main(String[] args) throws IOException { File f=new File("D:\\nte.txt"); i...
  • Java IO输入输出及乱码问题

    千次阅读 2018-08-22 20:32:20
    import java.io.BufferedReader; import java.io.FileReader; import java.io.IOException; public class File { public static void main(String[] args) { try(BufferedReader br =new BufferedReader...
  • Java IO流自动关闭

    千次阅读 2018-07-04 09:18:17
    File f = new File();File des = new File();try (FileInputStream input = new FileInputStream(f); FileOutputStream out = new FileOutputStream(des);) { } catch (FileNotFoundException e1)... } catch (IO...
  • java IO流方式上传下载文件,源代码

    热门讨论 2008-10-16 15:26:14
    java IO流方式上传下载文件源代码,2个JSP程序都经过测试通过,并在真实项目中使用。
  • java io实现文件复制

    千次阅读 2018-02-06 18:05:27
    import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; im....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,561,190
精华内容 624,476
关键字:

javaio

java 订阅