基本单词：
file ：文件
directory：文件夹
path：目录
静态成员变量
static String |
pathSeparator与系统相关的路径分隔符字符，为方便起见，表示为字符串。 |
|---|---|
static char |
pathSeparatorChar与系统相关的路径分隔符。 |
static String |
separator与系统相关的默认名称 - 分隔符字符，以方便的方式表示为字符串。 |
static char |
separatorChar与系统相关的默认名称分隔符。 |
路径：
绝对路径：是一个完整的路径
相对路径：是相对于项目的根路径而言
路径部分大小
**路径中的文件名称分隔符在win中是反斜杠 **
构造方法
| 方法 | 描述 |
|---|---|
File(File parent, String child) |
从父抽象路径名和子路径名字符串创建新的 File实例。 |
File(String pathname) |
通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。 |
File(String parent, String child) |
从父路径名字符串和子路径名字符串创建新的 File实例。 |
File(URI uri) |
通过将给定的 file: URI转换为抽象路径名来创建新的 File实例。 |
创建File对象，只是考虑将路径字符串封装在File对象中，不考虑真实与否
File(String parent, String child) ：
String parent，父路径
String child 子路经
路径工具
| 返回值 | 方法 | 描述 |
|---|---|---|
String |
getAbsolutePath() |
返回此抽象路径名的绝对路径名字符串。 |
String |
getPath() |
将此抽象路径名转换为路径名字符串 |
String |
getName() |
返回由此抽象路径名表示的文件或目录的名称。 |
long |
length() |
返回由此抽象路径名表示的文件的长度。 |
判断方法
| 返回值 | 方法 | 描述 |
|---|---|---|
boolean |
isAbsolute() |
测试这个抽象路径名是否是绝对的。 |
boolean |
isDirectory() |
测试此抽象路径名表示的文件是否为目录。 |
boolean |
isFile() |
测试此抽象路径名表示的文件是否为普通文件。 |
boolean |
isHidden() |
测试此抽象路径名命名的文件是否为隐藏文件。 |
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());
}
}
创建删除方法
| 返回值 | 函数名称 | 描述 |
|---|---|---|
boolean |
createNewFile() |
当且仅当具有该名称的文件尚不存在时，创建一个由该抽象路径名命名的新的空文件。 |
boolean |
delete() |
删除由此抽象路径名表示的文件或目录。 |
boolean |
mkdir() |
创建由此抽象路径名命名的目录。 |
boolean |
mkdirs() |
创建由此抽象路径名命名的目录，包括任何必需但不存在的父目录。 |
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);
}
}
}
}
}
文件过滤器
| 返回值 | 方法 | 返回值 |
|---|---|---|
File[] |
listFiles(FileFilter filter) |
返回一个抽象路径名数组，表示由此抽象路径名表示的满足指定过滤器的目录中的文件和目录。 |
File[] |
listFiles(FilenameFilter filter) |
返回一个抽象路径名数组，表示由此抽象路径名表示的满足指定过滤器的目录中的文件和目录。 |
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
构造方法
| 方法 | 描述 |
|---|---|
| FileOutputStream(String name) | 创建文件输出流以指定的名称写入文件。 |
| FileOutputStream(File file) | 创建文件输出流以写入由指定的 File对象表示的文件 |
| FileOutputStream(File file, boolean append) | 创建文件输出流以写入由指定的 File对象表示的文件。续写 |
| FileOutputStream(String name, boolean append) | 创建文件输出流以指定的名称写入文件。续写 |
方法
| 返回值 | 方法 | |
|---|---|---|
void |
close() |
关闭此文件输出流并释放与此流相关联的任何系统资源。 |
protected void |
finalize() |
清理与文件的连接，并确保当没有更多的引用此流时，将调用此文件输出流的 close方法。 |
FileChannel |
getChannel() |
返回与此文件输出流相关联的唯一的FileChannel对象。 |
FileDescriptor |
getFD() |
返回与此流相关联的文件描述符。 |
void |
write(byte[] b) |
将 b.length个字节从指定的字节数组写入此文件输出流。 |
void |
write(byte[] b, int off, int len) |
将 len字节从位于偏移量 off的指定字节数组写入此文件输出流。 |
void |
write(int b) |
将指定的字节写入此文件输出流。 |
换行符：
win
moc /r
lin /n
Reader&Writer
构造方法
protected |
Reader() |
创建一个新的字符流阅读器，其关键部分将在阅读器本身上同步。 |
|---|---|---|
protected |
Reader(Object lock) |
创建一个新的字符流阅读器，其关键部分将在给定对象上同步。 |
实现方法
| 返回值 | 方法 | 描述 |
|---|---|---|
int |
read() |
读一个字符 |
int |
read(char[] cbuf) |
将字符读入数组。 |
abstract int |
read(char[] cbuf, int off, int len) |
将字符读入数组的一部分。 |
int |
read(CharBuffer target) |
尝试将字符读入指定的字符缓冲区。 |
abstract void |
close() |
关闭流并释放与之相关联的任何系统资源。 |
FileWriter&FileReader
构造方法
| 方法 | 描述 |
|---|---|
| FileWriter(String fileName, boolean append) | 构造一个FileWriter对象，给出一个带有布尔值的文件名，表示是否附加写入的数据。 |
| FileWriter(File file, boolean append) | 给一个File对象构造一个FileWriter对象。 |
方法
| 返回值 | 方法 | 描述 |
|---|---|---|
Writer |
append(char c) |
将指定的字符附加到此作者。 |
Writer |
append(CharSequence csq) |
将指定的字符序列附加到此作者。 |
Writer |
append(CharSequence csq, int start, int end) |
将指定字符序列的子序列附加到此作者。 |
abstract void |
close() |
关闭流，先刷新。 |
abstract void |
flush() |
刷新流。 |
void |
write(char[] cbuf) |
写入一个字符数组。 |
abstract void |
write(char[] cbuf, int off, int len) |
写入字符数组的一部分。 |
void |
write(int c) |
写一个字符 |
void |
write(String str) |
写一个字符串 |
使用步骤：
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+"
");
}
} 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+"
");
}
} catch (Exception e) {
System.out.println(e);
}
}
}
Properties
Properties类表示一组持久的属性。 Properties可以保存到流中或从流中加载。 属性列表中的每个键及其对应的值都是一个字符串。
属性列表可以包含另一个属性列表作为其“默认值”; 如果在原始属性列表中找不到属性键，则会搜索此第二个属性列表。
构造方法
| 方法 | 描述 |
|---|---|
Properties() |
创建一个没有默认值的空属性列表。 |
Properties(Properties defaults) |
创建具有指定默认值的空属性列表。 |
实现方法
| 返回值 | 方法 | 描述 |
|---|---|---|
Set<String> |
stringPropertyNames() |
返回此属性列表中的一组键，其中键及其对应的值为字符串，包括默认属性列表中的不同键，如果尚未从主属性列表中找到相同名称的键。 |
String |
getProperty(String key) |
使用此属性列表中指定的键搜索属性。 |
| String | getProperty(String key, String defaultValue) |
使用此属性列表中指定的键搜索属性。 |
void |
load(Reader reader) |
以简单的线性格式从输入字符流读取属性列表（关键字和元素对）。 |
void |
store(OutputStream out, String comments) |
将此属性列表（键和元素对）写入此 Properties表中，以适合于使用 load(InputStream)方法加载到 Properties表中的格式输出流。 |
void |
store(Writer writer, String comments) |
将此属性列表（键和元素对）写入此 Properties表中，以适合使用 load(Reader)方法的格式输出到输出字符流。 |
Object |
setProperty(String key, String value) |
将指定的key映射到此key value中指定的value。 钥匙和价值都不能是null |
案例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
构造方法：
| 方法 | 描述 |
|---|---|
| BufferedInputStream (InputStream in) | More Actions创建一个 BufferedInputStream并保存其参数，输入流 in ，供以后使用。 |
| BufferedInputStream (InputStream in, int size) | 创建 BufferedInputStream具有指定缓冲区大小，并保存其参数，输入流 in ，供以后使用。 |
实现方法：
| 返回值 | 方法 | 描述 |
|---|---|---|
int |
available() |
返回从该输入流中可以读取（或跳过）的字节数的估计值，而不会被下一次调用此输入流的方法阻塞。 |
void |
close() |
关闭此输入流并释放与流相关联的任何系统资源。 |
void |
mark(int readlimit) |
见的总承包 mark的方法 InputStream 。 |
boolean |
markSupported() |
测试这个输入流是否支持 mark和 reset方法。 |
int |
read() |
从该输入流读取下一个数据字节。 值字节作为int返回为0到255 。 如果没有字节可用，因为流已经到达，则返回值-1 。 该方法阻塞直到输入数据可用，检测到流的结尾，或抛出异常。 |
int |
read(byte[] b, int off, int len) |
从给定的偏移开始，将字节输入流中的字节读入指定的字节数组。 |
void |
reset() |
见 reset法 InputStream的一般合同。 |
long |
skip(long n) |
见 skip法 InputStream的一般合同。 |
步骤：
- 创建FileInputStream对象，构造方法中绑定要读取的数据源
- 创建BufferedInputstream对象，构造方法中传递FileInputStream对象，提高读取效率。
- 使用BufferedInputstream对象中的read()方法，读取文件
- 释放资源
案例
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]+" ");
}
}catch (Exception e){
e.printStackTrace();
}
}
}
BufferedOutputStream
构造方法：
| 方法 | 描述 |
|---|---|
BufferedOutputStream(OutputStream out) |
创建一个新的缓冲输出流，以将数据写入指定的底层输出流。 |
BufferedOutputStream(OutputStream out, int size) |
创建一个新的缓冲输出流，以便以指定的缓冲区大小将数据写入指定的底层输出流。 |
实现方法：
| 返回值 | 方法 | 描述 |
|---|---|---|
void |
flush() |
刷新缓冲输出流。 |
void |
write(byte[] b, int off, int len) |
从指定的字节数组写入 len个字节，从偏移 off |
void |
write(int b) |
将指定的字节写入缓冲的输出流。 |
操作步骤
- 创建FileWriter对象，在构造方法中邦迪文件输出地址
- 使用FileWriter对象的writer方法，将数据写入到内存缓冲区中。
- 使用FileWriter对象的flush方法，将数据从内存缓冲区中刷新到文件中
- 关闭资源
案例
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
构造方法：
| 方法 | 描述 |
|---|---|
BufferedReader(Reader in) |
创建使用默认大小的输入缓冲区的缓冲字符输入流。 |
BufferedReader(Reader in, int sz) |
创建使用指定大小的输入缓冲区的缓冲字符输入流。 |
实现方法：
| 返回值 | 方法 | 描述 |
|---|---|---|
void |
close() |
关闭流并释放与之相关联的任何系统资源。 |
Stream<String> |
lines() |
返回一个 Stream ，其元素是从这个 BufferedReader读取的行。 |
void |
mark(int readAheadLimit) |
标记流中的当前位置。 |
boolean |
markSupported() |
告诉这个流是否支持mark（）操作。 |
int |
read() |
读一个字符 |
int |
read(char[] cbuf, int off, int len) |
将字符读入数组的一部分。 |
String |
readLine() |
读一行文字。 |
boolean |
ready() |
告诉这个流是否准备好被读取。 |
void |
reset() |
将流重置为最近的标记。 |
步骤：
- 创建FileReader对象，构造方法中绑定要读取的数据源
- 创建BufferedReader对象，构造方法中传递FileRead对象，提高读取效率。
- 使用BufferedReader对象中的read()方法，读取文件
- 释放资源
注意：
readline();包含行的内容的字符串，不包括任何行终止字符，如果已达到流的末尾，则为null
BufferedWriter
构造方法：
| 方法 | 描述 |
|---|---|
BufferedWriter(Writer out) |
创建使用默认大小的输出缓冲区的缓冲字符输出流。 |
BufferedWriter(Writer out, int sz) |
创建一个新的缓冲字符输出流，使用给定大小的输出缓冲区。 |
Writer out: 传递FileRWriter，为FileWriter增加缓冲区，提高写入效率
int size: 缓冲区大小
实现方法：
| 返回值 | 方法 | 描述 |
|---|---|---|
void |
close() |
关闭流，先刷新。 |
void |
flush() |
刷新流。 |
void |
newLine() |
写一行行分隔符。 |
void |
write(char[] cbuf, int off, int len) |
写入字符数组的一部分 |
void |
write(int c) |
写一个字符 |
void |
write(String s, int off, int len) |
写一个字符串的一部分。 |
步骤：
- 创建FileWriter对象，在构造方法中绑定文件输出地址
- 使用BufferedWriter对象的writer方法，将数据写入到内存缓冲区中。
- 使用BufferedWriter对象的flush方法，将数据从内存缓冲区中刷新到文件中
- 关闭资源
案例：对文本进行排序
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("
");
}
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+0000U+007F）。带有变音符号的拉丁文、希腊文、西里尔字母、亚美尼亚语、希伯来文、阿拉伯文、叙利亚文等字母则需要2字节编码（Unicode范围由U+0080U+07FF）。其他语言的字符（包括中日韩文字、东南亚文字、中东文字等）包含了大部分常用字，使用3字节编码。其他极少使用的语言字符使用4字节编码。
InputStreamReader & OutputStreamWriter
介绍：
- InputStreamReader是从字节流到字符流的桥：它读取字节，并使用指定的
charset将其解码为字符 。 它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集。 - OutputStreamWriter是字符的桥梁流以字节流：向其写入的字符编码成使用指定的字节
charset。 它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集。
最大的效率，请考虑在BufferedReader中包装一个InputStreamReader
InputStreamReader
构造方法
| 方法 | 描述 |
|---|---|
| InputStreamReader(InputStream in) | 创建一个使用默认字符集的InputStreamReader。 |
| InputStreamReader(InputStream in, Stringm charsetName) | 创建一个使用命名字符集的InputStreamReader。 |
InputStream in：输出流对象
String charsetName： 要输入的字符编码，不区分大小写，GBK/gbk,UTF-8/utf-8
实现方法
| 返回值 | 方法 | 描述 |
|---|---|---|
void |
close() |
关闭流并释放与之相关联的任何系统资源。 |
String |
getEncoding() |
返回此流使用的字符编码的名称。 |
int |
read() |
读一个字符 |
int |
read(char[] cbuf, int offset, int length) |
将字符读入数组的一部分。 |
boolean |
ready() |
告诉这个流是否准备好被读取。 |
步骤：
- 创建InputStreamReader 对象，构造方法中绑定要读取的数据源，设置编码格式
- 使用BufferedReader对象中的read()方法，读取文件
- 释放资源
OutputStream
构造方法
| 方法 | 描述 |
|---|---|
| OutputStreamWriter(OutputStream out) | 创建一个使用默认字符编码的OutputStreamWriter。 |
| OutputStreamWriter(OutputStream out, String charsetName) | 创建一个使用命名字符集的OutputStreamWriter。 |
OutputStream out：输出流对象
String charsetName： 要输出的字符编码，不区分大小写，GBK/gbk,UTF-8/utf-8
实现方法
| 返回值 | 方法 | 描述 |
|---|---|---|
void |
close() |
关闭流，先刷新。 |
void |
flush() |
刷新流。 |
String |
getEncoding() |
返回此流使用的字符编码的名称。 |
void |
write(char[] cbuf, int off, int len) |
写入字符数组的一部分。 |
void |
write(int c) |
写一个字符 |
void |
write(String str, int off, int len) |
写一个字符串的一部分。 |
步骤：
- 创建OutputStream 对象，构造方法中绑定要读取的数据源，设置编码格式
- 使用OutputStream对象中的writer()方法，写文件
- 释放资源
转换出师表
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("
");
}
br.close();
bw.close();
osw.close();
isr.close();
}
}
序列化
来自视频
构造方法：
| 方法 | 描述 | |
|---|---|---|
protected |
ObjectOutputStream() |
为完全重新实现ObjectOutputStream的子类提供一种方法，不必分配刚刚被ObjectOutputStream实现使用的私有数据。 |
|
ObjectOutputStream(OutputStream out) |
创建一个写入指定的OutputStream的ObjectOutputStream。 |
步骤：
- 实现java.io.Serializable接口，才能将对象输出
- 创建objectOutputStream对象，构造方法中传递输出流
- 使用objectOutputStream对象中的方法WriterObject，把对象写入到文件中
- 释放资源