1、File
（1）File类在java.io.file包下，作用：用来表示计算机磁盘上的文件或目录的对象。
（2）构造器：
File(File parent, String child) 从父抽象路径名和子路径名字符串创建新的 File实例。
File(String pathname) 通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。 File(String
parent, String child) 从父路径名字符串和子路径名字符串创建新的 File实例。 File(URI uri)
通过将给定的 file: URI转换为抽象路径名来创建新的 File实例。
案例：file对象的创建
File f1=new File("C:\\Users\\Administrator\\Desktop\\1.txt");
我们想要访问磁盘中的文件或目录，必须要知道其路径。
（3）方法
boolean exists() 测试此抽象路径名表示的文件或目录是否存在。
boolean isDirectory() 测试此抽象路径名表示的文件是否为目录。
boolean isFile() 测试此抽象路径名表示的文件是否为普通文件。
String getName() 返回由此抽象路径名表示的文件或目录的名称。
String getPath() 将此抽象路径名转换为路径名字符串。
String getAbsolutePath() 返回此抽象路径名的绝对路径名字符串。
String getParent() 返回此抽象路径名的父 null的路径名字符串，如果此路径名未命名为父目录，则返回null。
boolean canRead() 测试应用程序是否可以读取由此抽象路径名表示的文件。
boolean canWrite()
测试应用程序是否可以修改由此抽象路径名表示的文件。
boolean canExecute()
测试应用程序是否可以执行此抽象路径名表示的文件。
boolean isHidden() 测试此抽象路径名命名的文件是否为隐藏文件。
long lastModified() 返回此抽象路径名表示的文件上次修改的时间。
long length() 返回由此抽象路径名表示的文件的长度。
String[] list() 返回一个字符串数组，命名由此抽象路径名表示的目录中的文件和目录。
File[] listFiles() 返回一个抽象路径名数组，表示由该抽象路径名表示的目录中的文件。
boolean createNewFile() 当且仅当具有该名称的文件尚不存在时，原子地创建一个由该抽象路径名命名的新的空文件。
boolean mkdir() 创建由此抽象路径名命名的目录。
boolean mkdirs() 创建由此抽象路径名命名的目录，包括任何必需但不存在的父目录。
boolean delete() 删除由此抽象路径名表示的文件或目录。
这里写一下file中list()和listfiles9)的区别
File f=new File(“C:\Users\Administrator\Desktop\d”);
//获取包含的子目录和文件，只要名字
// String[] fileNames=f.list();
// for (int i = 0; i < fileNames.length; i++) {
// System.out.println(fileNames[i]);
// }
//获取包含的子目录和文件，所有信息（包含名字==）
File[] files=f.listFiles();
for (int i = 0; i < files.length; i++) {
File fz=files[i];
System.out.println(fz.getName()+" "+fz.lastModified());
}
（4）递归方法（递归函数）
当一个方法调用重复调用自身就属于递归。
阶乘递归案例
public class DiGui {
/**
* 普通方法
* @param n
*/
public static void jiecheng(int n) {
int jc=1;
for (int i = 1; i <=n; i++) {
jc*=i;
}
System.out.println(jc);
}
/**
* 递归方法
* @param args
*/
public static int jiecheng2(int n) {
if(n==1) {
return 1;
}
return n*jiecheng2(n-1);
}
public static void main(String[] args) {
// jiecheng(6);
System.out.println(jiecheng2(5));
// jiecheng2(5) =5*jiecheng2(4)=5*4*jiecheng2(3)=5*4*3*jiecheng2(2)=5*4*3*2*jiecheng2(1)=5*4*3*2*1
System.out.println(jiecheng2(6));
}
}
案例：使用递归遍历目录和文件名
public static void findAllFile(File dir,String flag) {
File[] files=dir.listFiles();
for (int i = 0; i < files.length; i++) {
File f=files[i];
System.out.println(flag+f.getName());
//如果是目录，继续遍历
if(f.isDirectory()) {
findAllFile(f,flag+"\t");
}
}
}
public static void main(String[] args) {
findAllFile(new File("C:\\Users\\Administrator\\Desktop\\d"),"");
}
2、IO流
（1）流的功能，用来传输数据
（2）流的分类
3、字节流
按照字节为单位处理数据的流，可以传输任何类型的数据。按照传输方向分为字节输出流和字节输入流
（1）字节输入流，负责读取数据
级父类：java.io.InputStream(抽象类)
实现的子类：读取的数据源不同
FileInputStream:从磁盘文件中读取数据。
构造器：创建字节输入流对象。
FileInputStream(File file) 通过打开与实际文件的连接创建一个 FileInputStream，该文件由文件系统中的 File对象 file命名。
FileInputStream(String name) 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name命名。
例：字节输出流的创建
//方式一：
File file=new File("c:\\a.txt");
FileInputStream fis=new FileInputStream(file);
//方式二：
String source="c:\\a.txt"；
FileInputStream fis=new FileInputStream(source);
字节流方法
void close() 关闭此文件输入流并释放与流相关联的任何系统资源。 int read() 从该输入流读取一个字节的数据。
int read(byte[] b) 从该输入流读取最多 b.length个字节的数据为字节数组。
int read(byte[] b,int off, int len) 从该输入流读取最多 len字节的数据为字节数组。
（2）字节输出流：负责写入数据。
顶级父类：java.io.OutputStream（抽象类）
实现的子类：写入的目的端不同
FileOutputStream：将数据写入磁盘文件中。
构造器：
FileOutputStream(File file) 创建文件输出流以写入由指定的 File对象表示的文件。
FileOutputStream(File file, boolean append) 创建文件输出流以写入由指定的
File对象表示的文件。 FileOutputStream(String name) 创建文件输出流以指定的名称写入文件。
FileOutputStream(String name, boolean append) 创建文件输出流以指定的名称写入文件。
字节输入流与字节输出流构造方法类似，不同的是字节输入流有两个构造方法有了新的参数，那个参数是布尔型的，一般默认为false，
这个参数的意思是追加时的方式，true表示直接追加到原有数据后面，flase表示为当先输入覆盖原先数据。
追加or覆盖：
FileOutputStream fos=new FileOutputStream("C:\\Users\\Administrator\\Desktop\\2.txt",true);
true表示追加，false表示覆盖，默认是覆盖。
字节输入流方法
void close() 关闭此文件输出流并释放与此流相关联的任何系统资源。
void write(int b) 将指定的字节写入此文件输出流。
void write(byte[] b) 将 b.length个字节从指定的字节数组写入此文件输出流。
void write(byte[] b, int off, int len) 将 len字节从位于偏移量off的指定字节数组写入此文件输出流。
（3）文件拷贝案例
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
public class CopyFile {
public static void copy(String source,String target) throws Exception {
// 创建输入流
FileInputStream fis=new FileInputStream(source);
// 创建输出流
FileOutputStream fos=new FileOutputStream(target);
// 读写过程
// 一次性读完写完
// byte[] b=new byte[fis.available()];
// fis.read(b);
// fos.write(b);
// 边读边写
byte[] b=new byte[1024*1024];
int i=fis.read(b);
while(i!=-1) {
fos.write(b,0,i);
i=fis.read(b);
}
// 关闭流
fos.close();
fis.close();
}
public static void main(String[] args) {
try {
copy("C:\\Users\\Administrator\\Desktop\\1.txt","D:\\1.txt");
} catch (Exception e) {
e.printStackTrace();
}
}
}
4、字符流
按照字符为单位来进行读写，一般用传输文件。按照传输方向分为：字符输出流和字符输入流
（1）字符输入流
顶级父类：java.io.Reader（抽象类）
按照读取的数据源类型不同，分为若干子类，最常用的是读取文件：FileReader。
构造器：创建字节输入流对象。
FileReader(File file) 创建一个新的 FileReader ，给出 File读取。
FileReader(String fileName) 创建一个新的 FileReader ，给定要读取的文件的名称。
方法：
void close() 关闭此文件输入流并释放与流相关联的任何系统资源。
int read() 从该输入流读取一个字节的数据。
int read(byte[] b) 从该输入流读取最多 b.length个字节的数据为字节数组。
int read(byte[] b,int off, int len) 从该输入流读取最多 len字节的数据为字节数组。
案例：字符流对象的创建与方法的使用
public static void main(String[] args) throws Exception {
// 1创建字符输入流对象
FileReader fr=new FileReader("C:\\Users\\Administrator\\Desktop\\1.txt");
// 2、读取数据
// int i=fr.read();
// System.out.println((char)i);
// int i=fr.read();
// while(i!=-1) {
// System.out.print((char)i);
// i=fr.read();
// }
// char[] c=new char[10];
// int i=fr.read(c);
// while(i!=-1) {
// System.out.print(new String(c,0,i));
// i=fr.read(c);
// }
char[] c=new char[10];
int i=fr.read(c,1,7);
while(i!=-1) {
System.out.print(new String(c,1,i));
i=fr.read(c,1,7);
}
// 3、关闭流
fr.close();
}
（2）字符输出流
顶级父类：java.io.Writer（抽象类）
按照写入的目的端类型不同，分为若干子类。
最常用的是写入文件：FileWriter
构造器：
FileWriter(File file) 给一个File对象构造一个FileWriter对象。
FileWriter(File file, boolean append) 给一个File对象构造一个FileWriter对象。 FileWriter(String
fileName) 构造一个给定文件名的FileWriter对象。 FileWriter(String fileName,boolean append) 构造一个FileWriter对象，给出一个带有布尔值的文件名，表示是否附加写入的数据。
方法：
void close() 关闭流，先刷新。 void write(int c) 写一个字符
void write(char[]cbuf) 写入一个字符数组。
void write(char[] cbuf, int off, int len) 写入字符数组的一部分。
void write(String str) 写一个字符串
void write(String str,int off, int len) 写一个字符串的一部分。
void flush() 刷新流。
案列
import java.io.FileWriter;
public class TestFileWriter {
public static void main(String[] args) throws Exception {
// 1创建一个字符输出流，负责写
FileWriter fw=new FileWriter("C:\\Users\\Administrator\\Desktop\\2.txt");
// 2写
// fw.write('a');
// fw.write('我');
// char[] c="我爱你".toCharArray();
// fw.write(c);
// char[] c="我爱你".toCharArray();
// fw.write(c,1,3);
// fw.write("我爱你");
fw.write("我爱你",1,3);
// 3关闭流
fw.close();
}
}
（3）文件拷贝
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class CopyFile {
public static void copy(String source,String target) throws IOException {
// 1创建流
FileReader fr=new FileReader(source);
FileWriter fw=new FileWriter(target);
// 2读写
char[] c=new char[1024];
int i=fr.read(c);
while(i!=-1) {
fw.write(c, 0, i);
fw.flush();//刷新，强制写
i=fr.read(c);
}
// 3关闭流
fw.close();//先刷新，再关闭
fr.close();
}
public static void main(String[] args) {
try {
copy("C:\\Users\\Administrator\\Desktop\\1.txt","C:\\Users\\Administrator\\Desktop\\2.txt");
} catch (IOException e) {
e.printStackTrace();
}
}
}
（4）字符集和乱码
字符集：字符的集合，以及每个字符对应的编码。
常见的字符集有：iso-8859-1、gbk、utf-8
字符集主要用于数据存储和传输的编码和解码。
iso-8859-1:
他就是ascii码，里面只有英文字符和对应的编码。
一个字符占1个字节（8个二进制位）。
GBK：
它是中国汉字编码，里面包含汉字字符和英文字符对应的编码。
一个英文字符占1个字节，一个汉字字符占2个字节。
UTF-8：
它是国际码，包含全球字符（包括英文、汉字==）对应的编码。
一个英文字符占1个字节，一个汉字字符占3个字节。
所有字符集中都包含英文字符，且英文字符对应的编码一致。
所有字符集中不一定包含汉字字符，且汉字字符对应的编码也不同。
GBK和UTF-8都支持中文字符，但是中文字符的编码不一样。
乱码：一个字符经过编码和解码后，与原先字符不一致。
中文乱码产生的原因：
第一种，采用了不支持汉字的字符集。
第二种，编码和解码采用不同的字符集。
5、高级流
（1）转换流
作用：将字节流变成字符流，可以指定字符集。
// 转换流
// 字节输入流变成字符输入流
// 如果不指定字符集，采用java默认字符集
InputStreamReader isr=new InputStreamReader(fis,"gbk");
// 将字节输出流变成字符输出流
// 如果不指定字符集，采用java默认字符集
OutputStreamWriter osw=new OutputStreamWriter(fos, "gbk");
案例
public class TestCastStream {
public static void main(String[] args) throws Exception {
// 字节输入流
FileInputStream fis=new FileInputStream("C:\\Users\\Administrator\\Desktop\\1.txt");
// 字节输出流
FileOutputStream fos=new FileOutputStream("C:\\Users\\Administrator\\Desktop\\2.txt");
// 转换流
// 字节输入流变成字符输入流
// 如果不指定字符集，采用java默认字符集
InputStreamReader isr=new InputStreamReader(fis,"gbk");
// 将字节输出流变成字符输出流
// 如果不指定字符集，采用java默认字符集
OutputStreamWriter osw=new OutputStreamWriter(fos, "gbk");
// 使用转换流读写
char[] c=new char[1024];
int i=isr.read(c);
while(i!=-1) {
osw.write(c,0,i);
i=isr.read(c);
}
//关闭
osw.close();
fos.close();
isr.close();
fis.close();
}
}
（2）缓冲流
带有缓冲区的流，先将数据读取到缓冲区，当缓冲区的数据满了再写入目标文件。
作用：减少写入的次数，提高了性能，提高了磁盘的使用寿命。
字节缓冲流：
字节缓冲输入流BufferdInputStream
字节缓冲输出流BufferedOutputSream
public class TestBuffered1 {
public static void main(String[] args) throws Exception {
// 字节输入流
FileInputStream fis=new FileInputStream("C:\\Users\\Administrator\\Desktop\\1.txt");
// 字节输出流
FileOutputStream fos=new FileOutputStream("C:\\Users\\Administrator\\Desktop\\2.txt");
// 缓冲流
// 字节缓冲输入流
BufferedInputStream bis=new BufferedInputStream(fis);
// 字节缓冲输出流
BufferedOutputStream bos=new BufferedOutputStream(fos);
// 使用缓冲流读写：缓冲区
byte[] b=new byte[1024];
int i=bis.read(b);
while(i!=-1) {
bos.write(b, 0, i);
i=bis.read(b);
}
// 关闭流
bos.close();
fos.close();
bis.close();
fis.close();
}
}
字符缓冲流：
字符缓冲输入流BufferedReader
字符缓冲输出流BufferedWriter
public class TestBuffered2 {
public static void main(String[] args) throws Exception {
// 字符输入流
FileReader fr=new FileReader("C:\\Users\\Administrator\\Desktop\\1.txt");
// 字符输出流
FileWriter fw=new FileWriter("C:\\Users\\Administrator\\Desktop\\2.txt");
// 缓冲流
// 字符缓冲输入流
BufferedReader br=new BufferedReader(fr);
// 字符缓冲输出流
BufferedWriter bw=new BufferedWriter(fw);
// 使用缓冲流读写：缓冲区
String s=br.readLine();
while(s!=null) {
bw.write(s+"\n");
s=br.readLine();
}
// 关闭流
bw.close();
fw.close();
br.close();
fr.close();
}
}
（3）对象流（序列化流）
对象的序列化：将对象转为字节码表示。
对象的反序列化：将字节码转为对象。
对象在存储和传输时，需要进行序列化和反序列化。
通用传输序列化格式：xml和json。
Xml格式：
<book category="COOKING">
<title lang="en">Everyday Italian</title>
<author>Giada De Laurentiis</author>
<year>2005</year>
<price>30.00</price>
</book>
Json格式：
{title:”Everyday Italian”,author:”Giada De Laurentiis”,year:2005,price:30.00}
对象序列化之前需要实现序列化接口Serializable
/**
* 如果对象需要ObjectOutputStream序列化，该对象所属的类必须实现序列化接口
* implements Serializable
* @author Administrator
*/
public class Person implements Serializable{
private int no;
private String name;
public int getNo() {
return no;
}
public void setNo(int no) {
this.no = no;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
序列化流 ObjectOutputStream
public class TestObject1 {
public static void main(String[] args) throws Exception {
// 序列化流使用ObjectOutputStream
Person p=new Person();
p.setNo(1001);
p.setName("张三");
FileOutputStream fos=new FileOutputStream("C:\\Users\\Administrator\\Desktop\\3.txt");
//fos.write((p.getNo()+","+p.getName()).getBytes());
ObjectOutputStream oos=new ObjectOutputStream(fos);
oos.writeObject(p);
oos.close();
fos.close();
}
}
反序列化流ObjectInputStream
public class TestObject2 {
public static void main(String[] args) throws Exception {
// 反序列化流ObjectInputStream
FileInputStream fis=new FileInputStream("C:\\Users\\Administrator\\Desktop\\3.txt");
ObjectInputStream ois=new ObjectInputStream(fis);
Person p=(Person)ois.readObject();
System.out.println(p.getNo());
System.out.println(p.getName());
ois.close();
fis.close();
}
}