IO流_2

File类

用来将文件或者文件夹封装成对象

方便对文件与文件夹的属性信息进行操作

File对象可以作为参数传递给流的构造函数

了解File类中的常用方法

构造方法

File(File parent, String child)    //从父抽象路径名和子路径名字符串创建新的 File实例。  
File(String pathname)    //通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。  
File(String parent, String child)    //从父路径名字符串和子路径名字符串创建新的 File实例。  
File(URI uri)    //通过将给定的 file: URI转换为抽象路径名来创建新的 File实例。  

import java.io.File;

public class FileDemo {
    public static void main(String[] args){
        constructiorDemo();
    }
    public static void constructiorDemo(){
        //可以将一个已存在的，或者不存在的文件或者目录封装成file对象
        File f1=new File("c:\\a.txt");
        File f2=new File("c:\\","a.txt");
        File f=new File("c:\\");
        File f3=new File(f,"a.txt");
        File f4=new File("c:"+File.separator+"abc"+File.separator+"a.txt");//字段分隔符
        System.out.println(f4);
    }
}

常见方法

import java.io.File;
import java.io.IOException;
import java.text.DateFormat;
import java.util.Date;

public class FileMethodDemo {

    public static void main(String[] args)throws IOException{
        /*getDemo();
        createAndDeleteDemo();
        isDemo();
        renameToDemo();
        listRootsDemo();
        listDemo();*/
        listDemo_2();
    }
    /*
     * File对象的常见方法
     * 1.获取
     *   1.1获取文件名称
     *   1.2获取文件路径
     *   1.3获取文件大小
     *   1.4获取文件修改时间
     */
    public static void getDemo(){
        File file=new File("a.txt");
        String name=file.getName();
        String absPath=file.getAbsolutePath();//绝对路径
        String path=file.getPath();
        long len=file.getFreeSpace();//剩余空间

        long time=file.lastModified();//最后一次修改时间
        Date date=new Date(time);
        DateFormat dateFormat=DateFormat.getDateTimeInstance(DateFormat.LONG,DateFormat.LONG);
        String str_time=dateFormat.format(date);
    }
    /*2.创建与删除
    * boolean*/
    public static void createAndDeleteDemo()throws IOException {
        File file=new File("file.txt");
        /*和输出流不一样，如果文件不存在，则创建，如果文件存在，则不创建*/
        boolean b=file.createNewFile();

        boolean c=file.delete();//删除文件

        File dir=new File("abc\\q1\\w\\e\\r");
        boolean d=dir.mkdir();//创建目录，如果目录底下有文件，delete删除无效,如果全是目录，则删除最底层
    }
    /*3.判断*/
    public static void isDemo(){
        File f=new File("a.txt");
        boolean b=f.exists();
        boolean c=f.isDirectory();//是否为目录
    }
    /*4.重命名*/
    public static void renameToDemo(){
        File f1=new File("c:\\0.mp3");
        File f2=new File("c:\\9.mp3");
        boolean b=f1.renameTo(f2);
    }
    /*5.系统根目录和容量获取*/
    public static void listRootsDemo(){
      /*  File[] files=File.listRoots();//系统根目录
        for (File file:files){
            System.out.println(file);
        }*/
      File file=new File("d:\\");
      System.out.println("getFreeSpace:"+file.getFreeSpace());
      System.out.println("getTotalSpace:"+file.getTotalSpace());
      System.out.println("getUsableSpace"+file.getUsableSpace());//返回此抽象路径名指定的分区上可用于此虚拟机的字节数
    }
    /*6.获取当前目录内容，包含隐藏文件
    * 调用list方法的File滴哦瞎忙活这家拍卖行封装的必须是目录
    * 否则会发生NullPointerException
    * 如果访问系统级目录也会发生空指针异常
    *
    * 如果目录存在但是没有内容，会返回一个数组，但是长度为0*/
    public static void listDemo(){
        File file=new File("c:\\");
        String[] names=file.list();
        for (String name:names){
            System.out.println(name);
        }
    }
}

过滤器

import java.io.File;

