标签：esc   length   font   需要   param   信息   utf8   其他   设置   

基本单词：

file ：文件

directory：文件夹

path：目录

静态成员变量

路径：

绝对路径：是一个完整的路径

相对路径：是相对于项目的根路径而言

路径部分大小

**路径中的文件名称分隔符在win中是反斜杠 \ **

构造方法

创建File对象，只是考虑将路径字符串封装在File对象中，不考虑真实与否

File(String parent, String child) ：

? String parent，父路径

? String child 子路经

路径工具

判断方法

package com.py.FileDemo;

import java.io.File;

public class ISMethods {
    /**
     * `boolean``isAbsolute()`测试这个抽象路径名是否是绝对的。
     * `boolean``isDirectory()`测试此抽象路径名表示的文件是否为目录。
     * `boolean``isFile()`测试此抽象路径名表示的文件是否为普通文件。
     * `boolean``isHidden()`测试此抽象路径名命名的文件是否为隐藏文件。
     * @param args
     */
    public static void main(String[] args) {
        File rmFile = new File("D:\\BaiduNetdiskDownload\\readme.txt");
// `boolean``isAbsolute()`测试这个抽象路径名是否是绝对的。
        boolean b = rmFile.isAbsolute();
        System.out.println(b);
//  `boolean``isDirectory()`测试此抽象路径名表示的文件是否为目录。
        System.out.println(rmFile.isDirectory());
//  `boolean``isFile()`测试此抽象路径名表示的文件是否为普通文件。
        System.out.println(rmFile.isFile());
//  `boolean``isHidden()`测试此抽象路径名命名的文件是否为隐藏文件。
        System.out.println(rmFile.isHidden());


    }

}

创建删除方法

package com.py.FileDemo;

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

/**
 * | `boolean` | `createNewFile()` | 当且仅当具有该名称的文件尚不存在时，创建一个由该抽象路径名命名的新的空文件。 |
 * | --------- | ----------------- | ------------------------------------------------------------ |
 * | `boolean` | `delete()`        | 删除由此抽象路径名表示的文件或目录。                         |
 * | `boolean` | `mkdir()`         | 创建由此抽象路径名命名的目录。                               |
 * | `boolean` | `mkdirs()`        | 创建由此抽象路径名命名的目录，包括任何必需但不存在的父目录。 |
 */
public class DemoCreateOr {
    public static void main(String[] args) {
        File[] files;
        File parent = new File("D:\\Download");
        File file = new File(parent,"Dir");

/*//        当且仅当具有该名称的文件尚不存在时，创建一个由该抽象路径名命名的新的空文件。
        try {
            file.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }
//      遍历文件夹
        listFiles(parent);
//    删除由此抽象路径名表示的文件或目录。
        file.delete();
        listFiles(parent);
//        创建由此抽象路径名命名的目录。
//        创建由此抽象路径名命名的目录。
        file.mkdir();
        listFiles(parent);

 */
//        创建由此抽象路径名命名的目录，包括任何必需但不存在的父目录。
        file.mkdirs();
        listFiles(parent);

    }

    private static void listFiles(File parent) {
        File[] files;

        if (parent.isDirectory()) {
            files = parent.listFiles();
            for (File a : files) {
                System.out.println(a.getName());
            }
            System.out.println("========================================");
        }
    }

}

递归

分类：直接递归和间接递归

注意：递归一定要有条件限制，保证递归可以顺利停下，递归的次数也不能太多，否则也会内存溢出。

前提：调用的时候，方法的主体不变，每次调用的参数不同，可以使用递归。

计算N递加到1

来自视频

递归查找文件&遍历目录

package com.py.FileDemo;

import java.io.File;

public class DemoPrintMenu {
    public static void main(String[] args) {
        File contents = new File("D:\\Download");

      seachfile(contents,"doc");

    }

