File类：
常用方法：
- exists() 测试此抽象路径名表示的文件或目录是否存在。
- reateNewFile() 当且仅当不存在具有此抽象路径名指定名称的文件时，不可分地创建个新的空文件。
- getAbsoluteFile() 返回此抽象路径名的绝对路径名形式。
- getAbsolutePath() 返回此抽象路径名的绝对路径名字符串。
- getCanonicalFile() 返回此抽象路径名的规范形式。
- getName() 返回由此抽象路径名表示的文件或目录的名称。
- getParentFile() 返回此抽象路径名父目录的抽象路径名；如果此路径名没有指定父目录则返回 null。
- getPath() 将此抽象路径名转换为一个路径名字符串。
- isDirectory() 测试此抽象路径名表示的文件是否是一个目录。
- list() 返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录。
- | listFiles() 返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件。
- mkdirs() 创建此抽象路径名指定的目录，包括所有必需但不存在的父目录。
递归列出和删除文件夹中所有文件和子文件夹：
//递归遍历文件夹
public static void listFiles(File dir) {
System.out.println(dir.getAbsolutePath());
File[] files=dir.listFiles();
if(files!=null&&files.length>0) {
for (File file : files) {
if(file.isDirectory()) {
//递归
listFile；s(file);
}else {
System.out.println(file.getAbsolutePath());
}
}
}
}
//递归删除文件夹
public static void deleteDir(File dir) {
File[] files=dir.listFiles();
if(files!=null&&files.length>0) {
for (File file : files) {
if(file.isDirectory()) {
deleteDir(file);
}else {
//删除文件
System.out.println(file.toString()+"-----"+file.delete());
}
}
}
//删除文件夹
System.out.println(dir.toString()+"*********"+dir.delete());
}
IO流（input,output）：
流的作用和原理：
流是一组有序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即是数据在两设备间的传输，他的本质是数据传输，根据数据传输特性将流抽象喂各种类，方便更方便直观的操作。
IO流的种类：
- 按照流的流向分：输入流、输出流
- 按照处理数据单位分：字节流、字符流
- 按照功能分：节点流、处理流
字节流：
- InputStream字节输入流，FileInputStream文件输入流,常用方法：
- int read()从输入流中读取数据的下一个字节。
- int read(byte[] b)从输入流中读取一定数量的字节，并将其存储在缓冲区数组b中。
- int read(byte[] b,int off, int len)将输入流中最多len个数据字节读入 byte 数组。
- OutputStream字节输出流，FileoutputStream文件输出流,常用方法：
- void flush()刷新此输出流并强制写出所有缓冲的输出字节。
- void write(byte[] b)将 b.length 个字节从指定的 byte 数组写入此输出流。
- void write(byte[] b,int off, int len)将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。
- void write(int b)将指定的字节写入此输出流。
使用字节流复制文件：
// 1 使用字节流复制文件
public static void copy1() throws Exception{
//1创建字节文件输入输出流
InputStream is=new FileInputStream("d:\\003.jpg");
OutputStream os=new FileOutputStream("d:\\004.jpg");
//2读、写
byte[] buf=new byte[1024*4];
int len=0;
while((len=is.read(buf))!=-1){
//buf缓冲区,0从第一个位置写，len写的长度
os.write(buf,0,len);
}
//3关闭
is.close();
os.close();
System.out.println("复制完成");
}
字符流：
字符输入流 Reader----->InputStreamReader---->FileReader
字符输出流 Writer----->OutputStreamWriter—>FileWriter
转换流：
1.实现字节流到字符流的转换
2.解决中文乱码的问题
中文编码
gb2312 （采用两个字节保存字符汉字，英文数字一个字节）
GBK （采用两个字节保存字符汉字，英文数字一个字节）
GB18030 (英文数字都是一个字节，中文是两个或四个字节)
Unicode字符集（包含每个国家的所有字符）国际通用
unicode编码 使用两个字节---65536个字符，浪费空间
为了节省空间使用转码形式
utf-8 使用 1 、2、3个字节 （EF BB BF 记事本添加的BOM（Byte Order Mark）头,编码的标记）
utf-16 使用两个字节---65536个字符 （FF FE 小端（尾） FE FF 大端（尾））
utf-32 使用4个字节
台湾 big5
ANSI:在简体中文Windows操作系统中, ANSI 编码代表 GBK 编码
只有转换流才能指定读取和写入的字符集
InputStreamReader类：
字节字符转换输入流，将字节输入流转换为字符输入流
InputStreamReader reader = new InputStreamReader(new FileInputStream(new File("file/input1.txt")),"UTF-8");
//读取
char[] arr = new char[16];
int len = 0;
while((len = reader.read(arr)) != -1) {
String string = new String(arr, 0, len);
System.out.println(string);
}
reader.close();
OutputStreamWriter类：
字符转换输出流，将内存中的字符转成字节保存到硬盘中。
public static void main(String[] args) throws IOException {
//1.实例化FIle对象
//注意：对于所有的输出流而言，文件可以不存在，在进行写入的过程中可以自动进行创建
//但是，对于所有的输入流而言，文件必须先存在，然后才能操作，否则，会抛出FileNotFounedException
File file = new File("file/output1.txt");
//2.实例化转换输出流
//如果不想覆盖源文件中的内容时，则在传参的时候，设置一个参数为true
OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream(file,true), "utf-8");
//3.写入
writer.write("家客户放假啊刚回家");
//4.刷新
writer.flush();
//5.关闭
writer.close();
}
缓冲流：
缓冲流是处理流的一种, 它依赖于原始的输入输出流, 它令输入输出流具有1个缓冲区, 显著减少与外部设备的IO次数, 而且提供一些额外的方法.
可见, 缓冲流最大的特点就是具有1个缓冲区! 而我们使用缓冲流无非两个目的:
-
减少IO次数(提升performance)
-
使用一些缓冲流的额外的方法.
如果使用记事本创建的文件，文件是utf-8或者unicode编码，文件的前面有一个BOM（Byte Order Mark）头,BOM作用指定文件使用的编码类型。GBK编码没有添加bom头。
utf-8:EF BB BF
unicode 小端: FF FE 或 66 00
unicode 大端 ：FE FF 或 00 66
BufferedInputStream类：
ublic static void main(String[] args) throws IOException {
//实例化一个File对象
File file = new File("file/test22.txt");
//实例化一个缓冲字节输入流的对象
BufferedInputStream input = new BufferedInputStream(new FileInputStream(file));
//读取
byte[] arr = new byte[4];
int len = input.read(arr);
String string = new String(arr, 0, len);
System.out.println(string);
input.mark(66);
len = input.read(arr);
string = new String(arr, 0, len);
System.out.println(string);
// 实现了效果：覆水可收
input.reset();
len = input.read(arr);
string = new String(arr, 0, len);
System.out.println(string);
input.close();
}
BufferedOutputStream类：
public static void main(String[] args) throws IOException {
//实例化FIle对象
File file = new File("test33.txt");
//实例化换种字节输出流
BufferedOutputStream output = new BufferedOutputStream(new FileOutputStream(file));
//写
output.write("你好的halle".getBytes());
//刷新
output.flush();
//关闭
output.close();
}
BufferedReader类：
public static void main(String[] args) throws IOException {
//实例化FIle对象
File file = new File("test33.txt");
//实例化缓冲字符流的对象
BufferedReader reader = new BufferedReader(new FileReader(file));
//方式一：read循环读取
/*
//读取
char[] arr = new char[8];
int len = 0;
while((len = reader.read(arr)) != -1) {
String string = new String(arr, 0, len);
}
*/
//方式二：readLine循环读取
/*
String result1 = reader.readLine();
System.out.println(result1);
String result2 = reader.readLine();
System.out.println(result2);
*/
String result = "";
while((result = reader.readLine()) != null) {
System.out.println("第一行：" + result);
}
reader.close();
}
BufferedWriter类：同BufferedOutputStream
内存流：
输入和输出都是从文件中来的，当然，也可将输出输入的位置设置在内存上，这就需要： ByteArrayInputStream和ByteArrayOutputStream
ByteArrayInputStream:将内容写入到内存中，是Inputstream的子类
ByteArrayOutputStream：将内存中数据输出，是OutputStream的子类
字母大小写转换：
public static void main(String[] args) throws IOException {
//定义一个字符串，全部由大写字母组成
String string = "HELLOWORLD";
//内存输入流
//向内存中输出内容，注意：跟文件读取不一样，不设置文件路径
ByteArrayInputStream bis = new ByteArrayInputStream(string.getBytes());
//内存输出流
//准备从内存中读取内容，注意：跟文件读取不一样，不设置文件路径
ByteArrayOutputStream bos = new ByteArrayOutputStream();
int temp = 0;
//read()方法每次只读取一个字符
while((temp = bis.read()) != -1) {
//将读取的数字转为字符
char c = (char)temp;
//将字符变为大写
bos.write(Character.toLowerCase(c));
}
//循环结束之后，所有的数据都在ByteArrayOutputStream中
//取出内容，将缓冲区内容转换为字符串
String newString = bos.toString();
//关闭流
bis.close();
bos.close();
System.out.println(newString);
}
标准输入输出流：
PrintStream类：PrintStream为其他输出流添加了功能，使它们能够方便地打印各种数据值表示形式。
PrintWriter类：向文本输出流打印对象的格式化表示形式。此类实现在 PrintStream中的所有 print方法。它不包含用于写入原始字节的方法。
对象流：
流中流动的数据是对象
将一个对象写入到本地文件中，被称为对象的序列化
将一个本地文件中的对象读取出来，被称为对象的反序列化
使用对象流
ObjectInputStream: 对象输出流
ObjectOutputStream：对象输入流
注意：
序列化对象的类型必须实现Serializable接口。否则不能序列化。
如果向将多个对象序列化到本地，可以借助于集合，【思路：将多个对象添加到集合中，将集合的对象写入到本地文件中，再次读出来，获取到的仍然是集合对象，遍历集合】。
对象中那些字段可以不序列化:
1 transient 修饰的字段
2 静态的字段
在要序列化类中添加字段，保证序列化和反序列化是同一个类
260
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
