基于Java回顾之I/O的使用详解

  工作后,使用的技术随着项目的变化而变化,时而C#,时而Java,当然还有其他一些零碎的技术。总体而言,C#的使用时间要更长一些,其次是Java。我本身对语言没有什么倾向性,能干活的语言,就是好语言。而且从面向对象的角度来看,我觉得C#和Java对我来说,没什么区别。

  这篇文章主要回顾Java中和I/O操作相关的内容,I/O也是编程语言的一个基础特性,Java中的I/O分为两种类型,一种是顺序读取,一种是随机读取。

  我们先来看顺序读取,有两种方式可以进行顺序读取,一种是InputStream/OutputStream,它是针对字节进行操作的输入输出流;另外一种是Reader/Writer,它是针对字符进行操作的输入输出流。

  下面我们画出InputStream的结构

FileInputStream:操作文件,经常和BufferedInputStream一起使用
    PipedInputStream:可用于线程间通信
    ObjectInputStream:可用于对象序列化
    ByteArrayInputStream:用于处理字节数组的输入
    LineNumberInputStream:可输出当前行数,并且可以在程序中进行修改

  下面是OutputStream的结构

PrintStream:提供了类似print和println的接口去输出数据

  下面我们来看如何使用Stream的方式来操作输入输出

使用InputStream读取文件


代码如下:

使用FileInputStream读取文件信息
 public static byte[] readFileByFileInputStream(File file) throws IOException
 {
     ByteArrayOutputStream output = new ByteArrayOutputStream();
     FileInputStream fis = null;
     try
     {
         fis = new FileInputStream(file);
         byte[] buffer = new byte[1024];
         int bytesRead = 0;
         while((bytesRead = fis.read(buffer, 0, buffer.length)) != -1)
         {
             output.write(buffer, 0, bytesRead);
         }
     }
     catch(Exception ex)
     {
         System.out.println("Error occurs during reading " + file.getAbsoluteFile());
     }
     finally
     {
         if (fis !=null) fis.close();
         if (output !=null) output.close();
     }
     return output.toByteArray();
 }

使用BufferedInputStream读取文件


代码如下:

public static byte[] readFileByBufferedInputStream(File file) throws Exception
 {
     FileInputStream fis = null;
     BufferedInputStream bis = null;
     ByteArrayOutputStream output = new ByteArrayOutputStream();
     try
     {
         fis = new FileInputStream(file);
         bis = new BufferedInputStream(fis);
         byte[] buffer = new byte[1024];
         int bytesRead = 0;
         while((bytesRead = bis.read(buffer, 0, buffer.length)) != -1)
         {
             output.write(buffer, 0, bytesRead);
         }
     }
     catch(Exception ex)
     {
         System.out.println("Error occurs during reading " + file.getAbsoluteFile());
     }
     finally
     {
         if (fis != null) fis.close();
         if (bis != null) bis.close();
         if (output != null) output.close();
     }
     return output.toByteArray();
 }

使用OutputStream复制文件


代码如下:

使用FileOutputStream复制文件
 public static void copyFileByFileOutputStream(File file) throws IOException
 {
     FileInputStream fis = null;
     FileOutputStream fos = null;
     try
     {
         fis = new FileInputStream(file);
         fos = new FileOutputStream(file.getName() + ".bak");
         byte[] buffer = new byte[1024];
         int bytesRead = 0;
         while((bytesRead = fis.read(buffer,0,buffer.length)) != -1)
         {
             fos.write(buffer, 0, bytesRead);
         }
         fos.flush();
     }
     catch(Exception ex)
     {
         System.out.println("Error occurs during copying " + file.getAbsoluteFile());
     }
     finally
     {
         if (fis != null) fis.close();
         if (fos != null) fos.close();
     }
 }

代码如下:

