Java中的IO流和反射-阿里云开发者社区

一、定义

流是指一连串流动的字符，是以先进先出的方式发送信息的通道。程序和数据之间是通过流进行关联的。

二、分类

1、按流向分
输出流：OutputStream和Writer作为基类
输入流：InputStream和Reader作为基类
2、按处理数据的单元划分
字节流：nputStream/OutputStream作为基类
字符流：Reader/Writer作为基类

三、流之间的层级关系

上层为基类
1、输入
Reader
InputStreamReader(可设置字符编码) Bufferendreader(带有缓冲区)
InputStream
FileInputStream objecInputStream（反序列化） DateInputStream（读二进制文件）
2、输出
Writer
OuputStreamWriterr(可设置字符编码) BufferendWriterr(带有缓冲区)
InputStream
FileOutputStream objecOutputStream（序列化） DateIOutputStream（读二进制文件）

四、流的正确使用

1、File类操作文件

package demo1;
import java.io.File;
import java.io.IOException;
/*
 * 使用File类创建文件,并实现更删除、显示文件名和路径操作
 */
public class Test1 {
  public static void main(String[] args) throws IOException {
    File file = new File("D:\\test1.txt");
    if(!file.exists()) {
      file.createNewFile();//不存在创建
    }else {
      file.delete();//存在删除
    }
    System.out.println("该文件的绝对路径名为"+file.getAbsolutePath());
    System.out.println("该文件名为："+file.getName());
  }
}

特别注意：创建File对象的时候可以放决相对路径也可以放决对路径
直接写test.txt代表的是在该项目底下的文件
而如果携程D:\test.txt的话是代表此文件在D盘下的文件

File类常用方法：

方法	说明
boolean exisit()	判断文件是否存在
String getName()	获得文件名
boolean creatNewFile()	创建文件（创建前要判断文件是否存在）

2、使用字节流FileInputStream读文本文件

package demo2;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
/*
 * 字节流FileInputStream读取文件
 */
public class Test1 {
  public static void main(String[] args) throws Exception {
    File file =new File("demo2.txt");
    FileInputStream fis = new FileInputStream(file);
    byte[] b = new byte[fis.available()];
    int data=-1;
    while((data=fis.read(b))!=-1) {
    }
    String str = new String(b);//将字节数组变为字符串
    System.out.println(str);
    fis.close();
  }
}

FileInputStream 常用方法

