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的作用：

巴特西

java的Io流机制的学习

最新文章

热门文章