    /**
     * 遍历一个目录
     * 1、得到目录下的文件列表数组
     * 2、取得第一个数组，判断是不是文件夹
     *      如果是文件夹继续调用自身
     *      如果不是文件夹输出打印
     *
     * @param path
     */
    //只往下走，不返回
    private static void printContent(File path) {
            File[] files = path.listFiles();
            for (File f:files) {
                if (f.isDirectory()){
                    printContent(f);
                }else {
                    System.out.println(f);
                }
            }

    }
    /**
     * 查找指定类型的文件
     * @param path
     * @param typer
     */
    private static void seachfile(File path, String typer) {
        File[] files = path.listFiles();
        for (File f:files) {
            if (f.isDirectory()){
                seachfile(f,typer);
            }else {
                if (f.getName().endsWith("."+typer)){
                    System.out.println(f);
                }
            }
        }

    }


}

文件过滤器

package com.py.FileDemo;

import java.io.File;

public class DemoSeachFile {
    public static void main(String[] args) {
        File path = new File("D:\\Download");
        seachFile(path);
    }

//    递归查询文件
    private static void seachFile(File path) {
        File[] files = path.listFiles(new MyFileFilter());
        for (File f : files) {
            if (f.isDirectory()) {
                seachFile(f);
            }else {
                System.out.println(f);
            }
        }
    }



}


package com.py.FileDemo;

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

public class MyFileFilter implements FileFilter {
    @Override
    public boolean accept(File pathname) {
        if (pathname.isDirectory()){
            return true;
        }
        return pathname.getName().toLowerCase().endsWith("doc");
    }
}

流

FileOutputStream&FileInputdStream

构造方法

方法

换行符：

win \r\n

moc /r

lin /n

Reader&Writer

构造方法

实现方法

FileWriter&FileReader

构造方法

方法

使用步骤：

? 1、创建FileWriter对象，在构造方法中邦迪文件输出地址

? 2、使用FileWriter对象的writer方法，将数据写入到内存缓冲区中。

? 3、 使用FileWriter对象的flush方法，将数据从内存缓冲区中刷新到文件中

? 4、关闭资源

package com.py.IO;

import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class DemoFileWriter {
    public static void main(String[] args) throws IOException {
        File path = new File("D:\\Download", "a.txt");

//     	1、创建FileWriter对象，在构造方法中邦迪文件输出地址
        FileWriter fileWriter = new FileWriter(path);
        ////2、使用FileWriter对象的writer方法，将数据写入到内存缓冲区中。
        fileWriter.write(97);
        //	3、 使用FileWriter对象的flush方法，将数据从内存缓冲区中刷新到文件中
        fileWriter.flush();
        //	4、关闭资源
        fileWriter.close();
        
        FileReader fileReader = new FileReader(path);
        System.out.println((char) fileReader.read());
        fileReader.close();
    }
}

close与flush差别：

close直接关掉

flush可以继续使用

异常处理

注意点：

1、要升级变量作用范围

2、对变量进行赋空值

3、对异常进行抓取，打印e

4、finally关闭也要进行异常判断和抓取

package com.py.IO;

import java.io.FileWriter;
import java.io.IOException;

