------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! -------    

 

  • IO

  • 常用基类

    字节流 InputStreamOutputStream

    常用方法

    int read() // 读取一个字节,以 int 形式返回

intread(byte[] b) // 读取最多数组长度个字节并存入该数组,返回实际读取字节

    void write(int d) // 写出一个字节

voidwrite(byte[] d) // 将给定字节数组中的所有字节全部写出

    void write(byte[] d, int off, int len) // 将字节数组中指定部分写出

 

    字符流 ReaderWriter

    常用方法

    int read() // 读取一个字符,以 int 形式返回

intread(char[] chs) // 读取最多数组长度个字符并存入数组返回读取有效字符

    void wirte(int c) // 写出一个字符

void write(char[]chs) // 将给定字符数组中所有字符写出

    void write(char[] chs, int offset, int len) // 将字符数组中指定部分写出

voidwirte(String str) // 将给定的字符串写出

voidwirte(String str, int off, int len) // 将字符串中指定部分写出

 

  • 缓冲字符流

    BufferedWriter  缓冲字符输出流

提高字节输出流的效率,继承 OutputStream

    BufferedWriter(Writer writer)

    void newLine() // 写出新换行,具有跨平台特性

 

    BufferedReader  缓冲字符输入流

    BufferedReader(Reader reader)

    String readLine() // 读取一行字符串,直到读取到换行符位置(不包含换行符)

        // 创建FileReader对象,传递字符串文件名

       FileReaderfr = new FileReader("C:\\BufferedDemo.txt");

 

       // 创建缓冲字符输入流对象,传递字符输入流对象

       BufferedReaderbr = new BufferedReader(fr);

 

       // 读取一个文本行

       Stringlen= null;

       while ((len = br.readLine()) != null) {

           System.out.println(len);

       }

      

       br.close();

 

字符串的编码和解码

package cn.itcast;

 

/*

 * 字符串编码和解码

 *  字符串 --> 字节数组

 *  字节数组 --> 字符串

 */

publicclassEncodingDemo {

 

    publicstaticvoid main(String[] args) throws Exception {

      

       // 字符串 --> 字节数组

       byte[] bs = "你好".getBytes(); // gbk

       for (byteb : bs) {

           System.out.print(b + " "); // -60 -29 -70 -61

       }

       System.out.println();

      

       byte[] bs2 = "你好".getBytes("utf-8");

       for (byteb : bs2) {

           System.out.print(b + " "); // -28 -67 -96 -27 -91 -67

       }

       System.out.println();

      

       byte[] bs3 = "你好".getBytes("big5");

       for (byteb : bs3) {

           System.out.print(b + " "); // -89 65 -90 110

       }

       System.out.println();

   

       // 字节数组 --> 字符串

       byte[] bytes = {-60, -29, -70, -61};

       Stringstring= newString(bytes);// gbk

       System.out.println(string);

      

       byte[] bytes2 = {-28, -67, -96, -27,-91, -67};

       Stringstring2= newString(bytes2,"utf-8");

       System.out.println(string2);

      

       byte[] bytes3 = {-89, 65, -90, 110};

       Stringstring3= newString(bytes3,"big5");

       System.out.println(string3);

      

    }

 

}

 

复制单级文件夹、修改名称、复制多级文件夹

package cn.itcast;

 

import java.io.BufferedInputStream;

import java.io.BufferedOutputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.util.Scanner;

 

/*

 * 复制单级文件夹

 *  1.在目标路径创建和源路径同名文件夹

 *  2.遍历源路径下的文件,并进行复制

 *  3.改进功能:复制多级文件夹

 *  4.增加复制文件后改名的功能

 */

