Java高级：IO流、File类、抽象基类、节点流、缓冲流、图片加密、其他流、对象流、随机存取文件流
2024-05-25 01:38:14
package com.atguigu.java3;import org.junit.Test;import java.io.File;
import java.io.IOException;
import java.util.Date;/*** File类的使用：** 1.File类的一个对象，代表一个文件或者一个文件目录（俗称：文件夹）* 2.File类声明在java.io包下* 3.File类中涉及到关于文件或者文件目录的创建、删除、重命名、修改时间、查询文件大小等方法* 并未涉及到写入或者读取文件内容的操作。如果需要读取或者写入文件内容，必须使用IO流来完成。* 4.后续File类的对象常会作为参数传递到流的构造器中，指明读取或者写入的“终点”。** @author* @create 2022-07-19 13:23*/
public class FileTest {/*1.如何创建File类的实例File(String filePath)File(String parentPath,String childPath)File(File parentPath,String childPath)2.相对路径：相较于某个路径下指明的路径绝对路径：包含盘符在内的文件或文件目录的路径3.路径分隔符windows:\\unix:/*/@Testpublic void test1(){//构造器1：File file1 = new File("hello.txt");//相对于当前moduleFile file2 = new File("E:\\workspace_idea\\JavaSenior\\day08\\he.txt");System.out.println(file1);System.out.println(file2);//构造器2：File file3 = new File("E:\\workspace_idea","JavaSenior");System.out.println(file3);//构造器3：File file4 = new File(file3,"hi.txt");System.out.println(file4);}/* File类的获取功能 public String getAbsolutePath()：获取绝对路径 public String getPath() ：获取路径 public String getName() ：获取名称 public String getParent()：获取上层文件目录路径。若无，返回null public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。 public long lastModified() ：获取最后一次的修改时间，毫秒值下面的两个方法适用于文件目录 public String[] list() ：获取指定目录下的所有文件或者文件目录的名称数组 public File[] listFiles() ：获取指定目录下的所有文件或者文件目录的File数组*/@Testpublic void test2(){File file1 = new File("hello.txt");File file2 = new File("E:\\io\\hi.txt");System.out.println(file1.getAbsolutePath());System.out.println(file1.getPath());System.out.println(file1.getName());System.out.println(file1.getParent());System.out.println(file1.length());System.out.println(new Date(file1.lastModified()));System.out.println();System.out.println(file2.getAbsolutePath());System.out.println(file2.getPath());System.out.println(file2.getName());System.out.println(file2.getParent());System.out.println(file2.length());System.out.println(new Date(file2.lastModified()));}@Testpublic void test3(){File file = new File("E:\\workspace_idea\\JavaSenior");String[] list = file.list();for (String i : list){System.out.println(i);}File[] files = file.listFiles();for (File i : files){System.out.println(i);}}/* File类的重命名功能 public boolean renameTo(File dest):把文件重命名为指定的文件路径比如：file1.renameTo(file2)为例：要想保证是成功的返回true,需要保证file1是真实存在的，并且file2不是真实存在的。*/@Testpublic void test4(){File file1 = new File("hi.txt");File file2 = new File("E:\\io\\hi.txt");boolean renameTo = file2.renameTo(file1);System.out.println(renameTo);}/* File类的判断功能 public boolean isDirectory()：判断是否是文件目录 public boolean isFile() ：判断是否是文件 public boolean exists() ：判断是否存在 public boolean canRead() ：判断是否可读 public boolean canWrite() ：判断是否可写 public boolean isHidden() ：判断是否隐藏*/@Testpublic void test5(){File file1 = new File("hi.txt");System.out.println(file1.isDirectory());System.out.println(file1.isFile());System.out.println(file1.exists());System.out.println(file1.canRead());System.out.println(file1.canWrite());System.out.println(file1.isHidden());File file2 = new File("hello.txt");System.out.println(file2.isDirectory());System.out.println(file2.isFile());System.out.println(file2.exists());System.out.println(file2.canRead());System.out.println(file2.canWrite());System.out.println(file2.isHidden());}/* File类的创建功能 public boolean createNewFile() ：创建文件。若文件存在，则不创建，返回false public boolean mkdir() ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。 public boolean mkdirs() ：创建文件目录。如果上层文件目录不存在，一并创建注意事项：如果你创建文件或者文件目录没有写盘符路径，那么，默认在项目路径下。 File类的删除功能 public boolean delete()：删除文件或者文件夹删除注意事项：Java中的删除不走回收站。要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录*/@Testpublic void test6() throws IOException {//文件的创建File file = new File("hello.txt");if (!file.exists()){file.createNewFile();System.out.println("创建成功");}else {//文件存在file.delete();System.out.println("删除成功");}}@Testpublic void test7(){//文件目录的创建File file1 = new File("E:\\io\\io1\\io3");boolean mkdir = file1.mkdir();if(mkdir){System.out.println("创建成功1");}File file2 = new File("E:\\io\\io1\\io4");boolean mkdir1 = file2.mkdirs();if(mkdir1){System.out.println("创建成功2");}//要想删除成功，io4文件目录下面不能有目录或者文件File file3 = new File("E:\\io\\io1\\io4");}
}
package com.atguigu.java;import org.junit.Test;import java.io.*;/*** 一、流的分类：* 1.按照操作的数据单位：字节流、字符流* 2.数据的流向：输入流、输出流* 3.流的角色：节点流、处理流** 二、流的体系结构* 抽象基类 节点流(文件流) 缓冲流（处理流的一种）* InputStream FileInputStream read(byte[] buffer) BufferedInputStream read(byte[] buffer)* OutputStream FileOutputStream write(byte[] buffer,0,len) BufferedOutputStream write(byte[] buffer,0,len) / flush()* Reader FileReader read(char[] cbuf) BufferedReader read(char[] cbuf / readLine())* Writer FileWriter write(char[] cbuf,0,len) BufferedWriter write(char[] cbuf,0,len) / flush()** @author* @create 2022-07-19 21:58*/
public class FileReadWriterTest {public static void main(String[] args) {}/*将day09下面的hello.txt文件读入到程序中，并输出到控制台。说明点：1.read()的理解：返回读取的一个字符。如果达到文件末尾，就返回-1.2.异常的处理：为了保证流资源一定可以执行关闭操作需要使用try-catch-finally处理异常。3.读入的文件一定要存在，否则会报FileNotFoundException.*/@Testpublic void test() {FileReader fr = null;try {//1.实例化File类的对象，指明要操作的文件File file = new File("hello.txt");//相较于当前的Module//2.提供具体的流fr = new FileReader(file);//3.数据的读入过程//read():返回读入的一个字符。如果达到文件末尾，返回-1.//方式一
// int data = fr.read();
// while (data != -1){
// System.out.print((char)data);
// data = fr.read();
// }//方式二：语法上的修改int data;while ((data = fr.read()) != -1){System.out.println((char)data);}} catch (IOException e) {e.printStackTrace();} finally {//4.流的关闭操作：一定要求手动关闭！否则容易导致内存泄漏问题try {if (fr != null){fr.close();}} catch (IOException e) {e.printStackTrace();}}}//对read()操作升级：使用read的重载方法。@Testpublic void testFileReader1() {FileReader fr = null;try {//1.File类的实例化File file = new File("hello.txt");//2.FileReader流的实例化fr = new FileReader(file);//3.读入的具体的操作细节//read(char[] cbuf):返回每次读入cbuf数组中的字符的个数。如果达到文件末尾返回-1.char[] cbuf = new char[5];int len;while ((len = fr.read(cbuf)) != -1){
// //方式一：
// //错误的写法：for (int i = 0;i < cbuf.length;i++){System.out.print(cbuf[i]);}
// //正确的写法
// for (int i = 0;i < len;i++){
// System.out.print(cbuf[i]);
// }//方式二：错误的写法，对应着方式一的错误写法
// String str = new String(cbuf);
// System.out.print(str);//正确的写法：String str = new String(cbuf,0,len);System.out.print(str);}} catch (IOException e) {e.printStackTrace();} finally {if (fr != null){try {//4.资源的关闭fr.close();} catch (IOException e) {e.printStackTrace();}}}}/*//从内存中写出数据到硬盘的文件里。说明：1.输出操作。对应的File可以不存在，会自动创建此文件2.File对应的硬盘中的文件如果不存在:输出过程就自动创建此文件File对应的硬盘中的文件如果存在：如果流使用的构造器是FileWriter(file,false)或者FileWriter(file)：对原有的文件覆盖如果流使用的构造器是FileWriter(file,true)：不会对原有的文件覆盖，而是追加内容。*/@Testpublic void testFileWriter() {FileWriter fw = null;try {//1.提供File类的对象，指明写出到的文件。File file = new File("hello1.txt");//2.提供FileWriter的对象，用于数据的写出fw = new FileWriter(file,true);//3.写出操作fw.write("I have a dream!\n");fw.write("you need have a dream too!");} catch (IOException e) {e.printStackTrace();} finally {if (fw != null){//4.流的关闭try {fw.close();} catch (IOException e) {e.printStackTrace();}}}}@Testpublic void test2() {FileReader fr = null;FileWriter fw = null;try {//1.实例化File文件,指明写入和读出的文件File srcFile = new File("hello.txt");File destFile = new File("hello2.txt");//2.创建输入和输出流fr = new FileReader(srcFile);fw = new FileWriter(destFile);//3.数据的读入和写出操作char[] cbuf = new char[5];int len;//记录每次读入到cbuf中的长度。while ((len = fr.read(cbuf)) != -1){fw.write(cbuf,0,len);//每次写出len个字符}} catch (IOException e) {e.printStackTrace();} finally {//4.关闭流资源try {if (fr != null){fr.close();}} catch (IOException e) {e.printStackTrace();}try {if (fw != null){fw.close();}} catch (IOException e) {e.printStackTrace();}}}
}
package com.atguigu.java;import org.junit.Test;import java.io.*;/*** 测试FileInputStream FileOutputStream的使用** 结论：* 1.对于文本文件(.txt .java .c .c++)，使用字符流来处理* 2.对于非文本文件(.jpg .doc .avi .mp4 .mp3 .ppt)，使用字节流来进行处理** @author* @create 2022-07-20 15:14*/
public class FileInputOutputStreamTest {//使用字节流FileInputStream是可能出现乱码的。@Testpublic void test() {FileInputStream fis = null;try {//1.造文件File file = new File("hello.txt");//2.造流fis = new FileInputStream(file);//3.读数据byte[] buffer = new byte[5];int len;//记录每次读取的字节的个数。while ((len = fis.read(buffer)) != -1){String str = new String(buffer,0,len);System.out.print(str);}} catch (IOException e) {e.printStackTrace();} finally {if (fis != null){//4.try {fis.close();} catch (IOException e) {e.printStackTrace();}}}}/*实现对照片的复制操作*/@Testpublic void testInputOutputStreamTest() {FileInputStream fis = null;FileOutputStream fos = null;try {//File srcFile = new File("润泽.jpg");File destFile = new File("润泽1.jpg");//fis = new FileInputStream(srcFile);fos = new FileOutputStream(destFile);//byte[] buffer = new byte[5];int len;while ((len = fis.read(buffer)) != -1){fos.write(buffer,0,len);}System.out.println("复制成功");//} catch (IOException e) {e.printStackTrace();} finally {if (fis != null){try {fis.close();} catch (IOException e) {e.printStackTrace();}}if (fos != null){try {fos.close();} catch (IOException e) {e.printStackTrace();}}}}//指定路径下文件的复制的方法public void copyFile(String srcPath,String destPath){FileInputStream fis = null;FileOutputStream fos = null;try {//File srcFile = new File(srcPath);File destFile = new File(destPath);//fis = new FileInputStream(srcFile);fos = new FileOutputStream(destFile);//byte[] buffer = new byte[5];int len;while ((len = fis.read(buffer)) != -1){fos.write(buffer,0,len);}System.out.println("复制成功");//} catch (IOException e) {e.printStackTrace();} finally {if (fis != null){try {fis.close();} catch (IOException e) {e.printStackTrace();}}if (fos != null){try {fos.close();} catch (IOException e) {e.printStackTrace();}}}}@Testpublic void testCopyFile() {long start = System.currentTimeMillis();String srcPath = "";String destPath = "";
// copyFile();long end = System.currentTimeMillis();System.out.println("复制花费的时间为：" + (end - start));}
}
package com.atguigu.java;import org.junit.Test;import java.io.*;/*** 处理流之一：缓冲流的使用* 1.缓冲流* BufferedInputStream* BufferedOutputStream* BufferedReader* BufferedWriter** 2.缓冲流的作用：提高流的读取和写入的速度。* 提高读写速度的原因：内部提供了一个缓冲区** 3.处理流，就是套接在已有的流的基础之上。** @author* @create 2022-07-20 16:34*/
public class BufferedTest {/*实现非文本文件的复制*/@Testpublic void BufferedTest() {FileInputStream fis = null;FileOutputStream fos = null;BufferedInputStream bis = null;BufferedOutputStream bos = null;try {//1.造文件File srcfile= new File("润泽.jpg");File destfile= new File("润泽2.jpg");//2.造流//2.1两个节点流fis = new FileInputStream(srcfile);fos = new FileOutputStream(destfile);//2.2两个缓冲流（处理流）bis = new BufferedInputStream(fis);bos = new BufferedOutputStream(fos);//3.复制的细节byte[] buffer = new byte[5];int len;//记录每次的长度。while ((len = bis.read(buffer)) != -1){bos.write(buffer,0,len);// bos.flush();//刷新缓冲区域}} catch (IOException e) {e.printStackTrace();} finally {//4.资源关闭：//要求：先关闭外层的流，再关闭内层的。if(bis != null){try {bis.close();} catch (IOException e) {e.printStackTrace();}}if(bos != null){try {bos.close();} catch (IOException e) {e.printStackTrace();}}//说明：关闭外层流的同时，内层流也会自动进行关闭。关于内层流的关闭可以省略。
// fis.close();
// fos.close();}}/*使用BufferedReader()和BufferedWriter()实现文本文件的复制*/@Testpublic void test() {BufferedReader br = null;BufferedWriter bw = null;try {//创建文件和相应的流br = new BufferedReader(new FileReader(new File("hello.txt")));bw = new BufferedWriter(new FileWriter(new File("hello3.txt")));//方式一
// //读写操作
// char[] cbuf = new char[1024];
// int len;
// while ((len = br.read(cbuf)) != -1){
// bw.write(cbuf,0,len);
// }//方式二String data;while ((data = br.readLine()) != null){//方法一：
// bw.write(data + "\n");//data中不包含换行符。//方法二：bw.write(data);//data中不包含换行符。bw.newLine();}} 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();}}}}
}
package com.atguigu.java;import org.junit.Test;import java.io.*;/*** 处理流之二：转换流的使用** 1.转换流：属于字符流，也是处理流* InputStreamReader：将一个字节的输入流转换为一个字符的输入流* OutputStreamWriter：将一个字符的输出流转换为一个字节的输出流** 2.作用：提供字节流和字符流之间的转换。** 3.解码：字节 字节数组--->字符数组* 编码：字符数组--->字节 字节数组** 4.字符集** 常见的编码表 ASCII：美国标准信息交换码。 用一个字节的7位可以表示。 ISO8859-1：拉丁码表。欧洲码表 用一个字节的8位表示。 GB2312：中国的中文编码表。最多两个字节编码所有字符 GBK：中国的中文编码表升级，融合了更多的中文文字符号。最多两个字节编码 Unicode：国际标准码，融合了目前人类使用的所有字符。为每个字符分配唯一的字符码。所有的文字都用两个字节来表示。 UTF-8：变长的编码方式，可用1-4个字节来表示一个字符。*** @author* @create 2022-07-20 22:56*/
public class InputStreamReaderTest {/*此时处理异常仍然应该使用try-catch-finallyInputStreamReader的使用实现字节的输入流到字符的输出流的转换。*/@Testpublic void test() throws IOException {FileInputStream fis = new FileInputStream("dbcp.txt");
// InputStreamReader isr = new InputStreamReader(fis);//使用系统默认的字符集//参数二指明了字符集，具体使用哪个字符集取决于文件"dbcp.txt"保存时使用的字符集。InputStreamReader isr = new InputStreamReader(fis,"UTF-8");//使用指定的字符集char[] cbuf = new char[20];int len;while ((len = isr.read(cbuf)) != -1){String str = new String(cbuf,0,len);System.out.print(str);}isr.close();}/*综合使用InputStreamReader 和 OutputStreamWriter*/@Testpublic void test3() {InputStreamReader isr = null;OutputStreamWriter osw = null;try {File file1 = new File("dbcp.txt");File file2 = new File("dbcp_gbk.txt");FileInputStream fis = new FileInputStream(file1);FileOutputStream fos = new FileOutputStream(file2);isr = new InputStreamReader(fis,"UTF-8");osw = new OutputStreamWriter(fos,"gbk");char[] cbuf = new char[20];int len;while ((len = isr.read(cbuf)) != -1){osw.write(cbuf,0,len);}} catch (IOException e) {e.printStackTrace();} finally {if(isr != null){try {isr.close();} catch (IOException e) {e.printStackTrace();}}if(osw != null){try {osw.close();} catch (IOException e) {e.printStackTrace();}}}}
}
package com.atguigu.java;import org.junit.Test;import java.io.*;/***其他流的使用:** 1.标准的输入、输出流* 2.打印流* 3.数据流** @author* @create 2022-07-21 11:59*/
public class OtherStreamTest {public static void main(String[] args) {BufferedReader br = null;try {InputStreamReader isr = new InputStreamReader(System.in);br = new BufferedReader(isr);while (true){System.out.println("请输入字符串：");String data = br.readLine();if ("e".equalsIgnoreCase(data) || "exit".equalsIgnoreCase(data)){System.out.println("程序结束");break;}else {String upperCase = data.toUpperCase();System.out.println(upperCase);}}} catch (IOException e) {e.printStackTrace();} finally {if (br != null){try {br.close();} catch (IOException e) {e.printStackTrace();}}}}/*1.标准的输入、输出流1.1System.in 标准的输入流，默认从键盘输入System.out 标准的输出流，默认从控制台输出1.2System类的setIn(InputStream is) setOut(PrintStream ps)方法重新指定输入和输出的流。1.3练习：从键盘输入字符串，要求将读取到的整行字符串转成大写输出。然后继续进行输入操作，直至当输入“e”或者“exit”时，退出程序。方法一：使用Scanner实现,调用了next()方法返回一个字符串方法二：System.in*/
// @Test
// public void test() {
// BufferedReader br = null;
// try {
// InputStreamReader isr = new InputStreamReader(System.in);
// br = new BufferedReader(isr);
// while (true){
// System.out.println("请输入字符串：");
// String data = br.readLine();
// if ("e".equalsIgnoreCase(data) || "exit".equalsIgnoreCase(data)){
// System.out.println("程序结束");
// break;
// }else {
// String upperCase = data.toUpperCase();
// System.out.println(upperCase);
// }
// }
// } catch (IOException e) {
// e.printStackTrace();
// } finally {
// if (br != null){
// try {
// br.close();
// } catch (IOException e) {
// e.printStackTrace();
// }
// }
// }
// }/*2.打印流:PrintStream PrintWriter2.1提供了一系列重载的print() 和 println()2.2练习：*/@Testpublic void test2(){PrintStream ps = null;try {//节点流FileOutputStream fos = new FileOutputStream(new File("hello4.txt"));// 创建打印输出流,设置为自动刷新模式(写入换行符或字节 '\n' 时都会刷新输出缓冲区)ps = new PrintStream(fos, true);if (ps != null) {// 把标准输出流(控制台输出)改成文件System.setOut(ps);}for (int i = 0; i <= 255; i++) { // 输出ASCII字符System.out.print((char) i);if (i % 50 == 0) { // 每50个数据一行System.out.println(); // 换行}}} catch (FileNotFoundException e) {e.printStackTrace();} finally {if (ps != null) {ps.close();}}}/*3.数据流3.1 DataInputStream 和 DataOutputStream3.2作用：用于读取或写出基本数据类型的变量或字符串练习：写出基本数据类型的变量或字符串到文件hello4.txt中。注意：处理异常仍要使用try-catch-finally*/@Testpublic void test3() {DataOutputStream dos = null;try {dos = new DataOutputStream(new FileOutputStream(new File("hello4.txt")));dos.writeUTF("胡歌");dos.flush();//只要执行就将内存中的数据写入文件。dos.writeInt(23);dos.flush();dos.writeBoolean(true);dos.flush();} catch (IOException e) {e.printStackTrace();} finally {if (dos != null){try {dos.close();} catch (IOException e) {e.printStackTrace();}}}}//练习：读出文件hello4.txt中基本数据类型的变量或字符串。//注意点：读取的顺序和写入的顺序要一致。@Testpublic void test4() {DataInputStream dis = null;try {dis = new DataInputStream(new FileInputStream(new File("hello4.txt")));String name = dis.readUTF();int age = dis.readInt();boolean isMale = dis.readBoolean();System.out.println("name=" + name);System.out.println("age=" + age);System.out.println("isMale=" + isMale);} catch (IOException e) {e.printStackTrace();} finally {if (dis != null){try {dis.close();} catch (IOException e) {e.printStackTrace();}}}}
}
package com.atguigu.exer;import org.junit.Test;import java.io.*;/*** @author* @create 2022-07-20 21:16*/
public class PicTest {//图片的加密@Testpublic void test() {FileInputStream fis = null;FileOutputStream fos = null;try {fis = new FileInputStream(new File("润泽.jpg"));fos = new FileOutputStream(new File("润泽(加密).jpg"));int data;while ((data = fis.read()) != -1){int i = data ^ 5;fos.write(i);}} catch (IOException e) {e.printStackTrace();} finally {if (fis != null){try {fis.close();} catch (IOException e) {e.printStackTrace();}}if (fos != null){try {fos.close();} catch (IOException e) {e.printStackTrace();}}}}//图片的解密@Testpublic void test1() {FileInputStream fis = null;FileOutputStream fos = null;try {fis = new FileInputStream(new File("润泽(加密).jpg"));fos = new FileOutputStream(new File("润泽3.jpg"));int data;while ((data = fis.read()) != -1){int i = data ^ 5;fos.write(i);}} catch (IOException e) {e.printStackTrace();} finally {if (fis != null){try {fis.close();} catch (IOException e) {e.printStackTrace();}}if (fos != null){try {fos.close();} catch (IOException e) {e.printStackTrace();}}}}
}
package com.atguigu.exer;import org.junit.Test;import java.io.*;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;/*** 练习3:获取文本上字符出现的次数,把数据写入文件** 思路：* 1.遍历文本每一个字符* 2.字符出现的次数存在Map中** Map<Character,Integer> map = new HashMap<Character,Integer>();* map.put('a',18);* map.put('你',2);** 3.把map中的数据写入文件** @author shkstart* @create 2019 下午 3:47*/
public class WordCount {/*说明：如果使用单元测试，文件相对路径为当前module如果使用main()测试，文件相对路径为当前工程*/@Testpublic void testWordCount() {FileReader fr = null;BufferedWriter bw = null;try {//1.创建Map集合
// Map<Character, Integer> map = new HashMap<Character, Integer>();Map<Character, Integer> map = new HashMap<Character, Integer>();//2.遍历每一个字符,每一个字符出现的次数放到map中fr = new FileReader("hello.txt");int c = 0;while ((c = fr.read()) != -1) {System.out.println(c);System.out.println();//int 还原 charchar ch = (char) c;// 判断char是否在map中第一次出现if (map.get(ch) == null) {map.put(ch, 1);} else {map.put(ch, map.get(ch) + 1);}}// //2.遍历每一个字符,每一个字符出现的次数放到map中
// fr = new FileReader("hello.txt");
// while (fr.read() != -1) {
// //int 还原 char
// System.out.println(fr.read());
// char ch = (char)fr.read();
// // 判断char是否在map中第一次出现
// if (map.get(ch) == null) {
// map.put(ch, 1);
// } else {
// map.put(ch, map.get(ch) + 1);
// }
// }//3.把map中数据存在文件count.txt//3.1 创建Writerbw = new BufferedWriter(new FileWriter("wordcount.txt"));//3.2 遍历map,再写入数据Set<Map.Entry<Character, Integer>> entrySet = map.entrySet();Iterator<Map.Entry<Character, Integer>> iterator = entrySet.iterator();while (iterator.hasNext()){Map.Entry<Character, Integer> entry = iterator.next();switch (entry.getKey()) {case ' ':bw.write("空格=" + entry.getValue());break;case '\t'://\t表示tab 键字符bw.write("tab键=" + entry.getValue());break;case '\r'://bw.write("回车=" + entry.getValue());break;case '\n'://bw.write("换行=" + entry.getValue());break;default:bw.write(entry.getKey() + "=" + entry.getValue());break;}bw.newLine();}
// for (Map.Entry<Character, Integer> entry : entrySet) {
// switch (entry.getKey()) {
// case ' ':
// bw.write("空格=" + entry.getValue());
// break;
// case '\t'://\t表示tab 键字符
// bw.write("tab键=" + entry.getValue());
// break;
// case '\r'://
// bw.write("回车=" + entry.getValue());
// break;
// case '\n'://
// bw.write("换行=" + entry.getValue());
// break;
// default:
// bw.write(entry.getKey() + "=" + entry.getValue());
// break;
// }
// bw.newLine();
// }} catch (IOException e) {e.printStackTrace();} finally {//4.关流if (fr != null) {try {fr.close();} catch (IOException e) {e.printStackTrace();}}if (bw != null) {try {bw.close();} catch (IOException e) {e.printStackTrace();}}}}
}
package com.atguigu.java;import org.junit.Test;import java.io.*;/*** 对象流的使用：** 1. ObjectInputStream ObjectOutputStream** 2.作用：用于存储和读取基本数据类型数据或对象的处理流。它的强大之处就是可* 以把Java中的对象写入到数据源中，也能把对象从数据源中还原回来。** 3.要想一个Java对象是可序列化的，需要满足相应的要求。见Person.java** 4.序列化机制：* 对象序列化机制允许把内存中的Java对象转换成平台无关的二进制流，从*而允许把这种二进制流持久地保存在磁盘上，或通过网络将这种二进制流传*输到另一个网络节点。//当其它程序获取了这种二进制流，就可以恢复成原*来的Java对象。** @author* @create 2022-07-21 17:24*/
public class ObjectInputOutputStream {/*序列化过程：将内存中的Java对象保存到磁盘中或者通过网络传输出去使用ObjectOutputStream实现*/@Testpublic void test() {ObjectOutputStream oos = null;try {oos = new ObjectOutputStream(new FileOutputStream(new File("object.dat")));oos.writeObject(new String("爱情公寓"));oos.flush();oos.writeObject(new Person("违章",23));oos.flush();} catch (IOException e) {e.printStackTrace();} finally {if (oos != null) {try {oos.close();} catch (IOException e) {e.printStackTrace();}}}}/*反序列化过程：将保存到磁盘中或者网络传输的Java对象写入到内存使用ObjectInputStream实现*/@Testpublic void test1() {ObjectInputStream ois = null;try {ois = new ObjectInputStream(new FileInputStream(new File("object.dat")));Object obj1 = ois.readObject();Object obj2 = ois.readObject();String str = (String)obj1;Person p = (Person)obj2;System.out.println(str);System.out.println(p);} catch (IOException e) {e.printStackTrace();} catch (ClassNotFoundException e) {e.printStackTrace();} finally {if (ois != null) {try {ois.close();} catch (IOException e) {e.printStackTrace();}}}}
}
package com.atguigu.java;import java.io.Serializable;/*** Person需要满足下面的要求才可以序列化：** 1.需要实现接口 Serializable** 2.需要当前类提供一个全局常量-serialVersionUID-序列版本号：public static final long serialVersionUID = 42243563465L;** 3.除了当前Person类需要实现Serializable接口之外，还必须保证其内部的所有属性也必须是可以序列化的。* 默认情况下基本数据类型也是可以序列化的。** 补充：ObjectOutputStream和ObjectInputStream不能序列化 static 和 transient 修饰的成员变量*** @author* @create 2022-07-21 17:47*/
public class Person implements Serializable {public static final long serialVersionUID = 42243563465L;private static String name;private transient int age;private Account account;public Person() {}public Person(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}@Overridepublic String toString() {return "Person{" +"name='" + name + '\'' +", age=" + age +'}';}
}class Account {private int id;
}
package com.atguigu.java;import org.junit.Test;import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;/*** 随机存取文件流** RandomAccessFile的使用* 1.RandomAccessFile直接继承于java.lang.Object类，实现了DataInput DataOutput接口* 2.RandomAccessFile既可以作为一个输入流，又可以作为一个输出流** 3.如果RandomAccessFile作为输出流时，写出的文件如果不存在，则在执行过程中自动创建* 如果写出的文件已经存在，则对已有内容从头开始覆盖。** 4.可以通过相关的操作，实现RandomAccessFile“插入”数据的效果。** @author* @create 2022-07-21 22:13*/
public class RandomAccessFileTest {@Testpublic void test() {RandomAccessFile raf1 = null;RandomAccessFile raf2 = null;try {//1.创建流的对象raf1 = new RandomAccessFile(new File("润泽.jpg"),"r");raf2 = new RandomAccessFile(new File("润泽1.jpg"),"rw");//2.复制操作byte[] buffer = new byte[1024];int len;while ((len = raf1.read(buffer)) != -1){raf2.write(buffer,0,len);}} catch (IOException e) {e.printStackTrace();} finally {if (raf1 != null){try {raf1.close();} catch (IOException e) {e.printStackTrace();}}if (raf2 != null){try {raf2.close();} catch (IOException e) {e.printStackTrace();}}}}@Testpublic void test2() throws IOException {//1.创建流的对象RandomAccessFile raf1 = new RandomAccessFile(new File("hello1.txt"),"rw");raf1.seek(3);//指针调到了角标为3的位置。raf1.write("123".getBytes());//覆盖操作raf1.close();}/*使用RandomAccessFile实现插入的效果*/@Testpublic void test3() throws IOException {//1.创建流的对象RandomAccessFile raf1 = new RandomAccessFile(new File("hello1.txt"),"rw");raf1.seek(3);//指针调到了角标为3的位置。//保存指针3后面的所有数据到StringBuilder中StringBuilder sb = new StringBuilder((int)new File("hello1.txt").length());byte[] buffer = new byte[20];int len;while ((len = raf1.read(buffer)) != -1) {
// sb.append(buffer.toString());sb.append(new String(buffer,0,len));}raf1.seek(3);raf1.write("xyz".getBytes());raf1.write(sb.toString().getBytes());raf1.close();}
}
Java高级：IO流、File类、抽象基类、节点流、缓冲流、图片加密、其他流、对象流、随机存取文件流相关推荐
- 【JavaSE8 高级编程 IO/NIO】IO入门系列①之抽象基类节点流转换流 2019_8_16
IO输入输出 IO 实现体系概述 [文档级] ①IO基石 四抽象基类 [IS,OS / R,W]抽象基类简述 子类及其实现接口 字节(FIS,OIS)字符(BR,ISR)读 字节(FOS,OOS,PS ...
- dj电商-模型类设计-1.x-模型类抽象基类
共同的字段 每一个模型类中都需要的字段 可以考虑把他们抽离出来 共同封装在一个父类中 共同的字段包括: 创建时间 更新时间 定义与使用 >自定义的一个模块 项目下建db目录 db目录下建base ...
- python抽象基类的作用_Python：多态、鸭子模型和抽象基类
1. 多态 什么是多态 -- 多态,指的是一种事务具有多种形态: -- python是一种动态语言,默认支持多态,同一个方法 调用 不同的类对象 ,执行的 结果各不相同: 多态实现 -- 继承:不同子 ...
- python 基类是什么_python之抽象基类
python之抽象基类 抽象基类,在这个类中定义一些方法,所有继承这个类的类必须实现这个方法,并且这个类不能被实例化, 使用抽象基类的情况: 1.某些情况下希望判断某个对象的类型 2.强制子类必须实现 ...
- 1.8（java高级特性）file文件与IO
文章目录 File类 File类常见的构造器 java默认的相对路径 路径分割符 File常用方法 File类的判断方法 File类的创建功能 JAVA的IO 流的分类 **按操作数据单位不同分为** ...
- Python高级：了解Python ABC（抽象基类）及 应用场景
ABC,Abstract Base Class(抽象基类),主要定义了基本类和最基本的抽象方法,可以为子类定义共有的API,不需要具体实现.相当于是Java中的接口或者是抽象类. 抽象基类可以不实现具 ...
- Python学习笔记28：从协议到抽象基类
Python学习笔记28:从协议到抽象基类 今后本系列笔记的示例代码都将存放在Github项目:https://github.com/icexmoon/python-learning-notes 在P ...
- Python ABC（抽象基类）
轉自:https://blog.csdn.net/qijiqiguai/article/details/77269839 ABC(Abstract Base Class抽象基类)主要定义了不需要具体实 ...
- C++中为什么要引入抽象基类和纯虚函数？
为什么要引入抽象基类和纯虚函数? 主要目的是为了实现一种接口的效果. 抽象类是一种特殊的类,它是为了抽象和设计的目的为建立的,它处于继承层次结构的较上层. ⑴抽象类的定义:带有纯虚函数的类为抽象类. ...
最新文章
- vue.js 多图上传，并可预览
- JavaScript二(第一个js程序)
- Semantic UI实现一个landing page
- 精简 opencv python_01_opencv_python_基本图像处理
- JavaScript 第三课 DOM
- 8-18-Exercise
- android listview的理解,Android ListView的理解
- 什么是二次元？什么是二次元衍生创作？它的魅力何在？
- 谁动过你的电脑？小姐姐们要学会保护好自己电脑里的小秘密呀
- web安全之XSS攻击
- 【前端 · 面试 】HTTP 总结（四）—— HTTP 状态码
- C#：数据库操作（待补充）
- 蘑菇街直播实战技巧带你解决直播开发难题
- 网络安全未来发展怎么样？
- c语言编程解百马百瓦古题,java编程题90道.doc
- c#创建画布_WinForm GDI编程：Graphics画布类
- 大数据薪水大概多少_大数据工程师工资一般多少钱
- 计算机应用数据结构是什么,应用数据结构
- 如何使DFC实现跨平台
- 【大数据】9大实战项目解决你所有烦恼（写论文、找工作）