使用BufferedOutputStream复制文件
 public static void copyFilebyBufferedOutputStream(File file)throws IOException
 {
     FileInputStream fis = null;
     BufferedInputStream bis = null;
     FileOutputStream fos = null;
     BufferedOutputStream bos = null;
     try
     {
         fis = new FileInputStream(file);
         bis = new BufferedInputStream(fis);
         fos = new FileOutputStream(file.getName() + ".bak");
         bos = new BufferedOutputStream(fos);
         byte[] buffer = new byte[1024];
         int bytesRead = 0;
         while((bytesRead = bis.read(buffer, 0, buffer.length)) != -1)
         {
             bos.write(buffer, 0, bytesRead);
         }
         bos.flush();
     }
     catch(Exception ex)
     {
         System.out.println("Error occurs during copying " + file.getAbsoluteFile());
     }
     finally
     {
         if (fis != null) fis.close();
         if (bis != null) bis.close();
         if (fos != null) fos.close();
         if (bos != null) bos.close();
     }
 }

这里的代码对异常的处理非常不完整,稍后我们会给出完整严谨的代码。

  下面我们来看Reader的结构

这里的Reader基本上和InputStream能够对应上。  

  Writer的结构如下

下面我们来看一些使用Reader或者Writer的例子

使用Reader读取文件内容


代码如下:

使用BufferedReader读取文件内容
 public static String readFile(String file)throws IOException
 {
     BufferedReader br = null;
     StringBuffer sb = new StringBuffer();
     try
     {
         br = new BufferedReader(new FileReader(file));
         String line = null;

while((line = br.readLine()) != null)
         {
             sb.append(line);
         }
     }
     catch(Exception ex)
     {
         System.out.println("Error occurs during reading " + file);
     }
     finally
     {
         if (br != null) br.close();
     }
     return sb.toString();
 }

使用Writer复制文件


代码如下:

使用BufferedWriter复制文件
 public static void copyFile(String file) throws IOException
 {
     BufferedReader br = null;
     BufferedWriter bw = null;
     try
     {
         br = new BufferedReader(new FileReader(file));
         bw = new BufferedWriter(new FileWriter(file + ".bak"));
         String line = null;
         while((line = br.readLine())!= null)
         {
             bw.write(line);
         }
     }
     catch(Exception ex)
     {
         System.out.println("Error occurs during copying " + file);
     }
     finally
     {
         if (br != null) br.close();
         if (bw != null) bw.close();
     }
 }

下面我们来看如何对文件进行随机访问,Java中主要使用RandomAccessFile来对文件进行随机操作。

创建一个大小固定的文件


代码如下:

创建大小固定的文件
 public static void createFile(String file, int size) throws IOException
 {
     File temp = new File(file);
     RandomAccessFile raf = new RandomAccessFile(temp, "rw");
     raf.setLength(size);
     raf.close();
 }

向文件中随机写入数据


代码如下:

向文件中随机插入数据
 public static void writeFile(String file, byte[] content, int startPos, int contentLength) throws IOException
 {
     RandomAccessFile raf = new RandomAccessFile(new File(file), "rw");
     raf.seek(startPos);
     raf.write(content, 0, contentLength);
     raf.close();
 }

接下里,我们来看一些其他的常用操作

移动文件


代码如下:

移动文件
 public static boolean moveFile(String sourceFile, String destFile)
 {
     File source = new File(sourceFile);
     if (!source.exists()) throw new RuntimeException("source file does not exist.");
     File dest = new File(destFile);
     if (!(new File(dest.getPath()).exists())) new File(dest.getParent()).mkdirs();
     return source.renameTo(dest);
 }

复制文件


代码如下:

复制文件
 public static void copyFile(String sourceFile, String destFile) throws IOException
 {
     File source = new File(sourceFile);
     if (!source.exists()) throw new RuntimeException("File does not exist.");
     if (!source.isFile()) throw new RuntimeException("It is not file.");
     if (!source.canRead()) throw new RuntimeException("File cound not be read.");
     File dest = new File(destFile);
     if (dest.exists())
     {
         if (dest.isDirectory()) throw new RuntimeException("Destination is a folder.");
         else
         {
             dest.delete();
         }
     }
     else
     {
         File parentFolder = new File(dest.getParent());
         if (!parentFolder.exists()) parentFolder.mkdirs();
         if (!parentFolder.canWrite()) throw new RuntimeException("Destination can not be written.");
     }
     FileInputStream fis = null;
     FileOutputStream fos = null;
     try
     {
         fis = new FileInputStream(source);
         fos = new FileOutputStream(dest);
         byte[] buffer = new byte[1024];
         int bytesRead = 0;
         while((bytesRead = fis.read(buffer, 0, buffer.length)) != -1)
         {
             fos.write(buffer, 0, bytesRead);
         }
         fos.flush();
     }
     catch(IOException ex)
     {
         System.out.println("Error occurs during copying " + sourceFile);
     }
     finally
     {
         if (fis != null) fis.close();
         if (fos != null) fos.close();
     }
 }