publicclassCopyFileFolder {

 

    publicstaticvoid main(String[] args) {

      

       Scannersc = new Scanner(System.in);

       System.out.println("请输入源路径");

       Stringsour= sc.nextLine();

       sour.replace("\\", "\\\\");

      

       System.out.println("请输入目标路径");

       Stringdest= sc.nextLine();

       dest.replace("\\", "\\\\");

      

       sc.close();

 

       longstart = System.currentTimeMillis();

      

       copyFolder(new File(sour), new File(dest));

      

       System.out.println("复制完成!!");

      

       longend = System.currentTimeMillis();

      

       System.out.println("总共用时 " + (end - start)+ " ms");

      

    }

 

    // 传递源路径和目标路径

    publicstaticvoid copyFolder(File sourPath, File destPath) {

       // 获取源文件夹名

       StringfolderName= sourPath.getName();

       // 根据目标路径和源文件夹名创建file对象

       FiledestFolder= newFile(destPath,folderName);

      

       // 创建目标文件夹

       destFolder.mkdirs(); // I:\Knownsec

       System.out.println("创建文件夹 " + destFolder.getName());

 

       // 遍历源路径获取所有文件名和文件夹名

       File[]files= sourPath.listFiles();

       for (File file : files) {

           // 判断如果是文件,获取文件名,进行复制操作

           if (file.isFile()) {

              // 获取文件名字符串形式

              StringfileName= file.getName();

              // System.out.println(fileName);

 

              // 根据目标父路径和源文件名创建file对象

              FiledestFile= newFile(destFolder,fileName);

 

              // 传递源文件对象和目标文件对象进行复制操作

              copyFile(file, destFile);

             

              rename(destFile);

           }else{ // 是文件夹,递归调用本函数

             

              // 此时,源路径为当前文件夹名,目标路径为刚才创建好的目标路径下的文件夹

              copyFolder(file, destFolder);

           }

       }

 

    }

 

    // 对文件进行重命名

    publicstaticvoid rename(File destFile) {

       // 获取文件父路径

       Fileparent= destFile.getParentFile();

       // 对文件名进行切割,方便获取文件扩展名

       String[]name= destFile.getName().split("\\.");

       // 将文件名扩展名替换为新的扩展名

       Stringchild= destFile.getName().replace(name[name.length - 1], "bak");

       // 根据父路径和新文件名构造新文件对象,

       FiledestNew= newFile(parent,child);

       // 传递改名后的新文件对象

       destFile.renameTo(destNew);

    }

 

    // 利用缓冲字节流实现读写字节数组实现复制文件

    publicstaticvoid copyFile(File file, File destFile) {

       // 声明缓冲字节流对象

       BufferedInputStreambis= null;

       BufferedOutputStreambos= null;

 

       try {

           // 创建缓冲字节流对象,封装字节流对象

           bis = new BufferedInputStream(new FileInputStream(file));

           bos = new BufferedOutputStream(new FileOutputStream(destFile));

 

           longstart = System.currentTimeMillis();

           byte[] b = newbyte[1024];

           intlen = 0;

           System.out.println("正在复制... " + file.getName() + " 文件大小约 " + (file.length()/1024)+ " KB");

           // 利用字节数组复制读写字节流

           while ((len = bis.read(b)) != -1) {

              bos.write(b, 0, len);

           }

           longend = System.currentTimeMillis();

           System.out.println("用时 " + (end- start)+ " ms");

 

       }catch(IOException e) {

           e.printStackTrace();

           thrownew RuntimeException("复制失败");

       }finally{

           try {

              if (bos != null) {

                  bos.close();

              }

           }catch(IOException e) {

              e.printStackTrace();

              thrownew RuntimeException("关闭资源失败");

           }finally{

              if (bis != null) {

                  try {

                     bis.close();

                  }catch(IOException e) {

                     e.printStackTrace();

                     thrownew RuntimeException("关闭资源失败");

                  }

              }

           }

       }

 

    }

 

}

 

 

 

  • IO流使用规律总结

   

    ----------------------------

    字节流

   

    OutputStream

       |-- FileOutputStream

       |-- BufferedOutputStream

    InputStream

       |-- FileInputStream

       |-- BufferedInputStream

   

    ----------------------------

    字符流

   

    Writer

       |-- OutputStreamWriter

           |-- FileWriter

       |-- BufferedWriter

    Reader

       |-- InputStreamReader

           |-- FileReader

       |-- BufferedReader

   

    ----------------------------

   

    明确数据源:

       数据源是文本,选择字符输入流

       需要指定编码表InputStreamReader

       不需要编码表 FileReader

       需要提高效率,字符数组缓冲BufferedReader 读取文本行

      

       数据源不是文本,数据源不明确,选择字节输入流

       FileInputStream

       需要提高效率,字节数组缓冲BufferedInputStream

明确数据目的:

       数据目的是文本,选择字符输出流

       需要指定编码表OutputStreamWriter

       不需要编码表 FileWriter

       需要提高效率,字符数组缓冲BufferedWriter 写入文本行

      

       数据目的不是文本,数据目的不明确,选择字节输出流

       FileOutputStream

       需要提高效率,字节数组缓冲BufferedOutputStream

 

操作基本数据类型的流

    DataInputStream

    DataOutputStream

内存操作流

    一般用于处理临时信息,不需要保存,使用后就可以删除

    只操作内存,不操作硬盘,不占用 OS 资源

    字节数组

    ByteArrayInputStream

    ByteArrayOutputStream

    字符数组

    CharArrayReader

    CharArrayWriter

    字符串

    StringReader

    StringWriter

 

打印流

    java.io.PrintStream  继承OutputStream

    是具有自动行刷新的缓冲字符输出流

    为其他输出流添加功能,打印流也是装饰流,不会抛出 IOException

    只操作数据目的,不操作数据源

    PrintWriter(File file) // 文件

    PrintWriter(String fileName)

    PrintWriter(OutputStream out) // 字节流

    PrintWriter(OutputStream out, boolean autoFlush) // 自动行刷新

    PrintWriter(Writer writer) // 字符流

    PrintWriter(Writer writer, boolean autoFlush) // 自动行刷新

    print println 方法

    PrintWriter 提供了丰富的重载 print println 方法。其中 println 方法在于输出目标数据后自动输出一个系统支持的换行符。若该流是具有自动行刷新的,那么每当通过 println 方法写出的内容都会被实际写出,而不是进行缓存。

    可以操作任意类型的数据

    void print(int/char/boolean/char[]/double/float/long/String)

 

标准输入输出流

    OutputStream

       |-- FileOutputStream

           |-- PrintStream

       |-- BufferedOutputStream

InputStream

       |-- FileInputStream

       |-- BufferedInputStream

    System.in(InputStream), System.out(PrintStream)

 

随机访问流 RandomAccessFile

    Java提供了一个可以对文件随机访问(读和写)的操作,该类不属于流,是 Object 类的子类,但融合了InputStream OutputStream 的功能,该类的读写是基于指针的操作

    RandomAccessFile(File file, String mode)

    RandomAccessFile(String filename, String mode)

只读模式 mode=r

    读写模式 mode=rw

字节数据读写操作

voidwrite(int d) // 向文件中写入一个字节, int 8

voidwrite(byte[] b) // 向文件中写出给定数组

voidwrite(byte[] b, int offset, int len) // 向文件中写出数组中指定部分

int read()// 从文件中读取一个字节读取一个byte 填充到int 8位,高位补0

intread(byte[] b) // 从文件中读取最多给定数组长度的字节两

void close()// 释放系统资源

文件指针操作

    long getFilePointer() // 获取当前的指针位置

    void seek(long pos) // 移动当前的指针位置

    int skipBytes(int n) // 跳过n个字节