Java基础-20

Java基础-IO流

IO流进阶2

1、IO流（File概述）

File类：

*用来将文件或者文件夹封装成对象*方便对文件或文件夹属性信息进行操作*File对象可以作为参数传递给流的构造函数*了解File类中的常见方法

java.io.File File类：文件和目录路径名的抽象表示形式。 用户界面和操作系统使用与系统相关的路径名字符串 来命名文件和目录。

测试代码：

import java.io.*;class FileDemo {    public static void main(String[] args)     {        consMethod();    }    //创建File对象    public static void consMethod()    {        //将a.txt封装成File对象，可以将已有的和未出现的文件或者文件夹封装成对象        File f1 = new File("a.txt");        File f2 = new File ("d:\\abc","b.txt");        File d = new File ("d:\\abc");        File f3 = new File(d,"c.txt");        System.out.println("f1:"+f1);        System.out.println("f2:"+f2);        System.out.println("f3:"+f3);        File f4 = new File("d:"+File.separator+"d.txt");        System.out.println("f4:"+f4);    }}

输出结果:

2、IO流（File对象功能-创建和删除）

File常见方法：创建、删除、判断、获取信息

（1）、创建 在指定位置创建文件，如果该文件已经存在，则不创建，返回false，和输出流不一样，输出流对象一建立创建文件，而且文件已经存在，会覆盖。

boolean creatNewFile();//当且仅当不存在具有此抽象路径名指定名称的文件时，不可分地创建一个新的空文件。boolean mkdir();//创建此抽象路径名指定的目录。boolean mkdirs();//创建此抽象路径名指定的目录，包括所有必需但不存在的父目录。

（2）、删除

boolean delete();//删除此抽象路径名表示的文件或目录。失败返回falsevoid deleteOnExit();//在虚拟机终止时，请求删除此抽象路径名表示的文件或目录。

3、IO流（File对象功能-判断）

（3）、判断

boolean exists();//测试此抽象路径名表示的文件或目录是否存在。boolean isFile();//测试此抽象路径名表示的文件是否是一个标准文件。boolean isDirectory();//测试此抽象路径名表示的文件是否是一个目录。boolean isHidden();//测试此抽象路径名指定的文件是否是一个隐藏文件。boolean isAbsolute();//测试此抽象路径名是否为绝对路径名。

测试代码：

import java.io.*;class FileDemo_1 {    public static void main(String[] args) throws IOException    {        Method_3();        System.out.println();        Method_2();    }    public static void Method_3() throws IOException    {        File f = new File("d:\\JAVADEMO\\day20\\FileCreatDemo.txt");        f.createNewFile();        f.mkdir();        //记住在判断文件对象是否是文件或者目的时，必须要先判断该文件对象封装的内容是否存在        System.out.println("dir:"+f.isDirectory());        System.out.println("file:"+f.isFile());        System.out.println(f.isAbsolute());    }    public static void Method_2() throws IOException    {        File f = new File ("fileDemo.txt");        System.out.println("exists:"+f.exists());        System.out.println("execute:"+f.canExecute());        //创建文件夹        File dir = new File("abc\\kk\\a\\a\\dd\\ee\\qq\\aa");        System.out.println("mkdir:"+dir.mkdirs());    }}

输出结果：

4、IO流（File对象功能-获取）

（4）、获取信息

String getName();//返回由此抽象路径名表示的文件或目录的名称。String getPath();//将此抽象路径名转换为一个路径名字符串。String getAbsolutePath();//返回此抽象路径名的绝对路径名字符串。String getParent();// 返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回 null。long lastModified();//返回此抽象路径名表示的文件最后一次被修改的时间。long length();//返回由此抽象路径名表示的文件的长度。

测试代码：

import java.io.*;class FileDemo_2 {    public static void main(String[] args) throws IOException    {        Method_4();        System.out.println();        Method_5();    }    public static void Method_4()    {        File f = new File ("file.txt");        System.out.println("path:"+f.getPath());        System.out.println("abspath:"+f.getAbsolutePath());        System.out.println("parent:"+f.getParent());        //该方法返回的是绝对路径中的父目录，如果获取的是相对路径，返回null，如果相对路径中有        //上一层目录，那么该目录就是返回结果    }    public static void Method_5()throws IOException    {        File f1 = new File("c:\\Test.java");        File f2 = new File("d:\\hhaha.java");        System.out.println("rename:"+f2.renameTo(f1));        System.out.println("file+f2:"+f2.createNewFile());        System.out.println("file+f1:"+f1.createNewFile());    }}

输出结果：

5、IO流（File对象功能-文件列表）

String [] list();//返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录。static File[] listRoots();//列出可用的文件系统根。

测试代码：

import java.io.*;class FileDemo_3 {    public static void main(String[] args) throws Exception    {        listDemo();        listRootsDemo();    }    public static void listDemo()throws Exception    {        File f = new File("c:\\");        String [] names = f.list();//调用list方法的file对象必须是封装了一个目录，该目录还必须存在。        for(int x= 0;x<names.length;x++)        {            System.out.println(names[x]);        }    }    public static void listRootsDemo()throws Exception    {        File[] files = File.listRoots();        for(File f:files)        {            System.out.println(f);        }    }}

输出结果：

6、IO流（File对象功能-文件列表2）

File [] listFiles();// 返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件。String [] list(FilenameFilter filter);//返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中满足指定过滤器的文件和目录。接口FilenameFilterboolean accept(File dir,String name);//测试指定文件是否应该包含在某一文件列表中。

Eg:

public boolean accept(File dir , String name){return name.endWith(".bmp");}

测试代码：

import java.io.*;class FileDemo_4 {    public static void main(String[] args) throws Exception    {         Method_3();         System.out.println("XXXXXXXXXXXXX");         Method_4();    }    public static void Method_3()throws Exception    {        File dir = new File("C:\\");        File []files = dir.listFiles();//获取当前目录下所有的文件的对象        for(File f : files)        {            System.out.println(f.getName()+"::"+f.getPath());        }    }    public static void Method_4()throws Exception    {        File dir = new File ("C:\\");        String [] arr = dir.list(new FilenameFilter()        {            //匿名内部类            public boolean accept(File dir,String name)            {                //System.out.println("XXXXXXXXXXXXX");                return name.endsWith(".mp3");            }        });        for(String filterFile:arr)        {            System.out.println(filterFile);        }    }}

输出结果：

7、IO流（列出目录下所有的内容-递归）

列出指定目录下文件或者文件夹，包括子目录中的内容，也就是列出指定目录下的所有内容。

因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可，在列出过程中出现的还是目录的话，还可以再次调用本功能，也就是函数自身调用自身。这种表现手法，或者编程手法，称为递归。

递归要注意：

（1）、限定条件。（2）、要注意递归的次数，尽量避免内存溢出。

递归图例：

测试代码：

import java.io.*;class FileDemo_5 {    public static void main(String[] args) throws Exception    {        File dir = new File("D:\\Program Files\\KWKGE");        showDir(dir);    }    public static void showDir(File dir)throws Exception    {        System.out.println(dir);        File [] files = dir.listFiles();        for(int x = 0 ; x<files.length;x++)        {            if(files[x].isDirectory())            {                showDir(files[x]);            }            else            {                System.out.println(files[x]);            }        }    }}

输出结果：

8、IO流（列出目录下所有内容-带层次）

Demo

import java.io.*;class FileDemo_6 {    public static void main(String[] args) throws Exception    {        File dir = new File("D:\\Program Files\\KWKGE");        showDir(dir,0);    }    public static String getLevel(int level)throws Exception    {        StringBuilder sb = new StringBuilder();        sb.append("|--");        for(int x = 0;x<level;x++)        {            sb.insert(0,"     ");        }        return sb.toString();    }    public static void showDir(File dir,int level)throws Exception    {        System.out.println(getLevel(level)+dir.getName());        level++;        File [] files = dir.listFiles();        for(int x = 0;x<files.length;x++)        {            if(files[x].isDirectory())            {                showDir(files[x],level);            }            else            {                System.out.println(getLevel(level)+files[x]);            }        }    }}

输出结果：

9、IO流（删除带内容的目录）

删除一个带内容的目录。图如下：

删除原理：在Windows中，删除目录从里面往外面删除的。既然从里面到外面删除。用递归。 测试代码：

import java.io.*;class FileDemo_7 {    public static void main(String[] args) throws Exception    {        File dir = new File ("d:\\JAVATEST");        removeDir(dir);    }    public static void removeDir(File dir)    {        File[] files = dir.listFiles();        for(int x = 0;x<files.length;x++)        {            if(files[x].isDirectory())            {                removeDir(files[x]);                System.out.println(files[x].toString()+"--file--:"+files[x].delete());            }            else            {                System.out.println(files[x].toString()+"--file--:"+files[x].delete());            }        }    }   }

输出结果：

10、IO流（创建java文件列表）

练习： 将一个指定目录下的java文件的绝对路径存储到一个文本文件中，建立一个java文件列表文件。

思路：

（1）、对指定的目录进行递归（2）、获取递归过程所有的java文件的路径。（3）、将这些路径存储到集合中。（4）、将集合中的数据写入到一个文件中。

测试代码：

import java.util.*;import java.io.*;class FileDemo_8 {    public static void main(String[] args) throws Exception    {        File dir = new File("d:\\JAVADEMO");        List<File> list = new ArrayList<File>();        fileToList(dir,list);        System.out.println(list.size());        File file = new File("d:\\javaList.txt");        writeToFile(list,file.toString());    }    public static void fileToList(File dir,List<File>list)    {        File[]files = dir.listFiles();        for(File file : files)        {            if(file.isDirectory())            {                fileToList(file,list);            }            else            {                if((file.getName().endsWith(".java")))                {                    list.add(file);                }            }        }    }    public static void writeToFile(List<File>list,String javaListFile)throws IOException//写到文件中    {        BufferedWriter bufw = null;        try        {            bufw = new BufferedWriter(new FileWriter(javaListFile));            for(File f : list)            {                String path = f.getAbsolutePath();                bufw.write(path);                bufw.newLine();                bufw.flush();            }        }        catch (IOException e)        {            throw e;        }        finally        {            try            {                if(bufw!=null)                {                    bufw.close();                }            }            catch (IOException e)            {                throw e;            }           }    }}

输出结果：

11、IO流（Properties简述）

java.util.Properties Properties 类表示了一个持久的属性集。Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。 Properties是hashtable的子类，也就是说它具备map集合的特点，而且它里面存储的键值对都是字符串。是集合中和IO技术相结合的集合容器，该对象的特点：可以用于键值对形式的配置文件。那么在加载数据时，需要数据有固定形式：键=值

12、IO流（Properties存取）

Object setProperty(String key,String value);//调用 Hashtable 的方法 put。String getProperty(String key);//用指定的键在此属性列表中搜索属性。Set <String> StringPropertyNames();//返回此属性列表中的键集，其中该键及其对应值是字符串，如果在主属性列表中未找到同名的键，则还包括默认属性列表中不同的键。

测试代码：

import java.io.*;import java.util.*;class PropertiesDemo{    public static void main(String []args)    {        Properties prop = new Properties();        prop.setProperty("zhangsan","30");        prop.setProperty("lisi","39");        System.out.println(prop);        String value = prop.getProperty("lisi");        System.out.println(value);        prop.setProperty("lisi",89+" ");        value = prop.getProperty("lisi");        System.out.println(value);        Set<String> names = prop.stringPropertyNames();        for(String s : names)        {            System.out.println(s+":"+prop.getProperty(s));        }    }}

输出结果：

13、IO流（存取配置文件）

void list(PrintStream out);//将属性列表输出到指定的输出流。void list(PrintWriter out);// 将属性列表输出到指定的输出流。void load(InputStream inStream);//从输入流中读取属性列表（键和元素对）。void load(Reader reader);//按简单的面向行的格式从输入字符流中读取属性列表（键和元素对）。void store(OutputStream out ,String comments);//以适合使用 load(InputStream) 方法加载到Properties 表中的格式，将此 Properties 表中的属性列表（键和元素对）写入输出流。void store(Writer writer,String comments);//以适合使用 load(Reader) 方法的格式，将此 Properties 表中的属性列表（键和元素对）写入输出字符。

测试代码：

import java.io.*;import java.util.*;class PropertiesDemo_1{    public static void main(String []args)throws IOException    {        loadDemo();        //method_1();    }    public static void loadDemo()throws IOException    {        Properties prop = new Properties();        FileInputStream fis = new FileInputStream("D:\\JAVADEMO\\day20\\info.txt");        //将流中的数据加载进Properties的对象中        prop.load(fis);        prop.setProperty("wangwu","30");        //以上修改了内容，可是修改了以后只是在内存中的数值，没存到数据流中。所以        FileOutputStream fos = new FileOutputStream("info.txt");        prop.store(fos,"haha");        System.out.println(prop);        prop.list(System.out);        fos.close();        fis.close();    }}

输出结果：

演示：如何将流中的数据存储到集合中，想要将config.ini中键值数据存到集合中进行操作。 思路：

（1）、用一个流和info.txt文件关联（2）、读取一行数据，将该行数据用“=”进行切割（3）、等号左边作为键，右边作为值，存入到Properties集合即可。

源文件：

测试代码：

import java.io.*;import java.util.*;class PropertiesDemo_2{    public static void main(String []args)throws IOException    {        method_1();    }    public static void method_1()throws IOException    {        BufferedReader bufr = new BufferedReader(new FileReader("D:\\eclipse\\configuration\\config.ini"));        String line = null;        Properties prop = new Properties();        while((line = bufr.readLine())!=null)        {            String[] arr = line.split("=");            System.out.println(arr[0]+"......"+arr[1]);            prop.setProperty(arr[0],arr[1]);        }        bufr.close();        System.out.println(prop);    }}

输出：

14、IO流（Properties练习）

用于记录应用程序运行次数 如果使用次数已到，那么给出注册提示

很容易想到的是计数器 可是该计数器定义在程序中，随着程序的运行而在内存中存在，并进行自增。 可是随着该应用程序的退出，该计数器也在内存中消失了。

下一次在启动该程序，又重新开始从0计数。这样不是我们想要的。

程序即使结束，该计数器的值也存在。下次程序启动会先加载该计数器的值并加1后再重新存储起来。所以要建立一个配置文件，用于记录该软件的使用次数。

该配置文件使用键值的形式，这样便于阅读数据，并操作数据。

键值对数据是map集合。数据是以文件形式存储，使用io技术。

那map+io--------------->properties

配置文件可以实现应用程序数据的共享。

测试代码：

import java.io.*;import java.util.*;class  RunCount{    public static void main(String[] args)throws IOException     {        Properties prop = new Properties();        File file = new File("D:\\JAVADEMO\\day20\\count.ini");        if(!file.exists())        {            file.createNewFile();        }        FileInputStream fis = new FileInputStream(file);        prop.load(fis);        int count = 0;        String value = prop.getProperty("time");        if(value!= null)        {            count = Integer.parseInt(value);            if(count >= 5)            {                System.out.println("您好，使用次数已到。拿钱！");                return;            }        }        count++;        prop.setProperty("time",count+" ");        FileOutputStream fos = new FileOutputStream(file);        prop.store(fos,"haha");        fos.close();        fis.close();    }}

输出结果：

15、IO流（PrintWriter）

打印流：该流提供了打印方法，可以将各种数据类型的数据都原样打印。

字节打印流：PrintStream，构造函数可以接收的参数类型

（1）、file对象，File（2）、字符串路径。String（3）、字节输出流。OutputStream

字符打印流：PrintWriter，构造函数可以接收的参数类型

（1）、file对象，File（2）、字符串路径：String（3）、字节输出流：OutputStream（4）、字符输出流：Writer

测试代码：

import java.io.*;import java.util.*;class PrintStreamDemo{    public static void main()throws IOException    {        BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));        PrintWriter out = new PrintWriter(System.out);//字符打印流        String line = null;        while((line = bufr.readLine())!=null)        {            if("over".equals(line));            {                break;            }            out.println(line.toUpperCase());            out.flush();//要等所有都输入完毕才能释放完，如果不想这样，可以这样：            //PrintWriter out = new PrintWriter(System.out，true);            //表示自动释放流        }        out.close();        bufr.close();    }}

16、IO流（合并流）

类SequenceInputStream（序列流），对多个流进行合并并操作。

测试代码：

import java.io.*;import java.util.*;class SequenceDemo{    public static void main(String [] args)throws IOException    {        Vector<FileInputStream> v = new Vector<FileInputStream>();        v.add(new FileInputStream("C:\\1.txt"));        v.add(new FileInputStream("C:\\2.txt"));        v.add(new FileInputStream("C:\\3.txt"));        Enumeration<FileInputStream> en = v.elements();        SequenceInputStream sis = new SequenceInputStream(en);        FileOutputStream fos = new FileOutputStream("C:\\4.txt");        byte[] buf = new byte[1024];        int len = 0;        while((len = sis.read(buf))!=-1)        {            fos.write(buf,0,len);        }        fos.close();        sis.close();    }}

输出结果：