public class FileListDemo {
    public static void main(String[] args) {
        listDemo();
    }
    /*6.获取当前目录内容，包含隐藏文件
     * 调用list方法的File滴哦瞎忙活这家拍卖行封装的必须是目录
     * 否则会发生NullPointerException
     * 如果访问系统级目录也会发生空指针异常
     *
     * 如果目录存在但是没有内容，会返回一个数组，但是长度为0*/
    public static void listDemo() {
        File file = new File("c:\\");
        String[] names = file.list(new FilterByJava());//过滤.java文件
        for (String name : names) {
            System.out.println(name);
        }
    }
    /*过滤.XXX文件*/
    public static void listDemo_2() {
        File dir = new File("c:\\");
        String[] names = dir.list(new SuffixFilter(".sys"));
        for (String name : names) {
            System.out.println(name);
        }
    }
    /*过滤隐藏文件*/
    public static void listDemo_3() {
        File dir = new File("c:\\");
        File[] files = dir.listFiles(new FilterByHidden());//拿到当前文件下的所有对象(隐藏文件)
        for (File file : files) {
            System.out.println(file);
        }
    }
}

过滤.java文件

package com.monfolld.IO流.File;

import java.io.File;
import java.io.FilenameFilter;

public class FilterByJava implements FilenameFilter {
    @Override
    public boolean accept(File dir,String name){
        return  name.endsWith(".java");
    }
}

过滤.xxx文件

package com.monfolld.IO流.File;

import java.io.File;
import java.io.FilenameFilter;
/*专门过滤后缀名*/
public class SuffixFilter implements FilenameFilter {
    private String suffix;
    public SuffixFilter (String suffix){
        super();
        this.suffix=suffix;
    }
    @Override
    public boolean accept(File dir,String name){
        return name.endsWith(suffix);
    }
}

过滤隐藏文件

package com.monfolld.IO流.File;

import java.io.File;
import java.io.FileFilter;

public class FilterByHidden implements FileFilter {
    @Override
    public boolean accept(File pathname){
        return  pathname.isHidden();
    }
}

练习：深度遍历文件夹

package com.monfolld.IO流.File;

import java.io.File;

/*需求：
*   对指定目录进行所有内容的列出(包括目录中的内容)
*   也可以理解为深度遍历*/
public class FileTest {
    public static void main(String[] args){
        File dir=new File("d:\\游戏");
        listAll(dir,0);
    }
    public static void listAll(File dir,int level){

        System.out.println(getSpace(level)+dir.getAbsolutePath());
        //获取指定目录下当前的所有文件夹或者对象
        level++;
        File[] files=dir.listFiles();

        for (int x=0;x<files.length;x++){
            if (files[x].isDirectory()){
                listAll(files[x],level);
            }
            System.out.println(files[x].getAbsolutePath());
        }
    }
    private static String getSpace(int level){
        StringBuilder sb=new StringBuilder();
        for (int x=0;x<level;x++){
            sb.append("|     ");
        }
        return sb.toString();
    }
}

删除目录

package com.monfolld.IO流.File;

import java.io.File;

//删除一个带内容的目录
//原理：必须从里面往外删
public class RemoveDirTest {
    public static void main(String[] args){
        File dir=new File("e:\\demodir");
        //dir.delete();
        removeDir(dir);
    }
    public static void removeDir(File dir){
        File[] files=dir.listFiles();
        for (File file:files){
            if (file.isDirectory()){
                removeDir(file);
            }else {
                System.out.println(file+":"+file.delete());
            }
        }
        System.out.println(dir+":"+dir.delete());
    }
}

Properties集合

表示了一个持久的属性集。

String getProperty(String key)    //使用此属性列表中指定的键搜索属性。 
String getProperty(String key, String defaultValue)     //使用此属性列表中指定的键搜索属性。  
void list(PrintStream out)    //将此属性列表打印到指定的输出流。  
void list(PrintWriter out)    //将此属性列表打印到指定的输出流。  
void store(OutputStream out, String comments)    //将此属性列表（键和元素对）写入此 Properties表中，以适合于使用 load(InputStream)方法加载到 Properties表中的格式输出流。  
void load(InputStream inStream)    //从输入字节流读取属性列表（键和元素对）。  

package com.monfolld.IO流.properties;

import java.io.*;
import java.util.Properties;
import java.util.Set;

