一、File

1.1、File概述

文件和目录路径名的抽象表示形式。

用户界面和操作系统使用与系统相关的路径名字符串 来命名文件和目录。此类呈现分层路径名的一个抽象的、与系统无关的视图。抽象路径名 有两个组件：

1. 一个可选的与系统有关的前缀 字符串，比如盘符，"/" 表示 UNIX 中的根目录，"\\\\" 表示 Microsoft Windows UNC 路径名。
2. 零个或更多字符串名称 的序列。

1.2、File创建与删除

import java.io.*;
class FileDemo1
{
    public static void main(String[] args)
    {
        method1();
    }
    public static void method1()
    {
        //创建File对象
        File f1=new File("a.txt");
        //第二种
        File f2=new File("d:\\abc","b.txt");
        //第三种
        File dir=new File("d:\\bcd");
        File f3=new File(dir,"c.txt");

        //使用分隔符
        File f4=new File("d:"+File.separator+"abc"+File.separator+"d.txt");
        //输出
        System.out.println("f1="+f1);//a.txt
        System.out.println("f2="+f2);//d:\abc\b.txt
        System.out.println("f3="+f3);//d:\bcd\c.txt
        System.out.println("f4="+f4);//d:\abc\d.txt

    }
}

创建文件

//创建文件，在指定位置创建文件，如果该文件已经存在，则不创建，返回 false
    public static void method1() throws IOException
    {
        File f=new File("d:\\file.txt");
        //创建
        sop("create: "+f.createNewFile());
        //删除，删除失败返回false
        //sop("delete:"+f.delete());
        //在退出时删除指定文件
        f.deleteOnExit();

    }

1.3、File判断 File获取

package com.pb.day20.io.file;

import java.io.File;
import java.io.IOException;

public class FileDemo2 {

    public static void main(String[] args) throws IOException {
        File f1=new File("d:\\a.txt");
        File f2=new File("e:\\c.txt");
        File dir1=new File("d:\\dbc");
        File dir2=new File("d:\\dbc\\dd\\aa\\d\\f\\dsf\\fsd");
        //判断文件是否存在，不存在就创建
        if(!f1.exists()){
            f1.createNewFile();
        }
        //判断文件夹是否存在
        if(!dir1.exists()){
            dir1.mkdir();//创建一层文件夹
        }
        //创建多层文件夹
        if(!dir2.exists()){
            dir2.mkdirs();
        }
        //判断
        sop("f1是文件吗?"+f1.isFile());
        sop("dir1是文件夹吗?"+dir1.isDirectory());
        sop("f1是可执行文件吗？"+f1.canExecute());
        sop("f1可读吗？"+f1.canRead());
        sop("f1可写吗？"+f1.canWrite());
        sop("f1是隐藏文件吗?"+f1.isHidden());
        //获取文件信息
        sop(f1.getName());//文件名
        sop(f1.getPath());//相对路径
        sop(f1.getAbsolutePath());//获取绝对路径,返回值是字符串
        sop(f1.getAbsoluteFile());//获取绝对路径,返回值是File类对象
        sop(f1.lastModified());//最后修改时间 长整型
        sop(f1.length());//文件字节大小，长整型
        //重命名
        sop(f1.renameTo(f2));//剪切的作用

    }
    public static void sop(Object obj){
        System.out.println(obj);
    }

}

1.4、File文件列表

package com.pb.day20.io.file;

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

public class FileDemo3 {

    public static void main(String[] args) {
        method3();

    }
    //列出当前目录下的指定文件
    public static void method3(){
        File f=new File("d:\\");
        File [] files=f.listFiles(new FilenameFilter() {

            @Override
            public boolean accept(File dir, String name) {
                //返回txt文件
                return  name.endsWith(".txt");
            }
        });
        for(File ff:files){
            System.out.println(ff.getName()+"..."+ff.length());
        }
    }

    //列表当前目录下的所有文件包含文件夹名字
    public static void method2(){
        File f=new File("c:\\");
        String [] names=f.list();//必须是目录，否则就是空指针异常
        for(String s:names){
            System.out.println(s);
        }
    }

    //列出当前系统的所有盘符
    public static void method1(){
        File [] files=File.listRoots();
        for(File f:files){
            System.out.println(f);
        }

    }

}

1.6、File列出所有递归

package com.pb.day20.io.file;
/**
 * 递归调用，
 * 列表指定目录下的，所有文件包括子目录中的文件
 */
