JAVA学习-IO流

IO流

FileInputStream

文件输入流

将文件中的字符输入到控制台

package com.myIO.demo01;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class Demo01 {
    public static void main(String[] args) {
        Demo01 demo01 = new Demo01();
        demo01.readMyFile();
    }
    public void readMyFile(){
        String filPath = "G:\\java\\hi.txt";
        FileInputStream fileInputStream =null;
        int myRead = 0;
        try {
            fileInputStream = new FileInputStream(filPath);
            //read方法，返回为-1表示读取结束
            while((myRead = fileInputStream.read()) != -1){
                System.out.print((char)myRead);//这里把myRead转成char输出
            }
        } catch (IOException e) {//read方法也有异常需要catch,所以这里直接改成IO 异常
            e.printStackTrace();
        } finally {
            try {
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
            }
        }
    }
}

**这里，我的hi.txt文件放在g:\java\hi.txt 转义符关系要写成 \\ **

read(byte[])方法

可以指定一次读取所读取的字节数，如果读取正常，返回实际读取的个数，如果返回-1表示读取完毕

package com.myIO.demo02;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class Demo02 {
    public static void main(String[] args) {
        Demo02 demo02 = new Demo02();
        demo02.myFileRead();

    }

    public void myFileRead(){
        String filePath = "g:\\java\\hi.txt";
        FileInputStream fileInputStream = null;
        int readLen = 0;
        byte[] bytes = new byte[5];//五个五个读取
        try {
            fileInputStream = new FileInputStream(filePath);
            while ((readLen = fileInputStream.read(bytes)) != -1){//这里是将读取到的长度返回给readLen,并读取五个字节给bytes
                System.out.println(new String(bytes,0,readLen));//利用了String的构造器,从bytes中索引0开始读取，长度为readLen
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
        }
    }
}

FileOutputStream

写入数据到文件，如果文件不存在，则会创建这个文件

三种方法写入文件

第一种，字节写入

package com.myIO.demo03;

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

public class Demo03 {
    public static void main(String[] args) {
        Demo03 demo03 = new Demo03();
        demo03.myFileWrite();
    }
    public void myFileWrite(){
        String filePath = "g:\\java\\a.txt";
        FileOutputStream fileOutputStream = null;
        try {
            fileOutputStream = new FileOutputStream(filePath);
            fileOutputStream.write('a');
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

第二种，字符串写入

利用字符数组

package com.myIO.demo03;

import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class Demo03 {
    public static void main(String[] args) {
        Demo03 demo03 = new Demo03();
        demo03.myFileWrite();
    }
    public void myFileWrite(){
        String filePath = "g:\\java\\a.txt";
        FileOutputStream fileOutputStream = null;
        String a = "hello,world";
        try {
            fileOutputStream = new FileOutputStream(filePath);
            fileOutputStream.write(a.getBytes());//getBytes方法，将字符串转换为字节数组
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

第三种，规定长度的字符串写入

package com.myIO.demo03;

import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class Demo03 {
    public static void main(String[] args) {
        Demo03 demo03 = new Demo03();
        demo03.myFileWrite();
    }
    public void myFileWrite(){
        String filePath = "g:\\java\\a.txt";
        FileOutputStream fileOutputStream = null;
        String a = "hello,world";
        try {
            fileOutputStream = new FileOutputStream(filePath);
            fileOutputStream.write(a.getBytes(),0,3);//从索引0开始写入，长度为3
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

**注意，以上写入均为覆盖写入，也就是每次写入都是全新的内容。如想要接着上次内容写入，则需要：

fileOutputStream = new FileOutputStream(filePath,true);//默认为false,不接着写入

文件拷贝

利用FileInputStream与FileOutputStream进行文件的拷贝

package com.myIO.demo04;

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

public class Demo04 {
    public static void main(String[] args) {
        Demo04 demo04 = new Demo04();
        demo04.myFileCopy();

    }
    public void myFileCopy() {
        String srcFilePath = "g:\\java\\1.jpg";
        String destFilePath = "g:\\java\\2.jpg";
        FileInputStream fileInputStream = null;
        FileOutputStream fileOutputStream =null;
        byte[] bytes = new byte[1024];
        int fileLen = 0;
        try {
            fileInputStream = new FileInputStream(srcFilePath);
            fileOutputStream = new FileOutputStream(destFilePath);
            while ((fileLen = fileInputStream.read(bytes)) != -1){
                fileOutputStream.write(bytes,0,fileLen);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fileInputStream.close();
                fileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

FileReader

read方法，每次读取一个字符（注意，不是字节，所以可以直接读取汉字）

package com.myIO.demo05;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class Demo05 {
    public static void main(String[] args) {
        Demo05 demo05 = new Demo05();
        demo05.myRader();

    }

    public void myRader(){
        FileReader fileReader = null;
        int myread = 0;
        String filePath = "g:\\java\\hi.txt";
        try {
            fileReader = new FileReader(filePath);
            while ((myread = fileReader.read() )!= -1){
                System.out.print((char)myread);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fileReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

也可以读取字符数组，提高效率

package com.myIO.demo05;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class Demo05 {
    public static void main(String[] args) {
        Demo05 demo05 = new Demo05();
        demo05.myRader();

    }

    public void myRader(){
        FileReader fileReader = null;
        String filePath = "g:\\java\\hi.txt";
        int readerLen = 0;
        char[] chars = new char[5];
        try {
            fileReader = new FileReader(filePath);
            while ((readerLen = fileReader.read(chars) )!= -1){
                System.out.print(new String(chars,0,readerLen));//利用了String的构造器来直接输出字符数组
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fileReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

FileWriter

字符写入，可以写入字符，字符数组，字符串。

但必须要有close(),或则flash()才能将数据完成写入！！！

BufferedReader

包装流/处理流

package com.myIO.demo07;

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

public class Demo07 {
    public static void main(String[] args) {
        Demo07 demo07 = new Demo07();
        demo07.bufRead();

    }
    public void bufRead(){
        BufferedReader bufferedReader = null;
        String readPath = "g:\\java\\hi.txt";
        String myRead = null;
        try {
            bufferedReader = new BufferedReader(new FileReader(readPath));
            while ((myRead = bufferedReader.readLine()) != null){//readLine方法，按行读取，高效率
                System.out.println(myRead);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                bufferedReader.close();//直接关闭包装流就行，源码可查是关闭了传进去的FileReader
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

BufferedWriter

package com.myIO.demo08;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class Demo08 {
    public static void main(String[] args) {
        Demo08 demo08 = new Demo08();
        demo08.bufWriter();
    }
    public void bufWriter(){
        BufferedWriter bufferedWriter = null;
        String filePath = "g:\\java\\a.txt";
        try {
            bufferedWriter = new BufferedWriter(new FileWriter(filePath,true));//如果需要接着输写，需要在FileWriter构造器里面append 填入true，默认false
            bufferedWriter.write("乌拉");
            bufferedWriter.newLine();//加入新一行，自动适合系统
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                bufferedWriter.close();//这一步忘了就完了！一定要记住！！！
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

文件拷贝

BufferedReader与BufferedWriter是读写字符的，不要用它们去处理二进制文件，例如声音,doc,pdf等

BufferedOutputStream/BufferedInputStream

可以处理二进制文件

package com.myIO.demo09;

import java.io.*;

public class Demo09 {
    public static void main(String[] args) {
        BufferedInputStream bufferedInputStream = null;
        BufferedOutputStream bufferedOutputStream = null;
        byte[] bytes = new byte[1024];
        int srcLen = 0;
        String srcPath = "g:\\java\\1.jpg";
        String  destPath = "g:\\java\\3.jpg";
        try {
            bufferedInputStream = new BufferedInputStream(new FileInputStream(srcPath));
            bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(destPath));
            while ((srcLen = bufferedInputStream.read(bytes)) != -1){
                bufferedOutputStream.write(bytes,0,srcLen);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
        }

    }
}

对象处理流

ObjectInputStream ObjectOutputStream

可以实现对数据和类型的序列化以及反序列化

注意

• 读写顺序要一致
• 要求实现序列化或反序列化对象，需要实现Serializable接口
• 序列化的类中建议添加SerialVersionUID,为了提高版本的兼容性
• 序列化对象时，默认将里面所有属性都进行序列化，但除了static或transient修饰的成员
• 序列化对象时，要求里面属性的类型也需要实现序列化接口
• 序列化具备可继承性，也就是如果某类已经是吸纳了序列化，则它的所有子类也实现了序列化

转换流

InputStreamReader

可以指定读取文件编码，将字节流转换成字符流。

OutputStramWriter

按照指定编码保存文件，字节流转换为字符流

打印流

打印流只有输出流，没有输入流

PrintStream

PrintStream out = System.out;
out.print("hello");//输出在屏幕
/////////////////////
//也可以利用print底层使用的write来输出
out.write("hello".getBytes());//这里要用getBytes()，因为这是字节输出流

默认输出的位置为屏幕，但可以修改：

System.setOut(new PrintStream("g:\\txy.txt"));//修改输出位置到了g:\txy.txt
System.out.println("hello");//输出位置在g:\txy.txt

PrintWriter

记住Writer都要close

Properties

读取配置文件

//Properties pro = (Reader);

遍历配置文件

pro.list(System.out);

根据键获取值

pro.getProperty("name");//返回一个String

创建

Properties pro = new Properties;
pro.setProperties("key","value");
pro.setProperties("...","...");
//将k-v保存到配置文件
pro.store(new FiloutputStream("src\\mysql2.properties"),null);

如果该文件没有对应的key就是创建

有对应的key就是修改