javaIO框架

javaIO框架

1.流

内存与存储设备之间传输数据的通道

1.1流的分类

• 按方向
• 输入流：将存储设备中的内容读入到内存中
• 输出流：将内存中的内容写入到存储设备中
• 按单位
• 字节流：以字节为单位，可以读写所有数据
• 字符流：以字符为单位，只能读写文本数据
• 按功能：
• 节点流：具有实际传输数据的读写功能
• 过滤流：在节点流的基础之上增加功能

1.2字节流的父类（抽象类）

InputStream：字节输入流

OutputStream：字节输出流

1.2.1FileInputStream

public static void main(String[] args) throws Exception{
     //创建FileInputStream,并指定文件路径
      FileInputStream fis=new FileInputStream("d:\\aaa.txt");
      //读取文件
      //单个字节读取
//      int data=0;
//     while ((data=fis.read())!=-1){
//       System.out.print((char)data);//abcdefg
//     }
     //一次读取多个字节
      byte[] buf=new byte[1024];
      int count=0;
     while ((count=fis.read(buf))!=-1){
       System.out.println(new String(buf,0,count));//abcdefg

     }
     //关闭
      fis.close();
      System.out.println();
      System.out.println("执行完毕");//执行完毕
    }

1.2.2FileOutputStream

public static void main(String[] args) throws Exception{
    //创建文件字节输出流对象
    FileOutputStream fos=new FileOutputStream("d:\\bbb.txt",true);//加true代表追加
    //写入文件
//    fos.write(97);
//    fos.write('b');
//    fos.write('c');
    String string="helloworld";//
    fos.write(string.getBytes());
    fos.close();
    System.out.println("执行完毕");
  }

1.2.3字节流复制文件

public static void main(String[] args) throws Exception{
  //创建流
  //文件字节输入流
  FileInputStream fis=new FileInputStream("D:\\001.png");
  //文件字节输出流
  FileOutputStream fos=new FileOutputStream("D:\\002.png");
  //一边读，一边写
  byte[] buf=new byte[1024];
  int count=0;
  while ((count=fis.read(buf))!=-1){
    fos.write(buf,0,count);
  }
  fis.close();
  fos.close();
  System.out.println("复制完毕");
}

1.2.4字节缓冲流

字节输入缓冲流

public static void main(String[] args) throws Exception{
    //创建BufferedInputStream
    FileInputStream fis=new FileInputStream("d:\\aaa.txt");
    BufferedInputStream bis=new BufferedInputStream(fis);
    //读取
//    int data=0;
//    while((data=bis.read())!=-1){
//      System.out.print((char)data);
//    }
    byte[] buf=new byte[1024];
    int count=0;
    while ((count=bis.read(buf))!=-1){
      System.out.print(new String(buf,0,count));
    }
    //关闭
    bis.close();
  }

字节输出缓冲流

public static void main(String[] args) throws Exception{
  //创建字节缓存输出流
  FileOutputStream fos=new FileOutputStream("D:\\buff.txt");
  BufferedOutputStream bos=new BufferedOutputStream(fos);
  //写入文件
  for (int i = 0; i < 10; i++) {
    bos.write("helloworld\r\n".getBytes());//写入8k缓存区
    bos.flush();//刷新到硬盘
  }
  //关闭(内部调用flush方法)
  bos.close();
}

1.3对象流

1.3.1序列化

序列化的类必须要实现Serializable接口

序列化类中的属性也必须要实现Serializable接口

序列化版本ID，保证序列化和反序列化是同一个类

使用transient修饰属性，这个属性不能序列化

静态属性不能序列化

序列化多个对象

