java的io流（同步阻塞式io流）

1.io流简介

不论是Reader，Writer，还是InputStream，OutputStream，在创建相应的对象是只是创建了相应的映射，相当于修了一条马路通向两个位置，但是本身并不参与数据的传输，数据的传输是通过数组完成的，这个传输的过程是单向的（nio的buffer是双向的）面向于流的传输（nio面向缓存数据块），对于读的时候不论基于单个字符还是基于数组，当没有可读的元素的时候返回值都是-1，有可读的时候返回的是有效数据的字节或字符长度，返回字符串的时候，在没有的情况下为null，对于一个输入流来说具有skip的方法，跳到我们制定的地方去开始输入，对于写我们可以设置为true在尾部添加，对于覆盖数据我们可以是用RandomAccessFile的seek设定覆盖的位置，对于我们对象流（序列化流）可以将一个文件保存在一个文件中，然后在另一个地方读取（读取的前提条件是相应的序列化类需要已经加载到JVM中），对于BufferedOutputStream等采用装饰模式，也就是在FileOutputStream外面包了一层，对于文件的乱码问题前面有一篇有介绍。

2.file

public class CreateFile {
    // 创建文件
    public static void creatFile(String filePath) throws Exception {
        File file = new File(filePath);
        if (!file.exists()) {
            file.createNewFile();
        } else {
            System.err.println("文件夹以及存在");
        }
    }

    // 创建文件夹
    public static void creatFolder(String filePath) {
        File file = new File(filePath);
        if (!file.exists()) {
            file.mkdirs();
        } else {
            System.err.println("文件夹以及存在");
        }
    }

    // 在指定的文件下搜索文件（可以模糊查找）
    public static List<String> FuzzySearch(String filePath, String regex) {
        LinkedList<String> lls = new LinkedList<>();
        regex = ".*" + regex + ".*";
        File file = new File(filePath);
        if (!file.exists()) {
            System.err.println("指定的目录不存在");
            return null;
        }
        if (!file.isDirectory()) {
            System.err.println("指定的不是目录");
            return null;
        }
        getErgodicFiles(regex, lls, file);
        if (lls.size() == 0) {
            System.out.println("没有找到符合的信息");
        }
        return lls;
    }

    // 遍历文件
    public static void getErgodicFiles(String regex, LinkedList<String> lls, File file) {
        if (file.isDirectory()) {
            File[] lfs = file.listFiles();
            for (File f : lfs) {
                if (!f.isDirectory()) {
                    String absolutePath = f.getAbsolutePath();
                    if (absolutePath.matches(regex)) {
                        lls.add(absolutePath);
                    }
                } else {
                    getErgodicFiles(regex, lls, f);
                }
            }
        }
    }

    // 遍历文件
    public static void getErgodicFiles(String fileName, File file) {
        if (file.isDirectory()) {
            File[] lfs = file.listFiles();
            for (File f : lfs) {
                if (!f.isDirectory()) {
                    f.delete();
                } else {
                    getErgodicFiles(fileName, f);
                }
            }
        }
    }

    public static void delete(String fileName) {
        File file = getFile(fileName);
        if (file == null) {
            return;
        }
        if (!file.isDirectory()) {
            file.delete();
            return;
        }
        getErgodicFiles(fileName, file);
        file.delete();
        System.out.println("删除成功");
    }

    // 设置文件只读，但是可以另存为
    public static void setOnlyRead(String fileName) {
        File file = getFile(fileName);
        if (file == null) {
            return;
        }
        file.setReadable(true);
        file.setWritable(false);
    }

    private static File getFile(String fileName) {
        File file = new File(fileName);
        if (!file.exists()) {
            System.err.println("指定的目录或者文件夹不存在不存在");
            return null;
        }
        return file;
    }

    public static void main(String[] args) throws Exception {
        // CreateFile.creatFile("F:/test/file");
        // CreateFile.creatFolder("F:/test/file1.txt");
        // List<String> fuzzySearch = CreateFile.FuzzySearch("F:/test", "file");
        // System.out.println(fuzzySearch);
        // CreateFile.delete("F:/test/file1.txt");
        // CreateFile.setOnlyRead("F:/test/file1/file.txt");
    }
}

3.new FileOutputStream与 new RandomAccessFile的区别

一个存在则新建，一个存在则覆盖覆盖，默认的seek是从0开始的，RandomAccessFile对同一文件可进行读写

4.更改某一个文件中的值然后保存

public static void main(String[] args) {
        try {
            InputStream resourceAsStream4 = PopertiesDemo1.class.getClassLoader()
                    .getResourceAsStream("cn/collection/demo/config.properties");
            Properties properties = new Properties();
            properties.load(resourceAsStream4);
            System.out.println(properties.getProperty("name"));
            properties.setProperty("name", "李四");
            System.out.println(properties.getProperty("name"));
            FileWriter fileWriter = new FileWriter("config1");
            // "aa" 描述信息
            properties.store(fileWriter, "aa");
            fileWriter.close();
        } catch (Exception e) {
            System.out.println("没有找到文件");
        }
    }

