IO

时间 2019-11-19

原文原文链接

IO
File：表明文件或者目录（文件夹）
  delete（）方法：若是删除的是普通的文本文件能够直接删除
        若是删除的是目录，
         1.若是目录中没有其余的文件或者目录能够直接删除
         2.若是目录中有其余的文件或者目录，先把当前目录中的文件删除才能删除当前的目录
  mkdir() 建立文件或者目录不能建立父目录
  mkdirs()   建立文件或者目录   若是父目录不存在，把父目录一块儿建立

     isDirectory()   判断文件是不是一个目录
  isFile()   判断是不是一个标准的文件

  length() 返回的是文件的长度大小

  list()   得到子文件或者目录的名字
  listFiles() ：File[]   得到子文件或者目录的对象存储到数组中


输入流    输出流
字节流（byte）   字符流（char）java

  字节流：若是读入的网络上的资源就用字节流好比：图片音频文本
  字符流：当肯定是偶数个字节才用字符流

  输入流：
   字节输入流：xxxxInputStream

   字符输入流：xxxxReader

  输出流：
   字节输入流：xxxxOutputStream

   字符输入流：xxxxWrite

转换流：
  InputStreamReader 和 OutputStreamWriter

   InputStreamReader：字节输入流转换为字符输入流
   OutputStreamWriter：字节输出流转换为字符输出流数据库

缓存流
  BufferedReader BufferedWriter

  数据先存储到缓冲区（8192字符大小），等缓冲区满了再一次性输出。

装饰者模式：
  好比二次开发的时候，发现原来的工具类功能不够强大，可是又不想改变原来的代码，就能够用
  装饰者模式来加强原来的功能。

  特色：
      1）装饰对象和真实对象有相同的接口。
   这样客户端对象就能以和真实对象相同的方式和装饰对象交互。
  （2）装饰对象包含一个真实对象的引用（reference）
  （3）装饰对象接受全部来自客户端的请求。它把这些请求转发给真实的对象。
  （4）装饰对象能够在转发这些请求之前或之后增长一些附加功能。
   这样就确保了在运行时，不用修改给定对象的结构就能够在外部增长附加的功能。

  装饰者模式简单示例：数组

public interface Car {
    //车启动时 功能
    public void run(); 
}

public class BMW1 implements Car{//这是宝马一代

    @Override
    public void run() {
        // TODO Auto-generated method stub
        System.out.println("最高时速200km/h");//只有这一个功能
    }
}

public class BMW2 implements Car{//这是宝马2代
    
    private BMW1 bm1;
    
    public BMW2(BMW1 bm1){
        this.bm1=bm1;
    }

    @Override
    public void run() {//加强了故障检测和故障排除功能
        // TODO Auto-generated method stub
        System.out.println("故障检测");
        bm1.run();
        System.out.println("故障排除");
        
    }

}

public class Go {
    
    public static void main(String[] args) {
        //真实的对象
        BMW1 bm1=new BMW1();
        
        //装饰对象
        BMW2 bm2=new BMW2(bm1);
        
        bm2.run();
    }

}

对象流
  ObjectOutputStream 和 ObjectInputStream

  注意存储的对象要实现Serializable缓存

实现Serializable 做用：

     标记Person 是可序列化的
       对象能够存储到文件中也能够经过网络进行传输
   空接口：名称：标记型的接口
            Serializable 标记型接口之一
         表明：对象可持久化的（对象保存到文件中了）

  示例：网络

public class Person implements Serializable{
    
    private String name;
    private int age;
    private String adgress;
    
    public Person(String name,int age,String adgress){
        this.name=name;
        this.age=age;
        this.adgress=adgress;
    }

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

}

public class Test4 {
    
    public void f1() throws Exception{
        Person p1=new Person("张三",20,"上海");
        
        ObjectOutputStream objOut=new ObjectOutputStream(new FileOutputStream("d:/a.txt"));
        
        objOut.writeObject(p1);
        
        objOut.flush();
        objOut.close();
    }
    
    public void f2() throws Exception{
        ObjectInputStream objIn=new ObjectInputStream(new FileInputStream("d:/a.txt"));
        
        Person p1=(Person) objIn.readObject();
        
        System.out.println(p1);
    }
    
    public static void main(String[] args) throws Exception{
        
        Test4 t=new Test4();
        
        t.f1();
        t.f2();
        
    }

}

