Java基础知识回顾-3 输入输出流

 Java基础知识回顾-3 输入输出流

http://tianya23.blog.51cto.com/1081650/406824

代码风格：http://svn.alibaba-inc.com/repos/ali_platform/spec/codestyle/

RandomAccessFile：支持随机读取，随意在文件内跳转，操作灵活但需要计算跳转的位置等

写入：

import java.io.File ;
import java.io.RandomAccessFile ;
public class RandomAccessFileDemo01{
    // 所有的异常直接抛出，程序中不再进行处理
    public static void main(String args[]) throws Exception{
        File f = new File("d:" + File.separator + "test.txt") ; // 指定要操作的文件
        RandomAccessFile rdf = null ;       // 声明RandomAccessFile类的对象
        rdf = new RandomAccessFile(f,"rw") ;// 读写模式，如果文件不存在，会自动创建
        String name = null ;
        int age = 0 ;
        name = "zhangsan" ;         // 字符串长度为8
        age = 30 ;                  // 数字的长度为4
        rdf.writeBytes(name) ;      // 将姓名写入文件之中
        rdf.writeInt(age) ;         // 将年龄写入文件之中
        name = "lisi    " ;         // 字符串长度为8
        age = 31 ;                  // 数字的长度为4
        rdf.writeBytes(name) ;      // 将姓名写入文件之中
        rdf.writeInt(age) ;         // 将年龄写入文件之中
        name = "wangwu  " ;         // 字符串长度为8
        age = 32 ;                  // 数字的长度为4
        rdf.writeBytes(name) ;      // 将姓名写入文件之中
        rdf.writeInt(age) ;         // 将年龄写入文件之中
        rdf.close() ;               // 关闭
    }
};

读取：

import java.io.File ;
import java.io.RandomAccessFile ;
public class RandomAccessFileDemo02{
    // 所有的异常直接抛出，程序中不再进行处理
    public static void main(String args[]) throws Exception{
        File f = new File("d:" + File.separator + "test.txt") ; // 指定要操作的文件
        RandomAccessFile rdf = null ;       // 声明RandomAccessFile类的对象
        rdf = new RandomAccessFile(f,"r") ;// 以只读的方式打开文件
        String name = null ;
        int age = 0 ;
        byte b[] = new byte[8] ;    // 开辟byte数组
        // 读取第二个人的信息，意味着要空出第一个人的信息
        rdf.skipBytes(12) ;     // 跳过第一个人的信息
        for(int i=0;i<b.length;i++){
            b[i] = rdf.readByte() ; // 读取一个字节
        }
        name = new String(b) ;  // 将读取出来的byte数组变为字符串
        age = rdf.readInt() ;   // 读取数字
        System.out.println("第二个人的信息 --> 姓名：" + name + "；年龄：" + age) ;
        // 读取第一个人的信息
        rdf.seek(0) ;   // 指针回到文件的开头
        for(int i=0;i<b.length;i++){
            b[i] = rdf.readByte() ; // 读取一个字节
        }
        name = new String(b) ;  // 将读取出来的byte数组变为字符串
        age = rdf.readInt() ;   // 读取数字
        System.out.println("第一个人的信息 --> 姓名：" + name + "；年龄：" + age) ;
        rdf.skipBytes(12) ; // 空出第二个人的信息
        for(int i=0;i<b.length;i++){
            b[i] = rdf.readByte() ; // 读取一个字节
        }
        name = new String(b) ;  // 将读取出来的byte数组变为字符串
        age = rdf.readInt() ;   // 读取数字
        System.out.println("第三个人的信息 --> 姓名：" + name + "；年龄：" + age) ;
        rdf.close() ;               // 关闭
    }
};

 

一、输入流

1、输入流， 从文件中读取内容到byte数组之中， 再截取byte数组中内容， 到结束字符为止

