java的Io流机制的学习

IO流机制

File类的使用

File类的构造方法

File(URI uri)

File(String pathname)

File(File parent, String child)

File(String parent, String child)

File类的常用方法

boolean exists():判断文件是否存在

boolean createNewFile() ：创建一个新文件,只能创建一个文件，不能创建目录（文件夹），创建时先判断文件 是否存在 ，不存在则创建并返回true, 存在则返回false.

File getAbsoluteFile() File 类型的绝对路径File文件形式，相当于 File file =new File（绝对名称），

String getAbsolutePath() String类型的绝对路径的字符串形式

String getName() : 获取的是路径的最后一级的名称

String getPath() //获取的是相对路径的名称：打File对象事调用的就是getPath()方法

String Parent() //返回当前文件的上一级目录，若没有上一级目录返回null

bolean isDirectory() //判断是否是文件

bolean isFile() //判断是否是文件夹

bolean delete()//删除一个文件或文件夹

File[] listFiles()// 只能获取当前文件夹下的的所有文件

Long length() //获取点前文件夹的长度

public class Test01_01 {
    public static void main(String[] args) throws IOException {
        // 创建文件对象：绝对路径
        File f1 = new File("d:/a.txt");
        // 创建文件对象：相对路径
        File f2 = new File("a.txt");
        boolean b1 = f1.createNewFile();
        boolean b2 = f2.createNewFile();

        String path1 = f1.getAbsolutePath(); //d:\a.txt
        String path2 =  f2.getAbsolutePath(); //C:\idea_workspace\basic-java\a.txt
        System.out.println(path1+" "+path2);
        File fpath1 = f1.getAbsoluteFile(); //d:\a.txt
        File fpath2 = f2.getAbsoluteFile(); //C:\idea_workspace\basic-java\a.txt
        System.out.println(fpath1+" "+fpath2);

        String name1 = f1.getName(); //a.txt
        String name2 = f2.getName(); //a.txt
        System.out.println(name1+" "+name2);
        /*
        获取的是相对路径
         */
        String  p1 = f1.getPath();//d:\a.txt
        String p2 = f2.getPath(); //d:\a.txt
        System.out.println(p1+" "+p2);
        File f3 = new File("d:/aaa/aa");
        System.out.println(f3.getParent()+"f3....");
        System.out.println(f2.getParent()+"f2....");
        Boolean b = f3.mkdirs();
        System.out.println(b);
        File f4 = new File(f3,"a"); //在 aaa/aa文件夹下再创建一个文件目录a
        String parent = f4.getParent();
        System.out.println(parent);
        f4.mkdir();
        File f5 = new File("d:/aaa/aa/a","a.txt");
        System.out.println(f5.getParent());
        System.out.println(f4.getName()); //a
        f5.createNewFile();//在d:/aaa/aa/a下创建一个a.txt文件
        System.out.println(f5); //d:\aaa\aa\a\a.txt,实际是复写了toStirng()方法，在toStirng中调用了getPath()
        //删除文件或文件夹delete()
        f2.delete();
        f1.delete();

    }

}

    public static void main(String[] args) {
        // 创建文件对象
        File f = new File("d:/aaa/b.txt");
        // 获得文件名
        String filename = f.getName();
        // 获得文件大小
        long filesize = f.length();
        // 获得文件的绝对路径
        String path = f.getAbsolutePath();
        // 获得父文件夹路径，返回字符串
        String parentPath = f.getParent();
        // 获得父文件夹路径，返回文件对象
        File parentFile = f.getParentFile();
        // 输出信息
        System.out.println("文件名：" + filename);
        System.out.println("文件大小：" + filesize);
        System.out.println("文件路径：" + path);
        System.out.println("文件父路径：" + parentPath);
        System.out.println("文件父路径：" + parentFile);
    }

运行结果

判断是否是文件或文件夹

    public static void main(String[] args) {
        // 创建文件对象
        File f1 = new File("d:/b.txt");
        // 判断是否是一个文件
        if(f1.isFile()) {
            System.out.println(f1.getName()+"是一个文件");
        }  else {
            System.out.println(f1.getName()+"不是一个文件");
        }
        // 创建文件对象
        File f2 = new File("d:/aaaa");
        // 判断是否是一个文件夹
        if(f2.isDirectory()) {
            System.out.println(f2.getName()+"是一个文件夹");
        }  else {
            System.out.println(f2.getName()+"不是一个文件夹");
        }
    }