public class propertiesDemo {
    public static void main(String[] args)throws IOException{
        /*Properties集合
        * 特点：
        * 1.该集合中的键和值都是字符串类型
        * 2.集合中的数据可以保存到流中，或者从流中获取
        * 通常该集合用于操作以键值对形式存在的配置文件 */
        test();
    }
    /*properties集合的存和取*/
    public static void propertiesDemo(){
        //创建一个Properties集合
        Properties prop=new Properties();
        //存储元素
        prop.setProperty("zhangsan","30");
        prop.setProperty("lisi","31");
        prop.setProperty("wangwu","36");
        prop.setProperty("zhaoliu","20");
        //修改元素
        prop.setProperty("wangwu","26");
        //取出所有元素
        Set<String> names=prop.stringPropertyNames();
        for (String name:names){
            String value=prop.getProperty(name);
            System.out.println(name+";"+value);
        }
    }
    public static void propertiesDemo_2(){
        Properties prop=new Properties();
        prop.setProperty("zhangsan","30");
        prop.setProperty("lisi","31");
        prop.setProperty("wangwu","36");
        prop.setProperty("zhaoliu","20");
        prop=System.getProperties();
        prop.list(System.out);//将此属性列表打印到指定的输出流。
    }
    public static void propertiesDemo_3()throws IOException {
        Properties prop=new Properties();
        //存储元素
        prop.setProperty("zhangsan","30");
        prop.setProperty("lisi","31");
        prop.setProperty("wangwu","36");
        prop.setProperty("zhaoliu","20");
        //想要将这些集合中的字符串兼职信息持久化存储到文件中华
        //需要关联输出流
        FileOutputStream fos=new FileOutputStream("info.txt");
        //将集合中数据存储到文件中，使用stroe
        prop.store(fos,"A");
        fos.close();
    }
    public static void propertiesDemo_4()throws IOException {
        Properties prop=new Properties();
        //集合中的数据来自一个文件
        //注意：必须要保证该文件中的数据就是键值对
        //需要使用读取流

        FileInputStream fis=new FileInputStream("info.txt");
        //使用load方法
        prop.load(fis);
        prop.list(System.out);
        fis.close();
    }
    //对已有的配置文件中的信息进行修改
    /*读取这个文件,并将这个文件中的键值数据存储到集合中
    在通过集合对数据进行修改
    再通过流将修改后的数据存储到文件中*/
    public static void test()throws IOException{
        //读取这个文件
        File file=new File("info.txt");
        if (!file.exists()){
            file.createNewFile();
        }
        FileReader fr=new FileReader(file);
        //常见集合存储配置信息
        Properties prop=new Properties();
        //将流中信息存储到集合中
        prop.load(fr);
        prop.setProperty("wangwu","16");

        FileWriter fw=new FileWriter(file);
        prop.store(fw,"123");
        fw.close();
        fr.close();

    }
}

获取一个程序运行次数

package com.monfolld.IO流.properties;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;

//定义功能，获取一个应用程序运行的次数，如果超过5次，给出使用次数已到轻注册的提示，并不要运行程序
/*思路：
* 1.应该有计数器
* 每次程序启动都需要计数一次，并且是在原有的次数上进行计算
* 2.计数器就是一个变量，突然冒出一想法，程序启动时候进行计数,计数器必须存在于内存并进行运算
* 可是程序一结束，计数器小时了，那么在此启动该程序，计数器又重新被初始化了
* 而我们需要多次启动同一个应用程序，使用的是同一个计数器
* 这就需要计数器的生命周期变长，从内存存储到硬盘文件中
* 3.如何使用这个计数器呢？
* 首先，程序启动时，应该先读取这个用于记录计数器的配置文件
* 获取上一次计数器次数，并且进行试用次数的判断
* 其次，对该次数进行自增，并自增厚的次数重新存储到配置文件中
* 4.文件中的信息该如何进行存储并体现
* 直接存储次数值可以，但是不明确该数据的含义，所以起名字就变得很重要
* 这就有了名字和值对应，所以可以使用键值对
* 可是映射关系map集合搞定，又要读取硬盘上的数据，所以map+io=Propties*/
public class propertiesTest {
    public static void main(String[] args)throws IOException{
        getAppCount();
    }
    public static void getAppCount()throws IOException {
        //将配置文件封装成File对象
        File confile=new File("count.properties");
        if (!confile.exists()){
            confile.createNewFile();
        }
        FileInputStream fis=new FileInputStream(confile);
        Properties prop=new Properties();
        prop.load(fis);
        //从集合中通过键获取次数
        String value=prop.getProperty("time");
        //定义计数器，记录获取到的次数
        int count=0;
        if (value!=null){
            count=Integer.parseInt(value);
            if (count>=5){
                throw new RuntimeException("使用次数已到，请注册");

            }
        }
        count++;
        //将改变后的次数重新存储到集合猩红
        prop.setProperty("time",count+"");
        FileOutputStream fos=new FileOutputStream(confile);
        prop.store(fos,"");
        fos.close();
        fis.close();
    }
}

