Io
File
文件和目录路径名的抽象表示。
java.io.File
Io流分类
IO:数据的读入写出,文件的上传下载
流:一连串流动的数据,以先入先出的方式进行传输–>流就是管道
数据源---->io---->目的地
数据源 : 数据的来源
目的地 : 数据流向的位置
流的分类:
操作单元分:
字节流:万能流 *****
字符流:纯文本内容
流向分: 以程序为中心
输入流
输出流
功能分:
节点流 : 真实能做读入写出的
功能流 : 增强节点流的功能,提高节点流的性能
流之间的分类是相辅相成的
java.io包
InputStream 字节输入流中最上层父类
文件流 : FileInputStream 文件字节输入流->节点流 字节流 输入流
操作文件,数据源为文件,使用文件字节输入流
字节数组流 : ByteArrayInputStream 字节数组输入流 ->节点流 字节流 输入流
操作字节数组,数据源是字节输入,使用字节数组输入流
代码:
public static void main(String[] args) throws IOException {
File src=new File("D://test.txt");
//FileInputStream(File file) 通过打开与实际文件的连接来创建 FileInputStream ,该文件由文件系统中的 File对象 file命名。
InputStream is=new FileInputStream(src);
//读入 int read() 每次读入一个字节数,返回读入到的字节,读不到返回-1
// int num=is.read();
/* System.out.println((char) num);
System.out.println((char)is.read());
System.out.println((char)is.read());
System.out.println(is.read());
//循环读入
/*int num = -1; //记录每次读到的字节
while((num=is.read())!=-1){
System.out.println((char)num);
}*/
//提高效率,每次读入一车(字节数组)的数据
//byte[] car = new byte[1024];
//int read(byte[]) 每次读入一个字节数组的数据,返回读入到字节数组中数据的个数,没有读到返回-1
//int len = is.read(car);
//System.out.println(new String(car,0,len));
//当内容比较多,需要重复读入,每次读入一个字节数组中的数据
/*byte[] car = new byte[2];
int len = -1; //记录每次读入到数组中数据的个数
while((len = is.read(car))!=-1){
System.out.println(new String(car,0,len));
}*/
//byte[] readAllBytes() 从输入流中读取所有剩余字节。
byte[] arr = is.readAllBytes();
System.out.println(new String(arr));
//关闭
is.close();
}
OutputStream 字节流输出流
FileOutputStream 文件字节输出流 -> 节点流
目的地为文件
ByteArrayOutputStream 字节数组输出流 -> 节点流
目的地为字节数组
注意: 在输出流写出的时候,如果目的地文件不存在,系统会自动创建目的地文件,如果目的地文件所在路径不存在,抛出异常java.io.FileNotFoundException:(系统找不到指定的路径。)
代码:
public static void main(String[] args) throws IOException {
//创建流,指定目的地
OutputStream os=new FileOutputStream("D://test2.txt");
//2.写出
os.write(97);
//3.刷出
os.flush();
//4.关闭
os.close();
}
字节流实现文件拷贝: *****
数据源-->输入流-->程序-->输出流-->目的地
步骤:
1.构建流(输入流 输出流)
2.读入写出
3.刷新
4.关闭(后打开的先关闭)
代码:
InputStream is=null;
OutputStream os=null;
try {
//1.构建流
is=new FileInputStream("D://test.txt");
os=new FileOutputStream("D://DDD//test.txt");
//2.读入写出
byte[] car=new byte[1024];
int len=-1;
while ((len=is.read(car))!=-1){
os.write(car,0,len);
}
//3.刷出
os.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
//4.关闭
if (os!=null){
try {
os.close();
}catch (IOException e) {
e.printStackTrace();
}
}
if (is!=null){
try {
is.close();
}catch (IOException e) {
e.printStackTrace();
}
}
}
字符流 (纯文本数据)
Reader 字符输入流
FileReader 文件字符输入流 ->节点流
Writer 字符输出流
FileWriter 文件字符输出流 ->节点流
通过字符流实现文件拷贝
代码:
public static void main(String[] args) throws IOException {
//1.构建流
Reader rd=new FileReader("D://test.txt");
Writer wr=new FileWriter("D://dest.txt");
//2.读入写出
char[] car=new char[1024];
int len=-1;
while ((len=rd.read(car))!=-1){
wr.write(car,0,len);
}
//3.刷新
wr.flush();
//4.
wr.close();
rd.close();
}
功能流
使用:包裹节点流使用
缓冲流 Buffered : 加快节点流的读写效率
字节缓冲流 :
字节输入缓冲流 BufferedInputStream
字节输出缓冲流 BufferedOutputStream
无新增方法,可以发生多态
字符缓冲流
代码:
//1.构建流
InputStream is=new BufferedInputStream(new FileInputStream("D://test.txt"));
OutputStream os=new BufferedOutputStream(new FileOutputStream("D://test1.txt"));
//2.读入写出
byte[] car=new byte[1024];
int len=-1;
while ((len=is.read(car))!=-1){
os.write(car,0,len);
}
//3.刷新
os.flush();
//4.关闭
os.close();
is.close();
字符流缓冲流
字符输入缓冲流 BufferedReader
新增功能: String readLine() 读一行文字。
字符输出缓冲流 BufferedWriter
新增功能: void newLine() 写一个行分隔符。
存在新增功能,不能发生多态
代码:
//构建流
BufferedReader rd=new BufferedReader(new FileReader("D://test.txt"));
BufferedWriter wd=new BufferedWriter(new FileWriter("D://dest.txt"));
//读入写出
String msg=null;
while ((msg=rd.readLine())!=null){
wd.write(msg);
wd.newLine();
}
//刷新
wd.flush();
//关闭
wd.close();
rd.close();
功能流 :
Data流 | 基本数据类型流 : 读写数据+保留数据类型->基本数据类型|字符串
是字节流的功能流
DataInputStream Data输入流
新增功能 : readXxx()
DataOuutputStream Data输出流
新增功能 : writeXxx()
代码:
public class Class003_DataInputStream {
public static void main(String[] args) throws IOException {
read("D:\\haha.txt");
}
public static void wirte(String path) throws IOException {
//构建输出流
DataOutputStream os = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(path)));
//准备数据
int i=100;
char ch='a';
boolean flog=false;
String msg="刘亦菲";
//写出
os.writeInt(i);
os.writeChar(ch);
os.writeBoolean(flog);
os.writeUTF(msg);
//刷新
os.flush();
//关闭
os.close();
}
public static void read(String path) throws IOException {
//构建流
DataInputStream is=new DataInputStream(new BufferedInputStream(new FileInputStream(path)));
//读入
int i =is.readInt();
char ch =is.readChar();
boolean flog =is.readBoolean();
String msg =is.readUTF();
//处理数据
System.out.println(i);
System.out.println(ch);
System.out.println(flog);
System.out.println(msg);
//关闭
is.close();
}
}
Object
Object流|对象流|引用数据类型流
字节流的功能流
ObjectInputStream 反序列化输入流
新增方法 Object readObject() 从ObjectInputStream中读取一个对象。 等等
ObjectOutputStream 序列化输出流
新增方法 void writeObject(Object obj) 将指定的对象写入ObjectOutputStream。
序列化: 将对象数据转为可存储或者可传输的状态的过程
不是所有类型的数据都能序列化 java.io.Serializable
如果写出的对象类型没有实现序列化接口,会遇到运行时异常java.io.NotSerializableException
序列化与反序列化顺序保持一致
不是所有的属性都需要序列化 transient
static的成员不会被序列化
如果父类实现类序列化接口,子类所有内容都可以进行序列化
子类实现了序列化接口,只能序列化子类独有的内容
序列号: 当实现了序列化的类型默认存在一个序列号
当类中的成员发生改变,序列号默认会重新生成
作用: 使用序列号可以实现检查前后版本不一致问题
解决不同版本的兼容问题: 手动设置序列号
通过快捷键生成序列号:
1.类型必须实现了序列化接口
2.Setting中进行配置
3.双击类名alt+enter,自动生成序列号
代码:
public class Class004_Obect {
public static void main(String[] args) throws IOException, ClassNotFoundException {
testOut("D://test.txt");
testIn("D://test.txt");
}
//序列化输出
public static void testOut(String path) throws IOException {
//输出流
ObjectOutputStream os=new ObjectOutputStream(new FileOutputStream(path));
//准备数据
int[] arr={1,2,3,4,5};
Person p=new Person("刘亦菲",18,1001);
//写出
os.writeObject(arr);
os.writeObject(p);
//刷出
os.flush();
//关闭
os.close();
}
//反序列化输出
public static void testIn(String path) throws IOException, ClassNotFoundException {
//构建输出流
ObjectInputStream is=new ObjectInputStream(new FileInputStream(path));
//读入
int[] arr= (int[]) is.readObject();
Person p= (Person) is.readObject();
//处理数据
System.out.println(p);
System.out.println(Arrays.toString(arr));
//关闭
is.close();
}
}
class Person implements Serializable{
private static final long serialVersionUID = -1108656603703788489L;
private String name;
private int age;
private int ID;
public Person() {
}
public Person(String name, int age, int ID) {
this.name = name;
this.age = age;
this.ID = ID;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int getID() {
return ID;
}
public void setID(int ID) {
this.ID = ID;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
", ID=" + ID +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age && ID == person.ID && Objects.equals(name, person.name);
}
}
CommonsIO
CommonsIO 是apache的一个开源的工具包,封装了IO操作的相关类,使用Commons IO可以很方便的读写文件,url源代码等。
是一个第三方的开源组件
使用第三方组件的步骤:
1.对应官网中下载源码 jar
2.在项目下新建一个文件夹目录lib,lib下存放以后项目所依赖的所有jar包
3.选中jar包,右键add as lib...
4.在项目下对应类中进行使用
代码:
public class Class001_CommonsIO {
public static void main(String[] args) throws IOException {
//#### IO工具类IOUtils
//`IOUtils.copy(InputStream input, OutputStream output) `// 此方法有多个重载方法,满足不同的输入输出流
IOUtils.copy(new FileInputStream("D://test.txt"),new FileOutputStream("D://xixi.txt"));
//IO 工具类 FilenameUtils
//`FilenameUtils.getBaseName(String filename)` // 去除目录和后缀后的文件名
System.out.println(FilenameUtils.getBaseName("D://test.txt"));
//`FilenameUtils.getExtension(String filename)` // 获取文件的后缀
System.out.println(FilenameUtils.getExtension("D://logo.png"));
//`isExtension(String fileName, String text) `// 判断fileName是否是text后缀名
System.out.println(FilenameUtils.isExtension("D://logo.jpg","png"));
//IO 工具类 FileUtils
//`FileUtils.copyFile(File srcFile, File destFile)` // 复制文件
FileUtils.copyFile(new File("D://test.txt"), FileUtils.getFile("D://hehe.txt"));
//`FileUtils.copyFileToDirectory(File srcFile, File destDir)` // 复制文件到一个指定的目录
FileUtils.copyFileToDirectory(new File("D://test.txt"), new File("D://eee")); //目标路径不存在,也可以帮助创建
//`FileUtils.writeStringToFile(File file, String data, String encoding, boolean append)`// 指定知否追加
FileUtils.writeStringToFile(new File("D://test.txt"), "\r\nwangwuwuwuwuwuwuwu", "UTF-8",true);
//`FileUtils.deleteDirectory(File directory)` // 删除文件夹,包括文件夹和文件夹里面所有的文件
FileUtils.deleteDirectory(new File("D://DDD"));
//`FileUtils.copyDirectory(File srcDir, File destDir)` // 复制文件夹(文件夹里面的文件内容也会复制)
FileUtils.copyDirectory(new File("D://AAA"), new File("D://BBB"));
//`FileUtils.copyDirectoryToDirectory(File srcDir, File destDir)` // 以子目录的形式将文件夹复制到到另一个文件夹下
FileUtils.copyDirectoryToDirectory(new File("D://AAA"), new File("D://BBB"));
//`FileUtils.copyDirectory(File srcDir, File destDir, FileFilter filter)` // 复制文件夹,带有文件过滤功能
FileUtils.copyDirectory(new File("D://AAA"), new File("D://HAHA"), FileFilterUtils.fileFileFilter());
}
}