public class DemoCatch {
    public static void main(String[] args) {
        FileWriter fw = null;

        try {
            fw = new FileWriter("D:\\Dowload\\b.txt",true);
            for (int i = 0; i < 50; i++) {
                fw.write("我就试试"+i+"\r\n");
            }
        } catch (Exception e) {
            System.out.println(e);
        }finally {
            if (fw!=null) {
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

升级处理操作

package com.py.IO;

import java.io.FileWriter;
import java.io.IOException;

public class DemoCatch02 {
    public static void main(String[] args) {
        //将变量声明的代码放在try括号中。可以自动释放资源
        try(  FileWriter  fw = new FileWriter("D:\\Dowload\\b.txt",true)) {

            for (int i = 0; i < 50; i++) {
                fw.write("我就试试"+i+"\r\n");
            }
        } catch (Exception e) {
            System.out.println(e);
        }

    }
}

Properties

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

属性列表可以包含另一个属性列表作为其“默认值”; 如果在原始属性列表中找不到属性键，则会搜索此第二个属性列表。

构造方法

实现方法

案例1、properties存储和遍历

package com.py.IO;

import java.util.Properties;
import java.util.Set;

public class DemoProperties {
    public static void main(String[] args) {
        Properties properties = new Properties();
        properties.setProperty("刘亦菲","170");
        properties.setProperty("迪丽热巴","175");
        properties.setProperty("鹤岛乃爱","168");
        properties.setProperty("蝴蝶人","165");
		//得到set集合，遍历
        Set<String> string = properties.stringPropertyNames();
        for (String key:string) {
            String s = properties.getProperty(key);
            System.out.println(key+s);

        }
    }
}

Properties集合是一个唯一和io相结合的集合

? 可以使用properties集合中的方法store，把集合中的临时数据，持久化的写到硬盘中去，

? 可以使用properties集合中的方法load，把持久化的硬盘数据读出来，放到集合中使用。

void store (Outputstream out,String comments)

void store (Writer writer,String comments)

参数：

? OutputStream out ：字节输出流，不能直接写中文

? Writer writer：字符输出，可以写中文

? String comments：注释用来解释说明保存的文件是用来干生么的，不能使用中文。一般用空字符串

void load(Reader reader) 以简单的线性格式从输入字符流读取属性列表（关键字和元素对）。

参数：

? inputstream ：字节输入流，不能读取包含中文的键值对，

? Reader ：字符输入流，能读取含有中文的键值对

注意：

• 键值对的文件中，键与值默认的连接符可以使用等号或者空格（其他符号）
• 键值对的文件中，可以使用#进行注释，被注释的键值对不会在被读取
• 键值对的文件中，键与值都是字符串，可以不用再加引号

案例2 store & load

		File file = new File("D:\\Download\\properties.txt");
        file.createNewFile();
//        将properties输出到文件中去
        properties.store(new FileWriter(file),"");

package com.py.IO;

import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;
import java.util.Set;

public class DemoProperties {
    public static void main(String[] args) throws IOException {
        Properties properties = new Properties();
        File file = new File("D:\\Download\\properties.txt");
        //将properties加载进内存
        properties.load(new FileReader(file));
        printProperties(properties);
    }


    private static void printProperties(Properties properties) {
        Set<String> string = properties.stringPropertyNames();
        for (String key:string) {
            String s = properties.getProperty(key);
            System.out.println(key+s);
        }
    }
}

缓冲流

来自视频

BufferedInputStream

构造方法：

实现方法：

步骤：

1. 创建FileInputStream对象，构造方法中绑定要读取的数据源
2. 创建BufferedInputstream对象，构造方法中传递FileInputStream对象，提高读取效率。
3. 使用BufferedInputstream对象中的read()方法，读取文件
4. 释放资源

案例

package com.py.IO;

import java.io.*;

public class DemoBuffer {
    public static void main(String[] args) {

        File file = new File("D:\\Download\\test.txt");
        //缓冲数组
        byte[] bytes = new byte[1024];
        try(FileInputStream ip = new FileInputStream(file);
            BufferedInputStream bip = new BufferedInputStream(ip);){
            //获得读取的有效长度
            int len = bip.read(bytes);
            //输出打印有效字节（AsCII）
            for (int i = 0; i < len; i++) {
                System.out.print(bytes[i]+"\t");
            }
        }catch (Exception e){
            e.printStackTrace();
        }

    }
}

BufferedOutputStream

构造方法：

实现方法：

操作步骤

1. 创建FileWriter对象，在构造方法中邦迪文件输出地址
2. 使用FileWriter对象的writer方法，将数据写入到内存缓冲区中。
3. 使用FileWriter对象的flush方法，将数据从内存缓冲区中刷新到文件中
4. 关闭资源

案例

package com.py.IO;

import java.io.*;

public class DemoBuffer {
    public static void main(String[] args) {

        File file = new File("D:\\Download\\test.txt");
        
        try(FileOutputStream ip = new FileOutputStream(file);
            BufferedOutputStream bip = new BufferedOutputStream(ip);) {

            file.createNewFile();
            bip.write("34987654322".getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

案例:缓冲复制文件

package com.py.IO;

import com.sun.xml.internal.ws.policy.privateutil.PolicyUtils;

import java.io.*;

public class CopyFile {
    public static void main(String[] args) {
        long time = System.currentTimeMillis();
        File newFile = new File("D:\\Download", "ok.png");
        File file = new File("C:\\Users\\Administrator.LAPTOP-59IVBBM9\\Pictures\\Screenshots", "屏幕截图(4).png");
        int len = 0;

        try(FileInputStream fis = new FileInputStream(file);
            BufferedInputStream bis = new BufferedInputStream(fis);
            FileOutputStream fos = new FileOutputStream(newFile,true);
            BufferedOutputStream bos = new BufferedOutputStream(fos);){

            byte[] bytes = new byte[1024];

            while ((len = bis.read(bytes))!=-1){
                bos.write(bytes,0,len);
            }
        }catch (IOException e){
            e.printStackTrace();
        }
        time = System.currentTimeMillis() - time;
        System.out.println(time +"毫秒");

    }
}

BufferedReader

构造方法：

实现方法：

步骤：

1. 创建FileReader对象，构造方法中绑定要读取的数据源
2. 创建BufferedReader对象，构造方法中传递FileRead对象，提高读取效率。
3. 使用BufferedReader对象中的read()方法，读取文件
4. 释放资源

注意：

readline();包含行的内容的字符串，不包括任何行终止字符，如果已达到流的末尾，则为null

BufferedWriter

构造方法：

Writer out: 传递FileRWriter，为FileWriter增加缓冲区，提高写入效率

int size: 缓冲区大小

实现方法：

步骤：

1. 创建FileWriter对象，在构造方法中绑定文件输出地址
2. 使用BufferedWriter对象的writer方法，将数据写入到内存缓冲区中。
3. 使用BufferedWriter对象的flush方法，将数据从内存缓冲区中刷新到文件中
4. 关闭资源

案例：对文本进行排序

package com.py.IO;

import java.io.*;
import java.util.HashMap;

public class SortAssay {

    /**
     * 排序文章
     * 1、创建字符输入流。绑定读取的文件
     * 2、创建缓冲字符输入流，放入字符输入流
     * 3、创建字符输出流绑定文件输出位置，
     * 4、创建缓冲字符输出流，放入字符输出流
     * 5、创建Hashmap(),
     * 6、读取一行，放入到字符串中，以.分割
     * 7、将分割后的前半段方法key，后半段放在value
     * 8、输出Hashmap
     */
    public static void main(String[] args) throws IOException {
//     * 1、创建字符输入流。绑定读取的文件
//     * 2、创建缓冲字符输入流，放入字符输入流
//     * 3、创建字符输出流绑定文件输出位置，
//     * 4、创建缓冲字符输出流，放入字符输出流
        File oFile = new File("D:\\Download\\Test", "csb.txt");
        File nFile = new File("D:\\Download\\Test", "出师表.txt");

        FileReader fr = new FileReader(oFile);
        FileWriter fw = new FileWriter(nFile);

        BufferedReader br = new BufferedReader(fr);
        BufferedWriter bw = new BufferedWriter(fw);

//      * 5、创建Hashmap(),
        HashMap<String,String> map = new HashMap<>();
//      * 6、读取一行，放入到字符串中，以.分割
        String lean;
        while((lean=br.readLine())!=null){
            String[] arr = lean.split("\\.");
//      * 7、将分割后的前半段方法key，后半段放在value
            map.put(arr[0],arr[1]);
        }
        for (String key: map.keySet()) {
            String s = map.get(key);
            lean = key+s;
            bw.write(lean);
            bw.write("\t\n");
        }
        
        
        bw.close();
        fw.close();
        br.close();
        fr.close();
    }


}

编码问题

常用编码表

ASCII：

ASCII ((American Standard Code for Information Interchange): 美国信息交换标准代码）是基于拉丁字母的一套电脑编码系统，主要用于显示现代英语和其他西欧语言。

GBK：

GBK编码，是在GB2312-80标准基础上的内码扩展规范，使用了双字节编码方案，其编码范围从8140至FEFE（剔除xx7F），共23940个码位，共收录了21003个汉字，完全兼容GB2312-80标准，

UTF-8

一个US-ASCIl字符只需1字节编码（Unicode范围由U+0000_{U+007F）。带有变音符号的拉丁文、希腊文、西里尔字母、亚美尼亚语、希伯来文、阿拉伯文、叙利亚文等字母则需要2字节编码（Unicode范围由U+0080}U+07FF）。其他语言的字符（包括中日韩文字、东南亚文字、中东文字等）包含了大部分常用字，使用3字节编码。其他极少使用的语言字符使用4字节编码。

InputStreamReader & OutputStreamWriter

介绍：

• InputStreamReader是从字节流到字符流的桥：它读取字节，并使用指定的charset将其解码为字符 。 它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集。
• OutputStreamWriter是字符的桥梁流以字节流：向其写入的字符编码成使用指定的字节charset 。 它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集。

最大的效率，请考虑在BufferedReader中包装一个InputStreamReader

来自视频

InputStreamReader

构造方法

InputStream in：输出流对象

String charsetName： 要输入的字符编码，不区分大小写，GBK/gbk,UTF-8/utf-8

实现方法

步骤：

1. 创建InputStreamReader 对象，构造方法中绑定要读取的数据源，设置编码格式
2. 使用BufferedReader对象中的read()方法，读取文件
3. 释放资源

OutputStream

构造方法

OutputStream out：输出流对象

String charsetName： 要输出的字符编码，不区分大小写，GBK/gbk,UTF-8/utf-8

实现方法

步骤：

1. 创建OutputStream 对象，构造方法中绑定要读取的数据源，设置编码格式
2. 使用OutputStream对象中的writer()方法，写文件
3. 释放资源

转换出师表

package com.py.IO;
import java.io.*;

public class TransltFile {
    /**
     * 转译文件，将GBK转译为UTF-8
     * 创建InputStreamReader对象，绑定阅读文件，
     * 创建BUfferedReader方法，将InputStreamReader传入
     * 创建OutputStreamWriter对象，绑定写出文件
     * 创建BUfferedWriter方法，将OutputStreamReader传入
     * byte数组，
     * 使用BUfferedReader的read方法，将读取的文件保存在缓存区中，
     * 使用BUfferedWriter的writer方法，将缓存数组保存在文件中
     * @param args
     */
    public static void main(String[] args) throws IOException {

//      * 创建InputStreamReader对象，绑定阅读文件，
//     * 创建BUfferedReader方法，将InputStreamReader传入
//     * 创建OutputStreamWriter对象，绑定写出文件
//     * 创建BUfferedWriter方法，将OutputStreamReader传入
        File oFile = new File("D:\\Download\\Test", "出师表.txt");
        File nFile = new File("D:\\Download\\Test", "出师表_UTF8.txt");

        InputStreamReader isr = new InputStreamReader(new FileInputStream(oFile),"UTF-8");
        BufferedReader br = new BufferedReader(isr);

        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(nFile),"GBK");
        BufferedWriter bw = new BufferedWriter(osw);
        String line;
        while ((line = br.readLine())!= null){
            bw.write(line);
            bw.write("\t\n");
        }

        br.close();
        bw.close();
        osw.close();
        isr.close();

    }
}

序列化

来自视频
构造方法：

步骤：

1. 实现java.io.Serializable接口，才能将对象输出
2. 创建objectOutputStream对象，构造方法中传递输出流
3. 使用objectOutputStream对象中的方法WriterObject，把对象写入到文件中
4. 释放资源

File

标签：esc   length   font   需要   param   信息   utf8   其他   设置   

原文地址：https://www.cnblogs.com/yuknight/p/13780298.html