import java.io.File ;
import java.io.InputStream ;
import java.io.FileInputStream ;
public class InputStreamDemo02{
    public static void main(String args[]) throws Exception{    // 异常抛出，不处理
        // 第1步、使用File类找到一个文件
        File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象
        // 第2步、通过子类实例化父类对象
        InputStream input = null ;  // 准备好一个输入的对象
        input = new FileInputStream(f)  ;   // 通过对象多态性，进行实例化
        // 第3步、进行读操作
        byte b[] = new byte[1024] ;     // 所有的内容都读到此数组之中
        int len = input.read(b) ;       // 读取内容
        // 第4步、关闭输出流
        input.close() ;                     // 关闭输出流\
        System.out.println("读入数据的长度：" + len) ;
        System.out.println("内容为：" + new String(b,0,len)) ;  // 把byte数组变为字符串输出
    }
};

2、数组流， 开辟文件内容大小的空间以便读入：byte b[] = new byte[(int)f.length()] ;

import java.io.File ;
import java.io.InputStream ;
import java.io.FileInputStream ;
public class InputStreamDemo03{
    public static void main(String args[]) throws Exception{    // 异常抛出，不处理
        // 第1步、使用File类找到一个文件
        File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象
        // 第2步、通过子类实例化父类对象
        InputStream input = null ;  // 准备好一个输入的对象
        input = new FileInputStream(f)  ;   // 通过对象多态性，进行实例化
        // 第3步、进行读操作
        byte b[] = new byte[(int)f.length()] ;      // 数组大小由文件决定
        int len = input.read(b) ;       // 读取内容
        // 第4步、关闭输出流
        input.close() ;                     // 关闭输出流\
        System.out.println("读入数据的长度：" + len) ;
        System.out.println("内容为：" + new String(b)) ;    // 把byte数组变为字符串输出
    }
};

3、

import java.io.File ;
import java.io.InputStream ;
import java.io.FileInputStream ;
public class InputStreamDemo04{
    public static void main(String args[]) throws Exception{    // 异常抛出，不处理
        // 第1步、使用File类找到一个文件
        File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象
        // 第2步、通过子类实例化父类对象
        InputStream input = null ;  // 准备好一个输入的对象
        input = new FileInputStream(f)  ;   // 通过对象多态性，进行实例化
        // 第3步、进行读操作
        byte b[] = new byte[(int)f.length()] ;      // 数组大小由文件决定
        for(int i=0;i<b.length;i++){
            b[i] = (byte)input.read() ;     // 读取内容
        }
        // 第4步、关闭输出流
        input.close() ;                     // 关闭输出流\
        System.out.println("内容为：" + new String(b)) ;    // 把byte数组变为字符串输出
    }
};

4、

import java.io.File ;
import java.io.InputStream ;
import java.io.FileInputStream ;
public class InputStreamDemo05{
    public static void main(String args[]) throws Exception{    // 异常抛出，不处理
        // 第1步、使用File类找到一个文件
        File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象
        // 第2步、通过子类实例化父类对象
        InputStream input = null ;  // 准备好一个输入的对象
        input = new FileInputStream(f)  ;   // 通过对象多态性，进行实例化
        // 第3步、进行读操作
        byte b[] = new byte[1024] ;     // 数组大小由文件决定
        int len = 0 ;
        int temp = 0 ;          // 接收每一个读取进来的数据
        while((temp=input.read())!=-1){
            // 表示还有内容，文件没有读完
            b[len] = (byte)temp ;
            len++ ;
        }
        // 第4步、关闭输出流
        input.close() ;                     // 关闭输出流\
        System.out.println("内容为：" + new String(b,0,len)) ;  // 把byte数组变为字符串输出
    }
};

二、输出流

1、