import java.io.File;

public class FileDemo4 {

    public static void main(String[] args) {
        File dir=new File("d:\\");
        getFiles(dir);
    }

    //递归
    public static void getFiles(File dir){
        System.out.println(dir);
        //获取文件数组，列表
        File[] files=dir.listFiles();
        //遍历
        for(File file:files){
            //判断是不是文件夹
        if(file.isDirectory()){
            //是文件夹就再次调用
            getFiles(file);
        }else{
            //不是就列表
            System.out.println(file);
        }
        }
    }

}

递归：

限定条件

注意递归的次数，尽量避免内存溢出

1.7、File删除带文件的目录

package com.pb.day20.io.file;

import java.io.File;

public class FileDemo5 {

    public static void main(String[] args) {
        File dir=new File("d:\\kk");
        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]);
            }else{
                //删除文件
            System.out.println(files[x]+"----file----"+files[x].delete());
            }
        }
        //删除空文件夹
        System.out.println(dir+"----dir----"+dir.delete());

    }

}

1.8、将一个文件夹的的所有文件，包含子目录都复制要另一个目录下

/*
将一个文件夹的的所有文件，包含子目录都复制要另一个目录下
*/
import java.io.*;
class IOCopy
{
    public static void main(String[] args)
    {
        //源文件
        File src=new File("D:\\music");
        //目的文件
        File des=new File("e:\\test");
        copyDir(src,des);
        System.out.println("复制完成!");
    }

    /*
    递归复制
    */
    public static void copyDir(File src,File des)
    {
        //获取列表
        File[] files=src.listFiles();
        //判断目标文件是否存在
        if(!des.exists()){
            //创建目录
            des.mkdir();
        }
        //遍历
        for(File f:files)
        {
            //判断是不是目录
            if(f.isDirectory())
            {
                //获取路径，拼接文件名，再次调用自己
            copyDir(new File(f.getPath()),new File(des+"\\"+f.getName()));
            //是不是文件
            }else if (f.isFile())
            {
                //复制
                copyFile(new File(f.getPath()),new File(des+"\\"+f.getName()));
            }

        }

    }
    //使用IO流复制文件
    public static void copyFile(File src,File des)
    {
        BufferedInputStream bis=null;
        BufferedOutputStream bos=null;
        try
        {
            bis=new BufferedInputStream(new FileInputStream(src));
            bos=new BufferedOutputStream(new FileOutputStream(des));
            //声明缓冲区
            int len=0;
            while((len=bis.read())!=-1)
            {
                bos.write(len);
            }

        }
        catch (IOException e)
        {
             e.printStackTrace();
        }finally
        {
            try
        {
            if(bos!=null)
                bos.close();
        }
        catch (IOException e)
        {
             e.printStackTrace();
        }
        try
        {
            if(bis!=null)
                bis.close();
        }
        catch (IOException e)
        {
             e.printStackTrace();
        }

        }
    }
}

二、Properties

2.1、Properties概述

Properties 类表示了一个持久的属性集。Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。

2.2、存取功能

public static void setAndGet(){
        //声明
        Properties prop=new Properties();
        //设置
        prop.setProperty("username", "root");
        prop.setProperty("password","root");
        //获取用户名对应的值
        System.out.println(prop.getProperty("username"));
        //修改密码
        prop.setProperty("password","root123");
        //获取全部key
        Set<String> keys=prop.stringPropertyNames();
        //遍历
        for(String s:keys){
            System.out.println(s+": "+prop.getProperty(s));
        }
    }

2.3、存取配置文件

    public static void method2() throws IOException {
        // 声明Properties集合
        Properties prop = new Properties();
        FileInputStream fis = new FileInputStream("D:/info.txt");

        FileOutputStream fos = new FileOutputStream("D:\\info.txt");

        //加载数组到集合
        prop.load(fis);
        System.out.println(prop);
        prop.list(System.out);

        //修改
        prop.setProperty("sex", "woman");
        prop.store(fos, "sex is woman");
        System.out.println(prop);
        fos.close();
        fis.close();
    }
    public static void method1() throws IOException {
        // 文件流
        BufferedReader br = new BufferedReader(new FileReader("D:\\info.txt"));
        // 声明Properties集合
        Properties prop = new Properties();
        String line = null;
        // 遍历
        while ((line = br.readLine()) != null) {
            // System.out.println(line);
            String[] arr = line.split("=");
            // System.out.println(arr[0]+"..."+arr[1]);
            prop.setProperty(arr[0], arr[1]);

        }
        System.out.println(prop);
        br.close();
    }

