Java入门之IO流

Writer

是所有字符输出流的父类，抽象类，不能实例化，如果需要实例化时只能调用它的子类

子类：OutputStreamWriter BufferedWriter（效率更高）

tips:输出时需要执行flush方法刷新，否则可能文件中无法显示数据

public class Test01 {  
    public static void main(String[] args) throws IOException{  
        //创建对象  
        Writer w1=new OutputStreamWriter(new FileOutputStream("D:\\md\\ac.text"));  
        //声明输出数据  
        String str1="壮士饥餐胡虏肉，笑谈渴饮匈奴血";  
        //输出  
        w1.write(str1);  
        //刷新  
        w1.flush();  
        //关闭资源  
        w1.close();  
    }  
}  

public class Test05 {  
    public static void main(String[] args) throws IOException {  
          
        //Writer w1=new  OutputStreamWriter(new FileOutputStream("c.txt"));  
        BufferedWriter b1=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("c.txt")));  
        //写出数据  
        b1.write("我自横刀向天笑");  
        b1.newLine(); //换行作用 
        b1.write("去留肝胆两昆仑");  
        b1.flush();  
        b1.close();  
        //w1.close();  
    }  
} 

Reader

所有字符输入流的父类，抽象类，不能被实例化，创建对象时实例化子类

子类：InputStreamReader BufferedReader

tips:读取字符串和数组是需要进行循环判断

public class Test01 {
	public static void main(String[] args) throws IOException {
		//创建对象
		Reader r1=new InputStreamReader(new FileInputStream("c.txt"));
		//读取
		int num=r1.read();
		//分析结果
		System.out.println(num);
		//关闭资源
		r1.close();
		System.out.println((char)(new FileInputStream("c.txt").read()));
	}
}

public class Test02 {  
    public static void main(String[] args) throws IOException {  
        //创建对象  
        Reader r1=new InputStreamReader(new FileInputStream("c.txt"));  
        //读取  
        int num=0;  
        while((num=r1.read())!=-1) {  
            System.out.print((char)num);  
        }  
        //关闭资源  
        r1.close();  
    }  
}

Writer和Reader的综合应用

public class Test03 {  
    public static void main(String[] args) throws IOException {  
        w("你好呀哈哈");  
        r();  
    }  
    public static void w(String msg) throws IOException {  
        //创建对象  
        Writer w1=new OutputStreamWriter(new FileOutputStream("b.txt"));  
        //输出内容  
        w1.write(msg);  
        //刷新  
        w1.flush();  
        //关闭资源  
        w1.close();  
    }  
    public static void r() throws IOException {  
        Reader r1=new InputStreamReader(new FileInputStream("b.txt"));  
        //读取数据  
        int num=0;  
        while ((num=r1.read())!=-1) {  
            System.out.print((char)num);  
        }  
        r1.close();  
    }  
} 

OutputStream

所有字节输出流的父类，抽象类，不能被实例化，创建对象时实例化子类

子类：FileOutputStream ObjectOutputStream （写出的是对象） PrintStream

public class Test01 {  
    public static void main(String[] args) throws FileNotFoundException, IOException {  
        //创建对象  
        ObjectOutputStream os1=new ObjectOutputStream(new FileOutputStream("a.txt"));  
        //写出数据  
        os1.write(123);  
        os1.writeByte(12);  
        os1.writeInt(123);  
        os1.writeDouble(12.12);  
        os1.writeUTF("hello 少年");//utf-8格式  
    }  
}

InputStream

所有字节输入流的父类，抽象类，不能被实例化，创建对象时实例化子类

子类：FileInputputStream ObjectInputputStream （写出的是对象） System.in

public class Test01 {  
    public static void main(String[] args) throws FileNotFoundException, IOException {  
          
        //创建对象  
        ObjectInputStream os = new ObjectInputStream(new FileInputStream("a.txt")); 
        //读取数据  
        int num = os.readInt();  
        //输出数据  
        System.out.println(num);  
        //读取数据  
        double d = os.readDouble();  
        //输出数据  
        System.out.println(d);  
        //读取数据  
        String s = os.readUTF();  
        //输出数据  
        System.out.println(s);  
        //关闭  
        os.close();  
          
    }  
}  

ObjectOutputStream和ObjectInputStream综合应用

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
//ObjectOutputStream    ObjectInputStream：写入和读取对象的信息
public class Test {
	public static void main(String[] args) throws ClassNotFoundException, IOException {
		w();
		r();
	}
	public static void w() throws FileNotFoundException, IOException {
		User user=new User("张三",1,18);
		//创建对象
		ObjectOutputStream os1=new ObjectOutputStream(new FileOutputStream("v.txt"));
		//写出
		os1.writeObject(user);
		os1.close();
	}
	public static void r() throws ClassNotFoundException, IOException {
		ObjectInputStream os2=new ObjectInputStream(new FileInputStream("v.txt"));
		Object object=os2.readObject();
		System.out.println(object);
		os2.close();
	}
}

import java.io.Serializable;  
  
public class User implements Serializable{  
    private static final long serialVersionUID = 1L;  
        private String name;  
        private int age;  
        private int gender;  
        public User() {  
              
        }  
        public User(String name,int age,int gender) {  
            super();  
            this.age=age;  
            this.gender=gender;  
            this.name=name;  
        }  
        public 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;  
        }  
        public int getGender() {  
            return gender;  
        }  
        public void setGender(int gender) {  
            this.gender = gender;  
        }  
        @Override  
        public String toString() {  
            return "User [name=" + name + ", age=" + age + ", gender=" + gender + "]";  
        }  
} 

Scanner

public static void main(String[] args) throws FileNotFoundException {  
    //修改标准输入流的数据源  
    System.setIn(new FileInputStream("a.txt"));  
    Scanner input=new Scanner(System.in);  
    //通过scanner获取数据  
    System.out.println(input.next());  
    //设置标准输出设置到文件中  
    System.setOut(new PrintStream(new File("c.txt")));  
    //通过打印输出内容  
    System.out.println("哈哈");  
    try {  
        input.close();  
        input.next();  
    }catch(IllegalStateException e) {  
        System.out.println(e.getMessage());  
    }         
}