import java.io.File ;
import java.io.OutputStream ;
import java.io.FileOutputStream ;
public class OutputStreamDemo01{
    public static void main(String args[]) throws Exception{    // 异常抛出，不处理
        // 第1步、使用File类找到一个文件
        File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象
        // 第2步、通过子类实例化父类对象
        OutputStream out = null ;   // 准备好一个输出的对象
        out = new FileOutputStream(f)  ;    // 通过对象多态性，进行实例化
        // 第3步、进行写操作
        String str = "Hello World!!!" ;     // 准备一个字符串
        byte b[] = str.getBytes() ;         // 只能输出byte数组，所以将字符串变为byte数组
        out.write(b) ;                      // 将内容输出，保存文件
        // 第4步、关闭输出流
        out.close() ;                       // 关闭输出流
    }
};

2、

import java.io.File ;
import java.io.OutputStream ;
import java.io.FileOutputStream ;
public class OutputStreamDemo02{
    public static void main(String args[]) throws Exception{    // 异常抛出，不处理
        // 第1步、使用File类找到一个文件
        File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象
        // 第2步、通过子类实例化父类对象
        OutputStream out = null ;   // 准备好一个输出的对象
        out = new FileOutputStream(f)  ;    // 通过对象多态性，进行实例化
        // 第3步、进行写操作
        String str = "Hello World!!!" ;     // 准备一个字符串
        byte b[] = str.getBytes() ;         // 只能输出byte数组，所以将字符串变为byte数组
        for(int i=0;i<b.length;i++){        // 采用循环方式写入
            out.write(b[i]) ;   // 每次只写入一个内容
        }
        // 第4步、关闭输出流
        out.close() ;                       // 关闭输出流
    }
};

3、

import java.io.File ;
import java.io.OutputStream ;
import java.io.FileOutputStream ;
public class OutputStreamDemo03{
    public static void main(String args[]) throws Exception{    // 异常抛出，不处理
        // 第1步、使用File类找到一个文件
        File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象
        // 第2步、通过子类实例化父类对象
        OutputStream out = null ;   // 准备好一个输出的对象
        out = new FileOutputStream(f,true)  ;   // 此处表示在文件末尾追加内容
        // 第3步、进行写操作
        String str = "Hello World!!!" ;     // 准备一个字符串
        byte b[] = str.getBytes() ;         // 只能输出byte数组，所以将字符串变为byte数组
        for(int i=0;i<b.length;i++){        // 采用循环方式写入
            out.write(b[i]) ;   // 每次只写入一个内容
        }
        // 第4步、关闭输出流
        out.close() ;                       // 关闭输出流
    }
};

4、

import java.io.File ;
import java.io.OutputStream ;
import java.io.FileOutputStream ;
public class OutputStreamDemo04{
    public static void main(String args[]) throws Exception{    // 异常抛出，不处理
        // 第1步、使用File类找到一个文件
        File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象
        // 第2步、通过子类实例化父类对象
        OutputStream out = null ;   // 准备好一个输出的对象
        out = new FileOutputStream(f,true)  ;   // 此处表示在文件末尾追加内容
        // 第3步、进行写操作
        String str = "\r\nHello World!!!" ;     // 准备一个字符串
        byte b[] = str.getBytes() ;         // 只能输出byte数组，所以将字符串变为byte数组
        for(int i=0;i<b.length;i++){        // 采用循环方式写入
            out.write(b[i]) ;   // 每次只写入一个内容
        }
        // 第4步、关闭输出流
        out.close() ;                       // 关闭输出流
    }
};

5、

import java.io.File ;
import java.io.OutputStream ;
import java.io.FileOutputStream ;
public class OutputStreamDemo05{
    public static void main(String args[]) throws Exception{    // 异常抛出，不处理
        // 第1步、使用File类找到一个文件
        File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象
        // 第2步、通过子类实例化父类对象
        OutputStream out = null ;   // 准备好一个输出的对象
        out = new FileOutputStream(f)  ;    // 实例化
        // 第3步、进行写操作
        String str = "Hello World!!!" ;     // 准备一个字符串
        byte b[] = str.getBytes() ;         // 只能输出byte数组，所以将字符串变为byte数组
        out.write(b) ;      // 写入数据
        // 第4步、关闭输出流
        // out.close() ;                        // 关闭输出流
    }
};