复制文件夹


代码如下:

复制文件夹
 public static void copyDir(String sourceDir, String destDir) throws IOException
 {

File source = new File(sourceDir);
     if (!source.exists()) throw new RuntimeException("Source does not exist.");
     if (!source.canRead()) throw new RuntimeException("Source could not be read.");
     File dest = new File(destDir);
     if (!dest.exists()) dest.mkdirs();

File[] arrFiles = source.listFiles();
     for(int i = 0; i < arrFiles.length; i++)
     {
         if (arrFiles[i].isFile())
         {
             BufferedReader reader = new BufferedReader(new FileReader(arrFiles[i]));
             BufferedWriter writer = new BufferedWriter(new FileWriter(destDir + "/" + arrFiles[i].getName()));
             String line = null;
             while((line = reader.readLine()) != null) writer.write(line);
             writer.flush();
             reader.close();
             writer.close();
         }
         else
         {
             copyDir(sourceDir + "/" + arrFiles[i].getName(), destDir + "/" + arrFiles[i].getName());
         }
     }
 }

删除文件夹


代码如下:

删除文件夹
 public static void del(String filePath)
 {
     File file = new File(filePath);
     if (file == null || !file.exists()) return;
     if (file.isFile())
     {
         file.delete();
     }
     else
     {
         File[] arrFiles = file.listFiles();
         if (arrFiles.length > 0)
         {
             for(int i = 0; i < arrFiles.length; i++)
             {
                 del(arrFiles[i].getAbsolutePath());
             }
         }
         file.delete();
     }
 }

获取文件夹大小


代码如下:

获取文件夹大小
 public static long getFolderSize(String dir)
 {
     long size = 0;
     File file = new File(dir);
     if (!file.exists()) throw new RuntimeException("dir does not exist.");
     if (file.isFile()) return file.length();
     else
     {
         String[] arrFileName = file.list();
         for (int i = 0; i < arrFileName.length; i++)
         {
             size += getFolderSize(dir + "/" + arrFileName[i]);
         }
     }

return size;
 }

将大文件切分为多个小文件


代码如下:

将大文件切分成多个小文件
 public static void splitFile(String filePath, long unit) throws IOException
 {
     File file = new File(filePath);
     if (!file.exists()) throw new RuntimeException("file does not exist.");
     long size = file.length();
     if (unit >= size) return;
     int count = size % unit == 0 ? (int)(size/unit) : (int)(size/unit) + 1;
     String newFile = null;
     FileOutputStream fos = null;
     FileInputStream fis =null;
     byte[] buffer = new byte[(int)unit];
     fis = new FileInputStream(file);
     long startPos = 0;
     String countFile = filePath + "_Count";
     PrintWriter writer = new PrintWriter(new FileWriter( new File(countFile)));
     writer.println(filePath + "\t" + size);
     for (int i = 1; i <= count; i++)
     {
         newFile = filePath + "_" + i;
         startPos = (i - 1) * unit;
         System.out.println("Creating " + newFile);
         fos = new FileOutputStream(new File(newFile));
         int bytesRead = fis.read(buffer, 0, buffer.length);
         if (bytesRead != -1)
         {
             fos.write(buffer, 0, bytesRead);
             writer.println(newFile + "\t" + startPos + "\t" + bytesRead);
         }
         fos.flush();
         fos.close();
         System.out.println("StartPos:" + i*unit + "; EndPos:" + (i*unit + bytesRead));
     }
     writer.flush();
     writer.close();
     fis.close();
 }

将多个小文件合并为一个大文件


代码如下:

