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 静态的字段
在要序列化类中添加字段,保证序列化和反序列化是同一个类