三、输入输出流转换

 （1）对象的输入输出流ObjectOutputStream、ObjectInputStream， 可以序列化对象或反序列化对象

【注意】（1）必须实现Serializable接口 （2）序列化的类不能是内部类

Student student = new Student();
    student.setName("zhangsan");
    student.setAge(10);

    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(new File("d:" + File.separator + "test.txt")));
    oos.writeObject(student);
    oos.close();

    ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("d:" + File.separator + "test.txt")));
    Student stu = (Student) ois.readObject();
    System.out.println(stu.getName() + "\t" + stu.getAge());
    ois.close();

 （2）序列化和反序列化一组对象

public class SerDemo{
    public static void main(String args[]) throws Exception{
        Person per[] = {new Person("张三",30),new Person("李四",31),
            new Person("王五",32)} ;
        ser(per) ;
        Object o[] = (Object[])dser() ;
        for(int i=0;i<o.length;i++){
            Person p = (Person)o[i] ;
            System.out.println(p) ;
        }
    }
    public static void ser(Object obj[]) throws Exception {
        File f = new File("D:" + File.separator + "test.txt") ; // 定义保存路径
        ObjectOutputStream oos = null ; // 声明对象输出流
        OutputStream out = new FileOutputStream(f) ;    // 文件输出流
        oos = new ObjectOutputStream(out) ;
        oos.writeObject(obj) ;  // 保存对象
        oos.close() ;   // 关闭
    }
    public static Object[] dser() throws Exception {
        File f = new File("D:" + File.separator + "test.txt") ; // 定义保存路径
        ObjectInputStream ois = null ;  // 声明对象输入流
        InputStream input = new FileInputStream(f) ;    // 文件输入流
        ois = new ObjectInputStream(input) ;    // 实例化对象输入流
        Object obj[] = (Object[])ois.readObject() ; // 读取对象
        ois.close() ;   // 关闭
        return obj ;
    }
};

 

 

四、文件的拷贝

（1）本地文件的拷贝

JDK中没有提供文件拷贝的相关方法，apache的commons下面有关于File的扩展FileUtils可以做到。具体参考如下链接：http://commons.apache.org/io/api-release/index.html

 （2）远程文件拷贝（大致思路：InputStream -> HttpURLConnection -> OutputStream）

public class HttpDistributeFileReceiverImpl implements DistributeFileReceiver {

    private static final Log logger = LogFactory.getLog(HttpDistributeFileReceiverImpl.class);