5.对象流

实现Externalizable接口，Externalizable继承了Serializable 接口，Externalizable中有两个方法需要重写writeExternal及readExternal，在writeObject和readObject时会调用相应的方法。

transient关键字表示瞬态的，在保存的是是后不会被保存进对象流，假如我么依旧添加，那么可以使用如下方法

public class Person implements Serializable {
    private String adress;
    // transient 关键字 表示瞬态 假如需要保存这个那么需要单独的去保存
    private transient int age;
    private static String name;
    private transient static int id;

    public String getAdress() {
        return adress;
    }

    public void setAdress(String adress) {
        this.adress = adress;
    }

    public static int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public Person() {
        super();
    }

    public Person(int age, String adress, int id, String name) {
        super();
        this.age = age;
        this.adress = adress;
        this.id = id;
        this.name = name;
    }

    public static String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    // 一定要为私有才可以被调用
    private void writeObject(ObjectOutputStream stream) throws IOException {
        // 将非静态的非瞬态的保存在对象流中
        stream.defaultWriteObject();
        stream.writeObject(age);
        stream.close();
    }

    // 一定要为私有才可以被调用
    private void readObject(ObjectInputStream stream) throws ClassNotFoundException, IOException {
　　　　　stream.defaultReadObject();
        age = (int) (stream.readObject());
        stream.close();
    }

    @Override
    public String toString() {
        return "Person [age=" + age + ", adress=" + adress + ",name=" + name + ",id=" + id + "]";
    }

}

6.分段读取文件，每次只保存一部分（网络版的在爬虫中）

public class SegmentedReadFile extends Thread {
	private volatile boolean flag = false;
	@Override
	public void run() {
		try {
			Scanner scanner = new Scanner(System.in);
			String nextLine = scanner.nextLine();
			if (nextLine.equals("true")) {
				this.flag = true;
			}
		} catch (Exception e) {
		}
	}

	public boolean test(String src, String target) throws IOException {
		File file = new File(src);
		File file2 = new File(target);
		// 这里以单个文件为例
		if (file.isDirectory()) {
			System.out.println("该路径是文件夹不是文件");
			return false;
		}
		if (!file.isFile()) {
			System.out.println("该文件路径不存在");
			return false;
		}
		if (!file2.isFile()) {
			try {
				file2.createNewFile();
			} catch (IOException e) {
				return false;
			}
		}
		FileInputStream fileInputStream=null;
		BufferedInputStream bufferedInputStream=null;
		FileOutputStream fileOutputStream=null;
		BufferedOutputStream bufferedOutputStream=null;
		if (file2.isFile()) {
			long lg1 = file.length();
			int segment = 24000000;
			fileInputStream = new FileInputStream(file);
			bufferedInputStream = new BufferedInputStream(fileInputStream);
			fileOutputStream = new FileOutputStream(file2, true);
			bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
			byte[] bys = new byte[1024];
			
			if (file.length() - file2.length() >= segment) {
				long lg = file2.length();
				bufferedInputStream.skip(lg);
				for (int i = 0; i <= segment / 1024; i++) {
					if (flag) {
						break;
					}
　　　　　　　　　　　　　　　　　　　　　　　　bufferedInputStream.read(bys);
					if (i < segment / 1024 ) {
						bufferedOutputStream.write(bys, 0, 1024);
					} else {
						bufferedOutputStream.write(bys, 0, segment%1024);
					}
				}
			} else if(file.length() - file2.length()>0){
				long lg = file2.length();
				bufferedInputStream.skip(lg);
				long lastSize=file.length() - file2.length();
				for (int i = 0; i <= lastSize / 1024; i++) {
					if (flag) {
						break;
					}
					int read = bufferedInputStream.read(bys);
					if (read != -1) {
						bufferedOutputStream.write(bys, 0, read);
					}
				}
			}else{
					System.out.println("传输完成");
			}
		}
		bufferedInputStream.close();
		bufferedOutputStream.close();
		System.gc();
		System.runFinalization();
		return true;
	}

	public static void main(String[] args) throws IOException {
		SegmentedReadFile segmentedReadFile = new SegmentedReadFile();
		segmentedReadFile.setDaemon(true);
		segmentedReadFile.start();
		boolean test = segmentedReadFile.test("G:/360安全浏览器下载安装包/tim_pc.exe", "G:/360安全浏览器下载安装包/tim_pc1.exe");
		if (!test) {
			System.out.println("传输失败");
		}
	}
}

7.重定向输出记录错误日志文件