方法	说明
inr read((byte[] b)	将数据缓存在字节数组中最后通过String的构造方法将字节数组转换成字符串输出
int read()	一个字节一个字节的读

3、使用字节流FileInputStream和FileOutputStream复制文本文件

package demo2;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/*
 * 复制文件
 */
public class Test2 {
  public static void main(String[] args) {
    FileInputStream fis =null;
    FileOutputStream fos=null;
    try {
      fis= new FileInputStream("D:\\demo1.txt");
      byte[] b = new byte[fis.available()];
      int date =-1;
      while((date=fis.read(b))!=-1){
      }
      fos = new FileOutputStream("E:\\Java\\java学习\\代码\\demo1.txt");
      fos.write(b);
    } catch (FileNotFoundException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }finally{
      if(null!=fos){
        try {
          fos.close();
        } catch (IOException e) {
          // TODO Auto-generated catch block
          e.printStackTrace();
        }
      }
      if(null!=fis){
        try {
          fis.close();
        } catch (IOException e) {
          // TODO Auto-generated catch block
          e.printStackTrace();
        }
      }
    }
  }
}

4、使用DataInputStream和DataOutputStream读写二进制文件

package demo3;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
/*
 * 复制图片,二进制流的应用
 */
public class Test1 {
  public static void main(String[] args) throws Exception {
    DataInputStream dis = new DataInputStream(new FileInputStream("D:\\1.jpg"));
    DataOutputStream  dos =new DataOutputStream(new FileOutputStream("E:\\Java\\java学习\\代码\\t.jpg"));
    int date=-1;
    while((date=dis.read())!=-1){
      dos.write(date);
    }
    dos.close();
    dis.close();
  }
}

5、字符流FileReader & FileWriter

package demo4;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
/*
 * 字符流FileReader & FileWriter
 */
public class Test1 {
  public static void main(String[] args) throws Exception {
    FileReader fr = new FileReader("demo2.txt");
    //方式一、一个字符一个字符的读
//    int date=-1;
//    while((date=fr.read())!=-1) {
//      System.out.print((char)date);
//    }
    //方式二：字符数组读文件
    char[] c = new char[1024];
    int data =-1;
    while((data=fr.read(c))!=-1) {
    }
    System.out.println(c);
    //为读出的文本文件追加字符
    FileWriter fw = new FileWriter("demo2.txt",true);
    fw.write("我做主");
    //关闭流
    fw.close();
    fr.close();
  }
}

6、使用带有缓冲区的流输入输出，异常处理

package demo5;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
/*
 * 使用带有缓冲区的流输入输出，异常处理
 */
public class Test1 {
  public static void main(String[] args) {
    InputStream is = null;
    InputStreamReader isr = null;
    BufferedReader br = null;
    BufferedWriter bw = null;
    try {
      // 读取文件
      is = new FileInputStream("demo5.txt");
      isr = new InputStreamReader(is, "GBK");
      br = new BufferedReader(isr);
      String info = null;
      while ((info = br.readLine()) != null) {
        System.out.println(info);
      }
      // 写入新的文本
      bw = new BufferedWriter(new FileWriter("demo5.txt", true));//熟悉之后都可以采用这种方式进行简写
      bw.newLine();
      bw.write("今天也要元气满满哦！");
    } catch (FileNotFoundException e) {
      e.printStackTrace();
    } catch (UnsupportedEncodingException e) {
      e.printStackTrace();
    } catch (IOException e) {
      e.printStackTrace();
    } finally {//注意如果不管流的话会导致很多东西出现bug，如果有bug先找是否正确的关闭流了
      if (null != bw) {
        try {
          bw.close();
        } catch (IOException e) {
          e.printStackTrace();
        }
      }
      if (null != br) {
        try {
          br.close();
        } catch (IOException e) {
          e.printStackTrace();
        }
      }
      if (null != isr) {
        try {
          isr.close();
        } catch (IOException e) {
          e.printStackTrace();
        }
      }
      if (null != is) {
        try {
          is.close();
        } catch (IOException e) {
          e.printStackTrace();
        }
      }
    }
  }
}

注意指定字符编码，请确认是GBK还是UTF-8

五、一个重要综合性利用流的例子

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;
public class IoDemo1 {
  public static void main(String[] args) {
    InputStream is = null;
    InputStreamReader isr = null;
    BufferedReader br = null;
    OutputStream os = null;
    OutputStreamWriter osw = null;
    BufferedWriter bw = null;
    try {
      // 读
      is = new FileInputStream("t1.txt");
      isr = new InputStreamReader(is, "GBK");
      br = new BufferedReader(isr);
      String info = br.readLine();
      System.out.println(info);
      // 写
      os = new FileOutputStream("t2.txt",true);
      osw = new OutputStreamWriter(os, "GBK");
      bw = new BufferedWriter(osw);
      bw.newLine();
      bw.write(info);
    } catch (FileNotFoundException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    } catch (UnsupportedEncodingException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    } finally {
      try {
        bw.close();
        osw.close();
        os.close();
        br.close();
        isr.close();
        is.close();
      } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      }
    }
  }
}

特别注意：一定要关闭流，有时候没关闭会出现很多的错误

六、序列化和反序列化

1、使用序列化保存对象信息（写出 objecOutputStream）

2、使用反序列化获取对象信息（写出 objecInputStream）
3、例子：

package Demo1;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
/*
 * 序列化和反序列化
 */