public class Student implements Serializable {
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public static void main(String[] args) throws Exception{
    FileOutputStream fos=new FileOutputStream("D:\\stu.bin");
    ObjectOutputStream oos=new ObjectOutputStream(fos);
    Student s = new Student("张三", 20);
    Student s2 = new Student("李四", 22);
    ArrayList<Student> list=new ArrayList<>();
    list.add(s);
    list.add(s2);
    oos.writeObject(list);//oos.writeObject(s);
    oos.close();
}

1.3.2反序列化

public static void main(String[] args) throws Exception{
    FileInputStream fis=new FileInputStream("D:\\stu.bin");
    ObjectInputStream ois=new ObjectInputStream(fis);
    //Student s=(Student) ois.readObject();
    ArrayList<Student> list=(ArrayList<Student>) ois.readObject();
    ois.close();
    System.out.println(list);
}

1.4字符流

字符编码

1.4.1字符流抽象类

1.4.1.1文件字符流

1.4.1.1.1Filereader

public static void main(String[] args) throws Exception{
        FileReader fr=new FileReader("D:\\aaa.txt");
        //读取
        //单个字符读取
//        int data=0;
//        while ((data=fr.read())!=-1){
//            System.out.print((char)data);
//        }
        //多个字符读取
        char[] by=new char[2];
        int count=0;
        while ((count=fr.read(by))!=-1){
            System.out.print(new String(by,0,count));//好好学习
        }
        //关闭
        fr.close();
    }

1.4.1.1.2FileWriter

public static void main(String[] args) throws Exception{
   FileWriter fw=new FileWriter("D:\\write.txt");
    for (int i = 0; i < 10; i++) {
        fw.write("hello\r\n");
        fw.flush();
    }
    fw.close();
    System.out.println("执行完毕");
}

使用FileReaser和FileWriter只能复制文本文件，不能复制图片和二进制文件

使用字节流可以复制任意文件

public static void main(String[] args) throws Exception{
   //使用FileReaser和FileWriter复制文本文件
   FileReader fr=new FileReader("D:\\write.txt");
   FileWriter fw=new FileWriter("D:\\write2.txt");
   int data=0;
   while ((data=fr.read())!=-1){
       fw.write(data);
       fw.flush();
   }
   fr.close();
   fw.close();
}

1.4.1.2BufferedReader的使用

 public static void main(String[] args) throws Exception{
       FileReader fr=new FileReader("D:\\write.txt");
       BufferedReader br=new BufferedReader(fr);
       //读取
        //第一种方式
//        char[] by=new char[1024];
//        int count=0;
//        while ((count=fr.read(by))!=-1){
//            System.out.println(new String(by,0,count));
//        }
        //第二种方式
        String line=null;
        while ((line=br.readLine())!=null){
            System.out.println(line);
        }
        br.close();
    }

1.4.2BufferedWriter的使用

public static void main(String[] args) throws Exception{
   FileWriter fw=new FileWriter("D:\\buffer.txt");
   BufferedWriter bw=new BufferedWriter(fw);
    for (int i = 0; i <10 ; i++) {
        bw.write("好好学习");
        bw.newLine();
        bw.flush();
    }
    bw.close();
}

1.4.3PrintWriter

public static void main(String[] args) throws Exception{
   PrintWriter pw=new PrintWriter("d:\\ccc.txt");
   pw.println(97);
   pw.println(3.14);
   pw.println(true);
   pw.println('a');
    System.out.println("执行完毕");
    pw.close();

}

1.4.4转换流

public static void main(String[] args) throws Exception{
    //InputStreamReader
   FileInputStream fis=new FileInputStream("d:\\write.txt");
   InputStreamReader isr=new InputStreamReader(fis,"utf-8");
   int data=0;
   while ((data=isr.read())!=-1){
       System.out.print((char)data);
   }
   isr.close();
}

public static void main(String[] args) throws Exception{
    //OutputStreamWriter
   FileOutputStream fos=new FileOutputStream("d:\\info.txt");
   OutputStreamWriter osw=new OutputStreamWriter(fos,"utf-8");
    for (int i = 0; i < 10; i++) {
        osw.write("我爱放学\r\n");
        osw.flush();
    }
    osw.close();
    System.out.println("执行成功");
}

2.File类

2.1分隔符

//分隔符
public static void separator(){
    System.out.println("路径分隔符"+File.pathSeparator);//路径分隔符;
    System.out.println("名称分隔符"+File.separator);//名称分隔符\
}

2.2文件操作

//文件操作
    public static void fileOpe()throws Exception{
        //创建文件
        File file=new File("d:\\file.txt");
        if(!file.exists()){
            boolean b=file.createNewFile();
            System.out.println(b);
        }
        //删除文件
        //直接删除
        //System.out.println(file.delete());
        //使用jvm退出时删除
//        file.deleteOnExit();
//        Thread.sleep(5000);//睡眠5秒
        //获取文件信息
        System.out.println("获取文件绝对地址"+file.getAbsoluteFile());
        System.out.println("获取文件路径"+file.getPath());
        System.out.println("获取文件名称"+file.getName());
        System.out.println("文件父目录"+file.getParent());
        System.out.println("获取文件长度"+file.length());
        System.out.println("文件创建时间"+new Date(file.lastModified()).toLocaleString());
        
        //判断
        System.out.println("文件是否可写"+file.canWrite());
        System.out.println("文件是否是文件"+file.isFile());
        System.out.println("文件是否隐藏"+file.isHidden());
    }

2.3文件夹操作

