javaIO总结（三）

使用指定的码表读写字符

原因：不同的文件有不一样的码表
InputStreamReader() 字符与字节之间的桥

import java.io.*;

/**
 * 用来转换不同编码格式文件
 * @author kiosk
 */
public class TransIO {
    public static void main(String[] args) throws IOException {
        BufferedReader bis = new BufferedReader( new InputStreamReader(new FileInputStream("utf-8.txt"),"UTF-8"));
        BufferedWriter bos = new BufferedWriter( new OutputStreamWriter(new FileOutputStream("gbk.txt"),"GBK"));
        int flag;
        while ((flag = bis.read()) != -1){
            bos.write(flag);
        }
        bis.close();
        bos.close();
    }
}

统计文本文件中的字符出现的次数

思想：
（1）创建输入流，读取。
（2）创建Map集合，将读取的次数存入在Map中（三元表达式）。
（3）建立输出流，将出现的次数输出在文件上。
代码：

/**
 * 统计一个文本的字符的个数
 *
 * @author kiosk
 */
public class Count {
    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new FileReader("hello.txt"));
        Map<Character, Integer> map = new TreeMap<>();
        int ch;
        while ((ch = reader.read()) != -1) {
            char c = (char) ch;
            //三元运算符，如果包含，就给值加1，如果不包含的话，就输入1
            map.put(c, map.containsKey(c) ? map.get(c) + 1 : 1);
        }
        reader.close();
        BufferedWriter writer = new BufferedWriter(new FileWriter("count.txt"));
        for (Character character : map.keySet()) {
         switch (character){
             case '\t':
                 writer.write("\\t"+ "：" +map.get(character) + "次数");
                 break;
             case '\n':
                 writer.write("\\n"+ "：" +map.get(character) + "次数");
                 break;
             case '\r':
                 writer.write("\\r"+ "：" +map.get(character) + "次数");
                 break;
             default:
                 writer.write("\\r"+ "：" +map.get(character) + "次数");
                 break;

         }
            writer.write(character+ "：" +map.get(character) + "次数");
            writer.newLine();

        }
        writer.close();
    }
}

IO（试用版软件）

模拟软件的使用期。
思路：先从文件中读取次数（缓冲字符流的readLine()方法），然后将读取的字符转换为数字，然后再进行自减操作，之后将减少的次数写入到原来的文件里。
代码如下：

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/**
 * @author kiosk
 * 1）使用带缓冲流的方法，要使用readLine方法
 * 2）将读取的内容转化为数字，可以判断还有多少次
 * 3）如果数字大于0则可以使用，如果数字不大于0，那就会提示购买正版
 */
public class Trial {
    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new FileReader("config.txt"));
        String line = reader.readLine();
        int num = Integer.parseInt(line);
        if(num > 0){
            System.out.println("你还有" + --num + "次机会");
            FileWriter writer = new FileWriter("config.txt");
            writer.write(String.valueOf(num));
            writer.close();
        }else{
            System.out.println("请您进行注册");
        }
        reader.close();
    }
}

递归调用来把一个文件夹下的后缀为.java文件遍历打印出来

import java.io.File;
import java.util.Scanner;

/**
 * 从键盘上输入一个文件夹，然后找出所有文件后缀为.java的文件
 * @author kiosk
 */
public class FindFile {
    public static void main(String[] args) {
        File dir = findDir();
        getFileName(dir);
    }

    /**
     * 获取输入键盘的文件夹文件
     * @return
     */
    public static File findDir(){
        Scanner scanner = new Scanner(System.in);
        while (true){
            String path = scanner.nextLine();
            File dir = new File(path);
            if(!dir.exists()){
                System.out.println("抱歉您输入的文件夹路径是不存在的，请您重新输入");
            }
            if(dir.isFile()){
                System.out.println("抱歉您输入的路径是一个文件，请您重新输入");
            }
            if(dir.isDirectory()){
                return dir;
            }
        }
    }
    public static void getFileName(File dir){
        File[] files = dir.listFiles();
        for (File file : files) {
            if(file.isFile() && file.getName().endsWith(".java")){
                System.out.println(file.getName());
            }else if(file.isDirectory()){
                getFileName(file);
            }
        }
    }
}

java中的序列流

可以把多个字节流整合在一起，从第一个被整合的流开始读取
问题：在复制两个文件为一个文件的时候文件的复用性太差，是两个并行的输入流。
代码：

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 序列化流
 * @author kiosk
 */
public class Sequence {
    public static void main(String[] args) throws IOException {
        FileInputStream fis1 = new FileInputStream("1.txt");
        FileOutputStream fos = new FileOutputStream("3.txt");
        int b1;
        while((b1 = fis1.read()) != -1){
            fos.write(b1 );
        }
        fis1.close();
        FileInputStream fis2 = new FileInputStream("2.txt");
        int b2;
        while((b2 = fis2.read()) != -1){
            fos.write(b2);
        }
        fis1.close();
    }
}

如何整合多个流？（应用的场景：MP3歌曲的串烧）
利用枚举
代码：

import java.io.*;
import java.util.Enumeration;
import java.util.Vector;

/**
* 整合多个
* @author kiosk
*/
public class Sequence2 {
   public static void main(String[] args) throws IOException {
       FileInputStream fis1 = new FileInputStream("1.txt");
       FileInputStream fis2 = new FileInputStream("2.txt");
       FileInputStream fis3 = new FileInputStream("3.txt");
       Vector<FileInputStream> vector = new Vector<>();
       vector.add(fis1);
       vector.add(fis2);
       vector.add(fis3);
       Enumeration enumeration = vector.elements();
       SequenceInputStream sis = new SequenceInputStream(enumeration);
       FileOutputStream fos = new FileOutputStream("4.txt");
       int read;
       while ((read = sis.read()) != -1){
           fos.write(read);
       }
       sis.close();
       fis3.close();
   }
}

内存输出流

像内存写数据，把内存当作一个缓冲区，写出之后可以一次性的获取所有的数据。
ByteArrayOutputStream
ByteArrayInputStream

import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class ByteOutput {
  public static void main(String[] args) throws IOException {
      FileInputStream fis = new FileInputStream("1.txt");
      ByteArrayOutputStream stream = new ByteArrayOutputStream();
      int b;
      while ((b = fis.read()) != -1){
          stream.write(b);
      }
      //将缓冲区的数据获取出来，并将数据存入在字节数组中
      byte[] bytes = stream.toByteArray();
      String string = new String(bytes);
      System.out.println(string);
      fis.close();
      //是在内存中的，所以是不用关掉，没有意义
  }
}

用内存流来将文件的字符读取出来打印在控制台上

import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.IOException;

/**
* @author kiosk
*/
public class Test{
  public static void main(String[] args) throws IOException {
      FileInputStream fis = new FileInputStream("1.txt");
      ByteArrayOutputStream baos = new ByteArrayOutputStream();
      byte[] bytes = new byte[5];
      int b;
      while ((b = fis.read(bytes)) != -1){
          baos.write(bytes,0,b);
      }
      fis.close();
      byte[] byteArray = baos.toByteArray();
      System.out.println(new String(byteArray));

  }
}