文件清单列表

package com.monfolld.IO流.properties;

import java.io.*;
import java.util.ArrayList;
import java.util.List;

/*获取指定目录下，指定拓展名的文件（包含子目录中的）
* 这些文件的绝对路径写入到一个文本文件中
* 简单说，就是建立一个指定扩展名的文件的列表
* 思路：
* 1.必须进行深度遍历
* 2.要在遍历的过程中进行锅炉，将符合条件的内容都存储到容器中
* 3.对容器的内容进行遍历并将绝对路径写入到文件中*/
public class Test {
    public static void main(String[] args){
    File dir=new File("d:\\idea的编程文件");
    FilenameFilter filter=new FilenameFilter() {
        @Override
        public boolean accept(File dir, String name) {
            return name.endsWith(".java");
        }
    };
    List<File> list=new ArrayList<File>();
    getFiles(dir,filter,list);
    File destFile=new File(dir,"javalist.txt");
    write2File(list,destFile);
    }
    public static void getFiles(File dir, FilenameFilter filter, List<File> list){
        File[] files=dir.listFiles();
        for (File file:files){
            if (file.isDirectory()){
                //递归啦
                getFiles(file,filter,list);
            }else {
                //对遍历到的文件进行过滤器的过滤，将符合条件File对象，存储到List集合中
                if (filter.accept(dir,file.getName())){
                    list.add(file);
                }
            }

        }
    }
    public static void write2File(List<File> list,File destFile){
        BufferedWriter bufw=null;
        try {
            bufw=new BufferedWriter(new FileWriter(destFile));
            for (File file:list){
                bufw.write(file.getAbsolutePath());
                bufw.newLine();
                bufw.flush();
            }
        }catch (IOException e){
            throw new RuntimeException("写入失败");
        }finally {
            if (bufw!=null)
                try {
                    bufw.close();
                }catch (IOException e){
                    throw new RuntimeException("关闭失败");
                }
        }
    }
}

PrintStream

package com.monfolld.IO流.print;

import java.io.IOException;
import java.io.PrintStream;

public class PrintStreamDemo {
    public static void main(String[] args)throws IOException {
        /*PrintStream:
        * 1.提供了打印方法可以对多种数据类型值进行打印，并且保持数据的表示形式
        * 2.它不抛IOException
        * 构造函数，接收三种类型的值
        * 1.字符串类型
        * 2.File对象
        * 3.字节输出流
        */
        PrintStream out=new PrintStream("print.txt");
        out.write(610);//只写最低8位
        //out.print(97);//将97先变成字符保持原样将数据打印到目的地
        out.close();

    }
}

PrintWriter

package com.monfolld.IO流.print;

import java.io.*;

public class PrintWriterDemo {
    public static void main(String[] args)throws IOException {
        /*PrintWriter:字符打印流
        * 构造函数参数：
        * 1.字符串路径
        * 2.File对象
        * 3.字节输出流
        * 4.字符输出流*/
        BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));
        //PrintWriter out=new PrintWriter(System.out);
        PrintWriter out=new PrintWriter(new FileWriter("out.txt"),true);//后面这个参数自动刷新
        String line=null;
        while ((line=bufr.readLine())!=null){
            if ("over".equals(line))
                break;
            out.println(line.toUpperCase());
            //out.flush();
        }
        out.close();
        bufr.close();
    }
}

SequenceInputStream

需求：将1.txt 2.txt 3.txt文件中的数据合并到一个文件中