运行结果：

获取当前文件夹下的所有文件列表

public class Test01_08 {
    public static void main(String[] args) {
        // 创建文件对象
        File f = new File("d:/aaa");
        // 获得文件夹下所有文件
        File[] files = f.listFiles();
        // 遍历文件数组
        for (File file : files) {
            // 将文件的名字打印到控制台
            System.out.println(file.getName());
        }
    }
}

listFiles(FileFilter filter）、File listFiles(FilenameFilter filter)

、listFile的重写方法

File[] listFiles(FileFilter filter) //返回该文件夹下满足指定过滤器条件的文件和目录。

File listFiles(FilenameFilter filter)

FileFilter 和 FilenameFilter 是一个接口，接口中只定义了accept()一个方法，要使用该接口就要实现该方法

boolean accept(File pathname)： FileFilter的方法，File pathname的File文件既有文件类型的也有目录类型的

boolean accept(File dir, String name) ： FilenameFilter的方法，

注：File dir：的所有文件都被封装成了一个目录

File[] file = f.listFile(FileFilter filter)方法的执行步骤：

1.获取文件夹下的所有文件，将所有的文件都封装成File类型

2.遍历获取的文件，调用FileFilter的accept（File pathname）方法，将文件挨个传入，根据accept()中定义的规则筛选文件，判断方法的返回值， 若方法的返回值为true则把当前遍历的File文件存放在File[]数组中`

注： 调用boolean accept(File dir, String name)的原理大致相同，只是还多了一个功能，能接收的当前文件 夹的文件名，String name：接收的是文件名称，不是路径名称

public class Test01_09 {
    public static void main(String[] args) {
        File f = new File("d:/aaa/aa/a");
        /**
         *    d:/aaa/aaa/a下有两个文件：一个_a文件夹，一个a.txt文件
         *    要求：只获取d:/aaa/aaa/a下的文件,不获取文件夹
         */
         File[] file = f.listFiles(new FilenameFilter() {
             @Override
             public boolean accept(File pathname, String name) {
                 System.out.println(name); //a.txt /_a
                 if(name.endsWith(".txt")){
                     return true;
                 }
                 return false;
             }
         });
        System.out.println(file[0]);
    }

}

**注： 使用FilenameFilter filter，所有文件都被封装成目录即文案夹

流的分类

按流向分：

• 输入流：从硬盘读取数据到内存
• 输出流：从内存中读取数据到硬盘

按读取的类型分：

• 字节流：读取时一次读取一个字节
  
  OutputStream: 输出字节流
  
  InPutStream: 输入字节流
• 字符流：读取时一次读取一个字符
  
  Reader: 输入字符流
  
  Writer：输出字节流

InputStream&OutPutStram

InputStream: 字节输入流

FileInputStream:

从硬盘读取文件内容到内存的的字节输入流

构造方法：

FileInputStream(File file)

FileInputStream(String name)

常用方法：

int read() //返回的是对应的字节数据，当没有数据时返回-1

int read(byte[] b) //返回值为读取的字节个数，

一个一个字节读取到byte[]数组中，再将byte[]数组的内容传递给应用程序

int read(byte[] b, int off, int len) //返回值为从内存中读取的字节个数

一个一个字节读取，将字节数据存放在指定的数组位置

public class Test03 {
    public static void main(String[] args) throws IOException {
        // 创建字节输入流对象并关联文件
        FileInputStream fis = new FileInputStream("d:/c.txt");
        // 定义变量接收读取的字节
        int len = -1;
        byte[] bytes = new byte[6];
        // 循环从流中读取数据
        while((len = fis.read(bytes))>0) {
            System.out.print(new String(bytes,0,len));
        }
        // 关闭流
        fis.close();
    }
}

程序读取流的流程：

java程序 -----》找到jvm虚拟机-------->通知Os操作系统-----》由OS去硬盘读取文件

os拿到文件的数据------》通知OS操作系统----->找到JVM虚拟机------》将数据返还给java程序

OutPutStram:字节输出流

FileOutputStream:从内存中读取数据到硬盘的输出流，读取的时候一个字节一个字节读取，输出的时候也是一个字节一个字节的输出

构造方法：

• FileOutputStream(File file) //创建一个输出流，将流关联到指定的输出目的地
• FileOutputStream(String name) //创建一个输出流，将流关联到指定的输出目的地
• FileOutputStream(File file, boolean append) //创建一个输出流，将流关联到指定的输出目的地，并指定是否将数据添加到文件末尾
  
  append = true:当流对象再与目的文件关联时，将数据添加到原文件的末尾
  
  append = false :当流对象再与目的文件关联时，覆盖原文件
• FileOutputStream(String name, boolean append) //创建一个输出流，将流关联到指定的输出目的地，并指定是否将数据添加到文件末尾 append = true:将数据添加到原文件的末尾 append = false :覆盖原文件

常用方法：

• void write(int b) ：//将一个字节写到指定目的地，数字>=255,写出的数据内容为空

• void write(byte[] b) // 将一个字节数组的数据写到目的地，写出的形式也是一个字节一个字节的写出到硬盘中

• void write(byte[] b, int off, int len) 将指定位置的字节数组的数据写到硬盘

• void close() //关闭流对象

  FileOutputStream fos = new FileInputStream("d/a.txt")的语义：

1.首先创建了一个输出流对象

2.输出流对象指向输出的目的地址d:/a.txt

fos.write(97)的语义：

流对象获取字节数据，将数据输出到指定的目的文件中

注：write(97)的97 代表的是一个字节，当写如文件中，文件展示是会根据编码表对数据进行解码，97在编码表中对应的是小写字母a

public class Test01 {
    public static void main(String[] args) throws IOException {
        // 1.创建字节输出流FileOutputStream对象并指定文件路径。
        FileOutputStream fos = new FileOutputStream("d:/a.txt");
        // 2.调用字节输出流的write(int byte)方法写出数据
        fos.write(254); //
        byte[] bytes = {97,98};
        fos.write(bytes);
        // 3.关闭流
        fos.close();
    }
}

文件的换行：

public class Test02 {
    public static void main(String[] args) throws IOException {
        // 1.创建字节输出流FileOutputStream对象并指定文件路径,并追加方式
        FileOutputStream fos = new FileOutputStream("d:/c.txt",true);
        // 2.调用字节输出流的write方法写出数据
        // 2.1 要输出的字符串
        String content = "i love java \r\n";
        for (int i = 0; i< 5; i++) {
            fos.write(content.getBytes());
        }
        // 3.关闭流
        fos.close();
    }
}

程序写出流的流程：

java程序 -----》找到jvm虚拟机-------->通知Os操作系统-----》由OS去内存读取文件

os拿到文件的数据------》通知OS操作系统----->找到JVM虚拟机------》将数据写入到硬盘

Reader&Writer

Reader:字符输入流

FileReader: 操作文件的字符输入流

构造方法：

FileReader(File file)

FileReader(String fileName)

常用方法：

int read()

int read(char[] cbuf) //读取数据时是按字符读取的，单底层又将字符转为字节对象，因此，返回值是字节的个数 l

例如：读取好aaahhh,

返回的int值为8，一个中文字符占2个字节

int read(char[] cbuf, int off, int len)

Writer：字符输出流

FileWriter：操作文件的字符输出流

构造方法：

• FileWriter(File file)
• FileWriter(String fileName)
• FileWriter(File file, boolean append)
• FileWriter(String fileName, boolean append)

常用方法：

• void write(int c)
• void write(char[] cbuf)
• void write(char[] cbuf, int off, int len)
• void write(String str)
• void write(String str, int off, int len)
• void flush() //将内存缓冲区的数据刷到目的文件中
• FileWriter的write()方法实现机制

首选，将要写出的字符数据转为字节数据，放到内存缓冲区中，使用flush()将缓冲区中的数据写入到文件中，因此文件的接收的还是字节数据，再根据文件的编码参照对应的编码表将字节转为对应的字符

Properties（属性集）的使用

Properties的作用：

• load(InputStream instream): //读取键值对文件到Properties集合
• store(OutputStream out, String comments)