前言

本周是学习java的第七周，学习了File对象和IO的四大抽象类

参考教程：

W3Cschool

本周学习要点：

1.路径对象使用String类。

2.System.getProperty("user.dir")可获取用户当前项目路径。

3.File对象有三种构造器：

File src = new File(pathname)
File src = new File(String parent, child)
File src = new File(File parent, child)

前者传入路径即可，后者需要传入两个路径，加起来等于需要路径即可。

4.对File对象调用getAbsolutePath()可以查看其绝对路径。

5.路径分绝对和相对，一般前期在windows开发，后期在部署时需要部署到linux服务器上，所以最好不要使用绝对路径，避免部署时需要修改。

6.一般可以使用双斜杠\\或反斜杠/或File.separator来表示目录分隔，但双斜杠需要转义，不推荐使用。

7.对File对象使用length方法会返回文件大小(若文件存在的话)。

8.需要记住的是，File可以构建一个不存在的路径(文件)。

9.状态判断

方法	作用
.exists()	判断是否存在（前提）
.isFile()	判断是否文件
.isDirectory()	判断是否目录

10.创建文件createNewFile()(不存在才创建)；删除文件delete()(存在才删除)。创建文件mkdir()，必须保证父目录存在；mkdirs()，父目录无须存在。

11.文件名，路径名的获取

方法	作用
.getName()	获取文件名
.getPath()	获取文件路径(取决于path是否绝对/相对路径)
.getAbsolutePath()	获取绝对路径
.getParent()	获取文件的上一级(取决文件的path而非绝对路径)
.getParentFile()	返回父对象(FIle对象)

12.列出下级名称和下级对象

方法	作用
.list()	列出下级名称(返回一个String数组)
.listFile()	列出下级对象(返回一个File数组)

13.一个完整的JavaBean需要对应的set，get方法和一个无参构造器(约定俗成的)。

14.四大抽象类InputStream、OutputStream、Reader、Writer ，前两个可以处理字节流和字符流、后两个只能处理字符流

15.可变参数，本质是动态的创建数组

    public static int getSum(int...arr){
        int sum = 0;
        for (int i : arr) {
            sum+=i;
        }
        return sum;

16.释放资源可以使用try-with-resource（jdk7以上支持）

try(InputStream in = new FileInputStream(src); OutputStream out = new FileOutputStream(dst))

将JavaBean存储到List里面（orm思想）

public class test2 {
    public static void main(String[] args) {
        User user1 = new User(1001,"张三",20004,"2018.5.5");
        User user2 = new User(1002,"李四",20020,"2018.2.5");
        User user3 = new User(1003,"王五",20010,"2018.1.5");
        List<User> list = new ArrayList<>();
        list.add(user1);
        list.add(user2);
        list.add(user3);
        for(User u:list){
            System.out.println(u);
        }
    }
}

class User{
    private int id;
    private String name;
    private double salary;
    private String hiredate;
    
    

    public User() {
    }

    public User(int id, String name, double salary, String hiredate) {
        super();
        this.id = id;
        this.name = name;
        this.salary = salary;
        this.hiredate = hiredate;
    }
    
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public double getSalary() {
        return salary;
    }
    public void setSalary(double salary) {
        this.salary = salary;
    }
    public String getHiredate() {
        return hiredate;
    }
    public void setHiredate(String hiredate) {
        this.hiredate = hiredate;
    }
    
    @Override
    public String toString() {
        return "id:"+id+".name:"+name+".salary:"+salary+".hiredate:"+hiredate;
    }
}

使用FileInputStream读取文件

        File src = new File("io.txt");//创建源
        InputStream ips = null;
        int temp=0;
        try {
            ips = new FileInputStream(src);
            while((temp=ips.read())!=-1){
                System.out.print((char)temp);
            }
        } catch (Exception e) {
            // TODO: handle exception
        }finally {
            if(ips!=null){
                try {
                    ips.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }

或

        File src = new File("io.txt");
        InputStream iStream = null;
        try {
            iStream = new FileInputStream(src);
            byte[] bs = new byte[(int)src.length()];
            iStream.read(bs);
            String st = new String(bs);
            System.out.println(st);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if(iStream!=null){
                try {
                    iStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

OutputStream写入文件

        File src = new File("io03.txt");//创建源，不存在则自动创建
        OutputStream os = null;
        try {
            os = new FileOutputStream(src,true);//为true则为追加模式
            String mString = "io try output";
            byte[] datas = mString.getBytes();
            os.write(datas,0,datas.length);
            os.flush();
            System.out.println("wrtite string successful!");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(os!=null){
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

文件的拷贝结合写入和读取

    public static void copy(String srcPath,String detPath) {
        File src = new File(srcPath);//源文件
        File det = new File(detPath);//目标文件
        InputStream is = null;
        OutputStream os = null;
        try {
            is = new FileInputStream(src);
            os = new FileOutputStream(det);
            byte[] bt = new byte[(int)src.length()];
            is.read(bt);
            os.write(bt,0,bt.length);
            os.flush();
            System.out.println("successful!!");
        } catch (Exception e) {
            // TODO: handle exception
        }finally {
            if(is!=null||os!=null){
                try {
                    System.out.println("closing!");
                    os.close();
                    is.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }

使用Reader和Writer拷贝

public static void copyByReWr(String srcCopy,String detCopy) {
        File src = new File(srcCopy);
        File det = new File(detCopy);
        Reader reader = null;
        Writer writer =null;
        try {
            reader = new FileReader(src);
            writer = new FileWriter(det);
            char[] cs = new char[(int)src.length()];
            String string;
            int len=-1;
            System.out.println("The file is copying!!!");
            System.out.println("*************************");
            while((len=reader.read(cs))!=-1){
                string = new String(cs,0,len);
                writer.append(string);
            }
            writer.flush();
            System.out.println("The file copy successfully!!");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(reader!=null||writer!=null){
                try {
                    writer.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                try {
                    reader.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }

将输入流输出流封装且调用

public class IOTest11 {
    public static void main(String[] args) {
        InputStream is = null;
        OutputStream os = null;
        try {
            is = new FileInputStream("io.txt");
            os = new FileOutputStream("io5.txt");
            StreamApi(is, os);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }finally {
            if(is!=null||os!=null){
                try {
                    os.close();
                    is.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }

    }   
    
    public static void StreamApi(InputStream is,OutputStream os) {
        byte[] st = new byte[1024];
        int len = -1;
        try {
            while((len=is.read(st))!=-1){
                os.write(st,0,len);
            }
            os.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

传统关闭流

    public static void Myclose(Closeable...ios) {
        for(Closeable io:ios){
            try {
                io.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

java第七周周报