package com.monfolld.IO流.squence;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.SequenceInputStream;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Vector;

public class SequenceInputStreamDemo {
    public static void main(String[] args)throws IOException {
        /*需求：将1.txt 2.txt 3.txt文件中的数据合并到一个文件中*/
        /*Vector<FileInputStream> v=new Vector<FileInputStream>();
        v.add(new FileInputStream("1.txt"));
        v.add(new FileInputStream("2.txt"));
        v.add(new FileInputStream("3.txt"));
        Enumeration<FileInputStream> en=v.elements();*/

        ArrayList<FileInputStream> al=new ArrayList<FileInputStream>();
        for (int x=1;x<=3;x++){
            al.add(new FileInputStream(x+".txt"));
        }
        final Iterator<FileInputStream> it=al.iterator();
        Enumeration<FileInputStream> en=new Enumeration<FileInputStream>() {
            @Override
            public boolean hasMoreElements() {
                return false;
            }

            @Override
            public FileInputStream nextElement() {
                return null;
            }
        };
        SequenceInputStream sis=new SequenceInputStream(en);
        FileOutputStream fos=new FileOutputStream("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();
    }
}

将一个文件切割

package com.monfolld;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;

/**/
public class SplitFileDemo {
    private static final int SIZE=1024*1024;
    public static void main(String[] args)throws IOException{
        File file=new File("d:\\demo.txt");
        splitFile(file);
    }
    public static void splitFile(File file)throws IOException {
        //用读取流关联文件
        FileInputStream fis=new FileInputStream(file);
        //定义一个1M的缓冲区
        byte[] buf=new byte[SIZE];
        //创建目的
        FileOutputStream fos=null;
        Properties prop=new Properties();
        int len=0;
        int count=1;
        File dir=new File("d:\\qwer");
        if (!dir.exists())
            dir.mkdirs();
        while ((len=fis.read(buf))!=-1){
            fos=new FileOutputStream(new File(dir,(count++)+".part"));
            fos.write(buf,0,len);
            fos.close();
        }
        //将被切割文件的信息保存到prop集合中
        prop.setProperty("partconut",count+"");
        prop.setProperty("filename",file.getName());

        fos=new FileOutputStream(new File(dir,count+".properties"));
        //将prop集合中的数据存储到文件中
        prop.store(fos,"save file info");
        fos.close();
        fis.close();
    }
}

文件合并

package com.monfolld.IO流.File;

import java.io.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Enumeration;
import java.util.Properties;

public class MergeFile {
    public static void main(String[] args)throws IOException{
        File dir=new File("d:\\qwer");
        mergeFile_2(dir);
    }
    public static void mergeFile_2(File dir)throws IOException{
        /*获取指定目录下的配置文件对象*/
        File[] files=dir.listFiles(new SuffixFilter(".properties"));
        if (files.length!=1)
        throw new RuntimeException(dir+",该目录下没有properties拓展名或者不唯一");
        //记录配置文件对象
        File config=files[0];
        //获取该文件中的信息
        Properties prop=new Properties();
        FileInputStream fis=new FileInputStream(config);

        prop.load(fis);

        String filename=prop.getProperty("filename");
        int count=Integer.parseInt(prop.getProperty("partconut"));

        //获取目录下的所有碎片文件
        File[] partFile=dir.listFiles(new SuffixFilter(".part"));


        if (partFile.length!=(count-1)){
            throw new RuntimeException("碎片文件不符合要求，个数不对,应该是"+count+"个");
        }
        //将碎片文件和流对象关联并存储到集合中
        ArrayList<FileInputStream> al=new ArrayList<FileInputStream>();
        for (int x=1;x<partFile.length;x++){
            al.add(new FileInputStream(partFile[x]));
        }
        //将多个流合并成一个序列流
        Enumeration<FileInputStream> en= Collections.enumeration(al);//枚举装入
        SequenceInputStream sis=new SequenceInputStream(en);//序列流将它们整合在一起

        FileOutputStream fos=new FileOutputStream(new File(dir,"4.part"));
        byte[] buf=new byte[1024];

        int len=0;
        while ((len=sis.read(buf))!=-1){
            fos.write(buf,0,len);
        }
        fos.close();
        sis.close();
    }
}