|
IO流
IO流是单向传递的
IO流是面向流传输数据的
IO流按照流向分类：输入流、输出流
IO流按照类型分类：字节流、字符流
IO流用于处理设备之间的数据传输
Java中所有对流的操作都在io包下
IO流
字节流
字符流
InputStream
OutputStream
BufferedInputStream
BufferedOutputStream
Reader
Writer
BufferedReader
BufferedWriter
IO流的整体框架
//Writer
import java.io.FileWriter;
import java.io.IOException;
public class Demo1 {
public static void main(String[] args) throws IOException {
// 字符输出流
//实例化FileWriter对象
FileWriter fileWriter = new FileWriter("C:\\Users\\fuwei\\Desktop\\Test\\aa.txt");
char[] arr={'a','b','c','d'};
//向文件里写入数字
fileWriter.append("asdd");
//向文件里写入字节数组
fileWriter.write(arr);
//向文件里写入字符串
fileWriter.write("你好，世界");
//对通道进行刷新，以便写入
fileWriter.flush();
}
}
//Reader
import java.io.FileReader;
import java.io.IOException;
public class Demo1 {
public static void main(String[] args) throws IOException {
// 字符输入流
FileReader fileReader = new FileReader("C:\\Users\\fuwei\\Desktop\\Test\\aa.txt");
int read = fileReader.read();//此时需要抛出异常
System.out.println((char)read);//这种方法只能读取单个字符
//读取多个字符
while (true){
int read1 = fileReader.read();
if (read1==-1){
break;
}
System.out.println((char)read1);
}
//另一种读取多个字符
int length = 0;
while ((length = fileReader.read())!=-1){
System.out.println((char)length);
}
}
}
//通过Writer和Reader实现文件的读取
import java.io.FileWriter;
import java.io.IOException;
public class Demo1 {
public static void main(String[] args) throws IOException {
FileReader read = new FileReader("C:\\Users\\fuwei\\Desktop\\Test\\aa.txt");
FileWriter write = new FileWriter("C:\\Users\\fuwei\\Desktop\\Test\\cc.txt");
char[] arr = new char[3];
int length= 0;
while ((length=read.read(arr))!=-1){
/*write.write(new String(arr,0,length));
//此时数据是在通道里一定要flush
write.flush();*/
write.write(arr, 0, length);
write.flush();
}
}
}
//BufferedReader和BufferedWriter实现文件的读取
import java.io.*;
public class Demo2 {
public static void main(String[] args) throws IOException {
//字节缓冲区
FileReader fr = new FileReader("C:\\Users\\fuwei\\Desktop\\Test\\bb1.txt");
BufferedReader br = new BufferedReader(fr);
FileWriter fw = new FileWriter("C:\\Users\\fuwei\\Desktop\\Test\\bb11.txt");
BufferedWriter bw = new BufferedWriter(fw);
String str = null;
while ((str=br.readLine())!=null){
bw.write(str);
bw.flush();
}
}
}
//InputStream、OutputStream字节流的简单应用
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class Demo1 {
// 字节流
public static void main(String[] args) throws IOException {
FileInputStream fis = new FileInputStream("C:\\Users\\fuwei\\Desktop\\Test\\picture.png");
FileOutputStream fos = new FileOutputStream("C:\\Users\\fuwei\\Desktop\\Test\\pp\\picture1.png");
System.out.println(fis.available());
byte[] arr = new byte[1024];
int length = 0;
while ((length=fis.read(arr))!=-1){
fos.write(arr,0,length);
fos.flush();
}
}
}
//Buffered所修饰的字节流效果和字符流的效果一样
//注意点
int available() 返回下一次对此输入流调用的方法可以不受阻塞地从此输入流读取（或跳过）的估计剩余字节数。（这个方法是在字节流中使用）
String readLine() 读取一行数据 放回字符串类型 读取不到返回null.(这个方法是在字符流中应用的)
//对文件进行简单的加密
import java.io.*;
/*
* 文件、视频等加密
* */
public class Demo1 {
public static void main(String[] args) {
copy("C:\\Users\\fuwei\\Desktop\\Test\\ff.txt", "C:\\Users\\fuwei\\Desktop\\Test\\ff1.txt");
}
public static void copy(String source,String target){
try (InputStream is = new FileInputStream(source); OutputStream os = new FileOutputStream(target)){
//实例化一个字节数组，用来存储每次读取到的数据
byte[] array = new byte[3];
// 声明一个变量，存储每次读取的字节数量
int length = 0;
//循环读取
while ((length=is.read(array))!=-1){
/*
* 如果需要增加加密操作，需要增加这一步
* */
array = lock(array);
//将读取到的数据写入到输出流中
os.write(array, 0, length);
os.flush();
}
System.out.println("文件拷贝完成");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
/*
* 实际的加密就是对元数据的加密
* 对一个字节数组中的数据进行加密、解密
* */
private static byte[] lock(byte[] array){
// 无论是加密还是解密，都要有一个密钥
int secury = 1234;
for (int i = 0;i<array.length;i++){
//一个数字对自己异或两次得到自身
//所以如果想要获得加密之后的文件还原，就需要对加密之后的文件再次执行一下，这样就可以还原了
array[i] ^= secury;
}
return array;
}
}
//创建多级目录
import java.io.File;
import java.io.IOException;
public class Demo1 {
public static void main(String[] args) {
/*
* 创建多级目录
* */
File file = new File("C:\\Users\\fuwei\\Desktop\\Test\\aaa\\bbbb\\cccc\\ddd\\haha.txt");
// 判断文件是否存在
if (!file.exists()){
// 如果文件不存在，获取父级节点
File parentFile = file.getParentFile();
// 判断父亲节点是否存在
if (!parentFile.exists()){
// 如果父亲节点不存在，所以创建父亲节点的目录
parentFile.mkdirs();
}
// 随后在创建文件
try {
file.createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
//删除多级目录里的文件
import java.io.File;
public class Demo4 {
public static void main(String[] args) {
/*
* 删除文件
* */
File file = new File("C:\\Users\\fuwei\\Desktop\\Test");
del(file);
}
public static boolean del(File file){
// 判断这个文件是否存在
// if (file.exists()){
// 获取文件的子目录：把子目录封装成一个数组
/* File[] files = file.listFiles();
for (int i = 0 ;i < files.length;i++){
del(file);
}*/
// }
// 首先判断是否是目录
if (file.isDirectory()){
// 获取目录下的子元素
File[] files = file.listFiles();
// 循环获取每一个元素
for (int i = 0;i<files.length;i++){
del(files[i]);
}
}
//删除文件，此时的file已经递归调用到最底层了
return file.delete();
}
}
|