    public void receive(String targetURL, String targetFileType, String targetDirPath, String targetFileNamePrefix) throws FileReceiveException {

        if (!isParameterValid(targetDirPath) || !isParameterValid(targetFileNamePrefix) || !isParameterValid(targetURL) || !isParameterValid(targetFileType)) {
            if (logger.isInfoEnabled()) {
                logger.info("parameter is invalid!");
            }
            return;
        }

        if (logger.isDebugEnabled()) {
            logger.debug("download from " + targetURL);
        }

        try {
            prepare(targetDirPath);
        } catch (PrepareDistributeEnvException e) {
            throw new FileReceiveException(e);
        }

        String newTargetFileName = targetFileNamePrefix + ".tar";
        String targetFileFullPath = targetDirPath + File.separator + newTargetFileName;
        File targetFile = null;
        FileOutputStream outputStream = null;

        try {
            targetFile = new File(targetFileFullPath);
            if (logger.isDebugEnabled()) {
                logger.debug("create file '" + targetFileFullPath + "' ......");
            }
            outputStream = new FileOutputStream(targetFile);
        } catch (FileNotFoundException e) {
            throw new FileReceiveException(e);
        }


        URL url = null;
        try {
            url = new URL(targetURL);
        } catch (MalformedURLException e) {
            throw new FileReceiveException("download file '" + targetURL + "' failed!", e);
        }

        HttpURLConnection connection = null;
        InputStream inputStream = null;

        try {

            connection = (HttpURLConnection)url.openConnection();
            inputStream = connection.getInputStream();

            byte[] buffer = new byte[1024];
            int len = 0;
            while ((len = inputStream.read(buffer, 0, 1024)) != -1 ) {
                outputStream.write(buffer, 0, len);
            };

            if (logger.isDebugEnabled()) {
                logger.debug("create file '" + targetFileFullPath + "' success!");
            }

        } catch (IOException e) {

            throw new FileReceiveException("download file '" + targetURL + "' failed!", e);

        } finally {
            if (outputStream != null) {
                try {
                    outputStream.close();
                } catch (IOException e) {
                    if (logger.isWarnEnabled()) {
                        logger.warn("close outputStream failed!\n"
                                + ExceptionUtil.getThrowableStackTrace(e));
                    }
                }
            }
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    if (logger.isWarnEnabled()) {
                        logger.warn("close inputStream failed!\n"
                                + ExceptionUtil.getThrowableStackTrace(e));
                    }
                }
            }
            if (connection != null) {
                connection.disconnect();
            }
        }

        try {
            if (MessageConstant.TARGET_PACKAGE_TYPE_FOR_ZIP.equals(targetFileType)) {
                FileUtil.unzip(targetFileFullPath, targetDirPath);
            } else if (MessageConstant.TARGET_PACKAGE_TYPE_FOR_TAR.equals(targetFileType)) {
                FileUtil.untar(targetFileFullPath, targetDirPath);
            } else {
                throw new FileReceiveException("unpackage failed, unknown package file type'" + targetFileType + "'");
            }

        } catch(UnzipFileException e) {
            throw new FileReceiveException(e);
        }

    }

    /**
     * 为预发布准备环境目录
     * @param targetWorkingDir
     * @throws PrepareDistributeEnvException
     */
    private void prepare(String targetWorkingDir) throws PrepareDistributeEnvException{

        if (logger.isDebugEnabled()) {
            logger.debug("try to locate target dir '" + targetWorkingDir + "'");
        }

        File targetDir = new File(targetWorkingDir);

        //if target dir exists
        if (targetDir.exists()) {
            //如果是目录
            if (targetDir.isDirectory()) {
                if (logger.isDebugEnabled()) {
                    logger.debug("target dir '" + targetWorkingDir + "' already exist!");
                }
                //清除目标目录
                try {
                    FileUtil.deleteDirs(targetDir);
                } catch (DeleteDirException e) {
                    throw new PrepareDistributeEnvException("delete target dir failed!", e);
                }

            } else {
                //如果是文件
                if (logger.isDebugEnabled()) {
                    logger.debug("target dir '" + targetWorkingDir + "' alread exists, but is file type");
                }
                //删除同名文件
                targetDir.delete();
            }

            //创建目标文件夹
            if (!targetDir.mkdirs()) {
                if (logger.isDebugEnabled()) {
                    logger.debug("create dir '" + targetWorkingDir + "' failed!");
                }
                throw new PrepareDistributeEnvException("create target dir failed!");
            }

            if (logger.isDebugEnabled()) {
                logger.debug("create target dir '" + targetWorkingDir + "' success!");
            }
            return;

        }

        //if target dir doesn't exist
        if (targetDir.mkdirs()) {
            if (logger.isDebugEnabled()) {
                logger.debug("create target dir '" + targetWorkingDir + "' success!");
            }
            return;
        } else {
            if (logger.isDebugEnabled()) {
                logger.debug("create target target dir '" + targetWorkingDir + "' failed!");
            }
            throw new PrepareDistributeEnvException("create target dir failed!");
        }


    }

    /**
     * 判断模型release包下载路径和参数是否有效
     * @return
     */
    private boolean isParameterValid(String parameter) {

        if (StringUtil.isEmpty(parameter) || StringUtil.isBlank(parameter) ) {

            return false;
        }

        return true;
    }

}