文件目录结构
注：io流的 *** 作 基本都是固定的 1.实例化节点0流 2.实例化处理流3.数据的 *** 作4.流的关闭
一.Fileimport org.junit.jupiter.api.Test;
import java.io.File;
import java.io.IOException;
import java.util.Date;
//file 指文件 或 文件目录 俗称文件夹
//相对路径 从module下开始
//分隔符 windows dos “/” unix: 详情可参考file中的separator
public class FileTest {
@Test
public void InstantiateFile() {
//创建file方式一 File(filepath)
//此时只是创建一个内存对象 并未 *** 作
File file1 = new File("hello.txt");
File file2 = new File("E:\Jdbc\IOTe\he.txt");
// System.out.println(file1);
// System.out.println(file2);
//构造器2 File(String parent, String child)
File file3 = new File("E:\Jdbc\","IOTe");
System.out.println(file3);
//构造器3 (File parent, String child)
File file4 = new File(file3,"h.txt");
// System.out.println(file4);
}
@Test
public void CommonMethod1(){
//常用方法
File file = new File("hello.txt");
//绝对路径
System.out.println(file.getAbsoluteFile());
//是否可读
System.out.println(file.canRead());
//是否可写
System.out.println(file.canWrite());
//获取名字
System.out.println(file.getName());
//获取相对路径
System.out.println(file.getPath());
//获取上层路径 若无 返回null 因为是相对路径 所以是null
System.out.println(file.getParent());
System.out.println(file.getParentFile());
//获取文件长度 字节数 不能获取目录
System.out.println(file.length());
//最后一次的修改时间 毫秒值
System.out.println(new Date(file.lastModified()));
}
@Test
public void CommonMethod2(){
//关于文件目录的方法
//目录必须存在
File file = new File("E:\Java");
String[] list = file.list();
for (String s: list) {
System.out.println(s);
}
//列出全路径
System.out.println();
System.out.println();
File[] file1 = file.listFiles();
for (File f: file1) {
System.out.println(f);
}
}
@Test
public void ParticularMethod(){
//特殊方法renameTo:public boolean renameTo(File dest) 将文件一的内容复制到文件二当中
File f1 = new File("hello.txt");//文件1必须存在
File f2 = new File("hi.txt");//文件2必须不存在，存在即false
boolean b = f1.renameTo(f2);
System.out.println(b);
}
@Test
public void JudgeMethod(){
//常见的判断方法
File file = new File("hello.txt");
//判断是否是文件目录
System.out.println(file.isDirectory());
//判断是否是文件
System.out.println(file.isFile());
//判断是否存在
System.out.println(file.exists());
//是否可读
System.out.println(file.canRead());
//是否可写
System.out.println(file.canWrite());
//是否可隐藏
System.out.println(file.isHidden());
}
@Test
public void CreateFile() throws IOException {
//创建硬盘中对应的文件或文件目录 本身就存在 不创建并返回false
//file类的创建、删除、重命名、修改时间等方法均需抛异常，且file不存在修改文件的内容等 *** 作
//修改内容等 *** 作需要用到IO流去 *** 作
File file = new File("a.txt");
System.out.println(file.createNewFile());
File directory = new File("D:\file");
//文件上层目录存在创建，不存在则不创建
System.out.println(directory.mkdir());
//文件上层目录存在创建，不存则一并创建
System.out.println(directory.mkdirs());
}
}
二.节点流
1.FileReader
public class FileReaderTest {
@Test
public void test1() {
//为了一定能关闭流的 *** 作，要用try catch
FileReader fr = null;
try {
//1.file 的实例化 指出 *** 纵的对象
File f = new File("hi.txt");
//2.提供具体的流
fr = new FileReader(f);
//3.数据的读入 read()返回读入的一个字符，到达末尾返回-1.
int data = fr.read();
//返回的是unicode码 即a=97 所以下面用到转换
while (data != -1) {
System.out.print((char) data);
data = fr.read();
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
//这个是防止fr在实例化时失败，即没有fr对象
assert fr != null;
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
//4.流的关闭 *** 作
//对于jvm的垃圾回收功能 数据库连接 输入输出流 Socket连接 jvm回收不了，
//需要手动关闭
}
@Test
public void test2() {
//read() 进阶版
FileReader fr = null;
try {
File f = new File("hi.txt");
fr = new FileReader(f);
//read(char[] cb):返回每次读入cb数组中字符的个数 如果读到最后一个值返回-1
char[] cb = new char[5];
int len;
while ((len = fr.read(cb)) != -1) {
//正确的 即读进去几个就遍历几个
//方式一
// for (int i = 0; i
2.FileWriter
public class FileWriterTest {
@Test
//1.写入的 *** 作中，允许文件不存在，如果不存在则在输出的过程直接进行创建
//2.如果本身文件就存在：
// （1）:writer(file)/writer(file,false) 则会对原文件进行覆盖
// （2）:writer(file,true)则会对原文件进行追加内容
public void test1() throws IOException {
//1.file 的实例化
File f = new File("hello.txt");
//2.FileWrite的实例化
FileWriter fw = new FileWriter(f);
//3.对数据进行 *** 作
fw.write("Position");
fw.write("You can see ?");
//4.进行资源的关闭
fw.close();
}
@Test
public void copy() throws Exception {
//1.实例化file
File file = new File("hi.txt");
File fl = new File("hi1.txt");
//2.创建输入输出流对象
FileReader fr = new FileReader(file);
FileWriter fw = new FileWriter(fl, true);
//3. *** 作数据
char[] cb = new char[5];
int len;
while ((len = fr.read(cb)) != -1) {
//我的里面8个字符 第一次len=5，第二次len=3
String str = new String(cb, 0, len);
fw.write(str, 0, len);
}
//4.资源关闭
fw.close();
fr.close();
}
}
3.FileInputStream 和 FileOutputStream
public class FileInputOutputStream {
@Test
public void copyImg() {
//注 字节流可以可以拿来复制文本文件的东西 在内存层面读可能会出出现乱码，但是复制好之后不会出现乱码
//数组的长度，不同长度 影响读取的速度 并非越大越好
FileOutputStream fos = null;
FileInputStream fis = null;
try {
//1.实例化file 注意路径符\
File file1 = new File("src\img.png");
File file2 = new File("2.png");
//2.实例化流
fos = new FileOutputStream(file2);
fis = new FileInputStream(file1);
//3. *** 作数据
byte[] by = new byte[5];
int len;
while((len=fis.read(by)) != -1){
fos.write(by,0,len);
}
} catch (IOException e) {
e.printStackTrace();
}finally {
//流的关闭
if (fos != null) {
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
三.处理流
1.缓冲流 BufferedInputStream BufferedOutputStream
public class Buffer1 {
@Test
public void copyImgPlus() throws IOException {
//1.实例化file
File file1 = new File("src\img.png");
File file2 = new File("3.png");
//2.创建节点流
FileInputStream fis = new FileInputStream(file1);
FileOutputStream fos = new FileOutputStream(file2);
//3.创建处理流 处理流就是套接在节点流之上
//缓冲流作用 增加读写速度（原因是因为内部提供了一个缓冲区）
BufferedInputStream bis = new BufferedInputStream(fis);
BufferedOutputStream bos = new BufferedOutputStream(fos);
//bis.flush;刷新缓冲区，Java后台自动刷新所以不用写
//4. *** 作数据
byte[] by = new byte[5];
int len;
while ((len=bis.read(by)) != -1){
bos.write(by,0,len);
}
//5.流的关闭 先关外层的再关内层的 关闭外层流的同时，内层流也会自动关闭
// 然后 try catch 快捷建 Alt Shift z
bos.close();
bis.close();
}
@Test
public void copyPlus() {
//用匿名对象 实例化file 实例化流
BufferedReader br = null;
BufferedWriter bw = null;
try {
br = new BufferedReader(new FileReader(new File("hi.txt")));
bw = new BufferedWriter(new FileWriter(new File("hi1.txt")));
// *** 作数据 方式一
// char[] cr = new char[5];
// int len;
// while ((len=br.read(cr)) != -1){
// bw.write(cr,0,len);
// }方式二 缓冲流里有直接读取一行的方法
String data;
while((data=br.readLine()) !=null){
// bw.write(data); 此时数据没有换行
//加换行符 或者直接 bw.newline()
bw.write(data+"n");
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//流的关闭
if (bw != null) {
try {
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (br != null) {
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
@Test
//加密 *** 作
public void encrypt() {
//实例化
FileInputStream fis = null;
FileOutputStream fos = null;
try {
fis = new FileInputStream("24.png");
// public FileInputStream(String name) 有这个形参 所以直接可以放文件路径
fos = new FileOutputStream("28.png");
// *** 作数据
byte[] bt = new byte[10];
int len;
while ((len=fis.read(bt)) != -1){
//主要就是进行异或运算 两次异或之后就得到了原来的文件
for (int i = 0; i < len; i++) {
bt[i] = (byte) (bt[i] ^ 2);
}
fos.write(bt,0,len);
}
} catch (IOException e) {
e.printStackTrace();
}finally {
//流的关闭
if (fos != null) {
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
2.转换流 InputStreamReader OutputStreamWriter
public class ChangeStream {
//转换流
//InputStreamReader 将字节的输入流转换为字符的输入流
//OutputStreamWriter 将字符的文件 转换为字节的文件
//作用 实现流之间的转换
// 解码 字节——>字符 编码 字符->字节
@Test
public void changeOut() throws IOException {
//1.实例化流 节点流
FileInputStream fis = new FileInputStream("hi.txt");
//2.实例话处理流（处理流）
InputStreamReader isr = new InputStreamReader(fis,"utf-8");
//次方法有 只有一个参数 参数为节点流对象 默认为的字符集是编译软件所设置的 两个参数的 第二个参数为文件保存时的字符集
//3. *** 作数据
char[] ca = new char[5];
int len;
while ((len= isr.read(ca)) != -1){
for (int i = 0; i < len; i++) {
System.out.print(ca[i]);
}
}
//4.流的关闭 容易观看 未用try catch
}
@Test
public void changeInOut() throws Exception {
//用字节流读取utf-8格式的文件 再以 gbk的形式输出
FileInputStream fis = new FileInputStream("hi.txt");
InputStreamReader isr = new InputStreamReader(fis);
FileOutputStream fos = new FileOutputStream("hi_gbk.txt");
OutputStreamWriter osw = new OutputStreamWriter(fos,"gbk");
char[] ca = new char[5];
int len;
while ((len= isr.read(ca)) != -1){
osw.write(ca,0,len);
}
isr.close();
osw.close();
}
}
3.对象流 ObjectInputStream ObjectOutputStream
public class ObjectStream {
//ObjectInputStream ObjectOutputStream
//作用 用于存储和读取基本类型的数据或对象的处理流 持久化Java中的数据
@Test
public void xlh() throws Exception {
//序列化 过程：将内存层面的数据存到磁盘中或者进行网络传输 ObjectOutputStream
//1.创建一个序列化对象 后缀名可以随意，因为不是用来给我们看的
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("result.sj"));
//2.把对象写进去
String s="我是最帅的";
oos.writeObject(s);
oos.flush();
//刷新 *** 作
oos.writeObject(new Teacher(99,"帅B"));
oos.flush();
//3.关闭流 记得try catch finally alt shift z
oos.close();
}
@Test
public void reverseXlh() throws Exception {
//反序列化 就是把序列化的数据还原到内存层面
//1.创建反序列化对象
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("result.sj"));
//2.把对象读出来
String s = (String) ois.readObject();
Teacher teacher = (Teacher) ois.readObject();
//测试数据是否读出
System.out.println(s);
System.out.println(teacher);
//3.关闭流 记得try catch finally alt shift z
ois.close();
}
}
注：关于序列化
public class Teacher implements Serializable {
//要想序列化一个对象 需要满足的条件
//1.继承 Serializable接口（该接口并没有具体的方法（这样的接口一般叫做标识））
//2.实例化一个常量 serialVersionUID = 42L
//3.注 static transient 修饰的成员变量不能序列化
//特殊： 当你所序列化的对象中含有其他对象属性没继承Serializable接口 也会出现问题
//解决： 把其他对象也实现此接口并赋予一个值serialVersionUID
private int id;
private String name;
//自己随便写一个 long类型的 如果未写 会自动生成 不过当再次修改之后再进行反序列化会出现一些问题
//作用 就是标识 就像身份z号一样
private static final long serialVersionUID =456464445452L;
public Teacher() {
}
public Teacher(int id, String name) {
this.id = id;
this.name = name;
}
@Override
public String toString() {
return "Teacher{" +
"id=" + id +
", name='" + name + ''' +
'}';
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public static long getSerialVersionUID() {
return serialVersionUID;
}
}
四.其他的流（部分流未写）
标准的输入输出流以及打印流
public class OtherStream {
public static void main(String[] args) throws Exception {
//标准的输入流： System.in 默认从键盘输入
//标准的输出流： System.out 默认从控制台输出
//setIn （InputStream）设置输入 setOut(PrintStream) 设置输出
// 键盘输入字符串->“整行”输出大写字符串 exit结束(@Test执行时会执行不了)
//1.接收数据 用转换流的原因 字节流才能使用System.in 用完之后要转换成字符
System.out.println("请输入想要转换的字符串");
InputStreamReader isr = new InputStreamReader(System.in);
//2.把数据放入缓冲流（因为缓冲流有接收一行的方法）
BufferedReader br = new BufferedReader(isr);
//3。 *** 作数据
while (true){
String data= br.readLine();
//不区分大小写
if ("exit".equalsIgnoreCase(data)) {
break;
}
//转为大写
String result = data.toUpperCase();
System.out.println(result);
}
//4.关闭流（记得try catch finally）
br.close();
}
@Test
public void printStream() {
//打印流
//PrintStream PrintWriter
//特点 1.不会抛IOException 2.只能接受相对应的流 3.都有自动flush()功能
//4.打印的所有字符都是使用平台的默认字符转换编码转换为字节，在需要使用字符而不是字节的情况下用PrintWriter
//1.实例化 注意不能用FileWrite printStream不能接收FileWrite的对象
PrintStream ps = null;
try {
FileOutputStream fos = new FileOutputStream("hi21.txt");
//2.创建打印流 true 是设置自动刷新（换行即刷新）
ps = new PrintStream(fos,true);
System.setOut(ps);
for (int i = 50; i <255; i++) {
//输出的是
System.out.print((char)i);
//实现每读取5个数据进行换行
if (i % 50==0) {
System.out.println();
}
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} finally {
if (ps != null) {
try {
ps.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）