File与IO基础
IO流的作用:持久化到磁盘
File类的使用
File类基本概念
- 文件和文件夹都是用File类来表示。
- File类是内存层面的对象，内存中创建出来的File对象不一定有一个真实存在的文件或文件夹，但是磁盘中真实的文件或文件夹必须创建一个对应的File对象才能操作。
- File文件可进行增删改查，但不能访问文件本身的内容，需要使用输入/输出流来进行访问。
- File对象一般作为流对象的构造器参数传入。如
FileInputStream fileInputStream = new FileInputStream(new File("hello.tex"));
File对象的创建
注意：文件夹和文件如果在磁盘中都没有的话，要分开分别创建文件夹和文件。
构造器
分隔符
示例小结
public class FileTest {
/**
* 文件创建的字符串参数意义
* @throws FileNotFoundException
*/
@Test
public void test1() throws FileNotFoundException {
//windows环境下用\\来作为文件夹分隔符，之所以用\\是因为\是转义符的意思，所有\\表示不转义
File fileA1 = new File("F:\\newwork\\roy-practice-metaverse\\hello-io.txt");
//windows环境下也可以像linux环境一样用/表示
File fileA2 = new File("F:/newwork/roy-practice-metaverse/hello-io.txt");
//Java提供了File.pathSeparator来拼接路径分隔符，用于读取不同的系统的路径分隔符
File fileA3 = new File("F:" + File.pathSeparator + "newwork" + File.pathSeparator + "roy-practice-metaverse" + File.pathSeparator + "hello-io.txt");
//相当于当前module模块下的hello-io.txt，如果是main方法则是当前工程下的hello-io.txt
File fileR = new File("hello-io.txt");
}
/**
* 文件创建的3种构造器
* @throws FileNotFoundException
*/
@Test
public void test2() throws FileNotFoundException {
//构造器1：File(String pathname)
File file1 = new File("F:/newwork/roy-practice-metaverse/hello-io.txt");
//构造器2：File(String parent, String child)
//child可以是文件或文件夹名称
File file2 = new File("F:/newwork","roy-practice-metaverse");
//构造器3：File(File parent, String child)
//child可以是文件或文件夹名称
File file3 = new File(file2,"hello-io.txt");
}
}
File类的常用方法
查询方法
注意：File类中的查看方法操作不会因为文件或文件夹不存在而报错，因为还都是内存层面的操作，没有涉及磁盘文件。
示例小结
/**
* File类的常用方法
* @throws FileNotFoundException
*/
@Test
public void test3() throws FileNotFoundException {
File file1 = new File("hi-io.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());//默认值0
System.out.println(file1.lastModified());//默认值0
System.out.println("------------------------------------");
File file2 = new File("F:/newwork/roy-practice-metaverse/hello-io.txt");
System.out.println(file2.getAbsolutePath());
//这个path的返回值就是我们创建file对象时传入的参数，参数是绝对路径就返回绝对路径，否则就是相对路径名
System.out.println(file2.getPath());
System.out.println(file2.getName());
System.out.println(file2.getParent());
System.out.println(file2.length());
System.out.println(file2.lastModified());
}
/**
* F:\newwork\roy-practice-metaverse\hi-io.txt
* hi-io.txt
* hi-io.txt
* null
* 0
* 0
* ------------------------------------
* F:\newwork\roy-practice-metaverse\hello-io.txt
* F:\newwork\roy-practice-metaverse\hello-io.txt
* hello-io.txt
* F:\newwork\roy-practice-metaverse
* 0
* 0
*/
/**
* File类的常用方法-文件夹方法
* @throws FileNotFoundException
*/
@Test
public void test4() throws FileNotFoundException {
//文件夹遍历时该文件夹必须存在，否则NPE
File file1 = new File("F:/newwork/roy-practice-metaverse");
String[] list = file1.list();
for (String name : list) {
System.out.println(name);
}
File[] files = file1.listFiles();
for (File file : files) {
System.out.println(file);
}
//移动文件或者重命名,要保证操作成功，需要 from在磁盘存在，而to不能存在这两个条件
File from = new File("hello-io.txt");
File to = new File("new-io.txt");
boolean success = from.renameTo(to);
System.out.println(success);
}
/**
* .idea
* hello-io.txt
* pom.xml
* src
* target
* F:\newwork\roy-practice-metaverse\.idea
* F:\newwork\roy-practice-metaverse\hello-io.txt
* F:\newwork\roy-practice-metaverse\pom.xml
* F:\newwork\roy-practice-metaverse\src
* F:\newwork\roy-practice-metaverse\target
* true
*
*
* Process finished with exit code 0
*/
File类的判断方法
File类的创建删除方法
示例小结
/**
* File类的判断功能
*
* @throws FileNotFoundException
*/
@Test
public void test5() throws FileNotFoundException {
File existFile = new File("new-io.txt");
System.out.println(existFile.isDirectory());
System.out.println(existFile.isFile());
System.out.println(existFile.exists());
System.out.println(existFile.canRead());
System.out.println(existFile.canWrite());
System.out.println(existFile.isHidden());
System.out.println("------------------------");
File notExistFile = new File("notExist-new-io.txt");
//当文件不存在的时候，结果是既不是文件夹也不是文件，所有如果有需要可以先判断是否存在
System.out.println(notExistFile.isDirectory());
System.out.println(notExistFile.isFile());
System.out.println(notExistFile.exists());
System.out.println(notExistFile.canRead());
System.out.println(notExistFile.canWrite());
System.out.println(notExistFile.isHidden());
}
/**
* false
* true
* true
* true
* true
* false
* ------------------------
* false
* false
* false
* false
* false
* false
*/
/**
* File类的创建删除文件/文件夹
*
* @throws FileNotFoundException
*/
@Test
public void test6() throws IOException {
//创建删除文件
File file = new File("create-file.txt");
if (!file.exists()) {
boolean flag = file.createNewFile();
if (flag) {
System.out.println("创建文件成功");
}
} else {
boolean delete = file.delete();
if (delete) {
System.out.println("删除文件成功");
}
}
//创建删除文件夹
File file2 = new File("create-dir");
if (!file2.exists()) {
boolean flag = file2.mkdir();
if (flag) {
System.out.println("创建文件夹成功");
}
} else {
boolean delete = file2.delete();
if (delete) {
System.out.println("删除文件夹成功");
}
}
//创建删除多级文件夹
File file3 = new File("create-dir1/sub-dir1");
if (!file3.exists()) {
//mkdirs可以递归创建文件夹，mkdir只能创建一级文件夹，如果有多级则创建不成功
boolean flag = file3.mkdirs();
if (flag) {
System.out.println("创建文件夹成功");
}
} else {
boolean delete = file3.delete();
if (delete) {
System.out.println("删除文件夹成功");
}
}
//删除多级文件夹,只能删除叶子节点的文件或文件夹，不能级联删除
//要想删除成功，被删除的文件夹下不能有子文件夹或者文件，如果是文件则文件要存在。
// File file4 = new File("create-dir1");
// System.out.println(file4.delete());//false
}
IO流原理及流的分类
基本概念
I/O是指Input/Output（输入流/输出流）的意思，用来处理设备之间的数据传输。
输入输出流的划分是个相对的概念，我们在操作选择输入输出流是站在程序或者说内存的角度上看流属于输入还是输出。
我们应该站在内存的角度上去看流，读到内存中要找输入流，从内存中读到磁盘或者其他网络端叫输出流。
IO流模板四步走
- File类对象创建
- 输入输出流的创建
- 读取/写入数据操作
- 关闭流资源
IO流的分类
- 数据单位
- 流向
- 角色
IO流体系
节点流和处理流
基本概念
流的选择
- 对于文本文件（.txt .java .c ...），使用字符流处理。
- 对于非文本文件(.doc .ppt .jpg .avi ...)，（只能）使用字节流处理。
注意：文本文件操作读取输入流后展示(即在内存层面去读时)时要使用字符流操作，避免会有乱码的情况。当然如果只是读取数据并写入到文件中，则都可以用。而非文本文件即使没有在内存层面去读，直接写入硬盘，也不能用字符流处理，否则文件会打开失败。
示例小结
字符流
public class FileReaderWriterTest {
/**
* 通过字符输入流读取文件数据打印到控制台
*/
@Test
public void test1() {
//注意，一开始写代码时可以先抛出异常，等后面整理时再针对性try-catch处理
//1、实例化要操作的文件对象
FileReader fr = null;
try {
//如果读取的文件不存在会报文件未找到异常
File file = new File("new-io.txt");
//2、创建具体的流
fr = new FileReader(file);
//3、数据的读入/写出
//从输入流中读取数据的下一个字节，没有返回-1
int data;
while ((data = fr.read()) != -1) {
//强转为字符
System.out.print((char) data);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//在关闭流时都要先判断字符输入流是否不为空
if (fr != null) {
//关闭流
try {
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
/**
* 通过字符输入流读取文件数据打印到控制台-加缓充
*/
@Test
public void test2() {
//注意，一开始写代码时可以先抛出异常，等后面整理时再针对性try-catch处理
//1、实例化要操作的文件对象
FileReader fr = null;
try {
//如果读取的文件不存在会报文件未找到异常
File file = new File("new-io.txt");
//2、创建具体的流
fr = new FileReader(file);
//3、数据的读入/写出
//从输入流中读取数据的下一个字节，没有返回-1
int len;
char[] cbuff = new char[1024];
//一次读取多个可以提供效率，len是每次读取到cbuff数组中的个数，没有则返回-1
while ((len = fr.read(cbuff)) != -1) {
//注意长度是len而不是数组cbuff的长度
//接收方式1：
System.out.print(new String(cbuff, 0, len));
//接收方式2：
/*for (int i = 0; i < len; i++) {
System.out.print(cbuff[i]);
}*/
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//在关闭流时都要先判断字符输入流是否不为空
if (fr != null) {
//关闭流
try {
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
/**
* 从内存中通过字符输出流写文件到硬盘中
* 输出操作的文件可以不存在，不存在时会自动创建此文件。
* 创建字符输出流时会有个append参数，默认是false,表示如果文件存在则覆盖
* 如果设置append参数=true，表示如果文件存在则会追加数据在文件里的末尾。
*/
@Test
public void test3() {
FileWriter fw = null;
try {
//1、实例化要操作的文件对象
File file = new File("out-io.txt");
//2、创建具体的流
//FileOutputStream(File file, boolean append) append=false表示覆盖，true表示在文件末尾追加
fw = new FileWriter(file);
//3、数据的写出
//直接写字符串，\n表示换行符
fw.write("everybody wants to rule the world!\n");
//也可以写字符数组
fw.write("不是哦，我只是个良民，活着就好!".toCharArray());
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fw != null) {
//4、关闭流资源
try {
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
/**
* 读取硬盘中的文件到新文件中（复制）-字符流版
*/
@Test
public void test5() {
FileReader fr = null;
FileWriter fw = null;
try {
//1、实例化要操作的读入/写出文件对象
File srcFile = new File("new-io.txt");
File destFile = new File("new-io-copy.txt");
//2、创建输入流和输出流
fr = new FileReader(srcFile);
fw = new FileWriter(destFile);
//3、数据的读入和写出操作
int len;
char[] buff = new char[1024];
while ((len = fr.read(buff)) != -1) {
//注意要读多少个写出多少长度len
fw.write(buff, 0, len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//4、关闭流资源
if (fw != null) {
try {
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (fr != null) {
try {
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
字节流
public class FileInOutPutStreamTest {
/**
* 读取硬盘中的文件到新文件中（复制）-字节流版
*/
@Test
public void test() {
copyFile("是大臣.jpg", "是大臣-copy.jpg");
}
public void copyFile(String srcPath, String destPath) {
FileInputStream fis = null;
FileOutputStream fos = null;
try {
//1、实例化要操作的读入/写出文件对象
File srcFile = new File(srcPath);
File destFile = new File(destPath);
// File srcFile = new File("new-io.txt");
// File destFile = new File("new-io-copy.txt");
//2、创建输入流和输出流
fis = new FileInputStream(srcFile);
fos = new FileOutputStream(destFile);
//3、数据的读入和写出操作
int len;
byte[] buff = new byte[1024];
while ((len = fis.read(buff)) != -1) {
//注意要读多少个写出多少长度len
fos.write(buff, 0, len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//4、关闭流资源
if (fos != null) {
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
缓冲流——处理流的一种
处理流就是套接在已有流的基础上的流。
作用：提高流的读写速度。
原因：内部提供了一个默认8K的缓冲区。缓冲区大小我们可以在构造器中指定大小。
示例小结
public class BufferedTest {
/**
* 使用缓存流进行复制
*/
@Test
public void test1() {
//971M耗时1444ms 测试后如果指定的buff缓冲区越大理论上越好，因为顺序写速度更快
long start = System.currentTimeMillis();
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
try {
//1、实例化要操作的读入/写出文件对象
File srcFile = new File("E:/mv/[电影天堂www.dygod.com]倩女幽魂3：道道道BD国语中字.rmvb");
File destFile = new File("nxq.rmvb");
//2.1、创建输入流和输出流
FileInputStream fis = new FileInputStream(srcFile);
FileOutputStream fos = new FileOutputStream(destFile);
//2.1、创建缓存流
bis = new BufferedInputStream(fis);
bos = new BufferedOutputStream(fos, 8192);//1444ms
// bos = new BufferedOutputStream(fos, 8192 / 2);//1952ms
// bos = new BufferedOutputStream(fos, 8192 * 2);//1202ms
// bos = new BufferedOutputStream(fos, 8192 * 8);//1101ms
//3、数据的读入和写出操作
byte[] buffer = new byte[1024];
int len;
while ((len = bis.read(buffer)) != -1) {
bos.write(buffer, 0, len);
//强制刷新缓冲区，会把缓冲区的数据刷新到磁盘中
// bos.flush();
}
long end = System.currentTimeMillis();
System.out.println(end - start);
} 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();
}
}
}
}
/**
* 使用缓存字符流进行文本复制
*/
@Test
public void test2() {
//971M耗时1444ms 测试后如果指定的buff缓冲区越大理论上越好，因为顺序写速度更快
long start = System.currentTimeMillis();
BufferedReader br = null;
BufferedWriter bw = null;
try {
//1、实例化要操作的读入/写出文件对象
//2.1、创建输入流和输出流
//2.1、创建缓存流
br = new BufferedReader(new FileReader(new File("new-io.txt")));
bw = new BufferedWriter(new FileWriter(new File("new-io-copy3.txt")));
//3、数据的读入和写出操作
//字符流读写的是字符，所以用字符容器
//方式一：使用char数组
/* char[] buffer = new char[1024];
int len;
while ((len = br.read(buffer)) != -1) {
bw.write(buffer, 0, len);
//强制刷新缓冲区，会把缓冲区的数据刷新到磁盘中
// bw.flush();
}*/
//方式二：使用String
String data;
while ((data = br.readLine()) != null) {
// bw.write(data+"\n");
//如果没有换号符，则会写在一起
bw.write(data);
bw.newLine();
}
long end = System.currentTimeMillis();
System.out.println(end - start);
} catch (IOException e) {
e.printStackTrace();
} finally {
//4、关闭流资源
if (br != null) {
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (bw != null) {
try {
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
转换流
基本概念
转换流属于字符流，看流的归属看后缀。
InputStreamReader将字节流转换成字符流，并解码（字节、字节数组--->字符、字符数组）。
OutputStreamWriter将字符流转换成字节流，并编码（字符、字符数组--->字节、字节数组）。
编码解码过程需要字符集进行处理。
字符集
ASCII:因为只要表示字母这些所有一个字节就够了。
GBK,UTF-8都兼容了ASCII码表，所有在把原本是UTF-8的文本解码GBK时对于英文的部分也不会有什么问题，但中文部分就会乱码。
GBK,GBK2312是通过首字符是0表示一个字节代码一个字符；首字符是1表示需要读取2个字节表示一个字符来规范编码的，即用最高位是1或0来表示两个字节或一个字节。
应用
编码和解码。
示例小结
public class TransferIOTest {
/**
* 转换流读文件打印
*/
@Test
public void test1() {
//1、创建字节流对象
InputStreamReader isr = null;
try {
FileInputStream fis = new FileInputStream("new-io.txt");
//没有指定解码的字符集的话就使用默认的字符集
// InputStreamReader isr = new InputStreamReader(fis);
//2、创建字符转换流
isr = new InputStreamReader(fis, "UTF-8");
//3、解码读取
char[] buff = new char[1024];
int len;
while ((len = isr.read(buff)) != -1) {
//因为我们使用了文件原本的UTF-8字符集编码格式，所有在打印时就不会出现解码出现乱码的问题。
System.out.println(new String(buff, 0, len));
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (isr != null) {
//4、关闭流资源
try {
isr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
/**
* hello,my io
* 我要被强转了
* hello,my io
* 我要被强转了
* hello,my io
* 我要被强转了我要被强转了我要被强转了我要被强转了我要被强转了
*/
/**
* 转换流读UTF-8文件保存成GBK文件
*/
@Test
public void test2() {
//1、创建字节流对象
InputStreamReader isr = null;
OutputStreamWriter osr = null;
try {
FileInputStream fis = new FileInputStream("new-io.txt");
FileOutputStream fos = new FileOutputStream("new-io-gbk.txt");
//没有指定解码的字符集的话就使用默认的字符集
// InputStreamReader isr = new InputStreamReader(fis);
//2、创建字符转换流
//写代码时必须要指定字符集格式
isr = new InputStreamReader(fis, "UTF-8");
osr = new OutputStreamWriter(fos, "GBK");
//3、解码读取
char[] buff = new char[1024];
int len;
while ((len = isr.read(buff)) != -1) {
osr.write(buff,0,len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (isr != null) {
//4、关闭流资源
try {
isr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (osr != null) {
//4、关闭流资源
try {
osr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
其他流
标准输入、输出流
打印流
数据流
示例小结
public class OtherTest {
/**
* 利用标准输入输出流从键盘中读取输入，转换成大写打印到控制台上
* 注意idea不支持使用@Test测试方法读取键盘的输入，所以要改用main方法
*
* @param args
*/
public static void main(String[] args) {
BufferedReader br = null;
try {
br = new BufferedReader(new InputStreamReader(System.in));
String data = "";
while (true) {
System.out.println("请输入：");
data = br.readLine();
if ("exit".equalsIgnoreCase(data)) {
System.out.println("再见！");
break;
}
System.out.println(data.toUpperCase());
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (br != null) {
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
/**
* 请输入：
* hhhh
* HHHH
* 请输入：
* exit
* 再见！
*/
/**
* 打印流
*/
@Test
public void test1() {
PrintStream ps = null;
try {
//创建打印输出流，并设置自动刷新，默认是false,自动刷新当遇到换行符或者\n时会刷新输出缓冲区
ps = new PrintStream(new FileOutputStream(new File("test-print.txt")),true);
//把标准输出流（打印到控制台改成我们文件），我们的log日志记录到文本中就是用的打印流PrintStream/PrintWriter
System.setOut(ps);
String str = "我就是来测试打印流的\n现在开始测试：abcedsakjfslkdjfdfskgjdfkg\nsdfsdfsdf\n结束";
System.out.println(str);
} catch (FileNotFoundException e) {
e.printStackTrace();
} finally {
if (ps != null) {
ps.close();
}
}
}
/**
* 数据流：读取和写出8种基本数据类型和字符串
*/
@Test
public void test2() throws Exception {
DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));
dos.writeUTF("期望薪资");
dos.writeInt(36000);
dos.writeBoolean(true);
dos.flush();
dos.close();
DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));
//注意读取数据的时候要按照写入的顺序读，否则会报错
System.out.println(dis.readUTF());
System.out.println(dis.readInt());
System.out.println(dis.readBoolean());
dis.close();
}
}
对象流
对象可序列化需满足3个条件
- 对象对应的类需要实现Serializable接口。
- 需定义一个全局常量serialVersionUID。
- 对象内的所有属性也必须是可序列化的，比如自定义的Address类，基本数据类型都是可序列号的。
序列化**：把内存中的对象转换为二进制流。这样便可以将二进制流持久化到磁盘或者传输到另一个网络节点上。
反序列化：将二进制流还原成Java对象。
serialVersionUID的作用
- 标识类的版本以便于版本兼容。
- 如果没有定义serialVersionUID的话Java会根据类的内部细节自动生成，如果类的实例变量发生了修改，自动生成的serialVersionUID就会发生改变。
- Java序列化机制是通过serialVersionUID来验证版本的一致性，如果版本不一致则在反序列化时会报版本不一致异常。
实例小结
ublic class ObjectInputOutputStreamTest {
/**
* 对象序列化
*
* @throws Exception
*/
@Test
public void test1() throws Exception {
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.txt"));
oos.writeObject(new Person("张三", 30, new Address("紫禁城1号")));
oos.writeObject(new String("我是艾米"));
oos.flush();
oos.close();
}
/**
* 对象反序列化
*
* @throws Exception
*/
@Test
public void test2() throws Exception {
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.txt"));
//需按照写入的对象顺序读取，否则会报错
Person person = (Person) ois.readObject();
String str = (String) ois.readObject();
System.out.println(person);
System.out.println(str);
ois.close();
}
/**
* Person(name=张三, age=30, address=Address(location=紫禁城1号))
* 我是艾米
*/
}
/**
* 对象可序列化需满足3个条件：
* 对象对应的类需要实现Serializable接口
* 需定义一个全局常量serialVersionUID
* 对象内的所有属性也必须是可序列化的，比如自定义的Address类，基本数据类型都是可序列号的。
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Person implements Serializable {
private static final long serialVersionUID = -6849344724054667710L;
private String name;
private int age;
private Address address;
}
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Address implements Serializable {
private static final long serialVersionUID = -684934470754667710L;
private String location;
}
随记存取文件流——断点续传
实例小结
public class RandomAccessFileTest {
/**
* 随机存取文件-读文件写到新的文件中
*/
@Test
public void test1() {
RandomAccessFile read = null;
RandomAccessFile write = null;
try {
//只读
read = new RandomAccessFile(new File("new-io.txt"), "r");
//可读可写
write = new RandomAccessFile(new File("test.txt"), "rw");
byte[] buff = new byte[1024];
int len;
while ((len = read.read(buff)) != -1) {
write.write(buff, 0, len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (read != null) {
try {
read.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (write != null) {
try {
write.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
/**
* 使用RandomAccessFile实现数据的插入效果
*/
@Test
public void test2() throws Exception {
//可读可写
RandomAccessFile raf = new RandomAccessFile(new File("test.txt"), "rw");
//将指针调到角标为3的位置，0开始。
raf.seek(3);
//保存角标3后的数据，然后再实现插入，最后再把角标3后位置的数据继续追加进来
//用字节数组输出流来保存数据避免乱码
ByteArrayOutputStream baos = new ByteArrayOutputStream();
byte[] buff = new byte[1024];
int len;
while ((len = raf.read(buff)) != -1) {
baos.write(buff, 0, len);
}
//调回要插入位置的指针
raf.seek(3);
raf.write("哈哈哈我插入进来了".getBytes());
raf.write(baos.toString().getBytes());
raf.close();
baos.close();
}
}
NIO.2中Path、Paths、Files类的使用
第三方common-io实现IO读写
依赖
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
<version>2.4</version>
</dependency>
示例
public class CommonsIOTest {
@Test
public void test() throws IOException {
File srcFile = new File("是大臣.jpg");
File destFile = new File("是大臣-copy3.jpg");
FileUtils.copyFile(srcFile, destFile);
}
}
参考
577-617
File与IO基础的更多相关文章
- Java入门 - 语言基础 - 20.Stream和File和IO
原文地址:http://www.work100.net/training/java-stream-file-io.html 更多教程:光束云 - 免费课程 Stream和File和IO 序号 文内章节 ...
- 总结java创建文件夹的4种方法及其优缺点-JAVA IO基础总结第三篇
本文是Java IO总结系列篇的第3篇,前篇的访问地址如下: 总结java中创建并写文件的5种方式-JAVA IO基础总结第一篇 总结java从文件中读取数据的6种方法-JAVA IO基础总结第二篇 ...
- 总结删除文件或文件夹的7种方法-JAVA IO基础总结第4篇
本文是Java IO总结系列篇的第4篇,前篇的访问地址如下: 总结java中创建并写文件的5种方式-JAVA IO基础总结第一篇 总结java从文件中读取数据的6种方法-JAVA IO基础总结第二篇 ...
- 总结java中文件拷贝剪切的5种方式-JAVA IO基础总结第五篇
本文是Java IO总结系列篇的第5篇,前篇的访问地址如下: 总结java中创建并写文件的5种方式-JAVA IO基础总结第一篇 总结java从文件中读取数据的6种方法-JAVA IO基础总结第二篇 ...
- java IO基础操作
java IO基础,通熟易懂,好久没复习java 基础了.这里是传送门... http://www.cnblogs.com/nerxious/archive/2012/12/15/2818848.ht ...
- Java笔记：Java 流(Stream)、文件(File)和IO
更新时间:2018-1-7 12:27:21 更多请查看在线文集:http://android.52fhy.com/java/index.html java.io 包几乎包含了所有操作输入.输出需要的 ...
- Java - 17 Java 流(Stream)、文件(File)和IO
Java 流(Stream).文件(File)和IO Java.io包几乎包含了所有操作输入.输出需要的类.所有这些流类代表了输入源和输出目标. Java.io包中的流支持很多种格式,比如:基本类型. ...
- Java总结：Java 流(Stream)、文件(File)和IO
更新时间:2018-1-7 12:27:21 更多请查看在线文集:http://android.52fhy.com/java/index.html java.io 包几乎包含了所有操作输入.输出需要的 ...
- Java-Runoob：Java Stream、File、IO
ylbtech-Java-Runoob:Java Stream.File.IO 1.返回顶部 1. Java 流(Stream).文件(File)和IO Java.io 包几乎包含了所有操作输入.输出 ...
随机推荐
- 霍尔效应实验 execl数据处理
execl 函数 =POWER() /*幂次*/ =ROUND() /*保留小数点后几位*/ =SQRT() /*开平方根*/ =POWER( x, 1/3 ) /*开立方根*/ =COUNTA() ...
- 新一代数据科学ide平台DataSpell提前发行版体验
1 简介 PyCharm开发公司jetbrains专门面向数据科学的ide项目DataSpell在前不久发布了其EAP版本(早期预览版本),为我们带来了诸多趋于成熟的功能特性,本文就将为大家介绍其使用 ...
- CSS引入字体文件
在css引入字体文件可以直接把以下代码复制到css文件中 /* 字体声明 */ @font-face {font-family: 'icomoon';src: url('fonts/icomoon.e ...
- go-zero 实战之 blog 系统
go-zero 实战项目:blog 本文以 blog 的网站后台为例,着重介绍一下如何使用 go-zero 开发 blog 的用户模块. 本文涉及的所有资料都已上传 github 仓库 kougazh ...
- kiyv Button参数属性
from kivy.uix.button import Button from kivy.uix.floatlayout import FloatLayout from kivy.app import ...
- Beta阶段性总结
1.题士开发总结 2.反思 2.1 Issue管理 从0522敲定各个功能的API后,团队成员及时沟通,积极开发,但由于开发过程没能有效体现在issue上(如未能及时在issue上形成记录,功能开发完 ...
- mysqld_exporter监控mysql信息
mysqld_exporter监控mysql信息 一.背景 二.prometheus接入mysqld_exporter 1.安装mysqld_exporter 2.创建mysqld_exporter用 ...
- OKR与影响地图，别再傻傻分不清
摘要:OKR和影响地图虽然都是为了一个目标去进行规划的方法,但是两者侧重的内容却不一致. 本文分享自华为云社区<一分钟读懂OKR与影响地图>,作者: 敏捷的小智. 什么是OKR及影响地图 ...
- linux exit 和 _exit的区别
今天仔细看了一下exit和_exit这两个函数的区别,实际上exit也是调用了_exit退出函数的,只不过在调用_exit之前,exit还进行了一些多余的工作,也正是因为这样,相比起来exit就没有那 ...
- Python pylint requires Python '>=3.4.*' but the running Python is 2.7.12
用pylint 1.9.x 安装 pip install pylint==1.9.3. 或者换源 pip install -i https://pypi.tuna.tsinghua.edu.cn/si ...