Java基础3 文件io
File-io
文件基础操作
FileDemo1.java
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
public class FileDemo1 {
public static void main(String[] args) {
//目标:创建File创建对象代表文件(文件/目录)，搞清楚其提供的对文件进行操作的方法。
File f1 = new File("D:\\IdeaProjects\\day5-oop\\game_StoneMaze\\src\\image\\0.png");
File f2 = new File("D:/IdeaProjects/day5-oop/game_StoneMaze/src/image/1.png");
System.out.println(f1);//直接打印地址 D:\IdeaProjects\day5-oop\game_StoneMaze\src\image\0.png
System.out.println(f2.length());//字节个数
System.out.println(f1.getName());//文件名
System.out.println(f1.isFile());//判断是否是文件
System.out.println(f1.isDirectory());//判断是否是目录
System.out.println("--------------------1--------------------");
//2、可以使用相对路径定位文件对象。只要带盘符的都称之为:绝对路径E:/resource/dlei.jpg
// 相对路径:不带盘符，默认是到你的idea工程下直接寻找文件的。一般用来找工程下的项目文件的。
//3、创建对象代表不存在的文件路径。
File f3 = new File("D:\\IdeaProjects\\day5-oop\\day03-file-io\\src\\com\\itheima\\123.txt");
System.out.println(f3.exists());
try {
System.out.println(f3.createNewFile());
} catch (IOException e) {
e.printStackTrace();
}
System.out.println(f3.length());
System.out.println("--------------------2--------------------");
//4、创建对象代表不存在的文件夹路径。
File f4 = new File("D:\\IdeaProjects\\day5-oop\\day03-file-io\\src\\com\\itheima\\this_is_a_dir");
System.out.println(f4.exists());
System.out.println(f4.mkdir());//mkdir只能创建一级文件夹
File f5 = new File("D:\\IdeaProjects\\day5-oop\\day03-file-io\\src\\com\\itheima\\this_is_a_dir2\\a\\bb");
System.out.println(f5.exists());
System.out.println(f5.mkdirs());//mkdirs能创建多级文件夹
System.out.println("--------------------3--------------------");
//5、创建File对象代表存在的文件，然后删除它
File f6 = new File("D:\\IdeaProjects\\day5-oop\\day03-file-io\\src\\com\\itheima\\123.txt");
System.out.println(f6.delete());
//6、创建File对象代表存在的文件夹，然后删除它
File f7 = new File("D:\\IdeaProjects\\day5-oop\\day03-file-io\\src\\com\\itheima\\this_is_a_dir2\\a\\bb");
System.out.println(f7.delete());//只能删除空文件夹
System.out.println("--------------------4--------------------");
//7、可以获取某个目录下的全部一级文件名称
File f9 = new File("D:\\IdeaProjects");
String[] list9 = f9.list();
for (String s : list9) {
System.out.println(s);
}
System.out.println("--------------------5--------------------");
//8、可以获取某个目录下的全部一级文件对象
File f10 = new File("D:\\IdeaProjects");
File[] list10 = f10.listFiles();
for (File file : list10) {
System.out.println(file.getAbsoluteFile());//打印绝对路径
}
System.out.println("--------------------6--------------------");
//使用listFiles方法时的注意事项:
//当主调是文件，或者路径不存在时，返回null
//当主调是空文件夹时，返回一个长度为0的数组
//当主调是一个有内容的文件夹时，将里面所有一级文件和文件夹的路径放在File数组中返回
//当主调是一个文件夹，且里面有隐藏文件时，将里面所有文件和文件夹的路径放在File数组中返回，包含隐藏文件
//当主调是一个文件夹，但是没有权限访问该文件夹时，返回null
File dir = new File("D:\\IdeaProjects\\day5-oop\\day03-file-io\\src\\com\\itheima\\bskvfbskvbskf");
System.out.println(dir.listFiles());
File dir2 = new File("D:\\IdeaProjects\\day5-oop\\day03-file-io\\src\\com\\itheima\\this_is_a_dir2\\a");
System.out.println(Arrays.toString(dir2.listFiles()));
}
}
文件查找
FileSearchTest4.java
import java.io.File;
public class FileSearchTest4 {
public static void main(String[] args) {
//目标:完成文件搜索。找出D:盘下的QQ.exe的位置
File dir = new File("D:/");
searchFile(dir,"background_new.png");
}
/**
* 递归搜索文件
* @param dir 搜索的目录
* @param fileName 搜索的文件名
*/
private static void searchFile(File dir, String fileName) {
//1.判断dir是否为空、是否存在、是否为文件
if(dir == null || !dir.exists() || dir.isFile()) return;
//2.获取目录下的所有一级文件或者文件夹对象
File[] files = dir.listFiles();
//3.判断当前目录下是否存在一级文件对象，存在才可以遍历
if(files == null || files.length == 0) return;
//4.遍历一级文件对象
for (File file : files) {
if(file.isFile() && file.getName().equals(fileName)){
System.out.println("找到文件：" + file.getAbsolutePath());
}else{
searchFile(file,fileName);
}
}
}
}
字符编码与解码
CharSetDemo1.java
import java.io.UnsupportedEncodingException;
import java.util.Arrays;
public class CharSetDemo1 {
public static void main(String[] args) throws UnsupportedEncodingException {
//目标:写程序实现字符编码和解码
//1.编码
String str = "我喜欢你abc123";
byte[] bytes = str.getBytes();//字符串转字节数组,默认使用utf-8
System.out.println(bytes);//打印地址 //[B@27d6c5e0
System.out.println(bytes.length);//3 * 4 + 1 * 6 = 18
System.out.println(Arrays.toString(bytes));//[-26, -120, -111, -27, -106, -100, -26, -84, -94, -28, -67, -96, 97, 98, 99, 49, 50, 51]
System.out.println("-----------------------------");
//1.编码
byte[] bytes2 = str.getBytes("GBK");
System.out.println(bytes2.length);//2 * 4 + 1 * 6 = 14
System.out.println(Arrays.toString(bytes2));//[-50, -46, -49, -78, -69, -74, -60, -29, 97, 98, 99, 49, 50, 51]
//2.解码
String str2 = new String(bytes2, "GBK");
System.out.println(str2);//我喜欢你abc123
}
}
文件字节输入流
FileInputStreamDemo1.java
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
public class FileInputStreamDemo1 {
public static void main(String[] args) throws Exception {
//目标:掌握文件字节输入流读取文件中的字节数组到内存中来。
//读取文本适合用字符流。字节流适合读取图片、音频、视频等文件，适合做数据的转移，比如文件复制
//1、创建文件字节输入流管道于源文件接通
//InputStream is = new FileInputStream(new File("day03-file-io\\src\\dlei02.txt"));
InputStream is = new FileInputStream("day03-file-io\\src\\dlei02.txt");//简化写法
//2、开始读取文件中的字节并输出。
int c;
while ((c = is.read()) != -1) {
System.out.print((char) c);//打印完没有换行
}
System.out.println("----------------------");
//3、定义一个字节数组用于每次读取字节
is = new FileInputStream("day03-file-io\\src\\dlei02.txt");
byte[] buffer = new byte[3];//创建字节数组，每次读取3个字节
//定义一个变量记住每次读取了多少个字节
int len;
while((len = is.read(buffer)) != -1){
System.out.println(new String(buffer,0, len)); //len是本次读取的字节数，从0开始
}
System.out.println("----------------------");
//拓展:每次读取多个字节，性能得到提升，因为每次读取多个字节，可以减少硬盘和内存的交互次数，从而提升性能。
//4、一次性读完文件的全部字节,可以避免乱码问题
//如果文件过大，创建的字节数组也会过大，可能引起内存溢出。
is = new FileInputStream("day03-file-io\\src\\dlei02.txt");
byte[] bytes = is.readAllBytes();
System.out.println(new String(bytes));
}
}
dlei02.txt
abcdef12345678
ghijkl12345678
res
abcdef12345678 ghijkl12345678---------------------- abc def 123 456 78 gh ijk l12 345 678 ---------------------- abcdef12345678 ghijkl12345678
文件字节输出流
FileOutPutStreamDemo1.java
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.nio.charset.StandardCharsets;
public class FileOutputStreamDemo1 {
public static void main(String[] args) throws Exception {
//目标:学会使用文件字节输出流。
//1、创建文件字节输出流管道与目标文件接通
//OutputStream os = new FileOutputStream("day03-file-io\\src\\demo4.txt");//覆盖管道
OutputStream os = new FileOutputStream("day03-file-io\\src\\demo4.txt", true);//追加管道
//2、写数据
os.write(97);
//os.write('我');//错误，因为字符'我'在ASCII表中对应的是int值20320，而FileOutputStream只能写入一个字节，所以会乱码。
os.write("\r\n".getBytes());//换行
//3、写一个字节数组
byte[] bytes = "我喜欢你abc123".getBytes();
os.write(bytes);
os.write("\r\n".getBytes());//换行
//4、写一个字节数组的一部分
os.write(bytes, 0, 6);
os.write("\r\n".getBytes());//换行
os.close();
}
}
demo4.txt
a
我喜欢你abc123
我喜
a
我喜欢你abc123
我喜
字节流 文件复制
CopyDemo1.java
import java.io.*;
public class CopyDemo1 {
public static void main(String[] args){
//目标:使用字节流完成文件的复制操作。
//源文件:D:\IdeaProjects\day5-oop\game_StoneMaze\src\image\background.png
//目标文件:D:\background_new.png (复制过去的时候必须带文件名的，无法自动生成文件名。)
String srcPath = "D:\\IdeaProjects\\day5-oop\\game_StoneMaze\\src\\image\\background.png";
String destPath = "D:\\background_new.png";
copyFile(srcPath,destPath);
copyFile2(srcPath,destPath);
}
public static void copyFile2(String srcPath,String destPath){
try(
//这里只能放资源对象，多个资源用try-with-resource语句。
//用完后，最终会自动调用close()方法。
MyConn mc = new MyConn();//自定义的资源对象
InputStream is = new FileInputStream(srcPath);
OutputStream os = new FileOutputStream(destPath);){
//3、读取一个字节数组，写入一个字节数组
byte[] bytes = new byte[1024];
int len;
while((len = is.read(bytes)) != -1){
os.write(bytes,0,len);//读取多少字节，就写入多少字节
}
System.out.println("复制完成");
}catch (Exception e){
e.printStackTrace();
}
}
public static void copyFile(String srcPath,String destPath){
InputStream is = null;
FileOutputStream os = null;
try{
is = new FileInputStream(srcPath);//1、创建一个文件字节输入流管道与源文件接通
os = new FileOutputStream(destPath);//2、创建一个文件字节输出流管道与目标文件接通
//3、读取一个字节数组，写入一个字节数组
byte[] bytes = new byte[1024];
int len;
while((len = is.read(bytes)) != -1){
os.write(bytes,0,len);//读取多少字节，就写入多少字节
}
System.out.println("复制完成");
}catch(Exception e){
e.printStackTrace();
}finally {
//finally的内容最后一定会执行一次:即便程序出现异常!
//4、释放资源
try{
if(os != null){
os.close();
}
}catch(Exception e){
e.printStackTrace();
}
try{
if(is != null){
is.close();
}
}catch(Exception e){
e.printStackTrace();
}
}
}
}
//自定义资源对象，只是用于测试try-with-resource语句。
class MyConn implements Closeable{
@Override
public void close() throws IOException {
System.out.println("MyConn连接关闭了");
}
}
文件字符输入流
FileReaderDemo1.java
import java.io.FileReader;
import java.io.Reader;
public class FileReaderDemo1 {
public static void main(String[] args) {
//目标:掌握文件字符输入流读取字符内容到程序中来
//1、创建文件字符输入流与源文件接通
try(
//1、创建文件字符输入流与源文件接通
Reader fr = new FileReader("D:\\IdeaProjects\\day5-oop\\day03-file-io\\src\\demo06.txt");){
//2、定义一个字符数组，每次读多个字符
char[] chs = new char[3];
int len;
while((len = fr.read(chs)) != -1){
//3、每次读取多个字符，将字符数组内容输出
System.out.print(new String(chs,0,len));
}
//拓展:文件字符输入流每次读取多个字符，性能较好，而且读取中文是按照字符读取，不会出现乱码!这是一种读取中文很好的方案。
}catch (Exception e){
e.printStackTrace();
}
}
}
demo06.txt
abcdef12345678 君问归期未有期 ghijkl12345678 巴山夜雨涨秋池 53546@##￥#5 山回路转不见君 52￥%……&&……%￥%556 雪上空留马行处
res
abcdef12345678 君问归期未有期 ghijkl12345678 巴山夜雨涨秋池 53546@##￥#5 山回路转不见君 52￥%……&&……%￥%556 雪上空留马行处
文件字符输出流
FileWriterDemo.java
import java.io.FileWriter;
import java.io.Writer;
public class FileWriterDemo {
public static void main(String[] args) {
//目标:搞清楚文件字符输出流的使用:写字符出去的流
try(
//1、创建文件字符输出流与目标文件接通,创建一个字符输出流对象，指定写出的目的地。
Writer fw = new FileWriter("D:\\IdeaProjects\\day5-oop\\day03-file-io\\src\\demo07.txt", true);){
//2、写数据
fw.write('a');fw.write(99);fw.write('我');fw.write("hello world");fw.write("\r\n");
//写字符串的一部分进去
fw.write("12345春江潮水连海平，海上明月共潮生".toCharArray(), 5, 15);
fw.write("\r\n");
//写字符数组进去
char[] chars = "hello world我欲乘风归去，又恐琼楼玉宇".toCharArray();
fw.write(chars);
fw.write("\r\n");
//字符输出流写出数据后，必须刷新流，或者关闭流，写出去的数据才能生效
fw.flush();
//刷新后，流可以继续使用
fw.close();//关闭资源，关闭包含刷新
}catch (Exception e){
e.printStackTrace();
}
}
}
demo07.txt
ac我hello world
春江潮水连海平，海上明月共潮生
hello world我欲乘风归去，又恐琼楼玉宇
缓冲字节输入流
BufferedInputStreamDemo1.java
import java.io.*;
public class BufferedInputStreamDemo1 {
public static void main(String[] args) {
//目标:掌握缓冲输入字节流的使用
//字节缓冲流自带8KB缓冲区，可以提高原始字节流、字符流读写数据的性能
//源文件:D:\IdeaProjects\day5-oop\game_StoneMaze\src\image\background.png
//目标文件:D:\background_new.png (复制过去的时候必须带文件名的，无法自动生成文件名。)
String srcPath = "D:\\IdeaProjects\\day5-oop\\game_StoneMaze\\src\\image\\background.png";
String destPath = "D:\\background_new.png";
copyFile(srcPath,destPath);
}
public static void copyFile(String srcPath,String destPath){
try(
//这里只能放资源对象，多个资源用try-with-resource语句。
//用完后，最终会自动调用close()方法。
InputStream fis = new FileInputStream(srcPath);
//把低级的字节输入流包装成高级的缓冲字节输入流
InputStream bis = new BufferedInputStream(fis);
OutputStream fos = new FileOutputStream(destPath);
//把低级的字节输入流包装成高级的缓冲字节输入流
OutputStream bos = new BufferedOutputStream(fos);
){
//3、读取一个字节数组，写入一个字节数组
byte[] bytes = new byte[1024];
int len;
while((len = bis.read(bytes)) != -1){
bos.write(bytes,0,len);//读取多少字节，就写入多少字节
}
System.out.println("复制完成");
}catch (Exception e){
e.printStackTrace();
}
}
}
缓冲字符输入流
BufferedReaderDemo1.java
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.Reader;
public class BufferedReaderDemo1 {
public static void main(String[] args) {
//目标:搞清楚缓冲字符输入流读取字符内容:性能提升了，多了按照行读取文本的能力。
try(
//1.创建文件字符输入流与源文件接通
Reader fr = new FileReader("D:\\IdeaProjects\\day5-oop\\day03-file-io\\src\\demo07.txt");
//2.创建缓冲字符输入流包装低级的字符输入流
BufferedReader br = new BufferedReader(fr);
){
//2.定义一个字符数组，每次读多个字符
char[] chars = new char[1024];
int len;//用于记录每次读取的字符个数
while((len = br.read(chars)) != -1){
//3.每次读取多个字符，将字符数组内容输出
System.out.print(new String(chars,0,len));
}
System.out.println("------------1------------");
//1.创建文件字符输入流与源文件接通
Reader fr2 = new FileReader("D:\\IdeaProjects\\day5-oop\\day03-file-io\\src\\demo07.txt");
//读取一行数据返回，如果没有数据可读了，会返回nu11
BufferedReader br2 = new BufferedReader(fr2);
System.out.println(br2.readLine());
System.out.println(br2.readLine());
System.out.println(br2.readLine());
System.out.println(br2.readLine());
System.out.println(br2.readLine());
System.out.println(br2.readLine());
System.out.println("------------2------------");
//使用循环改进，来按照行读取数据。
//定义一个字符串变量用于记住每次读取的一行数据
//目前读取文本最优雅的方案:性能好，不乱码，可以按照行读取。
Reader fr3 = new FileReader("D:\\IdeaProjects\\day5-oop\\day03-file-io\\src\\demo07.txt");
BufferedReader br3 = new BufferedReader(fr3);
String line;
while((line = br3.readLine()) != null){
System.out.println(line);
}
}catch (Exception e){
e.printStackTrace();
}
}
}
demo07.txt
ac我hello world
春江潮水连海平，海上明月共潮生
hello world我欲乘风归去，又恐琼楼玉宇
res
ac我hello world 春江潮水连海平，海上明月共潮生 hello world我欲乘风归去，又恐琼楼玉宇 ------------1------------ ac我hello world 春江潮水连海平，海上明月共潮生 hello world我欲乘风归去，又恐琼楼玉宇 null null null ------------2------------ ac我hello world 春江潮水连海平，海上明月共潮生 hello world我欲乘风归去，又恐琼楼玉宇
缓冲字符输入输出流 调整文本顺序
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class BufferedTest2 {
public static void main(String[] args) {
try(
//创建一个字符缓冲输入流对象与源文件链接。
BufferedReader br = new BufferedReader(new FileReader("D:\\IdeaProjects\\day5-oop\\day03-file-io\\src\\cjhyy_original.txt"));
//创建一个字符缓冲输出流对象与目标文件链接
BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\IdeaProjects\\day5-oop\\day03-file-io\\src\\cjhyy_sorted.txt"));
){
List<String> data = new ArrayList<>();
String line;
while((line = br.readLine()) != null){
data.add(line);
}
//如果文本序号的位数相同，可以直接用Collections.sort(data)排序
//Collections.sort(data);
//给集合中的每段内容，按照首字符排序
for (int i = 0; i < data.size(); i++) {
for (int j = i + 1; j < data.size(); j++) {
String s1 = data.get(i);
//str.indexOf(".")返回字符串中“.”的索引。substring(0, s1.indexOf("."))截取字符串中“.”之前的字符
int num1 = Integer.parseInt(s1.substring(0, s1.indexOf(".")));//得到“.”之前的数字序号
String s2 = data.get(j);
int num2 = Integer.parseInt(s2.substring(0, s2.indexOf(".")));
if (num1 > num2) {
data.set(i, s2);data.set(j, s1);//交换位置
}
}
}
for (String s : data) {
bw.write(s);
bw.newLine();
System.out.println(s);
}
}catch (Exception e){
e.printStackTrace();
}
}
}
cjhyy_original.txt
5. 江天一色无纤尘，皎皎空中孤月轮。 12. 玉户帘中卷不去，捣衣砧上拂还来。 3. 江流宛转绕芳甸，月照花林皆似霰。 9. 白云一片去悠悠，青枫浦上不胜愁。 1. 春江潮水连海平，海上明月共潮生。 16. 江水流春去欲尽，江潭落月复西斜。 7. 人生代代无穷已，江月年年望相似。 14. 鸿雁长飞光不度，鱼龙潜跃水成文。 10. 谁家今夜扁舟子？何处相思明月楼？ 6. 江畔何人初见月？江月何年初照人？ 18. 不知乘月几人归，落月摇情满江树。 2. 滟滟随波千万里，何处春江无月明！ 11. 可怜楼上月裴回，应照离人妆镜台。 8. 不知江月待何人，但见长江送流水。 15. 昨夜闲潭梦落花，可怜春半不还家。 4. 空里流霜不觉飞，汀上白沙看不见。 13. 此时相望不相闻，愿逐月华流照君。 17. 斜月沉沉藏海雾，碣石潇湘无限路。
res
1. 春江潮水连海平，海上明月共潮生。 2. 滟滟随波千万里，何处春江无月明！ 3. 江流宛转绕芳甸，月照花林皆似霰。 4. 空里流霜不觉飞，汀上白沙看不见。 5. 江天一色无纤尘，皎皎空中孤月轮。 6. 江畔何人初见月？江月何年初照人？ 7. 人生代代无穷已，江月年年望相似。 8. 不知江月待何人，但见长江送流水。 9. 白云一片去悠悠，青枫浦上不胜愁。 10. 谁家今夜扁舟子？何处相思明月楼？ 11. 可怜楼上月裴回，应照离人妆镜台。 12. 玉户帘中卷不去，捣衣砧上拂还来。 13. 此时相望不相闻，愿逐月华流照君。 14. 鸿雁长飞光不度，鱼龙潜跃水成文。 15. 昨夜闲潭梦落花，可怜春半不还家。 16. 江水流春去欲尽，江潭落月复西斜。 17. 斜月沉沉藏海雾，碣石潇湘无限路。 18. 不知乘月几人归，落月摇情满江树。
缓冲字符输出流
BufferedWriterDemo1.java
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.Writer;
public class BufferedWriterDemo1 {
public static void main(String[] args) {
//目标:搞清楚缓冲字符输出流的使用:提升了字输出流的写字符的性能，多了换行功能
try(
Writer fw = new FileWriter("D:\\IdeaProjects\\day5-oop\\day03-file-io\\src\\demo09.txt", true);
//创建一个缓冲字符输出流对象，把字符输出流对象作为构造参数传递给缓冲字符输出流对象
BufferedWriter bw = new BufferedWriter(fw);
) {
//2、写数据
bw.write('a');bw.write(99);bw.write('我');bw.write("hello world");
bw.write("\r\n");
bw.newLine();//写入一个换行符
//写字符串的一部分进去
bw.write("12345春江潮水连海平，海上明月共潮生".toCharArray(), 5, 15);
bw.write("\r\n");
bw.newLine();
//写字符数组进去
char[] chars = "hello world我欲乘风归去，又恐琼楼玉宇".toCharArray();
bw.write(chars);
bw.write("\r\n");
bw.newLine();
//字符输出流写出数据后，必须刷新流，或者关闭流，写出去的数据才能生效
bw.flush();
//刷新后，流可以继续使用
bw.close();//关闭资源，关闭包含刷新
}catch (Exception e){
e.printStackTrace();
}
}
}
demo09.txt
ac我hello world
春江潮水连海平，海上明月共潮生
hello world我欲乘风归去，又恐琼楼玉宇
低级流和缓冲流性能分析
TimeTest3.java
import java.io.*;
public class TimeTest3 {
private static final String SRC_FILE = "D:\\i got smoke-丁真.mp4";
private static final String DEST_FILE = "E:\\i got smoke-丁真.mp4";
public static void main(String[] args) {
// 目标:缓冲流，低级流的性能分析。
//使用低级的字节流按照一个一个字节的形式复制文件。太慢了
//copyFile1();
//使用低级的字节流按照字节数组的形式复制文件。
copyFile2();//1359ms
//使用高级的缓冲字节流按照一个一个字节的形式复制文件。
copyFile3();//3436ms
//使用高级的缓冲字节流按照字节数组的形式复制文件。
copyFile4();//250ms
}
//使用高级的缓冲字节流按照字节数组的形式复制文件。
private static void copyFile4() {
long startTime = System.currentTimeMillis();
try(
InputStream fis = new FileInputStream(SRC_FILE);
InputStream bis = new BufferedInputStream(fis);
OutputStream fos = new FileOutputStream(DEST_FILE);
OutputStream bos = new BufferedOutputStream(fos);
){
byte[] bytes = new byte[1024];
int len;
while((len = bis.read(bytes)) != -1){
bos.write(bytes,0,len);
}
}catch (Exception e){
e.printStackTrace();
}
long endTime = System.currentTimeMillis();
System.out.println("使用高级的缓冲字节流按照字节数组的形式复制文件耗时：" + (endTime-startTime) + "毫秒");
}
//使用高级的缓冲字节流按照一个一个字节的形式复制文件。
private static void copyFile3() {
long startTime = System.currentTimeMillis();
try(
InputStream fis = new FileInputStream(SRC_FILE);
InputStream bis = new BufferedInputStream(fis);
OutputStream fos = new FileOutputStream(DEST_FILE);
OutputStream bos = new BufferedOutputStream(fos);
){
int b;
while((b = bis.read()) != -1){
bos.write(b);
}
}catch (Exception e){
e.printStackTrace();
}
long endTime = System.currentTimeMillis();
System.out.println("使用高级的缓冲字节流按照一个一个字节的形式复制文件耗时：" + (endTime-startTime) + "毫秒");
}
//使用低级的字节流按照字节数组的形式复制文件。
private static void copyFile2() {
long startTime = System.currentTimeMillis();
try(
InputStream fis = new FileInputStream(SRC_FILE);
OutputStream fos = new FileOutputStream(DEST_FILE);
){
byte[] bytes = new byte[1024];
int len;
while((len = fis.read(bytes)) != -1){
fos.write(bytes,0,len);
}
}catch (Exception e){
e.printStackTrace();
}
long endTime = System.currentTimeMillis();
System.out.println("使用低级的字节流按照字节数组的形式复制文件耗时：" + (endTime-startTime) + "毫秒");
}
//使用低级的字节流按照一个一个字节的形式复制文件。
public static void copyFile1(){
long startTime = System.currentTimeMillis();
try(
InputStream fis = new FileInputStream(SRC_FILE);
OutputStream fos = new FileOutputStream(DEST_FILE);
) {
int b;
while((b = fis.read()) != -1){
fos.write(b);
}
} catch (Exception e) {
e.printStackTrace();
}
long endTime = System.currentTimeMillis();
System.out.println("使用低级的字节流按照一个一个字节的形式复制文件耗时：" + (endTime-startTime) + "毫秒");
}
}
字符输出流 编码格式问题
InputStreamReaderDemo2.java
import java.io.*;
public class InputStreamReaderDemo2 {
public static void main(String[] args) {
// 目标:使用字符输入转换流InputStreamReader解决不同编码读取乱码的问题
//InputStreamReader(字符输入转换流)解决不同编码时，字符流读取文本内容乱码的问题。
// 解决思路:先获取文件的原始字节流，再将其按真实的字符集编码转成字符输入流，这样字符输入流中的字符就不乱码了
//public InputStreamReader(InputStream is ,String charset) 把原始的字节输入流，按照指定字符集编码转成字符输入流(重点)
// 代码:UTF-8 <---> UTF-8 读取不乱码
// 代码:UTF-8 <---> GBK 读取乱码
try(
//先提取文件的原始字节流
InputStream is = new FileInputStream("D:\\IdeaProjects\\day5-oop\\day03-file-io\\src\\pipaxing.txt");
//指定字符集把原始字节流转换成字符输入流
Reader isr = new InputStreamReader(is,"GBK");
//创建缓冲字符输入流包装低级的字符输入流
BufferedReader br = new BufferedReader(isr);
){
String line;
while ((line = br.readLine()) != null){
System.out.println(line);
}
}catch (Exception e){
e.printStackTrace();
}
}
}
特殊流
DataStreamDemo1.java
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
public class DataStreamDemo1 {
public static void main(String[] args) {
//目标：特殊流的使用
//1.DataOutputStream:专门用于向文件写入特殊数据类型的
//2.DataInputStream:专门用于从文件读取特殊数据类型的
try(
DataOutputStream dos = new DataOutputStream(new FileOutputStream("D:\\IdeaProjects\\day5-oop\\day03-file-io\\src\\demo13_2.txt"));
){
dos.writeInt(100);
dos.writeBoolean(true);
dos.writeDouble(10.5);
dos.writeChar('a');
dos.writeUTF("hello");
dos.writeByte(32);
}catch (Exception e){
e.printStackTrace();
}
try(
DataInputStream dis = new DataInputStream(new FileInputStream("D:\\IdeaProjects\\day5-oop\\day03-file-io\\src\\demo13_2.txt"));
){
//收发之间一定要保持一致
System.out.println(dis.readInt());
System.out.println(dis.readBoolean());
System.out.println(dis.readDouble());
System.out.println(dis.readChar());
System.out.println(dis.readUTF());
System.out.println(dis.readByte());
}catch (Exception e){
e.printStackTrace();
}
}
}
demo13_2.txt 全是乱码
d@% a hello
打印流
PrintStreamDemo1.java
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.io.PrintWriter;
public class PrintStreamDemo1 {
public static void main(String[] args) {
//目标：打印流的使用
try(
//PrintStream ps = new PrintStream("D:\\IdeaProjects\\day5-oop\\day03-file-io\\src\\demo13.txt");
//PrintWriter pw = new PrintWriter("D:\\IdeaProjects\\day5-oop\\day03-file-io\\src\\demo13.txt");
//在低级流上确认是否追加数据
PrintWriter pw = new PrintWriter(new FileOutputStream("D:\\IdeaProjects\\day5-oop\\day03-file-io\\src\\demo13.txt",true));
){
//写什么就输出什么
pw.println("hello world");
pw.println('a');
pw.println(true);
pw.println(10);
pw.println(10.5);
}catch (Exception e){
e.printStackTrace();
}
}
}
demo13.txt
hello world a true 10 10.5
浙公网安备 33010602011771号