 //文件夹操作
    public static void directoryOpe() throws Exception{
        //创建文件夹
        File dir=new File("d:\\aaa\\bbb\\ccc");
        if(!dir.exists()){
//            dir.mkdir()//创建单机目录
            System.out.println("创建结果"+dir.mkdirs()); //创建多级目录
        }
        //删除文件夹
        //直接删除(只能删除空目录）
//        System.out.println("删除结果"+dir.delete());
        //使用jvm删除
//        dir.deleteOnExit();
//        Thread.sleep(5000);
        //获取文件信息
        System.out.println("获取绝对路径"+dir.getAbsoluteFile());
        System.out.println("获取路径"+dir.getPath());
        System.out.println("获取文件名称"+dir.getName());
        System.out.println("获取父目录"+dir.getParent());
        System.out.println("获取创建时间"+new Date(dir.lastModified()).toLocaleString());
        //判断
        System.out.println("文件是文件夹"+dir.isDirectory());
        System.out.println("文件是隐藏"+dir.isHidden());
        //遍历文件夹
        File dir2=new File("d:\\t");
        String[] files=dir2.list();
        for (String file : files) {
            System.out.println(file);
        }
    }

2.4FileFilter接口

 //FileFilter的使用
File[] files2=dir2.listFiles(new FileFilter() {
    @Override
    public boolean accept(File pathname) {
        if(pathname.getName().endsWith(".jpg")){
            return true;
        }
        return false;
    }
});
    for (File file : files2) {
        System.out.println(file.getName());
    }
}

2.5遍历递归和遍历删除

public class Test {
    public static void main(String[] args) {
        listDir(new File("d:\\j"));
    }
    //递归遍历文件夹
    public static void listDir(File dir){
        File[] files=dir.listFiles();
        System.out.println(dir.getAbsoluteFile());
        if(files!=null&&files.length>0){
            for (File file : files) {
                if(file.isDirectory()){
                    listDir(file);
                }
                else {
                    System.out.println(file.getAbsoluteFile());
                }
            }
        }
    }
}

//递归删除文件夹
public static void deleteDir(File dir){
    File[] files=dir.listFiles();
    if(files!=null&&files.length>0){
        for (File file : files) {
            if(file.isDirectory()){
                deleteDir(file);
            }
            else {
                System.out.println(file.getAbsoluteFile()+"删除"+file.delete());
            }
        }
    }
    System.out.println(dir.getAbsoluteFile()+"删除"+dir.delete());
}

2.6Properties

public static void main(String[] args) throws Exception{
    Properties properties=new Properties();
    //添加元素
    properties.setProperty("username","lily");
    properties.setProperty("age","20");
    System.out.println(properties.toString());
    //遍历元素
    //keySet
    //entrySet
    //stringPropertyNames
    Set<String> pronames=properties.stringPropertyNames();
    for (String string : pronames) {
        System.out.println(string+"===="+properties.getProperty(string));
    }
    //和流有关的方法
    //list
    PrintWriter pw=new PrintWriter("d:\\print.txt");
    properties.list(pw);
    pw.close();
    //store保存
    FileOutputStream fos=new FileOutputStream("d:\\store.properties");
    properties.store(fos,"注释");
    fos.close();
    //load加载
    Properties properties1=new Properties();
    FileInputStream fis=new FileInputStream("d:\\store.properties");
    properties1.load(fis);
    fis.close();
    System.out.println(properties1);
}