1、文件
- 创建文件对象的相关构造器和方法
- 相关方法:
new File(String pathname)
//根据路径构建一个File对象new File(File parent,String child)
//根据父目录文件+子路径构建new File(String parent,String child)
//根据父目录+子路径构建
这里就以方法1举例:
// 方法1 new File(String filePath) @Test public void creatNewFile(){ String filePath = "D:\\news1.txt"; File file = new File(filePath); try { file.createNewFile(); } catch (IOException e) { e.printStackTrace(); } System.out.println("文件创建成功"); }
- 相关方法:
- 获取文件信息的常用方法
public void info(){
String filePath = "D://news5.txt";
File file = new File(filePath);
try {
file.createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
System.out.println("文件名字="+file.getName());
System.out.println("文件绝对路径="+file.getAbsolutePath());
System.out.println("文件父级目录="+file.getParent());
System.out.println("文件大小(字节)="+file.length());
System.out.println("文件是否存在="+file.exists());
System.out.println("是不是一个文件="+file.isFile());
System.out.println("是不是一个目录="+file.isDirectory());
}
- 常用的文件操作
- 删除文件
@Test public void m2(){ String filePath = "D:\\news3.txt"; File file = new File(filePath); if(file.exists()){ if(file.delete()){ System.out.println(filePath+"删除成功"); }else{ System.out.println(filePath+"删除失败"); } }else{ System.out.println("该目录不存在"); } }
- 创建目录
创建一级目录:file.mkdir
创建多级目录:file.mkdirs
2、IO流原理及流的分类
- 流的分类
- 按操作数据单位不同分为:字节流(8bit)二进制文件,字符流(按字符)文本文件
- 按数据流的流向不同分为:输入流、输出流
- 按流的角色不同分为:节点流、处理流/包装流
抽象基类 | 字节流 | 字符流 |
---|---|---|
输入流 | InputStream | Reader |
输出流 | OutputStream | Writer |
(1)Java的IO流设计40多个类,实际上非常规则,都是从如上4个抽象基类派生的
(2)有这四个类派生出来的子类名称都是以其父类作为子类后缀
- InputStream:字节输入流;抽象类 InputStream是所有类字节输入流的超类
- InputStream常用的子类:
- FileInputStream:文件输入流
- BufferedInputStream:缓冲字节输入流
- ObjectInputStream:对象字节输入流
- InputStream常用的子类:
- OutputStream字节输出流
- OutputStream常用的子类
- FileOutputStream文件输出流
- FileOutputStream文件输出流
- OutputStream常用的子类
- Reader和Writer:
- FileReader和FileWriter是字符流,即按照字符来操作IO
- FileReader相关的方法:
- new FileReader(File/String)
- read:每次读取单个字符,返回该字符,如果文件末尾返回-1
- read(char[]):批量读取多个字符到数组,返回读取到的字符串,如果到文件末尾返回-1
- new String(char[]):将char[]转换成String
- new String(char[].off,len):将char[]的指定部分转换为String
- FileWriter常用方法
- new FileWriter(File/String):覆盖模式,相当于流的指针在首端
- new FileWriter(File/String,true):追加模式,相当于流的指针在尾端
- write(int):写入单个字符
- write(char[]):写入指定数组
- write(char[],off,len):写入指定数组的指定部分
- write(string):写入整个字符串
- write(string,off,len):写入字符串的指定部分
- 相关API:String类:toCharArray:将String转换成char[]
- 注意:FileWriter使用后,必须要关闭(close)或刷新(flush),否则写入不到指定的文件
3、节点流和处理流
-
基本介绍
- 节点流可以从一个特定的数据源读写数据,如FileReader、FileWriter等
- 处理流(也叫包装流)是“连接”在已存在的流(节点流或处理流)之上,为程序提供更为强大的读写功能,如BufferedReader、BufferedWriter等
-
节点流和处理流的区别和联系
- 节点流是底层流/低级流,直接跟数据相连接
- 处理流包装节点流,既可以消除不同节点流的实现差异,也可以提供更方便的方法来完成输入输出
- 处理流(也叫包装流)对节点流进行包装,使用修饰器设计模式,不会直接与数据向连接
-
处理流的功能主要体现在以下两个方面:
- 性能的提高:主要增加缓冲的方式来提高输入输出的效率
- 操作的便捷:处理流可能提供了一系列便捷的方法来一次输入输出大批的数据,使用更加灵活方便
-
模拟修饰器设计模式BufferedReader
Reader_抽象类:
public abstract class Reader_ {
//抽象类
public void readString(){
}
public void readFile(){
}
}
两个节点流类实现抽象类:FileReader_、StringReader_:
public class FileReader_ extends Reader_{
public void readFile(){
System.out.println("对文件进行读取。。。");
}
}
public class StringReader_ extends Reader_{
public void readString(){
System.out.println("对字符串进行读取。。。");
}
}
BufferedReader_也继承抽象类:
public class BufferedReader_ extends Reader_{
private Reader_ reader_;//属性是Reader_类型
//接收Reader_子类对象
public BufferedReader_(Reader_ reader_){
this.reader_=reader_;
}
//让方法更加灵活,多次读取文件
public void readFiles(int num){
for (int i = 0; i < num; i++) {
reader_.readFile();
}
}
// 扩展 readString,批量处理字符串数据
public void readStrings(int num){
for (int i = 0; i < num; i++) {
reader_.readString();
}
}
}
测试:
public class Test_ {
public static void main(String[] args) {
BufferedReader_ bufferedReader_ = new BufferedReader_(new FileReader_());
bufferedReader_.readFiles(10);
BufferedReader_ bufferedReader_1 = new BufferedReader_(new StringReader_());
bufferedReader_1.readStrings(10);
}
}
- BufferedWriter的使用
上面模拟了 BufferedReader的实现,下面将展示 BufferedWriter的使用:
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
public class BufferedWriter_ {
public static void main(String[] args) throws IOException {
String filePath = "D:\\ok.txt";
// 创建BufferedWriter
//new FileWriter(filePath)表示以覆盖的方式写入
//new FileWriter(filePath,true)在节点流里加一个true,表示以覆盖的方式写入
BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filePath,true));
bufferedWriter.write("哈哈哈哈");
//插入一个和系统相关的换行符
bufferedWriter.newLine();
bufferedWriter.close();
}
}
总结:
//1、创建BufferedWriter对象:
BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filePath,true));
//2、写入
bufferedWriter.write("哈哈哈哈");
bufferedWriter.newLine();
//3、关闭
bufferedWriter.close();
- 用Buffered拷贝(按字符来)
import java.io.*;
public class BufferedCopy {
public static void main(String[] args) {
BufferedReader br = null;
BufferedWriter bw = null;
String line;
try {
br = new BufferedReader(new FileReader("D:\\ok.txt"));
bw = new BufferedWriter(new FileWriter("D:\\ok1.txt"));
//读取写入
while((line= br.readLine())!=null){
bw.write(line);//每读取一行,就写入
bw.newLine();
}
} catch (IOException e) {
e.printStackTrace();
}finally {
if(bw!=null){
try {
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (br!=null){
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
- BufferedOutputStream
BufferedOutputStream是字节流,实现缓冲的输出流,可以将多个字节写入底层输出流中,而不必对每次字节写入调用底层系统
BufferedInputStream也类似。 - Buffered拷贝二进制文件(也可以拷贝文本文件)
import java.io.*;
public class BufferedCopy2 {
public static void main(String[] args) {
//创建BufferedInputStream对象和BufferedOutputStream对象
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
try {
//因为FileInputStream是InputStream的子类
bis = new BufferedInputStream(new FileInputStream("D:\\壁纸1.jpg"));
bos = new BufferedOutputStream(new FileOutputStream("D:\\bizi.jpg"));
//循环读取,并写入
byte[] buff = new byte[1024];
int readLen = 0;
while((readLen = bis.read(buff))!= -1){
bos.write(buff,0,readLen);
}
} catch (IOException e) {
e.printStackTrace();
}finally {
//关闭流,关闭外层流即可,底层会去关闭节点流
if(bis != null){
try {
bis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(bos != null){
try {
bos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
- 标准输入流和标准输出流
- 基本介绍
类型 | 默认设备 | |
---|---|---|
System.in标准输入 | InputStream | 键盘 |
System.out标准输出 | PrintStream | 显示器 |
- System.in编译类型是 InputStream
System.in运行类型是 BufferedInputStream
Scanner scanner = new Scanner(System.in);
String next = scanner.next();
-
System.out编译类型 PrintStream
System.out运行类型PrintStream -
对象流ObjectInputStream和ObjectOutputStream
-
基本介绍:
功能:提供了对基本类型或对象类型的序列化和反序列化的方法
ObjectOutputStream 提供序列化功能
ObjectInputStream 提供反序列功能
-
序列化和反序列化
- 序列化就是在保存数据时,保存数据的值和数据类型
- 反序列化就是在恢复数据时,恢复数据的值和数据类型
- 需要让某个对象支持序列化机制,则必须让其类是可序列化的,为了让其是可序列化的,该类必须实现如下两个接口之一:
(1)Serializable
//这是一个标记接口,没有方法
(2)Externalizable
//该接口有方法需要实现,因此我们一般实现的Serialzable接口
-
注意事项和细节说明
- 读写顺序一致
- 要求实现序列化或反序列化对象,需要实现Serializable
- 序列化的类中建议添加SerialVersionUID,为了提高版本的兼容性
- 序列化对象时,默认将里面所有属性都进行序列化,但除了static和transient修饰的成员
- 序列化对象时,要求里面属性的类型也需要实现序列化接口
- 序列化具备可继承性,也就是如果某类已经实现了序列化,则它的所有子类也就默认实现了序列化
-
序列化实例:
Dog类:
-
import java.io.Serializable;
public class Dog implements Serializable {
private String name;
private int age;
public Dog(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Dog{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
序列化:
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
//完成数据的序列化
public class ObjectStream_ {
public static void main(String[] args) throws Exception {
//序列化后,保存的文件格式不是文本,而是按照它的格式来保存
String filePath= "D:\\data.dat";
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath));
oos.writeInt(100); //int->Integer实现了Serializable
oos.writeBoolean(true); //boolean->Boolean实现了Serializable
oos.writeChar('a'); //char->Character实现了Serializable
oos.writeDouble(9.7);//double->Double实现了Serializable
oos.writeUTF("哈哈哈啊哈哈");
//保存一个dog对象
oos.writeObject(new Dog("小罗",10));
oos.close();
}
}
反序列化:
import java.io.FileInputStream;
import java.io.ObjectInputStream;
public class ObjectInputStream_ {
public static void main(String[] args) throws Exception {
String filePath="D:\\data.dat";
ObjectInputStream ios = new ObjectInputStream(new FileInputStream(filePath));
//读取(反序列化)的顺序要和保存数据(序列化)的顺序一致
System.out.println(ios.readInt());
System.out.println(ios.readBoolean());
System.out.println(ios.readChar());
System.out.println(ios.readDouble());
System.out.println(ios.readUTF());
System.out.println(ios.readObject());
//关闭流
ios.close();
}
}
-
转换流InputStreamReader和OutputStreamWriter
- InputStreamReader:Reader的子类,可以将InputStream(字节流)包装成Reader(字符流)
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;
public class InputStreamReader_ {
public static void main(String[] args) throws Exception {
String filePath="D:\\ok.txt";
//new FileInputStream(filePath)转成InputStreamReader,指定编码为utf-8
InputStreamReader isr = new InputStreamReader(new FileInputStream(filePath),"utf-8");
//把InputStreamReader传入BufferedReader
BufferedReader br =new BufferedReader(isr);
String s=br.readLine();
System.out.println(s);
br.close();
}
}
- OutputStreamWriter:Writer的子类,实现将OutputStream(字节流)包装成(字符流)
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
//把字节流转成字符流
public class OutputStreamWriter_ {
public static void main(String[] args) throws Exception {
OutputStreamWriter gbk = new OutputStreamWriter(new FileOutputStream("D:\\ok1111.txt"),"utf8");
gbk.write("哈哈哈哈很好");
gbk.close();
}
}
-
当处理纯文本数据时,如果使用字符里效率较高,并且可以有效解决中文问题,所以建议将字节流转换为字符流
-
可以在使用时指定编码格式
-
打印流PrintStream和PrintWriter
- 使用PrintStream
import java.io.IOException;
import java.io.PrintStream;
public class PrintStream_ {
public static void main(String[] args) throws IOException {
PrintStream out = System.out;
//在默认的情况, PrintStream 输出数据的位置是 标准输出,即显示器
out.print("ddddddsssdss");
//因为print底层使用的是write,所以可以直接调用write进行打印/输出
out.write("1223sdsd".getBytes());
out.close();
//可以修改打印流输出的文职/设备 ,这里修改为D:\ok111.txt
System.setOut(new PrintStream("D:\\ok111.txt"));
System.out.write("sdsfsdf".getBytes());
System.out.print("ddddddsssdss");
out.close();
}
}
- 使用PrintWrite
import java.io.PrintWriter;
public class PrintWriter_ {
public static void main(String[] args) {
//默认打印/输出在显示器
PrintWriter printWriter = new PrintWriter(System.out);
//修改到文件
// PrintWriter printWriter = new PrintWriter(new FileWriter("D:\\aa.txt"));
printWriter.print("哈哈哈");
printWriter.close();//flush+关闭,才会将数据写入到文件
}
}
- Properties类
-
基本介绍
- 专门用于读写配置文件的集合类
配置文件的格式为:键=值 - 注意:键值对不需要有空格,值不需要用引号引起来,默认类型为String
- 专门用于读写配置文件的集合类
-
Properties的常用方法
- load:加载配置文件的键值对到Properties对象
- list:将数据显示到指定设备
- getProperty(key):根据键获取值
- setProperty(key,value):设置键值对到Properties对象
- store:将Properties中的键值对存储到配置文件,在idea中,保存信息到配置文件,如果含有中文,会存储unicode码
-
Properties读取文件
-
import java.io.FileReader;
import java.util.Properties;
//使用Properties类来读取mysql.properties文件
public class Properties1 {
public static void main(String[] args) throws Exception {
// 1. 创建你Properties对象
Properties properties = new Properties();
//2、加载指定配置文件
properties.load(new FileReader("src\\mysql.properties"));
//3、把k-v显式控制台
properties.list(System.out);
// 4.根据key获取对应的值
String user = properties.getProperty("user");
System.out.println(user);
}
}
- Properties创建修改文件
import java.io.FileOutputStream;
import java.util.Properties;
public class Properties2 {
public static void main(String[] args) throws Exception {
//使用Properties类来创建 配置文件,修改配置文件类容
Properties properties = new Properties();
//创建
//1、如果该文件没有key,就是创建
//2、如果该文件有key,就是修改
properties.setProperty("charset","utf8");
properties.setProperty("user","汤姆123");
properties.setProperty("pwd","abc111");
//将k-v存储文件中,后面的null可以用字符串来写注释
properties.store(new FileOutputStream("src\\mysql2.properties"),null);
}
}