IO
文件
文件在程序中是以流的形式来操作的
流:数据在数据源(文件)和程序(内存)之间经历的路径
输入流:数据从数据源(文件)到程序(内存)的路径
输出流:数据从程序(内存)到数据源(文件)的路径
常用的文件操作：
new File(String pathname) //根据路径构建一个File对象
new File(File parent,String child) //根据父目录文件+子路径构建
new File(String parent String child) //根据父目录+子路径构建
createNewFile 创建新文件
getName //获取文件名字
getAbsolutePath //获取文件路径
getParent //获取文件父级目录
length //获取文件大小，字节大小
exists //是否存在文件
isFile //是否为文件
isDirectory //是否为目录
目录的操作和文件的删除：
-
mkdir创建一级目录
-
mkdirs创建多级目录
-
delete删除空目录或文件
IO流原理及流的分类
-
I/O是Input/Output的缩写，I/O技术是非常实用的技术，用于处理数据传输。如读/写文件，网络通讯等
-
Java程序中，对于数据的输入/输出操作以”流(stream)"”的方式进行
-
java.io包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过方法输入或输出数据
-
输入input:读取外部数据磁盘、光盘等存储设备的数据)到程序(内存)中
-
输出output:将程序(内存)数据输出到磁盘、光盘等存储设备中
流的分类
-
按操作数据单位不同分为:字节流(8 bit)二进制文件，字符流(按字符)文本文件
-
按数据流的流向不同分为:输入流，输出流
-
按流的角色的不同分为:节点流，处理流/包装流
- Java的IO流共涉及40多个类，实际上非常规则，都是从如上4个抽象基类派生的。
- 由这四个类派生出来的子类名称都是以其父类名作为子类名后缀。
IO流体系图
InputStream:字节输入流OutputStream:字节输出流
常用子类：
- FileInputStream 输入流(字节输入流) 使用完毕需要close，避免造成资源浪费
- BufferedInputStream:缓冲字节输入流
- ObjectlnputStream:对象字节输入流
package com.iostream;
import org.junit.jupiter.api.Test;
import java.io.FileInputStream;
import java.io.IOException;
public class fileInputStream {
public static void main(String[] args) {
}
/**
* 演示读取文件
* 单字节读取，效率较低
* ->使用read(byte[] b)
*/
@Test
public void readFile(){
String filePath = "E:\\hello.txt";
int readData = 0;
FileInputStream fileInputStream = null;
try {
//创建FileInputStream对象，用于读取文件
fileInputStream = new FileInputStream(filePath);
//从该输入流读取一个字节的数据。如果没有输入可用，此方法将阻止。
while ((readData = fileInputStream.read()) != -1) {
System.out.print((char) readData);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//关闭文件流，释放资源
try {
fileInputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
* 使用read(byte[] b)提高效率
*/
@Test
public void readFile1(){
String filePath = "E:\\hello.txt";
int readData = 0;
//字节数组
byte[] buffer = new byte[8]; //一次读取八个字节
FileInputStream fileInputStream = null;
try {
//创建FileInputStream对象，用于读取文件
fileInputStream = new FileInputStream(filePath);
//从该输入流读取一个字节的数据。如果没有输入可用，此方法将阻止。
while ((readData = (fileInputStream.read(buffer))) != -1) {
System.out.println(new String(buffer , 0 ,readData));
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//关闭文件流，释放资源
try {
fileInputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
package com.iostream;
import org.junit.jupiter.api.Test;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class fileOutputStream {
public static void main(String[] args) {
}
@Test
public void writeStream (){
//创建FileOutputStream对象
String filePath = "e:\\1.txt";
FileOutputStream fileOutputStream = null;
//得到FileOutputStream对象
try {
//new FileOutputStream(filePath);创建方式，当写入内容时，会覆盖原来的内容
//new FileOutputStream(filePath ， true);创建方式，当写入内容时，会追加到原内容的后面
fileOutputStream = new FileOutputStream(filePath , true);
//写入一个字节
//fileOutputStream.write('H');
//写入字符串
String str = "hello,world!";
// //str.getBytes()可以把字符串 ->字节数组
// fileOutputStream.write(str.getBytes());
fileOutputStream.write(str.getBytes() , 0 , str.length());
}catch (IOException e) {
e.printStackTrace();
} finally {
try {
fileOutputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
//文件拷贝
package com.iostream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileCopy {
public static void main(String[] args) {
//完成文件拷贝，先创建输入流读文件，在创建输出流写文件
String srcFilePath = "e:\\bomb_1.png";
String destFilePath = "e:\\bomb.png";
FileInputStream fileInputStream = null;
FileOutputStream fileOutputStream = null;
try {
fileInputStream = new FileInputStream(srcFilePath);
fileOutputStream = new FileOutputStream(destFilePath , true);
//定义一个字节数组，提高读取效率
byte[] buf = new byte[1024];
int readLen = 0; //记录读取长度
//读
while ((readLen = fileInputStream.read(buf)) != -1){
//一边读一边写
fileOutputStream.write(buf , 0 , readLen);
}
System.out.println("文件拷贝成功！");
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (fileInputStream != null) {
fileInputStream.close();
}
if (fileOutputStream != null) {
fileOutputStream.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
FileReader 和FileWriter
FileReader相关方法:
- new FileReader(File/String)
- read:每次读取单个字符，返回该字符，如果到文件末尾返回-1
- read(char[]):批量读取多个字符到数组，返回读取到的字符数,如果到文件末尾返回-1
相关API:
- new String(char[]):将char[]转换成String
- new String(charl,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)，否则写入不到指定的文件! 分析源码可得真正写数据得操作就在close和flush
这两个方法中！！！！！
close = flush + 关闭流 !!!
节点流和处理流
- 节点流可以从一个特定的数据源读写数据,如FileReader、FileWriter
- 处理流(也叫包装流)是“连接”在已存在的流（节点流或处理流）之上,为程序提供更为强大的读写功能,更加灵活如BufferedReader、BufferedWriter
节点流和处理流一览图
节点流和处理流区别与联系
- 节点流是底层流/低级流,直接跟数据源相接。
- 处理流(包装流)包装节点流，既可以消除不同节点流的实现差异，也可以提供更方便的方法来完成输入输出。
- 处理流(也叫包装流)对节点流进行包装，使用了修饰器设计模式,不会直接与数据源相连
处理流的功能主要体现在以下两个方面:
- 性能的提高:主要以增加缓冲的方式来提高输入输出的效率。
- 操作的便捷:处理流可能提供了一系列便捷的方法来一次输入输出大批量的数据,使用更加灵活方便
BufferedReader和BufferedWriter
-
BufferedReader 和 BufferedWriter属于字符流，是按照字符来读取数据的
-
关闭时处理流，只需要关闭外层流即可
package com.iostream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
public class BufferedCopy {
public static void main(String[] args) throws Exception{
String srcFilePath = "e:\\a.java";
String destFilePath = "e:\\b.java";
BufferedReader bufferedReader = new BufferedReader(new FileReader(srcFilePath));
BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(destFilePath));
String str;
while ((str = bufferedReader.readLine()) != null){
bufferedWriter.write(str);
bufferedWriter.newLine();
}
System.out.println("拷贝完毕！");
if (bufferedReader != null) {
bufferedReader.close();
}
if (bufferedWriter != null) {
bufferedWriter.close();
}
}
}
BufferedInputStream和BufferedOutputStream
- BufferedlnputStream是字节流，在创建BufferedInputStream时，会创建一个内部缓冲区数组
- BufferedOutputStream是字节流，实现缓冲的输出流,可以将多个字节写入底层输出流中，而不必对每次字节写入调用底层系统
package com.iostream;
import java.io.*;
public class BufferedCopy2 {
public static void main(String[] args) throws Exception{
String srcFilePath = "e:\\bomb.png";
String destFilePath = "e:\\bomb_1111.png";
BufferedInputStream bufferedInputStream = null;
BufferedOutputStream bufferedOutputStream = null;
bufferedInputStream = new BufferedInputStream(new FileInputStream(srcFilePath));
bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(destFilePath));
byte[] buff = new byte[1024]; //缓冲区
int readLen = 0; //记录长度
while ((readLen = bufferedInputStream.read(buff)) != -1){
bufferedOutputStream.write(buff);
}
if (bufferedInputStream != null) {
bufferedInputStream.close();
}
if (bufferedOutputStream != null) {
bufferedOutputStream.close();
}
}
}
对象流-ObjectInputStream和ObjectOutputStream
有如下需求：
- 将int num = 100这个int 数据保存到文件中,注意不是100数婷，而是int 100，并且，能够从文件中直接恢复int 100
- 将Dog dog = new Dog(“小黄”，3)这个dog对象保存到文件中，并且能够从文件恢复
- 上面的要求，就是能够将基本数据类型或者对象进行序列化和反序列化操作
序列化和反序列化
-
序列化就是在保存数据时，保存数据的值和数据类型
-
反序列化就是在恢复数据时，恢复数据的值和数据类型
-
需要让某个对象支持序列化机制,则必须让其类是可序列化的，为了让某个类是可序列化的，该类必须实现如下两个接口之一:
Serializable //一般实现该接口，因为这是一个标记接口，标记接口一般只要声明性质，其内部没有别的方法
Externalizable //该接口内部有方法在使用时需要实现，较为麻烦，故一般不用
由此引出对象流的概念：
- 功能:提供了对基本类型或对象类型的序列化和反序列化的方法
- ObjectOutputStream提供序列化功能
- ObjectInputStream提供反序列化功能
package com.iostream;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
public class ObjectOutputStream_ {
public static void main(String[] args) throws Exception{
//序列化输出的文件不是纯文本，而是按照其默认格式的，所以创建输出文件路径的时候只需要关注文件名即可，后缀任意
String filePath = "e:\\save.txt";
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath));
oos.writeInt(100); //自动完成装箱 int -> integer (实现了Serializable)
oos.writeBoolean(true); //也是自动装箱boolean -> Boolean (实现了Serializable)
oos.writeChar('Q'); //char -> Character (实现了Serializable)
oos.writeChars("QQQQQ");
oos.writeUTF("我的好大儿");
//保存一个dog对象
oos.writeObject(new Dog("大黄" , 20));
System.out.println("数据序列化完毕~~~");
oos.close();
}
}
package com.iostream;
import java.io.FileInputStream;
import java.io.ObjectInputStream;
public class ObjectInputStream_ {
public static void main(String[] args) throws Exception{
String filePath = "e:\\save.txt";
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filePath));
//反序列化的顺序要和序列化的顺序一致
System.out.println(ois.readInt());
System.out.println(ois.readBoolean());
System.out.println(ois.readChar());
char buf ; //缓存区
while ((buf = ois.readChar()) != '\0'){ //当chars中读出的char部位空字符（\0）时继续读
System.out.print(buf);
}
System.out.println(); //调整格式
System.out.println(ois.readUTF());
Object o = ois.readObject(); //将读出的对象传给o
System.out.println("运行类型=" + o.getClass());
System.out.println(o);
//如果我们希望调用Dog的方法，需要向下转型
Dog dog2 = (Dog)o;
System.out.println(dog2.getName());
ois.close();
}
}
package com.iostream;
import java.io.Serializable;
//需要实现Serializable接口才可以进行序列化
class Dog implements Serializable {
private String name;
private int age;
//serialVersionUID序列化的版本号，可以提高兼容性，在Dog类中添加新的属性后，可以将其视为原来版本的修改，而不是一个新的Dog类
private static final long serialVersionUID = 1L;
public Dog(String name, int age) {
this.name = name;
this.age = age;
}
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;
}
@Override
public String toString() {
return "Dog{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
注意事项：
1)读写顺序要一致
2)要求实现序列化或反序列化对象,需要实现 Serializable
3)序列化的类中建议添加SerialVersionUID,为了提高版本的兼容性(//serialVersionUID序列化的版本号，可以提高兼容性，例如在Dog类
中添加新的属性后，可以将其视为原来版本的修改，而不是一个新的Dog类)
4)序列化对象时，默认将里面所有属性都进行序列化，但除了static或transient修饰的成员
5)序列化对象时，要求里面属性的类型也需要实现序列化接口
6)序列化具备可继承性，也就是如果某类已经实现了序列化，则它的所有子类也已经默认实现了序列化
标准输入输出流
system.in 编译类型 InputStream
System.in 运行类型 BufferedInputStream
转换流-InputStreamReader 和 OutputStreamWriter
将字节流转换成字符流，且是按照自定义编码方式的转换。
- InputStreamReader: Reader的子类，可以将InputStream(字节流)包装成Reader(字符流)
- OutputStreamWriter: Writer的子类,实现将OutputStream(字节流)包装成Writer(字符流)‘’
- 当处理纯文本数据时,如果使用字符流效率更高，并且可以有效解决中文问题,所以建议将字节流转换成字符流
- 可以在使用时指定编码格式(比如utf-8, gbk , gb2312, ISO8859-1等)
package com.iostream;
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 = "e:\\123.txt";
InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream(filePath) , "gbk");
BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
String str ;
while ((str = bufferedReader.readLine()) != null) {
System.out.println(str);
}
}
}
package com.iostream;
import java.io.BufferedOutputStream;
import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
public class OutputStreamWriter_ {
public static void main(String[] args) throws Exception{
String filePath = "e:\\out.txt";
String charSet = "gbk";
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(filePath), charSet);
osw.write("tazhendewokusi,他真的我哭死");
osw.close();
System.out.println("文件保存成功-" + "编码方式：" + charSet);
}
}
打印流-PrintStream 和PrintWriter
package com.iostream;
import java.io.PrintStream;
import java.nio.charset.StandardCharsets;
public class PrintStream_ {
public static void main(String[] args) throws Exception{
//默认情况下PrintStream 输出数据的位置是标准输出，即显示器
PrintStream out = System.out;
out.println("shizheyangde,是这样的！");
//因为print底层调用的是write，故可以直接调用write来进行打印输出
out.write("meibanfa,没办法！".getBytes()); //write方法底层是对字符数组进行处理，故此处将传入的字符串做字符数组转换
out.write('\n');
//修改打印流输出的位置/设备
//将输出到屏幕改为输出到指定的文件夹
String filePath = "e:\\out111.txt";
System.setOut(new PrintStream(filePath));
System.out.println("lijieyixia,李姐一下！");
out.println("已将上文内容输出到指定文件夹！");
out.close();
}
}
Properties类
需求：
如下一个配置文件mysql.properties
ip =192.168.0.13
user=root
pwd=12345
请问编程读取ip，user和pwd的值是多少，单项输出ip值
传统解决方法:缺陷很明显，当内容过多且需要复杂操作时，得进行复杂的设计才可以实现
package com.iostream;
import java.io.BufferedReader;
import java.io.FileReader;
public class Properties01 {
public static void main(String[] args) throws Exception{
BufferedReader bis = new BufferedReader(new FileReader("e:\\mysql.properties"));
String str ;
while ((str = bis.readLine()) != null){
String[] split = str.split("=");
// System.out.println(split[0] + "的值是：" + split[1]);
if ("ip".equals(split[0])){
System.out.println("ip地址是：" + split[1]);
}
}
bis.close();
}
}
引入Properties类：Properties 父类是 Hashtable ,底层就是Hashtable核心方法
1)专门用于读写配置文件的集合类
配置文件的格式:
键=值
键=值
2)注意:键值对不需要有空格,值不需要用引号一起来。默认类型是String
3)Properties的常见方法
- load:加载配置文件的键值对到Properties对象
- list:将数据显示到指定设备/流对象
- getProperty(key):根据键获取值
- setProperty(key,value):设置键值对到Properties对象
- store:将Properties中的键值对存储到配置文件,在idea中，保存信息到配置文件,如果含有中文，会存储为unicode码
package com.iostream;
import java.io.FileReader;
import java.io.FileWriter;
import java.util.Properties;
public class Properties02 {
public static void main(String[] args) throws Exception{
Properties properties = new Properties();
properties.load(new FileReader("e:\\mysql.properties")); //读取
properties.list(System.out); //显示k-v
String user = properties.getProperty("user"); //根据键值关系获取用户名和密码
String pwd = properties.getProperty("pwd");
System.out.println("用户名是：" + user);
System.out.println("密码是：" + pwd);
Properties properties1 = new Properties();
//如果该文件没有key则是创建，有key则是修改
properties1.setProperty("ip" , "192.168.7.45");
properties1.setProperty("user" , "tom");
properties1.setProperty("pwd" , "4541841");
properties1.setProperty("pwd" , "99999999");
properties1.store(new FileWriter("e:\\mysql2.properties") , null); //一般没有注释置空即可
System.out.println("写入配置文件成功！");
}
}
浙公网安备 33010602011771号