浅克隆和深克隆
  浅克隆：学生时引用的老师teacher也被克隆了称为浅克隆

   克隆一个对象：要求被克隆的对象实现一个接口 Cloneable

   Cloneable 也是一个标记型接口：标记经过对象建立的类能够被克隆

   被克隆对象要重写clone（）方法
  ide

public class Student implements Cloneable{
    
    private int age;
    private String name;
    private Teacher teacher;
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Student(int age, String name) {
        super();
        this.age = age;
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Teacher getTeacher() {
        return teacher;
    }
    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }
    
    @Override
    protected Object clone() throws CloneNotSupportedException {
        // TODO Auto-generated method stub
        return super.clone();
    }

}

public class Teacher {
    
    private int age;
    private String name;
    private ArrayList<Student> student;
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    
    public ArrayList<Student> getStudent() {
        return student;
    }
    public void setStudent(ArrayList<Student> student) {
        this.student = student;
    }
    public Teacher(int age, String name) {
        super();
        this.age = age;
        this.name = name;
    }

}

public class Go {
    
    public static void main(String[] args) throws Exception {
        Student s1=new Student(20,"张三");
        Student s2=new Student(21,"李四");
        
        Teacher t=new Teacher(34,"陈老师");
        
        //创建学生和老师之间的联系
        s1.setTeacher(t);
        s2.setTeacher(t);
        ArrayList<Student> list=new ArrayList<Student>();
        list.add(s1);
        list.add(s2);
        t.setStudent(list);
        
        Student s1Clone=(Student) s1.clone();
        
        System.out.println(s1==s1Clone);
    }

}

深克隆：学生s1 引用的老师teacher没有被克隆称为深克隆
要用到对象流只须要把学生保存到文件中，读取出来后，与之相关联的老师也被克隆了工具

public class Student implements Serializable{
    
    private int age;
    private String name;
    private Teacher teacher;
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Student(int age, String name) {
        super();
        this.age = age;
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Teacher getTeacher() {
        return teacher;
    }
    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }

}

public class Teacher implements Serializable{
    
    private int age;
    private String name;
    private ArrayList<Student> student;
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    
    public ArrayList<Student> getStudent() {
        return student;
    }
    public void setStudent(ArrayList<Student> student) {
        this.student = student;
    }
    public Teacher(int age, String name) {
        super();
        this.age = age;
        this.name = name;
    }
}

public class Go {
    
    public static void main(String[] args) throws Exception {
        Student s1=new Student(20,"张三");
        Student s2=new Student(21,"李四");
        
        Teacher t=new Teacher(34,"陈老师");
        
        //创建学生和老师之间的联系
        s1.setTeacher(t);
        s2.setTeacher(t);
        ArrayList<Student> list=new ArrayList<Student>();
        list.add(s1);
        list.add(s2);
        t.setStudent(list);
        
        //用对象流 把s1保存到文件中
        ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("d:/a.txt"));
        
        oos.writeObject(s1);
        
        oos.flush();
        oos.close();
        
        ObjectInputStream oin=new ObjectInputStream(new FileInputStream("d:/a.txt"));
        
        Student s3=(Student) oin.readObject();
        oin.close();
        System.out.println(s1==s3);
        System.out.println(s1.getTeacher()==s3.getTeacher());
      }

}

properties：map集合下面的子类是以文件的形式进行存储的

做用：通常是用来配置文件好比存储用户名密码 java链接数据库参数

properties 存储的形式： username="张三" password="123456"this

public class Test6 {
    
    public static void main(String[] args) throws Exception {
        Properties pro=new Properties();
        File file=new File("user.properties");
        FileInputStream in=new FileInputStream(file);
        
        pro.load(in);//从user.properties中把键值对加载进来
        
        String name=pro.getProperty("username");
        String pass=pro.getProperty("password");

        System.out.println(name+"   "+pass);
    }

}

题目一：从一个文档读取文件内容，输出到控制台。spa

public static void main(String[] args) throws Exception {
        File file=new File("D:/a.txt");
        FileInputStream in=new FileInputStream(file);
        int len=0;
        byte[] by=new byte[1024];
        while((len=in.read(by))!=-1){
            String s=new String(by, 0, len);
            System.out.print(s);
        }
        
    }

View Code