目录
BufferedInputStream和BufferedOutputStream
对象流 ObjectInputStream和ObjectOutputStream
转换流 InputStreamReader和OutputStreamWriter
一、创建文件常用的三种方法
@SuppressWarnings("all")
public class CreateFile {
public static void main(String[] args) {
}
@Test
public void createFile01(){
//在内存中创建
File file = new File("e:\\new1.txt");
try {
//真实创建操作
file.createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
System.out.println("创建成功！");
}
@Test
public void createFile02() {
File parentFile = new File("e:\\");
String fileName = "new2.txt";
File file = new File(parentFile, fileName);
try {
file.createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
System.out.println("创建成功！");
}
@Test
public void createFile03(){
String parentPath = "e:\\";
String fileName = "new3.txt";
File file = new File(parentPath, fileName);
try {
file.createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
System.out.println("创建成功！");
}
}
二、常用的文件操作
1、对文件的操作
public class FileInformation {
public static void main(String[] args) {
}
@Test
public void getFileInformation(){
//相当于是把文件加载进内存中
File file = new File("e://new1.txt");
System.out.println("文件名："+file.getName());
System.out.println("文件绝对路径："+file.getAbsolutePath());
System.out.println("文件父级目录："+file.getParent());
//utf-8下，一个字母占一个字节，一个汉字占三个字节，一个空格占一个字节
System.out.println("文件大小（字节）："+file.length());
System.out.println("文件是否存在："+file.exists());
System.out.println("是不是一个文件："+file.isFile());
System.out.println("是不是一个目录："+file.isDirectory());
}
}2、对目录的操作
mkdir创建一级目录、mkdirs创建多级目录、delete删除空目录或者文件
//目录也是一种文件，只要目录下没有文件，就可以用delete
File file = new File("e:\\new1.txt");
File file2 = new File("e:\\new1");
boolean delete = file.delete();
boolean delete = file2.delete();
String path = "e:\\new\\a\\b\\c";
File file3 = new File(path);
if(!file3.exists()){
//一级目录可以使用mkdir，多级的话使用mkdirs
file3.mkdirs();
}
三、IO流原理及流的分类
io就是input和output的缩写，以程序为主体，将外部文件输入到系统，就是输入流，由系统输出到文件，就是输出流。
流的分类
按操作数据单位不同分为：字节流（8bit）和 字符流
字符流的读取效率比字节流高，字符流读取时由于编码不一样，所以无法确定一次具体读取几个字节，字节流一般用于操作二进制文件，比如视频、音频等，这样可以保证无损传输。字符流一般读取文本文件。
按数据的流向不同分为：输入流和输出流
按流的角色不同分为：节点流、处理流/包装流
java的IO流共涉及到40多个类，都是从上面4个抽象基类派生的
由这四个类派生出来的子类名称都是以其父类名作为子类名后缀
InputStream：字节输入流，是所有字节输入流的超类
常用的子类有：
FileInputStream：文件输入流
BufferedInputStream：缓冲字节输入流 直接父类是FilterInputStream
ObjectInputStream：对象字节输入流
FileInputStream
@Test
public void readFile(){
FileInputStream fileInputStream = null;
int readData = 0;
try {
fileInputStream = new FileInputStream("e:\\hello.txt");
//从输入流读取一个字节的数据，如果没有输入可用，就会返回-1，表示读取完毕
while ((readData = fileInputStream.read())!=-1) {
System.out.print((char) readData);
}
}catch (IOException e){
e.printStackTrace();
}finally {
try {
fileInputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}文件中，只有字母和符号，没有汉字，一个汉字占3个字节，使用read()方法一次读取的是一个字节，所以，如果文件中出现汉字，输出的内容就会出现乱码，等于只读取到了三分之一个汉字就输出，并且这种方式效率比较低。接下来，对这个代码进行优化，使用 read(byte[] b)
@Test
public void readFile2(){
FileInputStream fileInputStream = null;
byte[] buf = new byte[8];
int readlen = 0;
try {
fileInputStream = new FileInputStream("e:\\hello.txt");
//read(byte[] b) 如果读取正常，返回的是实际读取的字节数
while (((readlen = fileInputStream.read(buf)))!=-1) {
//相当于 buf,0,8 ->hello,world!o,wo
//System.out.print(new String(buf));
System.out.print(new String(buf,0,readlen));
}
}catch (IOException e){
e.printStackTrace();
}finally {
try {
fileInputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}FileOutputStream
@Test
public void writeFile(){
String path = "e:\\a.txt";
FileOutputStream fileOutputStream = null;
try {
//这种构造方法每次写入都是覆盖，append默认为false，可以设置
//append为true时，每次写入为追加
fileOutputStream = new FileOutputStream(path);
//fileOutputStream = new FileOutputStream(path,true);
//单次写入一个字符
//fileOutputStream.write('h');
//将整个字符串转为字节写入
String str = "hello,world!";
//fileOutputStream.write(str.getBytes());
//在字符串指定位置开始，写入指定个数的字节
fileOutputStream.write(str.getBytes(),0,3);
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
fileOutputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}案例：实现图片拷贝
@Test
public void fileCopy(){
FileInputStream fileInputStream = null;
FileOutputStream fileOutputStream = null;
byte[] buf = new byte[8];
int readlen = 0;
try {
fileInputStream = new FileInputStream("e:\\workbg.jpg");
fileOutputStream = new FileOutputStream("d:\\workbg.jpg");
while ((readlen = fileInputStream.read(buf))!=-1){
fileOutputStream.write(buf,0,readlen);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
fileInputStream.close();
fileOutputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}注意事项：readlen = fileInputStream.read(buf) fileOutputStream.write(buf,0,readlen);
一定要按照这种方式写出，数组大小为8，第一次读取到了8个，全部写出，第二次可能只读取到了3个，但是byte数组里面，后面5个字节还是第一次读取的数据，如果全部写出的话，文件就会出现问题，所以，记录每次读取到的length就显得十分重要了。
FileReader FileWriter
FileReader和FileWriter是字符流，即按照字符来操作io
方法跟FileInputStream和FileOutputStream大致类似
read：每次读取单个字符，返回该字符，如果到文件末尾返回-1
read(char[]) ：批量读取多个字符到数组中，返回读取到的字符数，到达末尾返回-1
new FileWriter(File/Stirng,true) true -> 追加模式 false -> 覆盖模式
大部分都跟FileOutputStream类似，可以对比学习，需要注意的是：
FileWriter使用后，必须要关闭（close）或者刷新（flush），否则写入不到指定的文件
FileReader
@Test
public void readFile1(){
FileReader fileReader = null;
int readData = 0;
try {
fileReader = new FileReader("e:\\a.txt");
while ((readData = fileReader.read()) != -1){
System.out.print((char)readData);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
fileReader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
@Test
public void readFile2(){
FileReader fileReader = null;
char[] c = new char[8];
int readlen = 0;
try {
fileReader = new FileReader("e:\\a.txt");
while ((readlen = fileReader.read(c)) != -1){
System.out.print(new String(c,0,readlen));
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
fileReader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}FileWriter
@Test
public void writerFile(){
FileWriter fileWriter = null;
try {
//覆盖模式
fileWriter = new FileWriter("e:\\a.txt");
//写入单个
fileWriter.write("h");
//写入字符数组
fileWriter.write("白尾黑猫去旅行".toCharArray());
//写入字符串
fileWriter.write("2白尾黑猫去旅行2");
//写入字符串的一部分
fileWriter.write("北京天津",0,2);
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
//this.writeBytes(); close = flush + 关闭流
//不flush或者不close的话，写出的数据还在内存中，并没有进入文件
fileWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}节点流和处理流
节点流可以从一个特定的数据源读写数据，如 FileReader、FileWriter
处理流（也叫包装流）是“连接”在已存在的流（节点流或处理流）之上，为程序提供更为强大的读写功能，也更加灵活，如 BufferedReader、BufferedWriter
节点流和处理流的区别和联系：
1、节点流是底层流/低级流，直接跟数据源相接
2、处理流（包装流），包装了节点流，既可以消除不同节点流的实现差异，也可以提供更方便的方法来完成输入输出
3、处理流（也叫包装流）对节点流进行包装，使用了修饰器设计模式，不会直接与数据源相连
处理流的功能主要体现在以下两个方面：
1、性能的提高：主要以增加缓冲的方式来提高输入输出的效率
2、操作的便捷：处理流可能提供了一系列便捷的方法来一次输入输出大批量的数据，使用更加灵活方便
因为节点流都是处理特定格式的文件，有处理文件的，有处理数组的，有处理管道的，比方说BufferReader，里面有一个Reader类型的属性，在构造方法中 以参数传入，对Reader的子类进行包装，并提供了更为强大的方法。
BufferedReader
@Test
public void testBufferedReader(){
BufferedReader bufferedReader = null;
String line = "";
try {
bufferedReader = new BufferedReader(new FileReader("e:\\a.txt"));
//直接读取一行，比FileReader效率高，返回如果为null，说明读取完毕
while ((line = bufferedReader.readLine()) != null){
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
//关闭的时候，只需要关闭包装流即可，源码关闭的是节点流
bufferedReader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}注意关闭包装流的时候，只需要关闭外层流，源码里关闭的是节点流
public void close() throws IOException {
synchronized (lock) {
if (in == null)
return;
try {
in.close();
} finally {
in = null;
cb = null;
}
}
}BufferedWriter
@Test
public void testBufferedWriter(){
BufferedWriter bufferedWriter = null;
try {
//以覆盖的方式进行写入 注意FileWriter是写入到内存，需要关闭或刷新后才能真正写入
//所以下面添加三行，类似于都在内存中一起写入，没有覆盖
//执行第二次的时候可以看出来覆盖的效果,想要追加在节点流中设置true即可
//bufferedWriter = new BufferedWriter(new FileWriter("e:\\b.txt",true));
bufferedWriter = new BufferedWriter(new FileWriter("e:\\b.txt"));
bufferedWriter.write("hello,白尾黑猫去旅行");
//插入换行符
bufferedWriter.newLine();
bufferedWriter.write("hello2,白尾黑猫去旅行");
bufferedWriter.newLine();
bufferedWriter.write("hello3,白尾黑猫去旅行");
bufferedWriter.newLine();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
bufferedWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}使用BufferedReader和BufferedWriter实现文件拷贝
@Test
public void testFileCopy(){
//读取e盘中的b.txt，拷贝到c.txt
BufferedReader bufferedReader = null;
BufferedWriter bufferedWriter = null;
String line = "";
try {
bufferedReader = new BufferedReader(new FileReader("e:\\b.txt"));
bufferedWriter = new BufferedWriter(new FileWriter("e:\\c.txt"));
//readLine方法读取的是一行的内容，没有换行符，所以需要自行插入
while ((line = bufferedReader.readLine()) != null){
bufferedWriter.write(line);
//自行插入换行
bufferedWriter.newLine();
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if(bufferedReader != null)
bufferedReader.close();
if(bufferedWriter != null)
bufferedWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}尤其注意，BufferedReader和BufferedWriter是按照字符操作的，不要去操作二进制文件，例如音频、视频、doc、pdf等，可能会造成文件损坏
需要使用处理流来处理二进制文件，所以有了BufferedInputStream和BufferedOutputStream
BufferedInputStream和BufferedOutputStream
@Test
public void testCopy(){
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
byte[] b = new byte[1024];
int readlen = 0;
try {
bis = new BufferedInputStream(new FileInputStream("e:\\a.jpg"));
bos = new BufferedOutputStream(new FileOutputStream("e:\\b.jpg"));
while ((readlen = bis.read(b)) != -1){
bos.write(b,0,readlen);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (bis!=null) {
bis.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}对象流 ObjectInputStream和ObjectOutputStream
对象流是需要将类型也保存下来，比如说int num = 100，以前都是将100保存到文件中，而现在要求将100 和 int 都保存在文件中，这种时候，就需要使用对象流。
序列化和反序列化：
1、序列化就是在保存对象时，保存数据的值和数据类型
2、反序列化就是在恢复数据时，恢复数据的值和数据类型
3、需要让某个对象支持序列化机制，则必须让其类是可序列化的，为了让某个类是可序列化的，该类必须实现如下两个接口之一：
Serializable // 这是一个标记接口
Externalizable // 这个接口继承了Serializable 需要实现两个方法，一般不用
ObjectOutputStream 提供序列化功能
ObjectInputStream 提供反序列化功能
ObjectOutputStream 序列化
@Test
public void testObjectOutputStream(){
ObjectOutputStream oos = null;
try {
oos = new ObjectOutputStream(new FileOutputStream("e:\\data.dat"));
oos.writeInt(100); //int 自动装箱成Integer ，Integer实现了Serializable
oos.writeDouble(1.1);//double 自动装箱成Double
oos.writeFloat(1.1f);//float 自动装箱成Float
oos.writeUTF("白尾黑猫去旅行"); //String
oos.writeChar('a');// char -> Character
oos.writeObject(new Dog("大黄",3));
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (oos != null) {
oos.close();
}
}catch (Exception e){
e.printStackTrace();
}
}
}
class Dog implements Serializable{
private String name;
private int age;
public Dog(String name,int age){
this.name = name;
this.age = age;
}
}注意，要实现Serializable接口
ObjectInputStream 反序列化
@Test
public void testObjectInputStream(){
ObjectInputStream ois = null;
try {
ois = new ObjectInputStream(new FileInputStream("e:\\data.dat"));
System.out.println(ois.readInt());
System.out.println(ois.readDouble());
System.out.println(ois.readFloat());
System.out.println(ois.readUTF());
System.out.println(ois.readChar());
//编译类型是object 但是运行类型是Dog
System.out.println(ois.readObject());
} catch (Exception e) {
e.printStackTrace();
} finally {
if (ois != null) {
try {
ois.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}对象流注意事项：
1）读写顺序要一致
2）要求实现序列化或反序列化对象，需要实现Serializable
3）序列化的类中建议添加SerialVersionUID，为了提高版本的兼容性
4）序列化对象时，默认将里面所有属性都进行序列化，但除了static或transient修饰的成员
5）序列化对象时，要求里面属性的类型也需要实现序列化接口
6）序列化具备可继承性，也就是如果某类已经实现了序列化，则它的所有子类也已经默认实现了序列化
标准输入输出流
System.in 标准输入流 设备就是键盘
System类中 public final static InputStream in = null;
编译类型是 InputStream
运行类型是 BufferedInputStream
public static void main(String[] args) {
while (true){
Scanner scanner = new Scanner(System.in);
System.out.println("请输入内容");
String next = scanner.next();
System.out.println("输入的内容是："+next);
if("exit".equals(next)){
break;
}
}
}System.out 标准输出流 设备就是显示器
System类中 public final static PrintStream out = null;
编译类型是 PrintStream
运行类型是 PrintStream
System.out.println("balabala");
转换流 InputStreamReader和OutputStreamWriter
介绍：
1）InputStreamReader是Reader的子类，可以将InputStream（字节流）包装成（转换）Reader（字符流）
2）OutputStreamWriter是Writer的子类，实现将OutputStream（字节流）包装成（转换）Writer（字符流）
3）当处理纯文本数据时，如果使用字符流效率更高，并且可以有效解决中文问题，所以建议将字节流转换成字符流
4）可以在使用时指定编码格式（比如utf-8、gbk、gb2312、ISO8859-1等）
// a.txt 文件内容为： hello 白尾黑猫去旅行
// 文件的编码格式默认为utf-8
@Test
public void test1(){
BufferedReader br = null;
try {
br = new BufferedReader(new FileReader("e:\\a.txt"));
System.out.println(br.readLine());
} catch (Exception e) {
e.printStackTrace();
} finally {
if (br != null) {
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}上面的例子是一个使用字符包装流读取文件内容的简单案例，正常读取，没有问题。
但是当把文件的默认编码由utf-8改为ANSI之后，读取就会出现乱码，这是因为字符包装流的默认读取编码为utf-8，所以需要使用转换流来保证效率和编码。
解决方案：
@Test
public void test2(){
InputStreamReader isr = null;
BufferedReader br = null;
try {
//首先将文件字节输入流转换成转换输入流，根据类图关系可知是Reader的子类
isr = new InputStreamReader(new FileInputStream("e:\\a.txt"), "gbk");
//将转换输入流包装成包装字符输入流，以提升读取效率
br = new BufferedReader(isr);
System.out.println(br.readLine());
} catch (Exception e) {
e.printStackTrace();
} finally {
if (isr != null) {
try {
//依旧是只关闭最外层流即可
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}InputStreamReader是对文件进行编码的读取，而OutputStreamWriter是对文件以指定编码进行写入
@Test
public void test(){
OutputStreamWriter osw = null;
BufferedWriter bw = null;
try {
osw = new OutputStreamWriter(new FileOutputStream("e:\\a.txt"), "gbk");
bw = new BufferedWriter(osw);
bw.write("hello 白尾黑猫去旅行！");
} catch (Exception e) {
e.printStackTrace();
} finally {
if (bw != null) {
try {
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}打印流 PrintStream 和 PrintWriter
打印流只有输出流，没有输入流
PrintStream 字节打印流
@Test
public void test(){
PrintStream out = null;
try {
//字节打印流 输出流 默认为输入到显示器
out = System.out;
out.println("我输出到了显示器");
//源码可得 println = print + newLine
//print 调用的是write
out.write("我用write输出到了显示器".getBytes());
//修改输出位置 native 调用c++来修改输出位置
System.setOut(new PrintStream("e:\\b.txt"));
out = System.out;
out.println("我没输出到显示器");
} catch (IOException e) {
e.printStackTrace();
} finally {
if (out != null) {
out.close();
}
}
}PrintWriter 字符打印流
注意：close的时候才是真正的写入
@Test
public void test(){
//将标准输出流直接传入
PrintWriter pw = null;
PrintWriter pw2 = null;
try {
pw = new PrintWriter(System.out);
pw.print("我输出到了显示器");
pw2 = new PrintWriter(new FileWriter("e:\\b.txt"));
pw2.println("hello 白尾黑猫去旅行");
} catch (IOException e) {
e.printStackTrace();
} finally {
//close的时候才是真正的写入
pw.close();
pw2.close();
}
}Properties类
1）专门用来读写配置文件的集合类
配置格式为： 键=值
2）注意：键值对不需要有空格，值不需要用引号引起来，默认类型是String
3）常用方法：
load：加载配置文件的键值对到Properties对象
list：将数据显示到指定设备
getProperty(key)：根据键获取值
setProperty(key,value)：设置键值对到Properties对象
store：将Properties中的键值对存储到配置文件，在idea中，保存信息到配置文件，如果含有中文，会存储为unicode码
@Test
public void test() throws Exception {
Properties properties = new Properties();
properties.load(new FileReader("E:\\ideaProjects\\demo\\target\\classes\\mysql.properties"));
//获取所有的键值对
properties.list(System.out);
//获取指定的键值对
System.out.println(properties.getProperty("ip"));
}
@Test
public void test2() throws Exception {
//创建properties配置文件
//如果该文件有key，再set的时候就是修改
//Properties父类是HashTable，底层就是HashTable
Properties properties = new Properties();
properties.setProperty("ip","1.1.1.1");
properties.setProperty("name","白尾黑猫去旅行");
properties.setProperty("pwd","123123");
properties.store(new FileWriter("E:\\ideaProjects\\demo\\target\\classes\\test.properties"),
"test");
}文章是跟着老韩学习自己做的笔记，有不对的望指教，谢谢！
509
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
