- 1 IO流的介绍
- 1.1 为什么要学习IO流
- 1.2 什么是IO流
- 1.3 IO流的分类
- 2 字节流输出流
- 2.1 字节输出流入门
- FileOutputStream类 :
- 构造方法 :
- 字节输出流写数据快速入门
- 2.2 字节输出流写数据的方法
- 2.3 写数据的换行和追加写入
- 3 字节输入流
- 3.1 字节输入流介绍
- 字节输入流类
- 构造方法
- 步骤
- 3.2 字节输入流读多个字节
- 3.3 图片的拷贝
- 3.4 异常的捕获处理
- JDK7版本之前处理方式 : 手动释放资源
- JDK7版本优化处理方式 : 自动释放资源
- 代码实践
- 3.4 字节输入流一次读一个字节数组
- 4 字节缓冲区流
- 4.1 字节缓冲流概述
- 4.2 字节缓冲流案例
- 4.3 缓冲流一次读写一个字节原理
- 4.4 缓冲流一次读写一个字节数组原理
- 5 Properties集合
- 5.1 Properties集合的概述
- 5.2 Properties作为集合的特有方法
- 5.3 properties中和IO相关的方法
- 6 ResourceBundle工具类
- 7 递归
- 通过变量,数组,或者集合存储数据
- 都是不能永久化存储 , 因为数据都是存储在内存中
- 只要代码运行结束，所有数据都会丢失
- 使用IO流
- 1，将数据写到文件中，实现数据永久化存储
- 2，把文件中的数据读取到内存中(Java程序)
- I 表示input ，是数据从硬盘进内存的过程，称之为读。
- O 表示output ，是数据从内存到硬盘的过程。称之为写。
- IO的数据传输，可以看做是一种数据的流动，按照流动的方向，以内存为参照物，进行读写操作
- 简单来说：内存在读，内存在写
- 按照流向区分
- 输入流 : 用来读数据
- 输出流 : 用来写数据
- 按照类型区分
- 字节流
- 字符流
- 注意 :
- 字节流可以操作任意文件 (所有类型文件) —>音频、视频、图片
- 字符流只能操作 纯文本文件 -->java、go文件
- 用windows记事本打开能读的懂，那么这样的文件就是纯文本文件。
- FileOutputStream类 :
- OutputStream有很多子类，我们从最简单的一个子类开始。
- java.io.FileOutputStream 类是文件输出流，用于将数据写出到文件
- 构造方法 :
- public FileOutputStream(File file)：创建文件输出流以写入由指定的 File对象表示的文件。
- public FileOutputStream(String name)： 创建文件输出流以指定的名称写入文件。
public class FileOutputStreamConstructor throws IOException { public static void main(String[] args) { // 使用File对象创建流对象 File file = new File("a.txt"); FileOutputStream fos = new FileOutputStream(file); // 使用文件名称创建流对象 FileOutputStream fos = new FileOutputStream("b.txt"); } } - 字节输出流写数据快速入门
- 创建字节输出流对象
- 写数据
- 释放资源
package com.itheima.outputstream_demo; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; public class OutputStreamDemo1 { public static void main(String[] args) throws IOException { // 创建字节输出流对象 // 如果指定的文件不存在 , 会自动创建文件 // 如果文件存在 , 会把文件中的内容清空 FileOutputStream fos = new FileOutputStream("day11_demo\a.txt"); // 写数据 // 写到文件中就是以字节形式存在的 // 只是文件帮我们把字节翻译成了对应的字符 , 方便查看 fos.write(97); fos.write(98); fos.write(99); // 释放资源 // while(true){} // 断开流与文件中间的关系 fos.close(); } }
-
字节流写数据的方法
- 1 void write(int b) 一次写一个字节数据
- 2 void write(byte[] b) 一次写一个字节数组数据
- 3 void write(byte[] b, int off, int len) 一次写一个字节数组的部分数据
package com.itheima.outputstream_demo; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; public class OutputStreamDemo2 { public static void main(String[] args) throws IOException { // 创建字节输出流对象 FileOutputStream fos = new FileOutputStream("day11_demo\a.txt"); // 写数据 // 1 void write(int b) 一次写一个字节数据 fos.write(97); fos.write(98); fos.write(99); // 2 void write(byte[] b) 一次写一个字节数组数据 byte[] bys = {65, 66, 67, 68, 69}; fos.write(bys); // 3 void write(byte[] b, int off, int len) 一次写一个字节数组的部分数据 fos.write(bys, 0, 3); // 释放资源 fos.close(); } }
package com.itheima.outputstream_demo;
import java.io.FileOutputStream;
import java.io.IOException;
public class OutputStreamDemo3 {
public static void main(String[] args) throws IOException {
// 创建字节输出流对象
FileOutputStream fos = new FileOutputStream("day11_demo\a.txt");
// void write(int b) 一次写一个字节数据
fos.write(97);
// 因为字节流无法写入一个字符串 , 把字符串转成字节数组写入
fos.write("rn".getBytes());
fos.write(98);
fos.write("rn".getBytes());
fos.write(99);
fos.write("rn".getBytes());
// 释放资源
fos.close();
}
}
package com.itheima.outputstream_demo;
import java.io.FileOutputStream;
import java.io.IOException;
public class OutputStreamDemo3 {
public static void main(String[] args) throws IOException {
// 创建字节输出流对象
// 追加写数据
// 通过构造方法 : public FileOutputStream(String name，boolean append) : 追加写数据
FileOutputStream fos = new FileOutputStream("day11_demo\a.txt" , true);
// void write(int b) 一次写一个字节数据
fos.write(97);
// 因为字节流无法写入一个字符串 , 把字符串转成字节数组写入
fos.write("rn".getBytes());
fos.write(98);
fos.write("rn".getBytes());
fos.write(99);
fos.write("rn".getBytes());
// 释放资源
fos.close();
}
// 写完数据换行操作
private static void method1() throws IOException {
// 创建字节输出流对象
FileOutputStream fos = new FileOutputStream("day11_demo\a.txt");
// void write(int b) 一次写一个字节数据
fos.write(97);
// 因为字节流无法写入一个字符串 , 把字符串转成字节数组写入
fos.write("rn".getBytes());
fos.write(98);
fos.write("rn".getBytes());
fos.write(99);
fos.write("rn".getBytes());
// 释放资源
fos.close();
}
}
3 字节输入流
3.1 字节输入流介绍
- 字节输入流类
- InputStream类 : 字节输入流最顶层的类 , 抽象类
— FileInputStream类 : FileInputStream extends InputStream
- InputStream类 : 字节输入流最顶层的类 , 抽象类
- 构造方法
- public FileInputStream(File file) : 从file类型的路径中读取数据
- public FileInputStream(String name) : 从字符串路径中读取数据
- 步骤
- 创建输入流对象
- 读数据
- 释放资源
-
package com.itheima.inputstream_demo; import java.io.FileInputStream; import java.io.IOException; public class FileInputStreamDemo1 { public static void main(String[] args) throws IOException { // 创建字节输入流对象 // 读取的文件必须存在 , 不存在则报错 FileInputStream fis = new FileInputStream("day11_demo\a.txt"); // 读数据 , 从文件中读到一个字节 // 返回的是一个int类型的字节 // 如果想看字符, 需要强转 int by = fis.read(); System.out.println((char) by); // 释放资源 fis.close(); } }
package com.itheima.inputstream_demo;
import java.io.FileInputStream;
import java.io.IOException;
public class FileInputStreamDemo2 {
public static void main(String[] args) throws IOException {
// 创建字节输入流对象
// 读取的文件必须存在 , 不存在则报错
FileInputStream fis = new FileInputStream("day11_demo\a.txt");
// 读数据 , 从文件中读到一个字节
// 返回的是一个int类型的字节
// 如果想看字符, 需要强转
// int by = fis.read();
// System.out.println(by);
// by = fis.read();
// System.out.println(by);
// by = fis.read();
// System.out.println(by);
//
// by = fis.read();
// System.out.println(by);
// by = fis.read();
// System.out.println(by);
// by = fis.read();
// System.out.println(by);
// 循环改进
int by;// 记录每次读到的字节
while ((by = fis.read()) != -1) {
System.out.print((char) by);
}
// 释放资源
fis.close();
}
}
3.3 图片的拷贝
package com.itheima.inputstream_demo;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileInputStreamDemo2 {
public static void main(String[] args) throws IOException {
// 创建字节输入流对象
FileInputStream fis = new FileInputStream("D:\传智播客\安装包\好看的图片\liqin.jpg");
// 创建字节输出流
FileOutputStream fos = new FileOutputStream("day11_demo\copy.jpg");
// 一次读写一个字节
int by;
while ((by = fis.read()) != -1) {
fos.write(by);
}
// 释放资源
fis.close();
fos.close();
}
}
3.4 异常的捕获处理
- JDK7版本之前处理方式 : 手动释放资源
package com.itheima.inputstream_demo; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; public class FileInputStreamDemo4 { public static void main(String[] args) { FileInputStream fis = null ; FileOutputStream fos = null; try { // 创建字节输入流对象 fis = new FileInputStream("D:\传智播客\安装包\好看的图片\liqin.jpg"); // 创建字节输出流 fos = new FileOutpu tStream("day11_demo\copy.jpg"); // 一次读写一个字节 int by; while ((by = fis.read()) != -1) { fos.write(by); } } catch (IOException e) { e.printStackTrace(); } finally { // 释放资源 if(fis != null){ try { fis.close(); } catch (IOException e) { e.printStackTrace(); } } // 释放资源 if(fos != null){ try { fos.close(); } catch (IOException e) { e.printStackTrace(); } } } } } - JDK7版本优化处理方式 : 自动释放资源
-
JDK7优化后可以使用 try-with-resource 语句 , 该语句确保了每个资源在语句结束时自动关闭。
简单理解 : 使用此语句,会自动释放资源 , 不需要自己在写finally代码块了 -
注意：使用前提是资源的类型必须是AutoCloseable接口的实现类
-
格式 :
格式 : try (创建流对象语句1 ; 创建流对象语句2 ...) { // 读写数据 } catch (IOException e) { 处理异常的代码... } 举例 : try ( FileInputStream fis1 = new FileInputStream("day11_demo\a.txt") ; FileInputStream fis2 = new FileInputStream("day11_demo\b.txt") ) { // 读写数据 } catch (IOException e) { 处理异常的代码... }
-
- 代码实践
package com.itheima.inputstream_demo; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; public class FileInputStreamDemo5 { public static void main(String[] args) { try ( // 创建字节输入流对象 FileInputStream fis = new FileInputStream("D:\传智播客\安装包\好看的图片\liqin.jpg"); // 创建字节输出流 FileOutputStream fos = new FileOutputStream("day11_demo\copy.jpg") ) { // 一次读写一个字节 int by; while ((by = fis.read()) != -1) { fos.write(by); } // 释放资源 , 发现已经灰色 , 提示多余的代码 , 所以使用 try-with-resource 方式会自动关流 // fis.close(); // fos.close(); } catch (IOException e) { e.printStackTrace(); } } }
-
FileInputStream类 :
- public int read(byte[] b) : 从输入流读取最多b.length个字节的数据, 返回的是真实读到的数据个数
package com.itheima.inputstream_demo; import javax.sound.midi.Soundbank; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; public class FileInputStreamDemo6 { public static void main(String[] args) throws IOException { // 创建字节输入流对象 FileInputStream fis = new FileInputStream("day11_demo\a.txt"); // public int read(byte[] b)： // 1 从输入流读取最多b.length个字节的数据 // 2 返回的是真实读到的数据个数 byte[] bys = new byte[3]; // int len = fis.read(bys); // System.out.println(len);// 3 // System.out.println(new String(bys));// abc // // len = fis.read(bys); // System.out.println(len);// 2 // System.out.println(new String(bys));// efc System.out.println("==========代码改进==============="); // int len = fis.read(bys); // System.out.println(len);// 3 // System.out.println(new String(bys, 0, len));// abc // // len = fis.read(bys); // System.out.println(len);// 2 // System.out.println(new String(bys, 0, len));// ef System.out.println("==========代码改进==============="); int len; while ((len = fis.read(bys)) != -1) { System.out.print(new String(bys , 0 , len)); } fis.close(); } } -
对复制图片的代码进行使用一次读写一个字节数组的方式进行改进
package com.itheima.inputstream_demo; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; public class FileInputStreamDemo7 { public static void main(String[] args) throws IOException { // 创建字节输入流对象 FileInputStream fis = new FileInputStream("D:\传智播客\安装包\好看的图片\liqin.jpg"); // 创建字节输出流 FileOutputStream fos = new FileOutputStream("day11_demo\copy.jpg"); byte[] bys = new byte[1024]; int len;// 每次真实读到数据的个数 int by; while ((len = fis.read(bys)) != -1) { fos.write(bys, 0, len); } // 释放资源 fis.close(); fos.close(); } }
-
字节缓冲流：
- BufferOutputStream：缓冲输出流
- BufferedInputStream：缓冲输入流
-
构造方法：
- 字节缓冲输出流：BufferedOutputStream(OutputStream out)
- 字节缓冲输入流：BufferedInputStream(InputStream in)
-
为什么构造方法需要的是字节流，而不是具体的文件或者路径呢？
- 字节缓冲流仅仅提供缓冲区，不具备读写功能 , 而真正的读写数据还得依靠基本的字节流对象进行操作
package com.itheima.bufferedstream_demo;
import java.io.*;
public class BufferedStreamDemo1 {
public static void main(String[] args) throws IOException {
// 创建高效的字节输入流对象
// 在底层会创建一个长度为8192的数组
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\传智播客\安装包\好看的图片\liqin.jpg"));
// 创建高效的字节输出流
// 在底层会创建一个长度为8192的数组
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("day11_demo\copy.jpg"));
// 使用高效流 , 一次读写一个字节
int by;
while ((by = bis.read()) != -1) {
bos.write(by);
}
// byte[] bys = new byte[1024];
// int len;// 每次真实读到数据的个数
// while ((len = bis.read(bys)) != -1) {
// bos.write(bys, 0, len);
// }
// 释放资源
// 在底层会把基本的流进行关闭
bis.close();
bos.close();
}
}
4.3 缓冲流一次读写一个字节原理
4.4 缓冲流一次读写一个字节数组原理
- 四种方式复制视频文件效率对比
package com.itheima.bufferedstream_demo;
import java.awt.image.DataBufferDouble;
import java.io.*;
public class BufferedStreamDemo2 {
public static void main(String[] args) throws IOException {
long startTime = System.currentTimeMillis();
// method1();
// method2();
// method3();
method4();
long endTime = System.currentTimeMillis();
System.out.println("花费的时间为:" + (endTime - startTime) + "毫秒");
}
// 4 缓冲流一次读写一个字节数组
private static void method4() throws IOException {
// 创建高效的字节输入流
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\a.wmv"));
// 创建高效的字节输出流
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("day11_demo\copy.wmv"));
// 一次读写一个字节数组
byte[] bys = new byte[1024];
int len;// 每次真实读到数据的个数
while ((len = bis.read(bys)) != -1) {
bos.write(bys, 0, len);
}
// 释放资源
bis.close();
bos.close();
}
// 3 缓冲流一次读写一个字节
private static void method3() throws IOException {
// 创建高效的字节输入流
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\a.wmv"));
// 创建高效的字节输出流
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("day11_demo\copy.wmv"));
// 一次读写一个字节
int by;
while ((by = bis.read()) != -1) {
bos.write(by);
}
// 释放资源
bis.close();
bos.close();
}
// 2 基本的字节流一次读写一个字节数组
private static void method2() throws IOException {
// 创建基本的字节输入流对象
FileInputStream fis = new FileInputStream("D:\a.wmv");
// 创建基本的字节输出流对象
FileOutputStream fos = new FileOutputStream("day11_demo\copy.wmv");
// 一次读写一个字节数组
byte[] bys = new byte[1024];
int len;// 每次真实读到数据的个数
while ((len = fis.read(bys)) != -1) {
fos.write(bys, 0, len);
}
// 释放资源
fis.close();
fos.close();
}
// 1 基本的字节流一次读写一个字节
private static void method1() throws IOException {
// 创建基本的字节输入流对象
FileInputStream fis = new FileInputStream("D:\a.wmv");
// 创建基本的字节输出流对象
FileOutputStream fos = new FileOutputStream("day11_demo\copy.wmv");
// 一次读写一个字节
int by;
while ((by = fis.read()) != -1) {
fos.write(by);
}
// 释放资源
fis.close();
fos.close();
}
}
5 Properties集合
5.1 Properties集合的概述
-
properties是一个Map体系的集合类
- public class Properties extends Hashtable
- public class Properties extends Hashtable
-
为什么在IO流部分学习Properties
- Properties中有跟IO相关的方法
-
当做双列集合使用
- 不需要加泛型 , 工作中只存字符串
package com.itheima.properties_demo; import java.util.Map; import java.util.Properties; import java.util.Set; public class PropertiesDemo1 { public static void main(String[] args) { // 创建集合对象 Properties properties = new Properties(); // 添加元素 properties.put("it001" , "张三"); properties.put("it002" , "李四"); properties.put("it003" , "王五"); // 遍历集合 : 键找值 Set
- Object setProperty(String key, String value) 设置集合的键和值，都是String类型，相当于put方法
- String getProperty(String key) 使用此属性列表中指定的键搜索属性 , 相当于get方法
- Set stringPropertyNames() 从该属性列表中返回一个不可修改的键集，其中键及其对应的值是字符串 , 相当于keySet方法
package com.itheima.properties_demo;
import java.util.Properties;
import java.util.Set;
public class PropertiesDemo2 {
public static void main(String[] args) {
// 创建集合对象
Properties properties = new Properties();
// 添加元素
properties.setProperty("it001", "张三");
properties.setProperty("it002", "李四");
properties.setProperty("it003", "王五");
// 遍历集合 : 键找值
Set set = properties.stringPropertyNames();
for (String key : set) {
System.out.println(key + "---" + properties.getProperty(key));
}
}
}
5.3 properties中和IO相关的方法
- void load(InputStream inStream) 以字节流形式 , 把文件中的键值对, 读取到集合中
- void load(Reader reader) 以字符流形式 , 把文件中的键值对, 读取到集合中
- void store(OutputStream out, String comments) 把集合中的键值对,以字节流形式写入文件中 , 参数二为注释
- void store(Writer writer, String comments) 把集合中的键值对,以字符流形式写入文件中 , 参数二为注释
package com.itheima.properties_demo;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Properties;
public class PropertiesDemo3 {
public static void main(String[] args) throws IOException {
// 创建Properties集合对象
Properties properties = new Properties();
// void load(InputStream inStream) 以字节流形式 , 把文件中的键值对, 读取到集合中
properties.load(new FileInputStream("day11_demo\prop.properties"));
// 打印集合中的数据
System.out.println(properties);
}
}
package com.itheima.properties_demo;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;
public class PropertiesDemo3 {
public static void main(String[] args) throws IOException {
Properties properties = new Properties();
properties.setProperty("zhangsan" , "23");
properties.setProperty("lisi" , "24");
properties.setProperty("wangwu" , "25");
properties.store(new FileOutputStream("day11_demo\prop2.properties") , "userMessage");
}
private static void method1() throws IOException {
// 创建Properties集合对象
Properties properties = new Properties();
// void load(InputStream inStream) 以字节流形式 , 把文件中的键值对, 读取到集合中
properties.load(new FileInputStream("day11_demo\prop.properties"));
// 打印集合中的数据
System.out.println(properties);
}
}
6 ResourceBundle工具类
目标：
- 能够熟练使用ResourceBundle工具类快速读取属性文件的值
概述：
java.util.ResourceBundle它是一个抽象类，我们可以使用它的子类PropertyResourceBundle来读取以.properties结尾的配置文件。
通过静态方法直接获取对象：
static ResourceBundle getBundle(String baseName) 可以根据名字直接获取默认语言环境下的属性资源。
参数注意: baseName
1.属性集名称不含扩展名。
2.属性集文件是在src目录中的
比如：src中存在一个文件 user.properties
ResourceBundle bundle = ResourceBundle.getBundle("user");
ResourceBundle中常用方法：
String getString(String key) : 通过键，获取对应的值
代码实践
通过ResourceBundle工具类
将一个属性文件 放到src目录中，使用ResourceBundle去获取键值对数据
package com.itheima.resourcebundle_demo;
import java.util.ResourceBundle;
public class ResourceBundleDemo {
public static void main(String[] args) {
// public static final ResourceBundle getBundle(String baseName)
// baseName : properties文件的名字 , 注意 : 扩展名不需要加上 , properties必须在src的根目录下
ResourceBundle resourceBundle = ResourceBundle.getBundle("user");
// String getString(String key) : 通过键，获取对应的值
String value1 = resourceBundle.getString("username");
String value2 = resourceBundle.getString("password");
System.out.println(value1);
System.out.println(value2);
}
}
内容小结
-
如果要使用ResourceBundle加载属性文件，属性文件需要放置在哪个位置？
src的根目录
-
请描述使用ResourceBundle获取属性值的大致步骤是怎样的？
1 获取ResourceBundle对象 2 通过ResourceBundle类中的getString(key) : 根据键找值
递归就是方法自己掉自己，递归要有停止条件（出口），否则会出现StackOverflowError异常
递归的好处：
-
把一个复杂的问题层层转化为一个与原问题相似的规模较小的问题来解决
-
小的问题解决，大的问题也会逐一进行解决
递归问题注意事项：
- 递归出口：否则会出现栈溢出异常
- 递归规则：需要找到与原问题相似的规模较小的问题
//求阶乘
public class Test1 {
public static void main(String[] args) {
int result = jiecheng(5);
System.out.println(result);
}
private static int jiecheng(int n) {
if (n == 1){
//出口
return 1;
}else {
return n * jiecheng(n - 1);
}
}
}
//递归删除文件夹及其内容
public class Test2 {
public static void main(String[] args) {
File file = new File("basic-code\date\directory");
deleteFiles(file);
}
//接受一个file路径，删除此路径下所有内容
public static void deleteFiles(File file){
//先获取所有儿子辈的文件
File[] files = file.listFiles();
//提高代码健壮性
if (files == null){
return;
}
//遍历数组
for (File f : files) {
if (f.isFile()){
//如果是文件，直接删除
f.delete();
}else{
//目录
deleteFiles(f);
}
}
//删除当前目录
file.delete();
}
}