示例

public static void method() throws IOException{
        File file=new File("a.txt");

        //判断文件是否存在
        if(!file.exists()){
            file.createNewFile();
        }
        FileInputStream fis=new FileInputStream(file);
        //声明集合
        Properties prop=new Properties();
        prop.load(fis);
        int count=0;
        String value=prop.getProperty("times");
        if(value!=null){
            count=Integer.parseInt(value);
            //判断次数
            if(count>=5){
                System.out.println("使用次数已经用完，请续费!");
                return;
            }
        }
        //次数+1
        count++;
        //把KEY和VALUE放回去
        prop.setProperty("times", count+"");
        FileOutputStream fos=new FileOutputStream(file);
        prop.store(fos, "次数+1");
        fos.close();
        fis.close();
    }

三、PrintWriter与序列流

3.1、PrintWriter与PrintStream

package com.pb.io.properties.demo1;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;

/**
 * 从键盘接收数据，并输出在控制台
 * 使用PrintWriter
 *
 */
public class PrintWriterDemo {

    public static void main(String[] args) throws IOException {
        //从键盘接收数据，并输出在控制台
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

        //使用打印流输出，并自动刷新
        PrintWriter pw=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)),true);

        String line=null;
        System.out.println("请输入内容，以over结束!");
        while((line=br.readLine())!=null){
            if("over".equals(line)){
                break;
            }
            pw.println(line);
        }
        pw.close();
        br.close();
    }

}

3.2、序列流--SequenceInputStream

SequenceInputStream 表示其他输入流的逻辑串联。它从输入流的有序集合开始，并从第一个输入流开始读取，直到到达文件末尾，接着从第二个输入流读取，依次类推，直到到达包含的最后一个输入流的文件末尾为止。

四、合并流

4.1、合并流

package com.pb.io.properties.demo1;

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

public class SequenceDemo {

    public static void main(String[] args) throws IOException {

        Vector<FileInputStream> v=new Vector<FileInputStream>();
        v.add(new FileInputStream("d:\\1.txt"));
        v.add(new FileInputStream("d:\\2.txt"));
        v.add(new FileInputStream("d:\\3.txt"));
        //转换为枚举
        Enumeration<FileInputStream> en=v.elements();
        //合并流
        SequenceInputStream sis=new SequenceInputStream(en);
        //目标文件
        FileOutputStream fos=new FileOutputStream("d:\\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();
    }

}

五、分割流

5.1、分割流

package com.pb.io.properties.demo1;

import java.io.File;
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;

/**
 * 将文件切割
 * 再合并
 *
 */
public class SplitDemo {

    public static void main(String[] args) throws IOException {

        //split();
        merge();
    }
    //合并
    public static void merge() throws IOException{
        File src=new File("D:\\split");
        File [] files=src.listFiles();
        ArrayList<FileInputStream> list=new ArrayList<FileInputStream>();
        for(File f:files){
            list.add(new FileInputStream(f));
        }
        Iterator<FileInputStream> it=list.iterator();
        //创建枚举
        Enumeration<FileInputStream> en=new Enumeration<FileInputStream>() {

            @Override
            public FileInputStream nextElement() {

                return it.next();
            }
            @Override
            public boolean hasMoreElements() {
                return it.hasNext();
            }
        };

        //创建合并流
        SequenceInputStream sis=new SequenceInputStream(en);
        FileOutputStream fos=new FileOutputStream("D:\\split\\t.mp3");
        byte[] buf=new byte[1024];
        int len=0;
        while((len=sis.read(buf))!=-1){
            fos.write(buf,0,len);
        }
        fos.close();
        sis.close();

    }

    //切割
    public static void split() throws IOException{
        //源文件
        File file=new File("D:\\gm.mp3");

        FileInputStream fis=new FileInputStream(file);
        //目标
        FileOutputStream fos=null;
        //缓冲区
        byte[] buf=new byte[1024*1024];
        int len=0;
        int count=1;
        while((len=fis.read(buf))!=-1){
            fos=new FileOutputStream("D:\\split\\"+(count++)+".part");
            fos.write(buf,0,len);
        }
        fos.close();
        fis.close();
    }

}