java基础 IO流
目录
IO流简述：
整体框架：
FileInputStream
为了在使用字节输入流读取中文内容输出不乱码，可以考虑：
FileOutputStream
Reader
FileReader
BufferedReader
InputStreamReader
FileWriter
BufferedWriter
OutputStreamWriter
资源释放的方式
缓冲流
对象序列化流
ObjectInputStream
ObjectOutputStream
打印流
PrintStream
PrintWriter
Properties与属性文件
流相关强大api
IO流简述：
I表示intput，写入内存，负责读取。
O表示output，从内存写出，负责写出。
整体框架：
流中的数据最小单位分为：
字节流：操作所有类型的文件，一个一个字节操作
InputStream：字节输入流
FileInputStream
BufferedInputStream
ObjectInputStream
OutputStream：字节输出流
FileOutPutSteam
BufferedOutputStream
ObjectOutputStream
PrintStream
字符流：只能操作纯文本文件，一个一个字符操作
Reader：字符输入出流
FileReader
BufferedReader
Writer：字符输出出流
FileWriter
BufferedWriter
PrintWriter
FileInputStream
public FileInputStream(File file)
public FileInputStream(String pathname)
public int read() 每次读取一个字节返回，如果字节已经没有可读的返回-1。性能较慢 读取中文字符输出会有乱码问题。
// 1、创建一个文件字节输入流管道读取源文件数据。
// InputStream is = new FileInputStream(new File("file-io-app\\src\\data.txt"));
// 简化写法，对应上面的第二个api，其实方法内部是调用了上面的方法
InputStream is = new FileInputStream("file-io-app\\src\\data.txt");// 2、读取一个字节返回 （每次读取一个字节，再次调用时会接着读取，读取完毕返回-1）
// int b1 = is.read();
// System.out.println((char)b1);// 3、使用循环，遇到中文（三个字节）而每次只读取一个字节
// 定义一个变量记录每次读取的字节 a b 3 中文
// o o o [ooo]
int b;
while (( b = is.read() ) != -1){
System.out.print((char) b);
}
public int read(byte[] buffer) 每次读取一个字节数组返回，如果字节已经没有可读的返回-1。读取的性能得到了提升，但读取中文字符输出还是无法避免乱码问题。
// 1、创建一个文件字节输入流管道与源文件接通
InputStream is = new FileInputStream("file-io-app/src/data02.txt");// 2、定义一个字节数组，用于读取字节数组
// byte[] buffer = new byte[3]; // 3B
// int len = is.read(buffer);
// System.out.println("读取了几个字节：" + len);
// String rs = new String(buffer);
// System.out.println(rs);
//
// int len1 = is.read(buffer);
// System.out.println("读取了几个字节：" + len1);
// String rs1 = new String(buffer);
// System.out.println(rs1);
// // buffer = [a b c]
//
// // buffer = [a b c] ==> [c d c]
// int len2 = is.read(buffer);
// System.out.println("读取了几个字节：" + len2);
// // 读取多少倒出多少
// String rs2 = new String(buffer,0 ,len2);
// System.out.println(rs2);
//
// int len3 = is.read(buffer);
// System.out.println(len3); // 读取完毕返回-1// 3、改进使用循环，每次读取一个字节数组
byte[] buffer = new byte[3];
int len; // 记录每次读取的字节数。
while ((len = is.read(buffer)) != -1) {
// 读取多少倒出多少
System.out.print(new String(buffer, 0 , len));
}
字节流复制文件：
try {
// 1、创建一个字节输入流管道与原文件接通
InputStream is = new FileInputStream("file-io-app/src/test.txt");// 2、创建一个字节输出流管道与目标文件接通
OutputStream os = new FileOutputStream("file-io-app/src/test2.txt");// 3、定义一个字节数组转移数据
byte[] buffer = new byte[1024];
int len; // 记录每次读取的字节数，这是为了避免在最后一次读取时，读了一个buffer的数组，但最后几个位实际上是没有真实数据，就会乱码。
while ((len = is.read(buffer)) != -1){
os.write(buffer, 0 , len);
}
System.out.println("复制完成！");// 4、关闭流。
os.close();
is.close();
} catch (Exception e){
e.printStackTrace();
}
为了在使用字节输入流读取中文内容输出不乱码，可以考虑：
定义一个与文件一样大的字节数组，一次性读取完文件的全部字节。 可以避免乱码，但如果文件过大，字节数组可能引起内存溢出。
方式一 自己定义。定义一个字节数组与文件的大小一样大，然后使用读取字节数组的方法，一次性读取完成。
public int read(byte[] buffer) 每次读取一个字节数组返回，如果字节已经没有可读的返回-1
方式二 官方为API。可以直接把文件的全部数据读取到一个字节数组中。
public byte[] readAllBytes() throws IOException 直接将当前字节输入流对应的文件对象的字节数据装到一个字节数组返回。
// 1、创建一个文件字节输入流管道与源文件接通
File f = new File("file-io-app/src/data03.txt");
InputStream is = new FileInputStream(f);// 2、定义一个字节数组与文件的大小刚刚一样大。
// byte[] buffer = new byte[(int) f.length()];
// int len = is.read(buffer);
// System.out.println("读取了多少个字节：" + len);
// System.out.println("文件大小：" + f.length());
// System.out.println(new String(buffer));// 读取全部字节数组，原理就是上一步自定义的写法
byte[] buffer = is.readAllBytes();
System.out.println(new String(buffer));
FileOutputStream
public FileOutputStream(File file)
public FileOutputStream(File file，boolean append) 可追加数据
public FileOutputStream(String filepath)
public FileOutputStream(String filepath，boolean append)
public void write(int a) 写一个字节出去
public void write(byte[] buffer) 写一个字节数组出去
public void write(byte[] buffer , int pos , int len) 写一个字节数组的一部分出去。
流的关闭与刷新
flush() 刷新流，还可以继续写数据
close() 关闭流，释放资源，但是在关闭之前会先刷新流。一旦关闭，就不能再写数据
换行
os.write(“\r\n”.getBytes())
// 1、创建一个文件字节输出流管道与目标文件接通
OutputStream os = new FileOutputStream("file-io-app/src/out04.txt" , true); // 追加数据管道
// OutputStream os = new FileOutputStream("file-io-app/src/out04.txt"); // 先清空之前的数据，写新数据进入// 2、写数据出去
// a.public void write(int a):写一个字节出去
os.write('a');
os.write(98);
os.write("\r\n".getBytes()); // 换行
// os.write('徐'); // [ooo]// b.public void write(byte[] buffer):写一个字节数组出去。
byte[] buffer = {'a' , 97, 98, 99};
os.write(buffer);
os.write("\r\n".getBytes()); // 换行byte[] buffer2 = "我是中国人".getBytes();
// byte[] buffer2 = "我是中国人".getBytes("GBK");
os.write(buffer2);
os.write("\r\n".getBytes()); // 换行// c. public void write(byte[] buffer , int pos , int len):写一个字节数组的一部分出去。
byte[] buffer3 = {'a',97, 98, 99};
os.write(buffer3, 0 , 3);
os.write("\r\n".getBytes()); // 换行// os.flush(); // 写数据必须，数据可能还在内存，刷新数据才能见效。并且可以继续使用流
os.close(); // 释放资源，包含了刷新的！关闭后流不可以使用了
字节流读取中文输出会乱码，或者内存溢出。
读取中文输出，字符流更合适，最小单位是按照单个字符读取的。
Reader
public FileReader(File file)
public FileReader(String pathname)
public int read() 每次读取一个字符返回，如果字符已经没有可读的返回-1
public int read(char[] buffer) 每次读取一个字符数组，返回读取的字符个数，如果字符已经没有可读的返回-1
每次读取一个字符， 读取中文字符不会出现乱码（如果代码文件编码一致） 性能较慢。
FileReader
public int read() 每次读取一个字符返回，如果字符已经没有可读的返回-1
// 目标：每次读取一个字符。
// 1、创建一个字符输入流管道与源文件接通
Reader fr = new FileReader("file-io-app\\src\\data06.txt");// 2、读取一个字符返回，没有可读的字符了返回-1
// int code = fr.read();
// System.out.print((char)code);
//
// int code1 = fr.read();
// System.out.print((char)code1);// 3、使用循环读取字符
int code;
while ((code = fr.read()) != -1){
System.out.print((char) code);
}
public int read(char[] buffer) 每次读取一个字符数组，返回读取的字符数，如果字符已经没有可读的返回-1
// 1、创建一个文件字符输入流与源文件接通
Reader fr = new FileReader("file-io-app/src/data07.txt");// 2、用循环，每次读取一个字符数组的数据。 1024 + 1024 + 8
char[] buffer = new char[1024]; // 1K个字符，不是1kb
int len;
while ((len = fr.read(buffer)) != -1) {
String rs = new String(buffer, 0, len);
System.out.print(rs);
}
每次读取一个字符数组，读取的性能得到了提升 读取中文字符输出不会乱码。
// 1、创建一个字符输出流管道与目标文件接通
// Writer fw = new FileWriter("file-io-app/src/out08.txt"); // 覆盖管道，每次启动都会清空文件之前的数据
Writer fw = new FileWriter("file-io-app/src/out08.txt", true); // 覆盖管道，每次启动都会清空文件之前的数据
// a.public void write(int c):写一个字符出去
fw.write(98);
fw.write('a');
fw.write('徐'); // 不会出问题了
fw.write("\r\n"); // 换行// b.public void write(String c)写一个字符串出去
fw.write("abc我是中国人");
fw.write("\r\n"); // 换行// c.public void write(char[] buffer):写一个字符数组出去
char[] chars = "abc我是中国人".toCharArray();
fw.write(chars);
fw.write("\r\n"); // 换行// d.public void write(String c ,int pos ,int len):写字符串的一部分出去
fw.write("abc我是中国人", 0, 5);
fw.write("\r\n"); // 换行// e.public void write(char[] buffer ,int pos ,int len):写字符数组的一部分出去
fw.write(chars, 3, 5);
fw.write("\r\n"); // 换行// fw.flush();// 刷新后流可以继续使用
fw.close(); // 关闭包含刷线，关闭后流不能使用
BufferedReader
try (
// 代码：UTF-8 文件 UTF-8 不会乱码
// 1、创建一个文件字符输入流与源文件接通。
// Reader fr = new FileReader("io-app2/src/data01.txt");// 代码：UTF-8 文件 GBK 乱码. abc 我 爱 你中国
// oo oo
Reader fr = new FileReader("D:\\resources\\data.txt");
// a、把低级的字符输入流包装成高级的缓冲字符输入流。
BufferedReader br = new BufferedReader(fr);
){String line;
while ((line = br.readLine()) != null){
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}
public BufferedReader(Reader r)
public String readLine() 读取一行数据返回，如果本行没有数据且下一行没有数据，返回null
try (
// 1、创建一个文件字符输入流与源文件接通。
Reader fr = new FileReader("io-app2/src/data01.txt");
// a、把低级的字符输入流包装成高级的缓冲字符输入流。
BufferedReader br = new BufferedReader(fr);
){// 2、用循环，每次读取一个字符数组的数据。 1024 + 1024 + 8
// char[] buffer = new char[1024]; // 1K字符
// int len;
// while ((len = br.read(buffer)) != -1) {
// String rs = new String(buffer, 0, len);
// System.out.print(rs);
// }String line;
while ((line = br.readLine()) != null){
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}
InputStreamReader
解决字符集编码不一样的问题：
// 代码UTF-8 文件 GBK "D:\\test.txt"
// 1、提取GBK文件的原始字节流。 abc 我
// ooo oo
InputStream is = new FileInputStream("D:\\test.txt");
// 2、把原始字节流转换成字符输入流
// Reader isr = new InputStreamReader(is); // 默认以UTF-8的方式转换成字符流。字符集不一样的话还是会乱码的 跟直接使用FileReader是一样的
Reader isr = new InputStreamReader(is , "GBK"); // 以指定的GBK编码转换成字符输入流 完美的解决了乱码问题BufferedReader br = new BufferedReader(isr);
String line;
while ((line = br.readLine()) != null){
System.out.println(line);
}
FileWriter
public FileWriter(File file)
public FileWriter(File file，boolean append)
public FileWriter(String filepath)
public FileWriter(String filepath，boolean append)
void write(int c)
void write(char[] cbuf)
void write(char[] cbuf, int off, int len)
void write(String str)
void write(String str, int off, int len)
void write(int c)
flush() 刷新流，还可以继续写数据
close() 关闭流，释放资源，但是在关闭之前会先刷新流。一旦关闭，就不能再写数据
实现数据追加
public FileWriter(String filepath，boolean append)
换行
fw.write(“\r\n”)
BufferedWriter
public BufferedWriter(Writer w)
public void newLine()
// 1、创建一个字符输出流管道与目标文件接通
Writer fw = new FileWriter("io-app2/src/out02.txt"); // 覆盖管道，每次启动都会清空文件之前的数据
//Writer fw = new FileWriter("io-app2/src/out02.txt", true); // 追加数据
BufferedWriter bw = new BufferedWriter(fw);// a.public void write(int c):写一个字符出去
bw.write(98);
bw.write('a');
bw.write('徐'); // 不会出问题了
bw.newLine(); // bw.write("\r\n"); // 换行// b.public void write(String c)写一个字符串出去
bw.write("abc我是中国人");
bw.newLine(); // bw.write("\r\n"); // 换行// c.public void write(char[] buffer):写一个字符数组出去
char[] chars = "abc我是中国人".toCharArray();
bw.write(chars);
bw.newLine(); // bw.write("\r\n"); // 换行// d.public void write(String c ,int pos ,int len):写字符串的一部分出去
bw.write("abc我是中国人", 0, 5);
bw.newLine(); // bw.write("\r\n"); // 换行// e.public void write(char[] buffer ,int pos ,int len):写字符数组的一部分出去
bw.write(chars, 3, 5);
bw.newLine(); // bw.write("\r\n"); // 换行// fw.flush();// 刷新后流可以继续使用
bw.close(); // 关闭包含刷线，关闭后流不能使用
OutputStreamWriter
// 1、定义一个字节输出流，默认是UTF-8
OutputStream os = new FileOutputStream("io-app2/src/out03.txt");// 2、把原始的字节输出流转换成字符输出流
// Writer osw = new OutputStreamWriter(os); // 以默认的UTF-8写字符出去 跟直接写FileWriter一样
Writer osw = new OutputStreamWriter(os , "GBK"); // 指定GBK的方式写字符到UTF-8文件中，这个测试就会乱码// 3、把低级的字符输出流包装成高级的缓冲字符输出流。
BufferedWriter bw = new BufferedWriter(osw);bw.write("我爱中国1~~");
bw.write("我爱中国2~~");
bw.write("我爱中国3~~");bw.close();
资源释放的方式
finally：在异常处理时提供finally块来执行所有清除操作，比如说IO流中的释放资源 特点：被finally控制的语句最终一定会执行，除非JVM退出。
finally代码块是最终一定要执行的，可以在代码执行完毕的最后用于释放资源。
try {
FileOutputStream fos = new FileOutputStream("test.txt");
fos.write(97);
} catch (IOException e) {
e.printStackTrace();
} finally{
}
public static void main(String[] args) {
InputStream is = null;
OutputStream os = null;
try {// System.out.println(10/ 0);
// 1、创建一个字节输入流管道与原视频接通
is = new FileInputStream("file-io-app/src/out04.txt");// 2、创建一个字节输出流管道与目标文件接通
os = new FileOutputStream("file-io-app/src/out05.txt");// 3、定义一个字节数组转移数据
byte[] buffer = new byte[1024];
int len; // 记录每次读取的字节数。
while ((len = is.read(buffer)) != -1){
os.write(buffer, 0 , len);
}
System.out.println("复制完成了！");// System.out.println( 10 / 0);
} catch (Exception e){
e.printStackTrace();
} finally {
// 无论代码是正常结束，还是出现异常都要最后执行这里//万一流最开始是null，后面又有异常，关流就会报错
System.out.println("========finally=========");
try {
// 4、关闭流。
if(os!=null)os.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
if(is != null) is.close();
} catch (IOException e) {
e.printStackTrace();
}
}System.out.println(test(10, 2));
}public static int test(int a , int b){
try {
int c = a / b;
return c;
}catch (Exception e){
e.printStackTrace();
return -111111; // 计算出现bug.
}finally {
System.out.println("--finally--");
// 哪怕上面有return语句执行，也必须先执行完这里才可以！
// 开发中不建议在这里加return ，如果加了，返回的永远是这里的数据了，这样会出问题！
return 100;
}
}
finally虽然可以用于释放资源，但太繁琐，下面的方法，自动释放资源、代码简洁。try只能放资源。
资源都是实现了Closeable/AutoCloseable接口的类对象。
try (
// 这里面只能放置资源对象，用完会自动关闭：自动调用资源对象的close方法关闭资源（即使出现异常也会做关闭操作）
// 1、创建一个字节输入流管道与原视频接通
InputStream is = new FileInputStream("file-io-app/src/out04.txt");
// 2、创建一个字节输出流管道与目标文件接通
OutputStream os = new FileOutputStream("file-io-app/src/out05.txt");// int age = 23; // 这里只能放资源
MyConnection connection = new MyConnection(); // 最终会自动调用资源的close方法
) {// 3、定义一个字节数组转移数据
byte[] buffer = new byte[1024];
int len; // 记录每次读取的字节数。
while ((len = is.read(buffer)) != -1){
os.write(buffer, 0 , len);
}
System.out.println("复制完成了！");} catch (Exception e){
e.printStackTrace();
}
class MyConnection implements AutoCloseable{
@Override
public void close() throws IOException {
System.out.println("连接资源被成功释放了！");
}
}
JDK 9释放资源的方式，仅做了解
// 这里面只能放置资源对象，用完会自动关闭：自动调用资源对象的close方法关闭资源（即使出现异常也会做关闭操作）
// 1、创建一个字节输入流管道与原视频接通
InputStream is = new FileInputStream("file-io-app/src/out04.txt");
// 2、创建一个字节输出流管道与目标文件接通
OutputStream os = new FileOutputStream("file-io-app/src/out05.txt");
try ( is ; os ) {
// 3、定义一个字节数组转移数据
byte[] buffer = new byte[1024];
int len; // 记录每次读取的字节数。
while ((len = is.read(buffer)) != -1){
os.write(buffer, 0 , len);
}
System.out.println("复制完成了！");} catch (Exception e){
e.printStackTrace();
}
缓冲流
BufferedInputStream
BufferedOutputStream
自带了8KB缓冲池、可以提高原始流读写数据的性能。
字节缓冲流
字节缓冲输入流： BufferedInputStream
public BufferedInputStream(InputStream is) 包装一下
public BufferedOutputStream(OutputStream os)
try (
// 这里面只能放置资源对象，用完会自动关闭：自动调用资源对象的close方法关闭资源（即使出现异常也会做关闭操作）
// 1、创建一个字节输入流管道与原视频接通
InputStream is = new FileInputStream("D:\\resources\\newmeinv.jpeg");
// a.把原始的字节输入流包装成高级的缓冲字节输入流
InputStream bis = new BufferedInputStream(is);
// 2、创建一个字节输出流管道与目标文件接通
OutputStream os = new FileOutputStream("D:\\resources\\newmeinv222.jpeg");
// b.把字节输出流管道包装成高级的缓冲字节输出流管道
OutputStream bos = new BufferedOutputStream(os);) {
// 3、定义一个字节数组转移数据
byte[] buffer = new byte[1024];
int len; // 记录每次读取的字节数。
while ((len = bis.read(buffer)) != -1){
bos.write(buffer, 0 , len);
}
System.out.println("复制完成了！");} catch (Exception e){
e.printStackTrace();
}
字节缓冲输出流：BufferedOutputStream
字符缓冲流 字符缓冲输入流：BufferedReader
字符缓冲输出流：BufferedWriter
对象序列化流
准备对象：
@Data
public class Student implements Serializable {
// 申明序列化的版本号码
// 序列化的版本号与反序列化的版本号必须一致才不会出错！例如当版本升级到2后，直接反序列化 1版本写入的对象文件就会报错local class incompatible
private static final long serialVersionUID = 1;
private String name;
private String loginName;
// transient修饰的成员变量不参与序列化了，避免被人获取到敏感信息
private transient String passWord;
private int age ;}
ObjectInputStream
// 1、创建对象字节输入流管道包装低级的字节输入流管道
ObjectInputStream is = new ObjectInputStream(new FileInputStream("io-app2/src/obj.txt"));// 2、调用对象字节输入流的反序列化方法
Student s = (Student) is.readObject();System.out.println(s);
ObjectOutputStream
序列化对象的输出流
// 1、创建学生对象
Student s = new Student("陈磊", "chenlei","1314520", 21);// 2、对象序列化：使用对象字节输出流包装字节输出流管道
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("io-app2/src/obj.txt"));// 3、直接调用序列化方法
oos.writeObject(s);// 4、释放资源
oos.close();
System.out.println("序列化完成了~~");
打印流
打印什么数据就是什么数据，使用方便。基于缓冲流，性能高效。
PrintStream
继承自字节输出流OutputStream，支持写字节数据
public PrintStream(OutputStream os)
public PrintStream(File f)
public PrintStream(String filepath)
public void print(Xxx xx) 打印任意类型的数据
PrintWriter
继承自字符输出流Writer，支持写字符数据
// 1、创建一个打印流对象
// PrintStream ps = new PrintStream(new FileOutputStream("io-app2/src/ps.txt"));
// PrintStream ps = new PrintStream(new FileOutputStream("io-app2/src/ps.txt" , true)); // 追加数据，在低级管道后面加True
// PrintStream ps = new PrintStream("io-app2/src/ps.txt" );
PrintWriter ps = new PrintWriter("io-app2/src/ps.txt"); // 打印功能上与PrintStream的使用没有区别ps.println(97);
ps.println('a');
ps.println(23.3);
ps.println(true);
ps.println("我是打印流输出的，我是啥就打印啥");ps.close()
System.out.println底层其实就是打印流
System.out.println("锦瑟无端五十弦");
System.out.println("一弦一柱思华年");// 改变输出语句的位置（重定向）
PrintStream ps = new PrintStream("io-app2/src/log.txt");
System.setOut(ps); // 把系统打印流改成我们自己的打印流System.out.println("庄生晓梦迷蝴蝶");
System.out.println("望帝春心托杜鹃");
Properties与属性文件
其实就是一个Map集合，但是我们一般不会当集合使用，因为HashMap更好用。
Properties代表的是一个属性文件，可以把自己对象中的键值对信息存入到一个属性文件中去。 属性文件：后缀是.properties结尾的文件,里面的内容都是 key=value，后续做系统配置信息的。
void load(InputStream inStream) 从输入字节流读取属性列表（键和元素对）
void load(Reader reader) 从输入字符流读取属性列表（键和元素对）
void store(OutputStream out, String comments) 将此属性列表（键和元素对）写入此 Properties表中，以适合于使用 load(InputStream)方法的格式写入输出字节流
void store(Writer writer, String comments) 将此属性列表（键和元素对）写入此 Properties表中，以适合使用 load(Reader)方法的格式写入输出字符流
public Object setProperty(String key, String value) 保存键值对（put）
public String getProperty(String key) 使用此属性列表中指定的键搜索属性值 (get)
public Set<String> stringPropertyNames() 所有键的名称的集合 (keySet()
写数据到配置文件
// 需求：使用Properties把键值对信息存入到属性文件中去。
Properties properties = new Properties();
properties.setProperty("admin", "123456");
properties.setProperty("dlei", "003197");
properties.setProperty("heima", "itcast");
System.out.println(properties);/**
参数一：保存管道 字符输出流管道
参数二：保存心得
*/
properties.store(new FileWriter("io-app2/src/users.properties") , "this is users!! i am very happy! give me 100!");
从配置文件读取数据
// 需求：Properties读取属性文件中的键值对信息。（读取）
Properties properties = new Properties();
System.out.println(properties);// 加载属性文件中的键值对数据到属性对象properties中去
properties.load(new FileReader("io-app2/src/users.properties"));System.out.println(properties);
String rs = properties.getProperty("dlei");
System.out.println(rs);
String rs1 = properties.getProperty("admin");
System.out.println(rs1);
流相关强大api
commons-io
官网：Commons IO – Commons IO Overview
// 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"));
jd7自己对代码的优化：New IO的技术
// Files.copy(Path.of("D:\\resources\\hushui.jpeg"), Path.of("D:\\resources\\hushui3.jpeg"));
FileUtils.deleteDirectory(new File("D:\\new"));
java基础 IO流相关推荐
- Java基础-IO流对象之数据流（DataOutputStream与DataInputStream）
Java基础-IO流对象之数据流(DataOutputStream与DataInputStream) 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.数据流特点 操作基本数据类型 ...
- Java基础IO流(二)字节流小案例
JAVA基础IO流(一)https://www.cnblogs.com/deepSleeping/p/9693601.html ①读取指定文件内容,按照16进制输出到控制台 其中,Integer.to ...
- # Java基础——IO流
Java基础--IO流 File类的使用(熟悉构造器和方法的使用) File类的一个对象,代表一个文件或一个文件目录(俗称:文件夹) File类的声明在java.io包下 文件和文件目录路径的抽象表示 ...
- Java基础IO流之字符流的使用
☆引言☆ 大家好,我是痛而不言笑而不语的浅伤.IO流分为字节流和字符流,而上一篇文章我们学习了字节流(Java基础IO流之字符流的使用),这篇文章带大家一起来学习字符流吧.对文章中描述错误的希望大家积 ...
- 黑马程序员-JAVA基础-IO流之字符流和字符流缓冲区
------- android培训.java培训.期待与您交流!------- Java 的IO 流 是实现输入和输出的基础,Java 中把不同的输入.输出源抽象表述为"流" (S ...
- Java基础—IO流
第一讲 IO概述 1. 流的概念 IO流即InputOutput的缩写,在Java中IO流用来处理设备之间的数据传输,Java对数据的操作是通过IO流的方式, 我们可以把IO流抽象的当作一根管道, ...
- java基础 io流 字节流 字符流 节点流 包装流 转换流 缓冲流 对象流 打印流 Properties类
目录 1.概念 2.常用的文件操作 2.1 创建文件 2.2 获取文件相关信息 2.3 目录的操作和文件删除 3. IO流原理及流的分类 3.1 流的分类 4.InputStream 字节输入流 4. ...
- JAVA基础 IO流技术学习笔记
目录 一.IO 流技术介绍 1.1 什么是IO? 1.2 流的概念 1.3 数据源 1.3.1 什么是数据源? 1.3.2数据源的分类 二.第一个简单的IO流程序 三.IO流经典写法(适用于任何 ...
- java基础--IO流之File类
一.File类概述 用来将文件或者文件夹封装成对象,方便对文件与文件夹的属性信息进行操作,File对象可以作为参数传递给流的构造函数 二.File类常见方法: 1,创建 boolean createN ...
- Java基础——IO流
IO流基础知识内容: 1.java.io包下 File类:java程序中的此类的一个对象,就对应着硬盘中的一个文件或网络中的一个资源. File file1 = new File("d:\\ ...
最新文章
- Linux之链接命令
- 错误消息“禁止您没有访问此服务器上的权限/”（关闭）
- Python字符串基本操作
- CTFshow 命令执行 web40
- Web API应用架构设计分析（2）
- 二级c语言无纸化三合一_学习攻略|计算机二级考试重点及注意事项
- Deltix Round, Summer 2021 (open for everyone, rated, Div. 1 + Div. 2)
- WeakReference带来了什么
- 世界首富比尔·盖茨的母亲有多厉害？
- 编写android驱动程序,Android 驱动编写LED-NDK程序
- 建立网站的全套流程与详细解释（转载）
- 电子工程可以报考二建_二建报考要求是工程类专业怎么办？非工程类专业可以报名吗？...
- 黑客已经盗了 $15,945,221.72 美元！
- 【转】LDA-linear discriminant analysis
- 前端css简易拾色器
- 10.柱状图-----人口普查各地区人口排行榜
- 威斯敏斯特教堂（西敏寺）墓碑上的话（WestMinster Abbey，When I was young and fre
- 考拉：你以为我想呆萌？幼年吃屎长大磕毒，差点就没活下来
- 【Nginx】记录 nginx 配置文件中 location下根据 ua (user-agent) 判断移动端和电脑端不同浏览器来源
- canvas实现图片旋转