public class Redirect1 {
   public static void main(String[] args) throws FileNotFoundException {
     String str="hello world";
     PrintStream printStream = new PrintStream("y.txt");
　　//可以不关闭，自动会刷新缓存
     printStream.print(str);
}

8.字节字符转换流

public static void main(String[] args) throws IOException {
         //方式一
         FileInputStream fileInputStream = new  FileInputStream("1.txt");
         //不乱码的前提是知道编码，或者是unicode码的\u方式写的
         InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream,"utf-8");
         BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
         //java内存中是使用unicode码保存的
         String readLine = bufferedReader.readLine();
         System.out.println(readLine);
         if(bufferedReader!=null){
             bufferedReader.close();
         }
         if(inputStreamReader!=null){
             inputStreamReader.close();
         }
         if(fileInputStream!=null){
             fileInputStream.close();
         }
         FileOutputStream fileOutputStream = new FileOutputStream("3.txt");
         OutputStreamWriter outputStreamWriter = new  OutputStreamWriter(fileOutputStream,"gbk");
         BufferedWriter bufferedWriter = new  BufferedWriter(outputStreamWriter);
         bufferedWriter.write(readLine);
         if(bufferedWriter!=null){
             bufferedWriter.close();
         }
         if(outputStreamWriter!=null){
             outputStreamWriter.close();
         }
         if(fileOutputStream!=null){
             fileOutputStream.close();
         }
         FileInputStream fileInputStream1 = new  FileInputStream("3.txt");
         //按指定解码然后按unicode保存
         InputStreamReader inputStreamReader1 = new InputStreamReader(fileInputStream1,"gbk");
         BufferedReader bufferedReader1 = new BufferedReader(inputStreamReader1);
         String readLine1 = bufferedReader1.readLine();
        //将unicode码有转换成了工作空间相应的编码
         System.out.println(readLine1);
         if(bufferedReader1!=null){
             bufferedReader1.close();
         }
         if(inputStreamReader1!=null){
             inputStreamReader1.close();
         }
         if(fileInputStream1!=null){
             fileInputStream1.close();
         }
         //方式二
         ByteArrayOutputStream byteArrayOutputStream = new  ByteArrayOutputStream();
         byteArrayOutputStream.write(readLine1.getBytes());
        //因为我的工作空间是utf-8的
         String string = byteArrayOutputStream.toString("utf-8");
         byteArrayOutputStream.close();
         System.out.println(string);
         FileInputStream fileInputStream2 = new  FileInputStream("3.txt");
         ByteArrayOutputStream byteArrayOutputStream2 = new  ByteArrayOutputStream();
         byte [] bs =new byte [1024];
         int len =0;
         while((len=fileInputStream2.read(bs))!=-1){
             byteArrayOutputStream2.write(bs, 0, len);
         }
         //不会乱码
         String string2 = byteArrayOutputStream2.toString("gbk");
         fileInputStream2.close();
         byteArrayOutputStream2.close();
         System.out.println(string2);
         //readLine.getBytes(charset)
        //Charset.forName("UTF-8").encode(str)
   }

9.其他一些流

SequenceInputStream  合并多个流文件 SequenceInputStream(Enumeration<? extends InputStream> e)

PrintWriter 与 PrintStream 差不多

PipedWriter 是向与其它线程共用的管道中写入数据

CharArrayWriter、StringWriter 是两种基本的介质流，它们分别向Char 数组、String 中写入数据

DataOutputStream 保存相应的数据，按保存的顺序读取

ZipOutputStream  压缩流   批量压缩（文件夹）可以使用这个方法putNextEntry(ZipEntry e)，ZipEntry(String name)使用指定名称创建新的 ZIP 条目。

ZipInputStream 解压流 

public class ZipInputStreamDemo2 {
    public static void main(String[] args) throws IOException {
        File file = new File("d:" + File.separator + "zipFile.zip");
        File outFile = null;
        ZipFile zipFile = new ZipFile(file);
        ZipInputStream zipInput = new ZipInputStream(new FileInputStream(file));
        ZipEntry entry = null;
        InputStream input = null;
        OutputStream output = null;
        while ((entry = zipInput.getNextEntry()) != null) {
            System.out.println("解压缩" + entry.getName() + "文件");
            outFile = new File("d:" + File.separator + entry.getName());
            if (!outFile.getParentFile().exists()) {
                outFile.getParentFile().mkdir();
            }
            if (!outFile.exists()) {
                outFile.createNewFile();
            }
            input = zipFile.getInputStream(entry);
            output = new FileOutputStream(outFile);
            int temp = 0;
            while ((temp = input.read()) != -1) {
                output.write(temp);
            }
            input.close();
            output.close();
        }
    }

}

//多个文件进行压缩
public class ZipOutputStreamDemo2 {
    public static void main(String[] args) throws IOException {
        // 要被压缩的文件夹
        File file = new File("d:" + File.separator + "temp");
        File zipFile = new File("d:" + File.separator + "zipFile.zip");
        InputStream input = null;
        ZipOutputStream zipOut = new ZipOutputStream(new FileOutputStream(zipFile));
        zipOut.setComment("hello");
        if (file.isDirectory()) {
            File[] files = file.listFiles();
            for (int i = 0; i < files.length; ++i) {
                input = new FileInputStream(files[i]);
                zipOut.putNextEntry(new ZipEntry(file.getName() + File.separator + files[i].getName()));
                int temp = 0;
                while ((temp = input.read()) != -1) {
                    zipOut.write(temp);
                }
                input.close();
            }
        }
    }
}