将多个小文件合并成一个大文件
 public static void linkFiles(String countFile) throws IOException
 {
     File file = new File(countFile);
     if (!file.exists()) throw new RuntimeException("Count file does not exist.");
     BufferedReader reader = new BufferedReader(new FileReader(file));
     String line = reader.readLine();
     String newFile = line.split("\t")[0];
     long size = Long.parseLong(line.split("\t")[1]);
     RandomAccessFile raf = new RandomAccessFile(newFile, "rw");
     raf.setLength(size);
     FileInputStream fis = null;
     byte[] buffer = null;

while((line = reader.readLine()) != null)
     {
         String[] arrInfo = line.split("\t");
         fis = new FileInputStream(new File(arrInfo[0]));
         buffer = new byte[Integer.parseInt(arrInfo[2])];
         long startPos = Long.parseLong(arrInfo[1]);
         fis.read(buffer, 0, Integer.parseInt(arrInfo[2]));
         raf.seek(startPos);
         raf.write(buffer, 0, Integer.parseInt(arrInfo[2]));
         fis.close();
     }
     raf.close();
 }

执行外部命令


代码如下:

执行外部命令
 public static void execExternalCommand(String command, String argument)
 {
     Process process = null;
     try
     {
         process = Runtime.getRuntime().exec(command + " " + argument);
         InputStream is = process.getInputStream();
         BufferedReader br = new BufferedReader(new InputStreamReader(is));
         String line = null;
         while((line = br.readLine()) != null)
         {
             System.out.println(line);
         }
     }
     catch(Exception ex)
     {
         System.err.println(ex.getMessage());
     }
     finally
     {
         if (process != null) process.destroy();
     }
 }

(0)