public class Test1 {
  public static void main(String[] args) throws Exception, IOException {
    ArrayList<Student> list = new ArrayList<Student>();
    Student stu1 =new Student("jck",12,"男");
    Student stu2 =new Student("lick",13,"男");
    Student stu3 =new Student("as",12,"女");
    list.add(stu1);
    list.add(stu2);
    list.add(stu3);
    //反序列化储存
    ObjectOutputStream oos =new ObjectOutputStream(new FileOutputStream("demo1.txt"));
    oos.writeObject(list);
    //反序列化
    ObjectInputStream ois =new ObjectInputStream(new FileInputStream("demo1.txt"));
    Object obj=ois.readObject();
    ArrayList<Student> stuList = (ArrayList<Student> )obj;
    for(int i =0;i<stuList.size();i++) {
      Student stu=stuList.get(i);
      System.out.println(stu);
    }
  }
}

七、反射

package Demo2;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class Test1 {
  public static void main(String[] args) {
    //先获取Student类对应的Class对象
    Class cla=Student.class;
    //获取所有构造方法
    Constructor[] cons=cla.getConstructors();
    //获取所有构造方法的个数
    System.out.println(cons.length);
    //获取所有构造方法名字
    for (int i = 0; i < cons.length; i++) {
      System.out.println(cons[i].getName());
    }
    //获取共有的属性(只能是public修饰的)
    Field[] fields=cla.getFields();
    for (int i = 0; i < fields.length; i++) {
      System.out.println(fields[i].getName());
    }
    //获取所有的属性
    Field[] fis=cla.getDeclaredFields();
    for (int i = 0;  i< fis.length; i++) {
      System.out.println(fis[i].getType());
    }
    //获取类的方法
    Method[] methods=cla.getMethods();
    for (int i = 0; i < methods.length; i++) {
      System.out.println(methods[i].getName());
    }
  }
}

package Demo2;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
/**
 * 通过反射使用有参构造方法构造Student对象
 * @author Administrator
 *
 */
public class Test2 {
  public static void main(String[] args) throws NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
    //获取Student对应的Class对象
    Class<Student> cla=Student.class;
    //获取Class对象中的构造方法
    Constructor<Student> cons=cla.getConstructor(String.class,int.class,String.class);
    //为构造方法传递参数
    Student stu=cons.newInstance("jack",100,"123456");
    System.out.println(stu);
  }
}

package Demo2;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
/*
 * 通过反射使用有参构造方法构造Student对象
 */
public class Test3 {
  public static void main(String[] args) throws Exception, SecurityException {
    //获取Student的class对象
    Class cla = Student.class;
    //获取Class对象中的构造方法
    Constructor<Student> cons=cla.getConstructor();
    Student stu=cons.newInstance();
    //获得指定set方法为属性赋值
    Method setNameMethod=cla.getDeclaredMethod("setName", String.class);
    setNameMethod.invoke(stu, "jack");
    Method setAgeMethod=cla.getDeclaredMethod("setAge", int.class);
    setAgeMethod.invoke(stu, 18);
    Method setSexMethod=cla.getDeclaredMethod("setSex", String.class);
    setSexMethod.invoke(stu, "男");
    System.out.println(stu);
  }
}

package Demo2;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
/*
 *通过反射直接为私有属性赋值 
 */
public class Test4 {
  public static void main(String[] args) throws Exception, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
    // 获取Student的class对象
    Class cla = Student.class;
    // 获取Class对象中的构造方法
    Constructor<Student> cons = cla.getConstructor();
    Student stu = cons.newInstance();
    //访问私有成员
    Field nameField=cla.getDeclaredField("name");
    //获取私有属性的操作权限
    nameField.setAccessible(true);
    nameField.set(stu, "张三");
    Field ageField=cla.getDeclaredField("age");
    //获取私有属性的操作权限
    ageField.setAccessible(true);
    ageField.set(stu, 30);
    Field sexField=cla.getDeclaredField("sex");
    //获取私有属性的操作权限
    sexField.setAccessible(true);
    sexField.set(stu, "男");
    System.out.println(stu);
  }
}

反射机制在java框架中会用到！
掌握流的类名，通过相关的构造方法去构造流！

Java中的IO流和反射

一、定义

二、分类

三、流之间的层级关系

四、流的正确使用

五、一个重要综合性利用流的例子

六、序列化和反序列化

七、反射

热门文章

最新文章

相关课程

相关电子书