文件 File
文件
1. 文件的一些常用方法
package com.ljw.study;
import java.io.File;
import java.util.Arrays;
import java.util.Date;
public class FileDemo {
public static void main(String[] args) {
// 构造文件对象
// 绝对路径,构造文件夹对象
File f1 = new File("d:/work/code/ljw/Test");
System.out.println(f1.exists()); // 文件是否存在
// 相对路径,如果是eclipse的话,就是相对于项目目录
File f2 = new File("employee.ser");
System.out.println("f2的绝对路径:" + f2.getAbsolutePath());
System.out.println(f2.exists());
// 以f1为父目录创建文件对象
File f3 = new File(f1,"LOL.exe");
System.out.println("f3的绝对路径:" + f3.getAbsolutePath());
System.out.println(f2.isDirectory()); // 是否是文件夹
System.out.println(f2.isFile()); // 是否为文件(非文件夹)
System.out.println(f2.length()); // 文件长度
System.out.println(new Date(f2.lastModified())); // 最后的修改时间
// System.out.println(f2.renameTo(new File("employee.ser")));// 文件重命名
System.out.println(Arrays.toString(f1.list())); // 以字符串数组的形式,返回当前文件夹下的所有文件(不包含子文件及子文件夹)
System.out.println(Arrays.toString(f1.listFiles())); // 以文件数组的形式,返回当前文件夹下的所有文件(不包含子文件及子文件夹)
// 以字符串形式返回获取所在文件夹
System.out.println(f1.getParent());
// 以文件形式返回获取所在文件夹
f2.getParentFile();
// 创建文件夹,如果父文件夹skin不存在,创建就无效
f1.mkdir();
// 创建文件夹,如果父文件夹skin不存在,就会创建父文件夹
f1.mkdirs();
// 创建一个空文件,如果父文件夹skin不存在,就会抛出异常
f1.createNewFile();
// 所以创建一个空文件之前,通常都会创建父目录
f1.getParentFile().mkdirs();
// 列出所有的盘符c: d: e: 等等
f1.listRoots();
// 刪除文件
f.delete();
// JVM结束的时候,刪除文件,常用于临时文件的删除
f.deleteOnExit()
}
}
2. 读取和写入文件数据
2.1 以字节流方式
2.1.1 读取数据
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
public class TestStream {
public static void main(String[] args) {
try {
//准备文件lol.txt其中的内容是AB,对应的ASCII分别是65 66
File f =new File("d:/lol.txt");
//创建基于文件的输入流
FileInputStream fis =new FileInputStream(f);
//创建字节数组,其长度就是文件的长度
byte[] all =new byte[(int) f.length()];
//以字节流的形式读取文件所有内容
fis.read(all);
for (byte b : all) {
//打印出来是65 66
System.out.println(b);
}
//每次使用完流,都应该进行关闭
fis.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
2.1.2 写入数据
package com.ljw.practice;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
File f = new File("d:/xyz/abc/def/lol2.txt");
f.getParentFile().mkdirs();
try {
FileOutputStream outputFile = new FileOutputStream(f);
String s = "秋天,多了一些思念";
byte[] b = s.getBytes(); // 将字符串转换为字节数组byte[]
outputFile.write(b);
outputFile.close();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
2.2 以字符流方式
2.2.1 读取数据
package com.ljw.practice;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
public class FileDemo {
public static void main(String[] args) {
File f = new File("d:/lol.txt");
try(FileReader fr = new FileReader(f)){ // 数据流写在try()里面,系统会帮我们自动关闭数据流
char[] c = new char[(int) f.length()];
fr.read(c);
for(char i:c) {
System.out.print(i);
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
2.2.2 写入数据
package com.ljw.practice;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class FileDemo {
public static void main(String[] args) {
File f = new File("d:/lol.txt");
File f2 = new File("d:/lol2.txt");
try(FileReader fr = new FileReader(f);FileWriter fw = new FileWriter(f2)){
char[] c = new char[(int) f.length()];
fr.read(c); // 读出数据到字符数组
fw.write(c); // 写入数据从数组到文件
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
2.3 以缓存流方式
- 缓存流必须建立在一个存在的流的基础上
- 以介质是硬盘为例,字节流和字符流的弊端:在每一次读写的时候,都会访问硬盘。 如果读写的频率比较高的时候,其性能表现不佳。
- 为了解决以上弊端,采用缓存流。缓存流在读取的时候,会一次性读较多的数据到缓存中,以后每一次的读取,都是在缓存中访问,直到缓存中的数据读取完毕,再到硬盘中读取。
- 如果需要立即将缓存中的数据写入硬盘,可以使用
flush()
方法
2.3.1 读取数据
package stream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
public class TestStream {
public static void main(String[] args) {
File f = new File("d:/lol.txt");
// 创建文件字符流
// 缓存流必须建立在一个存在的流的基础上
try (
FileReader fr = new FileReader(f);
BufferedReader br = new BufferedReader(fr);
)
{
while (true) {
// 一次读一行
String line = br.readLine();
if (null == line)
break;
System.out.println(line);
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
2.3.2 写入数据
package com.ljw.practice;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
public class FileDemo {
public static void main(String[] args) {
File f = new File("d:/lol2.txt");
try (
// 创建文件字符流
FileWriter fw = new FileWriter(f);
// 缓存流必须建立在一个存在的流的基础上
PrintWriter pw = new PrintWriter(fw);
) {
pw.println("garen kill teemo");
pw.println("teemo revive after 1 minutes");
pw.println("teemo try to garen, but killed again");
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
2.4 以数据流方式
- 使用数据流的writeUTF()和readUTF() 可以进行数据的格式化顺序读写
- 要用DataInputStream 读取一个文件,这个文件必须是由DataOutputStream 写出的,否则会出现EOFException,因为DataOutputStream 在写出的时候会做一些特殊标记,只有DataInputStream 才能成功的读取。
2.4.1 实例
- 以数据流的方式读写数据
package com.ljw.practice;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileDemo {
public static void main(String[] args) {
write();
read();
}
private static void read() {
File f = new File("d:/lol2.txt");
try(
FileInputStream fi = new FileInputStream(f);
DataInputStream di = new DataInputStream(fi); // 创建一个数据流对象
)
{
boolean b = di.readBoolean();
int i = di.readInt();
String s = di.readUTF();
System.out.println(b);
System.out.println(i);
System.out.println(s);
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
}
private static void write() {
File f = new File("d:/lol2.txt");
try(
FileOutputStream fo = new FileOutputStream(f);
DataOutputStream dos = new DataOutputStream(fo);
)
{
dos.writeBoolean(false);
dos.writeInt(200);
dos.writeUTF("中国");
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
2.5 以对象流(序列化对象)
- 把一个对象序列化有一个前提是:这个对象的类,必须实现了Serializable接口
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import charactor.Hero;
public class TestStream {
public static void main(String[] args) {
//创建一个Hero garen
//要把Hero对象直接保存在文件上,务必让Hero类实现Serializable接口
Hero h = new Hero();
h.name = "garen";
h.hp = 616;
//准备一个文件用于保存该对象
File f =new File("d:/garen.lol");
try(
//创建对象输出流
FileOutputStream fos = new FileOutputStream(f);
ObjectOutputStream oos =new ObjectOutputStream(fos);
//创建对象输入流
FileInputStream fis = new FileInputStream(f);
ObjectInputStream ois =new ObjectInputStream(fis);
) {
oos.writeObject(h);
Hero h2 = (Hero) ois.readObject();
System.out.println(h2.name);
System.out.println(h2.hp);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
3. 拆分文件 和 合并文件
3.1 拆分文件
package com.ljw.practice;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
File file = new File("d:/F.docx");
try {
FileInputStream inFile = new FileInputStream(file);
int i = 1;
while(true) {
byte[] b = new byte[1024*100];
int n = inFile.read(b);
if(n==-1) { // 没有读到数据返回 -1
break;
}
File f1 = new File(String.format("d:/F-%d.docx",i)); // 占位符
FileOutputStream outFile = new FileOutputStream(f1);
outFile.write(b);
i++;
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
3.2 合并文件
package com.ljw.practice;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
File newF = new File("d:/newF.docx");
try {
FileOutputStream outNewF = new FileOutputStream(newF);
for(int i=1;i<5;i++) {
File f = new File(String.format("d:/F-%d.docx", i));
byte[] b = new byte[(int) f.length()];
FileInputStream inf = new FileInputStream(f);
inf.read(b);
outNewF.write(b);
inf.close();
}
outNewF.close();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
4. 中文问题
package com.ljw.practice;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
public class FileDemo {
public static void main(String[] args) {
File f = new File("d:/lol.txt");
try (FileInputStream fis = new FileInputStream(f);) {
byte[] all = new byte[(int) f.length()];
fis.read(all);
//文件中读出来的数据是
System.out.println("文件中读出来的数据是:");
for (byte b : all)
{
int i = b&0xff; //只取16进制的后两位
System.out.println(Integer.toHexString(i));
}
System.out.println("把这个数字,放在GBK的棋盘上去:");
String str = new String(all,"GBK");
System.out.println(str);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
综合练习
- 复制文件或文件夹
- 查找指定的内容
package com.ljw.practice;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
public class FilePractice {
public static void main(String[] args) {
//----------复制文件--------------
File srcFile = new File("d:/lol.txt");
File destFile = new File("d:/lol3.txt");
copyFile(srcFile,destFile);
//----------复制文件夹------------
File srcFolder = new File("d:/xyz");
File destFolder = new File("d:/xyz-副本");
copyFolder(srcFolder,destFolder);
//----------查找---------------
String s = "hello";
findFileContent(s, srcFolder);
}
/**
* 复制文件
* @param srcFile:源文件
* @param destFile:目标文件
* @return void
*/
public static void copyFile(File srcFile, File destFile) {
if(srcFile.exists()) {
try(
// 创建读取文件流对象
FileInputStream fi = new FileInputStream(srcFile);
// 创建写入文件流对象
FileOutputStream fo = new FileOutputStream(destFile);
)
{
byte[] b = new byte[10];
int i;
while(true) {
i = fi.read(b);
if(-1==i) {
break;
}
fo.write(b,0,i);
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}else {
System.out.println("文件不存在");
}
}
/**
* 复制文件夹
* @param srcFile
* @param destFile
*/
public static void copyFolder(File srcFile, File destFile) {
if(srcFile.isDirectory()) {
File[] files = srcFile.listFiles();
destFile.mkdir();
for(File f:files) {
if(f.isDirectory()) {
String newFolderPath = destFile.getAbsolutePath()+"\\"+f.getName();
File newFolder = new File(newFolderPath);
newFolder.mkdir();
System.out.println("新文件夹的位置是:"+newFolderPath);
copyFolder(f,newFolder);
}else {
String newFilePath = destFile.getAbsolutePath()+"\\"+f.getName();
System.out.println("新文件的位置是:"+newFilePath);
File newF = new File(newFilePath);
copyFile(f,newF);
}
}
}else {
copyFile(srcFile, destFile);
}
}
/**
* 查找指定的文件内容
* @param s:要查找的字符串
* @param file:要查找的文件对象
*/
public static void findFileContent(String s,File file) {
if(file.isDirectory()) {
File[] files = file.listFiles();
for(File f:files) {
findFileContent(s,f);
}
}else {
try(
FileReader fr = new FileReader(file);
BufferedReader br = new BufferedReader(fr);
) {
while(true) {
String str = br.readLine();
if(null == str) {break;}
if(str.contains(s)) {
System.out.println("找到目标字符串"+s+",在文件:"+file.getAbsolutePath());
break;
}
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
}
}
}
文件 File的更多相关文章
- Android studio 菜单介绍 3.1.文件(File)
文件(File) 3.1.1.New 1. Android Studio中的Project相当于Eclipse中的Workspace 3.1.5.Close Prject 关闭当前项目打开的窗口 2. ...
- 文件File
前面的话 不能直接访问用户计算机中的文件,一直都是Web应用开发中的一大障碍.2000年以前,处理文件的唯一方式就是在表单中加入<input type="file">字 ...
- c#中字节数组byte[]、图片image、流stream,字符串string、内存流MemoryStream、文件file,之间的转换
字节数组byte[]与图片image之间的转化 字节数组转换成图片 public static Image byte2img(byte[] buffer) { MemoryStream ms = ne ...
- Java笔记:Java 流(Stream)、文件(File)和IO
更新时间:2018-1-7 12:27:21 更多请查看在线文集:http://android.52fhy.com/java/index.html java.io 包几乎包含了所有操作输入.输出需要的 ...
- Java文件File类学习总结
java.io.File类 代表文件和目录,在开发中,读取文件.生成文件.删除文件.修改文件的属性都会用到该类. 常见构造方法: public File(String pathName){} 以pat ...
- java学习笔记(九):Java 流(Stream)、文件(File)和IO
Java 的控制台输入由 System.in 完成. 为了获得一个绑定到控制台的字符流,你可以把 System.in 包装在一个 BufferedReader 对象中来创建一个字符流.需要import ...
- Go标准库之读写文件(File)
Go标准库之读写文件(File) 创建一个空文件 package main import ( "log" "os" ) func main() { file, ...
- Java - 17 Java 流(Stream)、文件(File)和IO
Java 流(Stream).文件(File)和IO Java.io包几乎包含了所有操作输入.输出需要的类.所有这些流类代表了输入源和输出目标. Java.io包中的流支持很多种格式,比如:基本类型. ...
- 文件 File 常见操作 工具 MD
Markdown版本笔记 我的GitHub首页 我的博客 我的微信 我的邮箱 MyAndroidBlogs baiqiantao baiqiantao bqt20094 baiqiantao@sina ...
- Java总结:Java 流(Stream)、文件(File)和IO
更新时间:2018-1-7 12:27:21 更多请查看在线文集:http://android.52fhy.com/java/index.html java.io 包几乎包含了所有操作输入.输出需要的 ...
随机推荐
- Open Source v.s. Open Core
摘要 本文翻译自 CMSWire 网站的<Open Source vs. Open Core: What's the Difference?>,主要介绍 Open Source 和 Ope ...
- yii2 rules 规则
required : 必须值验证属性 [['字段名'],required,'requiredValue'=>'必填值','message'=>'提示信息']; #说明:CRequiredV ...
- mysql中间件分享(Mysql-prxoy,Atlas,DBProxy,Amoeba,cobar,TDDL)
hello 各位小伙伴大家好,我是小栈君,这期我们分享关于mysql中间件的研究,也就是数据层的读写分离和负载均衡,希望能够在实际的应用中能够帮助到各位小伙伴. 下期我们将继续分享go语言的系列讲解, ...
- 用到的Dos命令总结 持续更新
1.xcopy命令:复制的扩展命令 常用参数:/s:复制空文件夹 不使用可能会造成文件混乱 /y忽略覆盖提示 使用/y会直接覆盖全部 例子:xcopy lark-UI\dist C:\U ...
- Elasticsearch Java API 很全的整理
Elasticsearch 的API 分为 REST Client API(http请求形式)以及 transportClient API两种.相比来说transportClient API效率更高, ...
- POJ 3784 Running Median (模拟水过带翻译)
Description Moscow is hosting a major international conference, which is attended by n scientists fr ...
- Windows系统调用中的系统服务表描述符
Windows内核分析索引目录:https://www.cnblogs.com/onetrainee/p/11675224.html Windows系统调用中的系统服务表描述符 在前面,我们将解过 ...
- p0wnedshell的介绍与使用
0x01 前言 p0wnedShell是一个用c#编写的攻击性PowerShell主机应用程序,它不依赖于PowerShell .exe,而是在PowerShell runspace环境(. net) ...
- [JOYOI1463] 智商问题
题目限制 时间限制 内存限制 评测方式 题目来源 1500ms 131072KiB 标准比较器 Local 题目背景 各种数据结构帝~ 各种小姊妹帝~ 各种一遍AC帝~ 来吧! 题目描述 某个同学又有 ...
- springboot Jar包 部署到Linux服务器运行脚本
1.jar包同级目录 , 如下: #!/bin/sh RESOURCE_NAME=demo.jar tpid=`ps -ef|grep $RESOURCE_NAME|grep -v grep|grep ...