缓冲流
缓冲概述
字节缓冲流
public class Test {
public static void main(String[] args) {
try (
// 定义一个字节输入流管道与原视频接通
InputStream is = new FileInputStream("Learn\\src\\Picture\\2.txt");
//把原始的字节输入流包装成高级的缓冲字节输入流
InputStream bis = new BufferedInputStream(is);
// 创建一个字节流输出管道与目标文件接通
OutputStream os = new FileOutputStream("Learn\\src\\Picture\\f1.txt");
// 把字节输出流管道包装成高级的字节输出流管道
OutputStream bos = new BufferedOutputStream(os);
) {
// 定义一个字节数组来转移数据
byte[] buffer = new byte[1024];
int len; //记录每次读取的字节数
while ((len = is.read()) != -1) {
bos.write(buffer , 0 ,len);
}
bos.close();
bis.close();
System.out.println("复制完成");
} catch (Exception e) {
e.printStackTrace();
}
}
}
字节缓冲流的性能分析
public class Test {
private static final String SRC_FILE = "F:\\Windows\\Test File\\Java\\Learn\\src\\Picture\\2.txt";
private static final String DEST_FILE = "F:\\Windows\\Test File\\Java\\Learn\\src\\Picture\\";
public static void main(String[] args) {
copy01(); //使用低级的字节流按照一个一个字节的形式复制文件
copy02(); //使用低级的字节流按照一个一个字节数组的形式复制文件
copy03(); //缓冲流一个一个字节复制文件
copy04(); //缓冲流一个一个字节数组复制文件
}
/**
* //缓冲流一个一个字节数组复制文件
*/
private static void copy04() {
long startTime = System.currentTimeMillis();
try (
InputStream bis = new BufferedInputStream(new FileInputStream(SRC_FILE));
OutputStream bos = new BufferedOutputStream(new FileOutputStream(DEST_FILE + "f2.txt"))
){
byte[] buffer = new byte[1024];
int len; //记录每次读取字节长度
if ((len = bis.read()) != -1) {
bos.write(buffer,0,len);
}
bis.close();
bos.close();
}catch (Exception e){
e.printStackTrace();
}
long endTime = System.currentTimeMillis();
System.out.println("所用时间为:" + (endTime - startTime) / 1000.0 + "s");
}
/**
* //缓冲流一个一个字节复制文件
*/
private static void copy03() {
long startTime = System.currentTimeMillis();
try (
InputStream is = new FileInputStream(SRC_FILE);
InputStream bis = new BufferedInputStream(is);
OutputStream os = new FileOutputStream(DEST_FILE + "f1.txt");
OutputStream bos = new BufferedOutputStream(os);
){
int b;
if ((b = bis.read()) != -1) {
bos.write(b);
}
bis.close();
bos.close();
is.close();
os.close();
}catch (Exception e) {
e.printStackTrace();
}
long endTime = System.currentTimeMillis();
System.out.println("所用时间为:" + (endTime - startTime) / 1000.0 + "s");
}
/**
* //使用低级的字节流按照一个一个字节数组的形式复制文件
*/
private static void copy02() {
long startTime = System.currentTimeMillis();
try (
InputStream is = new FileInputStream(SRC_FILE);
OutputStream os = new FileOutputStream(DEST_FILE + "f1.txt");
){
byte[] buffer = new byte[1024];
int len; //记录每次读取字节数
while ((len = is.read(buffer)) != -1) {
os.write(buffer,0,len);
}
is.close();
os.close();
}catch (Exception e) {
e.printStackTrace();
}
long endTime = System.currentTimeMillis();
System.out.println("所用时间为:" + (endTime - startTime) / 1000.0 + "s");
}
/**
* 使用低级的字节流按照一个一个字节的形式复制文件
*/
private static void copy01() {
long startTime = System.currentTimeMillis();
try (
// 创造低级的字节输入流与源文件接通
InputStream is = new FileInputStream(SRC_FILE);
// 创建低级的字节输出流与目标文件接通
OutputStream os = new FileOutputStream(DEST_FILE + "f1.txt");
){
// 定义一个变量记录每次读取的字节(一个一个字节的复制)
int b;
while ((b = is.read()) != -1) {
os.write(b);
}
is.close();
os.close();
}catch (Exception e){
e.printStackTrace();
}
long endTime = System.currentTimeMillis();
System.out.println("所用时间为:" + (endTime - startTime) / 1000.0 + "s");
}
}
字符缓冲流
public class Test {
private static final String SRC_FILE = "F:\\Windows\\Test File\\Java\\Learn\\src\\Picture\\2.txt";
private static final String DEST_FILE = "F:\\Windows\\Test File\\Java\\Learn\\src\\Picture\\f1.txt";
public static void main(String[] args) throws Exception{
try (
Reader fr = new FileReader(DEST_FILE);
BufferedReader br = new BufferedReader(fr);
){
int b;
while ((b = br.read()) != -1){
System.out.println(br.readLine());
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
}
public class Test {
private static final String SRC_FILE = "F:\\Windows\\Test File\\Java\\Learn\\src\\Picture\\2.txt";
private static final String DEST_FILE = "F:\\Windows\\Test File\\Java\\Learn\\src\\Picture\\f1.txt";
public static void main(String[] args) throws Exception{
// shift +F6:用于快速修改变量名
try (
Writer fw = new FileWriter(DEST_FILE);
BufferedWriter bw = new BufferedWriter(fw);
){
bw.write("我");
bw.newLine();
bw.write(85);
bw.newLine();
bw.write("abc");
bw.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
}
public class Test {
public static void main(String[] args) throws Exception{
try (
// 1. 创建缓冲字符输入流管道与源文件接通
BufferedReader br = new BufferedReader(new FileReader("Learn\\src\\Picture\\csb.txt"));
){
// 2. 定义一个list集合
List<String> data = new ArrayList<>();
// 3. 定义循环按照行拷贝
String line;
while ((line = br.readLine()) != null) {
data.add(line);
}
// 4. 排序
// 自定义排序规则
List<String> size = new ArrayList<>();
Collections.addAll(size,"一","二","三","四","五","陆","柒","八","九","十","十一");
Collections.sort(data, (o1 ,o2) -> size.indexOf(o1.substring(0,o1.indexOf("."))) - size.indexOf(o2.substring(0,o2.indexOf("."))));
//5. 定义缓冲字符输出管道与目标文件接通
BufferedWriter wr = new BufferedWriter(new FileWriter("Learn\\src\\Picture\\f1.txt"));
// 遍历集合中的每行文章写出去,且要换行
for (String datum : data) {
wr.write(datum);
wr.newLine();
}
wr.close();
br.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
}
转换流
不同编码读取乱码问题
字符输入转换流
public class Test {
public static void main(String[] args) throws Exception{
//GBK文件
// 1. 提取GBK文件的原始字节流,并转换成字符输入流
Reader isr = new InputStreamReader(new FileInputStream("Learn\\src\\Picture\\99.txt") ,"GBK");
BufferedReader br= new BufferedReader(isr);
String line;
while ((line = br.readLine()) != null) {
System.out.println(line);
}
}
}
字符输出转换流
public class Test {
public static void main(String[] args) throws Exception{
//GBK文件
// 1. 定义一个字节输出流,并转换成字符输出流
Writer osw = new OutputStreamWriter(new FileOutputStream("Learn\\src\\Picture\\f1.txt"));
BufferedWriter bw = new BufferedWriter(osw);
bw.newLine();
bw.write("我");
bw.close();
}
}
序列化对象
对象序列化
/**
* 对象要序列化,必须实现 Serializable接口
*/
public class Student implements Serializable {
private transient String passWord; // transient修饰的成员变量不参与序列化了
public class Test {
public static void main(String[] args) throws Exception{
// 1.创建学生对象
Student s = new Student("张三" ,"zhang","123456",20);
// 2. 对象序列化,使用对象字节输出流包装字节输出流管道
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("Learn\\src\\Picture\\2.txt"));
// 3. 直接调用序列化方法
oos.writeObject(s);
// 4. 释放资源
oos.close();
}
}
对象反序列化
public class Test {
public static void main(String[] args) throws Exception{
// 1.创建对象字节输入流管道包装低级的字节输入流管道
ObjectInputStream is = new ObjectInputStream(new FileInputStream("Learn\\src\\Picture\\2.txt"));
// 2. 调用对象字节输入流的反序列化方法
Student s = (Student) is.readObject();
System.out.println(s);
}
}
打印流
PrintStream、PrintWriter
public class Test {
public static void main(String[] args) throws Exception{
// 1.创建一个打印流对象
PrintStream ps = new PrintStream(new FileOutputStream("Learn\\src\\Picture\\2.txt"));
ps.println(97);
ps.println('a');
ps.println(23.3);
ps.println(true);
ps.println("打印字符串");
ps.close();
}
}
public class Test {
public static void main(String[] args) throws Exception{
// 1.创建一个打印流对象
// 与PrintStream的使用没有区别
PrintWriter ps = new PrintWriter("Learn\\src\\Picture\\2.txt");
ps.println(97);
ps.println('a');
ps.println(23.3);
ps.println(true);
ps.println("打印字符串");
ps.write("字符串");
ps.close();
}
}
输出语句的重定向
public class Test {
public static void main(String[] args) throws Exception{
System.out.println("Java牛逼");
//改变输出语句的位置(重定向)
PrintStream ps = new PrintStream("Learn\\src\\Picture\\f1.txt");
System.setOut(ps); //把系统的打印流改成我们自己的打印流
System.out.println("打印到文件里了");
}
}
Properties
public class Test {
public static void main(String[] args) throws Exception{
Properties properties = new Properties();
properties.setProperty("admin","123456");
System.out.println(properties);
/**
* 参数一:保存管道 字符输出流管道
* 参数二:添加注释
*/
properties.store(new FileWriter(("Learn\\src\\Picture\\2.txt")),"");
}
}
public class Test {
public static void main(String[] args) throws Exception{
Properties properties = new Properties();
System.out.println(properties);
// 加载属性文件中的键值对数据到属性对象properties中去
properties.load(new FileReader("Learn\\src\\Picture\\2.txt"));
System.out.println(properties);
String rs = (String) properties.get("dlei");
}
}
IO框架
/**
目标:Commons-io包的使用介绍。
什么是Commons-io包?
commons-io是apache开源基金组织提供的一组有关IO操作的类库,
可以挺提高IO功能开发的效率。commons-io工具包提供了很多有关io操作的类,
见下表:
| 包 | 功能描述 |
| ----------------------------------- | :------------------------------------------- |
| org.apache.commons.io | 有关Streams、Readers、Writers、Files的工具类 |
| org.apache.commons.io.input | 输入流相关的实现类,包含Reader和InputStream |
| org.apache.commons.io.output | 输出流相关的实现类,包含Writer和OutputStream |
| org.apache.commons.io.serialization | 序列化相关的类
步骤:
1. 下载commons-io相关jar包;http://commons.apache.org/proper/commons-io/
2. 把commons-io-2.6.jar包复制到指定的Module的lib目录中
3. 将commons-io-2.6.jar加入到classpath中
小结:
IOUtils和FileUtils可以方便的复制文件和文件夹!!
*/
public class CommonsIODemo01 {
public static void main(String[] args) throws Exception {
// 1.完成文件复制!
// IOUtils.copy(new FileInputStream("D:\\resources\\hushui.jpeg"),
// new FileOutputStream("D:\\resources\\hushui2.jpeg"));
// 2.完成文件复制到某个文件夹下!
// FileUtils.copyFileToDirectory(new File("D:\\resources\\hushui.jpeg"), new File("D:/"));
// 3.完成文件夹复制到某个文件夹下!
// FileUtils.copyDirectoryToDirectory(new File("D:\\resources") , new File("D:\\new"));
// FileUtils.deleteDirectory(new File("D:\\new"));
// JDK1.7 自己也做了一些一行代码完成复制的操作:New IO的技术
// Files.copy(Path.of("D:\\resources\\hushui.jpeg"), Path.of("D:\\resources\\hushui3.jpeg"));
FileUtils.deleteDirectory(new File("D:\\new"));
}
}