相关推荐

  • java基础知识I/O流使用详解

    "流"概念源于UNIX中的管道(pipe)的概念.在UNIX中,管道是一条不间断的字节流,用来实现程序或进程间的通信,或读写外围设备.外部文件等,它屏蔽了实际的I/O设备中处理数据的细节.   一个流,必有源端和目的端,它们可以是计算机内存的某些区域,也可以是磁盘文件,甚至可以是Internet上的某个URL. 流的方向是重要的,根据流的方向,流可以分为两类:输入流和输出流.其实输入/输出是想对于内存来说的.实际上,流的源端和目的端可简单地看成是字节的生产者和消费者,对于输入流,可不必

  • Java I/O 操作及优化详细介绍

    概要: 流是一组有顺序的,有起点和终点的字节集合,是对数据传输的总称或抽象.即数据在两设备间的传输称为流,流的本质是数据传输,根据数据传输特性将流抽象为各种类,方便更直观的进行数据操作. Java I/O I/O,即 Input/Output(输入/输出) 的简称.就 I/O 而言,概念上有 5 种模型:blocking I/O,nonblocking I/O,I/O multiplexing (select and poll),signal driven I/O (SIGIO),asynchr

  • Java I/O技术之文件操作详解

    在java程序设计中,I/O操作是通过java.io包中的类和接口来实现的,因此,我们第一步要做的就是import这个包. java.io提供了一个File类,这是类很容易让人产生误会,它表示的是一个文件名或者目录名,而不是文件本身,所以通过这个类没法对文件里面的数据进行操作.File类提供了一序列对文件操作的功能:删除文件,创建目录,查询文件大小等等.要想对文件数据进行操作那就需要流对象了,在这里就暂时不做介绍. 下面通过一个叫做FileExtension类来对File类中的各种操作进行封装,

  • 基于Java回顾之多线程同步的使用详解

    首先阐述什么是同步,不同步有什么问题,然后讨论可以采取哪些措施控制同步,接下来我们会仿照回顾网络通信时那样,构建一个服务器端的"线程池",JDK为我们提供了一个很大的concurrent工具包,最后我们会对里面的内容进行探索. 为什么要线程同步? 说到线程同步,大部分情况下, 我们是在针对"单对象多线程"的情况进行讨论,一般会将其分成两部分,一部分是关于"共享变量",一部分关于"执行步骤". 共享变量 当我们在线程对象(Run

  • 基于Java回顾之I/O的使用详解

    工作后,使用的技术随着项目的变化而变化,时而C#,时而Java,当然还有其他一些零碎的技术.总体而言,C#的使用时间要更长一些,其次是Java.我本身对语言没有什么倾向性,能干活的语言,就是好语言.而且从面向对象的角度来看,我觉得C#和Java对我来说,没什么区别. 这篇文章主要回顾Java中和I/O操作相关的内容,I/O也是编程语言的一个基础特性,Java中的I/O分为两种类型,一种是顺序读取,一种是随机读取. 我们先来看顺序读取,有两种方式可以进行顺序读取,一种是InputStream/Ou

  • 基于Java中进制的转换函数详解

    十进制转成十六进制: Integer.toHexString(int i) 十进制转成八进制 Integer.toOctalString(int i) 十进制转成二进制 Integer.toBinaryString(int i) 十六进制转成十进制 Integer.valueOf("FFFF",16).toString() 八进制转成十进制 Integer.valueOf("876",8).toString() 二进制转十进制 Integer.valueOf(&qu

  • 基于Java中throw和throws的区别(详解)

    系统自动抛出的异常 所有系统定义的编译和运行异常都可以由系统自动抛出,称为标准异常,并且 Java 强烈地要求应用程序进行完整的异常处理,给用户友好的提示,或者修正后使程序继续执行. 语句抛出的异常 用户程序自定义的异常和应用程序特定的异常,必须借助于 throws 和 throw 语句来定义抛出异常. throw是语句抛出一个异常. 语法:throw (异常对象); throw e; throws是方法可能抛出异常的声明.(用在声明方法时,表示该方法可能要抛出异常) 语法:[(修饰符)](返回

  • 基于java解析JSON的三种方式详解

    本文实例分析了基于java解析JSON的三种方式.分享给大家供大家参考,具体如下: 一.什么是JSON? JSON是一种取代XML的数据结构,和xml相比,它更小巧但描述能力却不差,由于它的小巧所以网络传输数据将减少更多流量从而加快速度. JSON就是一串字符串 只不过元素会使用特定的符号标注. {} 双括号表示对象 [] 中括号表示数组 "" 双引号内是属性或值 : 冒号表示后者是前者的值(这个值可以是字符串.数字.也可以是另一个数组或对象) 所以 {"name"

  • Spring中基于Java的配置@Configuration和@Bean用法详解

    一.首先,需要xml中进行少量的配置来启动Java配置: <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://ww

  • 基于Java class对象说明、Java 静态变量声明和赋值说明(详解)

    先看下JDK中的说明: java.lang.Object java.lang.Class<T> Instances of the class Class represent classes and interfaces in a running Java application. An enum is a kind of class and an annotation is a kind of interface. Every array also belongs to a class tha

  • Java基于装饰者模式实现的染色馒头案例详解

    本文实例讲述了Java基于装饰者模式实现的染色馒头案例.分享给大家供大家参考,具体如下: 一.模式定义 装饰者模式,是在不改变原类文件和使用继承的情况下,动态扩展一个对象功能,它是通过创建一个包装对象,也就是装饰来包装真实的对象. 装饰对象和真实对象有相同接口,这样客户端对象就可以和真实对象相同方式和装饰对象交互. 装饰对象包含一个真实对象的引用. 二.模式举例 1. 模式分析 我们借用黑心商贩制做染色馒头案例说明这一模式. 2. 装饰者模式静态类图 3. 代码示例 3.1 创建馒头接口--IB

  • Java基于享元模式实现五子棋游戏功能实例详解

    本文实例讲述了Java基于享元模式实现五子棋游戏功能.分享给大家供大家参考,具体如下: 一.模式定义 享元模式,以共享的方式高效地支持大量的细粒度对象.通过复用内存中已存在的对象,降低系统创建对象实例的性能消耗.享元的英文是Flyweight,表示特别小的对象,即细粒度对象. 二.模式举例 1. 模式分析 我们借用五子棋游戏来说明这一模式. 2. 享元模式静态类图 3. 代码示例 3.1 创建抽象棋子一AbstractChessman package com.demo.flyweight.obj

  • Java 自定义Spring框架与核心功能详解

    目录 Spring核心功能结构 核心容器 spring-beans和spring-core模块 spring-context模块 spring-context-support模块 spring-context-indexer模块 spring-expression模块 AOP和设备支持 数据访问与集成 Web组件 通信报文 集成测试 bean概述 在上一讲中,我们对Spring的基本使用进行了一个简单的回顾,接下来,我们就来看一下Spring核心功能结构. Spring核心功能结构 Spring

随机推荐