lubacui
- 浏览: 27009 次
- 性别:
- 来自: 上海
-
文章分类
最新评论
用java写的一个文件操作类包
关键字: 转
前几天仔细看了看java的I/O操作，呵呵。就写了一个操作文件的类包，功能有创建文件或目录，删除文件或目录，复制文件或目录，移动文件或目录，设置文件或目录属性，查看文件或目录大小。呵呵，功能比较简单，源代码为：
创建：
Java代码
package fileOperation;
import java.io.File;
/**创建一个新的文件或目录
* @author wakin
*
*/
public class Create
{
/**
* 根据路径名创建文件
* @param filePath 路径名
* @return 当创建文件成功后，返回true,否则返回false.
*
*/
public boolean createFile(String filePath) {
boolean isDone = false;
File file = new File(filePath);
if(file.exists())
throw new RuntimeException("File: "+filePath+" is already exist");
try {
isDone = file.createNewFile();
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
return isDone;
}
/**
* 根据路径名创建目录
* @param filePath 路径名
* @return 当创建目录成功后，返回true,否则返回false.
*/
public boolean createDir(String filePath) {
boolean isDone = false;
File file = new File(filePath);
if(file.exists())
throw new RuntimeException("FileDirectory: "+filePath+" is already exist");
isDone = file.mkdirs();
return isDone;
}
}
package fileOperation;
import java.io.File;
/**创建一个新的文件或目录
* @author wakin
*
*/
public class Create
{
/**
* 根据路径名创建文件
* @param filePath 路径名
* @return 当创建文件成功后，返回true,否则返回false.
*
*/
public boolean createFile(String filePath) {
boolean isDone = false;
File file = new File(filePath);
if(file.exists())
throw new RuntimeException("File: "+filePath+" is already exist");
try {
isDone = file.createNewFile();
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
return isDone;
}
/**
* 根据路径名创建目录
* @param filePath 路径名
* @return 当创建目录成功后，返回true,否则返回false.
*/
public boolean createDir(String filePath) {
boolean isDone = false;
File file = new File(filePath);
if(file.exists())
throw new RuntimeException("FileDirectory: "+filePath+" is already exist");
isDone = file.mkdirs();
return isDone;
}
}
删除：
Java代码
package fileOperation;
import java.io.File;
import java.io.IOException;
/**
* 删除一个文件或目录
* @author wakin
*
*/
public class Delete
{
/**
* 删除路径名所代表的文件。
* @param filePath 路径名
* @return 当文件成功删除，返回true,否则返回false.
*/
public boolean deleteFile(String filePath) throws IOException{
File file = new File(filePath);
if(file.exists()) {
file.delete();
//System.out.println(filePath+"文件已删除.");
return true;
}
else {
//System.out.println("逻辑错误："+filePath+"文件不存在.");
return false;
}
}
/**
* 删除路径名所代表的目录
* @param filePath 路径名
* @return 当目录成功删除，返回true,否则返回false.
*/
public boolean deleteDir(String filePath) throws IOException{
boolean isDone = false;
File file = new File(filePath);
//判断是文件还是目录
if(file.exists()&&file.isDirectory()){
if(file.listFiles().length==0){
file.delete();
isDone = true;
}
else {
File [] delFiles = file.listFiles();
for(int i=0;i<delFiles.length;i++){
if(delFiles[i].isDirectory()){
deleteDir(delFiles[i].getAbsolutePath()); //递归调用deleteDir函数
}
else {
delFiles[i].delete();
}
}
}
//删除最后剩下的目录名。
deleteDir(filePath);
isDone = true;
}
else
return false;
return isDone;
}
}
package fileOperation;
import java.io.File;
import java.io.IOException;
/**
* 删除一个文件或目录
* @author wakin
*
*/
public class Delete
{
/**
* 删除路径名所代表的文件。
* @param filePath 路径名
* @return 当文件成功删除，返回true,否则返回false.
*/
public boolean deleteFile(String filePath) throws IOException{
File file = new File(filePath);
if(file.exists()) {
file.delete();
//System.out.println(filePath+"文件已删除.");
return true;
}
else {
//System.out.println("逻辑错误："+filePath+"文件不存在.");
return false;
}
}
/**
* 删除路径名所代表的目录
* @param filePath 路径名
* @return 当目录成功删除，返回true,否则返回false.
*/
public boolean deleteDir(String filePath) throws IOException{
boolean isDone = false;
File file = new File(filePath);
//判断是文件还是目录
if(file.exists()&&file.isDirectory()){
if(file.listFiles().length==0){
file.delete();
isDone = true;
}
else {
File [] delFiles = file.listFiles();
for(int i=0;i<delFiles.length;i++){
if(delFiles[i].isDirectory()){
deleteDir(delFiles[i].getAbsolutePath()); //递归调用deleteDir函数
}
else {
delFiles[i].delete();
}
}
}
//删除最后剩下的目录名。
deleteDir(filePath);
isDone = true;
}
else
return false;
return isDone;
}
}
复制：
Java代码
package fileOperation;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* 复制文件和文件夹工具类，能判断源文件不存在，源文件不可读，目标文件已经存在，
* 目标路径不存在，目标路径不可写等情况
* @author wakin
*
*/
public class Copy
{
/**根据源路径名和目标路径名复制文件。
*
* @param source_name 源路径名
* @param dest_name 目标路径名
* @param type 值为判断如果目标路径存在是否覆盖，1为覆盖旧的文件，2为不覆盖，操作取消。
* @return 当复制成功时返回1， 当目标文件存在且type值为2时返回2，其他情况返回0
* @throws IOException 发生I/O错误
*/
public int copyFile(
String source_name,
String dest_name,
int type) throws IOException {
int result = 0;
int byte_read;
byte [] buffer;
File source_file = new File(source_name);
File dest_file = new File(dest_name);
FileInputStream source = null;
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
FileOutputStream dest = null;
try {
if(!source_file.exists() || !source_file.isFile()) //不存在
throw new RuntimeException("FileCopy: no such source file:"+source_name);
if(!source_file.canRead()) //不可读
throw new RuntimeException("FileCopy: source file"+source_name
+"is unreadable");
if(dest_file.exists()) {
if(dest_file.isFile()) {
if(type==1) {
dest_file.delete(); //覆盖
result = 1 ;
}
else if(type==2) {
result = 2;
return result; //不覆盖 ，程序返回。
}
}
else
throw new RuntimeException("FileCopy: destination"+dest_name
+"is not a file.");
}
else {
File parentDir = new File(dest_file.getParent()); //获得目录信息
if(!parentDir.exists()) {
throw new RuntimeException("FileCopy: destination"+dest_name
+"directory doesn't exist."); //目录不存在
}
if(!parentDir.canWrite())
throw new RuntimeException("FileCopy: destination"+dest_name
+"is unwriteable."); //目录不可写
}
//开始复制文件
//输入流
source = new FileInputStream(source_file);
bis = new BufferedInputStream(source);
//输出流
dest = new FileOutputStream(dest_file);
bos = new BufferedOutputStream(dest);
buffer = new byte[1024*5];
while((byte_read=bis.read(buffer))!=-1) {
bos.write(buffer, 0, byte_read);
}
result = 1;
} catch (IOException e) {
// TODO: handle exception
e.printStackTrace();
} finally {
if(source!=null){
bis.close();
source.close();
}
if(dest!=null) {
bos.flush();
bos.close();
dest.flush();
dest.close();
}
}
return result;
}
/**根据源路径名和目标路径名复制目录。
* 复制目录以复制文件为基础，通过递归复制子目录实现。
* @param source_name 源路径名
* @param dest_name 目标路径名
* @param type 值为判断如果目标路径存在是否覆盖，1为覆盖旧的目录，2为不覆盖，操作取消。
* @return 当复制成功时返回1， 当目标目录存在且type值为2时返回2，其他情况返回0
* @throws IOException 发生I/O错误
*/
public int copyDirectory(
String source_name,
String dest_name,
int type
) throws IOException {
File source_file = new File(source_name);
File dest_file = new File(dest_name);
int result = 0;
Delete del = new Delete(); //用于删除目录文件
if(!source_file.exists()||source_file.isFile()) //不存在
throw new RuntimeException("DirCopy: no such dir"+source_name);
if(!source_file.canRead()) //不可读
throw new RuntimeException("DirCopy: source file"+source_name
+"is unreadable");
if(dest_file.exists()) {
if(type==1) {
del.deleteDir(dest_name); //覆盖
result = 1;
}
if(type==2) {
result = 2; //不覆盖
return result;
}
}
if(!dest_file.exists()) {
new File(dest_name).mkdirs(); //创建目标目录
File[] fileList = source_file.listFiles();
for(int i=0;i<fileList.length;i++){
System.out.println(fileList[i].getName());
if(fileList[i].isFile()){
//用copyFile函数复制文件
this.copyFile(
source_name+"/"+fileList[i].getName(),
dest_name+"/"+fileList[i].getName(),
type);
}
else if(fileList[i].isDirectory()){
//递归
copyDirectory(
source_name+"/"+fileList[i].getName(),
dest_name+"/"+fileList[i].getName(), type);
}
}
result = 1;
}
return result;
}
}
package fileOperation;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* 复制文件和文件夹工具类，能判断源文件不存在，源文件不可读，目标文件已经存在，
* 目标路径不存在，目标路径不可写等情况
* @author wakin
*
*/
public class Copy
{
/**根据源路径名和目标路径名复制文件。
*
* @param source_name 源路径名
* @param dest_name 目标路径名
* @param type 值为判断如果目标路径存在是否覆盖，1为覆盖旧的文件，2为不覆盖，操作取消。
* @return 当复制成功时返回1， 当目标文件存在且type值为2时返回2，其他情况返回0
* @throws IOException 发生I/O错误
*/
public int copyFile(
String source_name,
String dest_name,
int type) throws IOException {
int result = 0;
int byte_read;
byte [] buffer;
File source_file = new File(source_name);
File dest_file = new File(dest_name);
FileInputStream source = null;
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
FileOutputStream dest = null;
try {
if(!source_file.exists() || !source_file.isFile()) //不存在
throw new RuntimeException("FileCopy: no such source file:"+source_name);
if(!source_file.canRead()) //不可读
throw new RuntimeException("FileCopy: source file"+source_name
+"is unreadable");
if(dest_file.exists()) {
if(dest_file.isFile()) {
if(type==1) {
dest_file.delete(); //覆盖
result = 1 ;
}
else if(type==2) {
result = 2;
return result; //不覆盖 ，程序返回。
}
}
else
throw new RuntimeException("FileCopy: destination"+dest_name
+"is not a file.");
}
else {
File parentDir = new File(dest_file.getParent()); //获得目录信息
if(!parentDir.exists()) {
throw new RuntimeException("FileCopy: destination"+dest_name
+"directory doesn't exist."); //目录不存在
}
if(!parentDir.canWrite())
throw new RuntimeException("FileCopy: destination"+dest_name
+"is unwriteable."); //目录不可写
}
//开始复制文件
//输入流
source = new FileInputStream(source_file);
bis = new BufferedInputStream(source);
//输出流
dest = new FileOutputStream(dest_file);
bos = new BufferedOutputStream(dest);
buffer = new byte[1024*5];
while((byte_read=bis.read(buffer))!=-1) {
bos.write(buffer, 0, byte_read);
}
result = 1;
} catch (IOException e) {
// TODO: handle exception
e.printStackTrace();
} finally {
if(source!=null){
bis.close();
source.close();
}
if(dest!=null) {
bos.flush();
bos.close();
dest.flush();
dest.close();
}
}
return result;
}
/**根据源路径名和目标路径名复制目录。
* 复制目录以复制文件为基础，通过递归复制子目录实现。
* @param source_name 源路径名
* @param dest_name 目标路径名
* @param type 值为判断如果目标路径存在是否覆盖，1为覆盖旧的目录，2为不覆盖，操作取消。
* @return 当复制成功时返回1， 当目标目录存在且type值为2时返回2，其他情况返回0
* @throws IOException 发生I/O错误
*/
public int copyDirectory(
String source_name,
String dest_name,
int type
) throws IOException {
File source_file = new File(source_name);
File dest_file = new File(dest_name);
int result = 0;
Delete del = new Delete(); //用于删除目录文件
if(!source_file.exists()||source_file.isFile()) //不存在
throw new RuntimeException("DirCopy: no such dir"+source_name);
if(!source_file.canRead()) //不可读
throw new RuntimeException("DirCopy: source file"+source_name
+"is unreadable");
if(dest_file.exists()) {
if(type==1) {
del.deleteDir(dest_name); //覆盖
result = 1;
}
if(type==2) {
result = 2; //不覆盖
return result;
}
}
if(!dest_file.exists()) {
new File(dest_name).mkdirs(); //创建目标目录
File[] fileList = source_file.listFiles();
for(int i=0;i<fileList.length;i++){
System.out.println(fileList[i].getName());
if(fileList[i].isFile()){
//用copyFile函数复制文件
this.copyFile(
source_name+"/"+fileList[i].getName(),
dest_name+"/"+fileList[i].getName(),
type);
}
else if(fileList[i].isDirectory()){
//递归
copyDirectory(
source_name+"/"+fileList[i].getName(),
dest_name+"/"+fileList[i].getName(), type);
}
}
result = 1;
}
return result;
}
}
移动：本来想用renameTo方法来实现的，但是发现这个方法有些问题。在我的博客里写明了，希望大家能指点一下。
Java代码
package fileOperation;
import java.io.File;
import java.io.IOException;
/**
* 移动文件/目录，利用Delete类和Copy类来实现。
* @author wakin
*
*/
public class Move {
/**
* 利用Copy类的函数和Delete类来完成移动文件/目录的操作。
* @param source_name 源路径名
* @param dest_name 目标路径名
* @param type type 值为判断如果目标路径存在是否覆盖，1为覆盖旧的文件/目录，2为不覆盖操作取消。
* @return 当移动成功后返回1，当目标目录存在且type值为2时返回2，其他情况返回0
* @throws IOException 发生I/O错误
*/
public int move(String source_name,String dest_name,int type) throws IOException{
int result = 0;
Copy copy = new Copy();
Delete delete = new Delete();
File source_file = new File(source_name);
//File dest_file = new File(dest_name);
if(!source_file.exists())
throw new RuntimeException("FileMove: no such source file:"+source_name);
if(source_file.isFile()){
result = copy.copyFile(source_name, dest_name, type); //调用Copy类的copyFile函数
if(result ==1)
delete.deleteFile(source_name); //调用Delete类的deleteFile函数删除源文件
}
else {
result = copy.copyDirectory(source_name, dest_name, type);//调用Copy类的copyDirectory函数
if(result == 1)
delete.deleteDir(source_name); //调用Delete类的deleteDir函数删除源目录
}
return result;
}
}
package fileOperation;
import java.io.File;
import java.io.IOException;
/**
* 移动文件/目录，利用Delete类和Copy类来实现。
* @author wakin
*
*/
public class Move {
/**
* 利用Copy类的函数和Delete类来完成移动文件/目录的操作。
* @param source_name 源路径名
* @param dest_name 目标路径名
* @param type type 值为判断如果目标路径存在是否覆盖，1为覆盖旧的文件/目录，2为不覆盖操作取消。
* @return 当移动成功后返回1，当目标目录存在且type值为2时返回2，其他情况返回0
* @throws IOException 发生I/O错误
*/
public int move(String source_name,String dest_name,int type) throws IOException{
int result = 0;
Copy copy = new Copy();
Delete delete = new Delete();
File source_file = new File(source_name);
//File dest_file = new File(dest_name);
if(!source_file.exists())
throw new RuntimeException("FileMove: no such source file:"+source_name);
if(source_file.isFile()){
result = copy.copyFile(source_name, dest_name, type); //调用Copy类的copyFile函数
if(result ==1)
delete.deleteFile(source_name); //调用Delete类的deleteFile函数删除源文件
}
else {
result = copy.copyDirectory(source_name, dest_name, type);//调用Copy类的copyDirectory函数
if(result == 1)
delete.deleteDir(source_name); //调用Delete类的deleteDir函数删除源目录
}
return result;
}
}
查看，设置属性：
Java代码
package fileOperation;
import java.io.File;
/**
* 查看，修改文件或目录的属性
* @author wakin
*
*/
public class Attribute {
/**
* 查看路径名所表示文件或目录的属性。
* @param fileName 路径名
*/
public void lookAttribute(String fileName) {
boolean canRead;
boolean canWrite;
boolean canExecute;
File file = new File(fileName);
if(!file.exists())
throw new RuntimeException("File:"+fileName+"is not exist");
canRead = file.canRead();
canWrite = file.canWrite();
canExecute = file.canExecute();
System.out.println("Can read:"+canRead+" Can write:"+canWrite+" Can Execute:"+canExecute);
}
/**
* 设置路径名所表示的文件或目录的的属性。？部分功能可能在windows下无效。
* @param fileName 路径名
* @param readable 是否可读
* @param writable 是否可写
* @param executable 是否可执行
* @param ownerOnly 是否用户独享
* @return 属性设置成功，返回true,否则返回false
*/
public boolean setAttribute(
String fileName,
boolean readable,
boolean writable,
boolean executable,
boolean ownerOnly)
{
boolean isDone = false;
File file = new File(fileName);
isDone = file.setReadable(readable, ownerOnly)
&& file.setWritable(writable, ownerOnly)
&& file.setExecutable(executable, ownerOnly);
return isDone;
}
}
package fileOperation;
import java.io.File;
/**
* 查看，修改文件或目录的属性
* @author wakin
*
*/
public class Attribute {
/**
* 查看路径名所表示文件或目录的属性。
* @param fileName 路径名
*/
public void lookAttribute(String fileName) {
boolean canRead;
boolean canWrite;
boolean canExecute;
File file = new File(fileName);
if(!file.exists())
throw new RuntimeException("File:"+fileName+"is not exist");
canRead = file.canRead();
canWrite = file.canWrite();
canExecute = file.canExecute();
System.out.println("Can read:"+canRead+" Can write:"+canWrite+" Can Execute:"+canExecute);
}
/**
* 设置路径名所表示的文件或目录的的属性。？部分功能可能在windows下无效。
* @param fileName 路径名
* @param readable 是否可读
* @param writable 是否可写
* @param executable 是否可执行
* @param ownerOnly 是否用户独享
* @return 属性设置成功，返回true,否则返回false
*/
public boolean setAttribute(
String fileName,
boolean readable,
boolean writable,
boolean executable,
boolean ownerOnly)
{
boolean isDone = false;
File file = new File(fileName);
isDone = file.setReadable(readable, ownerOnly)
&& file.setWritable(writable, ownerOnly)
&& file.setExecutable(executable, ownerOnly);
return isDone;
}
}
查看大小：
Java代码
package fileOperation;
import java.io.File;
import java.io.IOException;
/**
* 计算文件或目录的空间大小。
* @author wakin
*
*/
public class Size {
/**
* 计算路径名代表的文件或目录所占空间的大小。
* @param fileName 路径名
* @return 所占字节数
* @throws IOException 发生I/O错误
*/
public static long getSize(String fileName) throws IOException {
long result = 0;
File file = new File(fileName);
if(!file.exists())
throw new RuntimeException("No such source file:"+fileName);
if(file.isFile()){
return file.length();
}
else {
String [] FileList = file.list();
for(int i =0;i<FileList.length;i++) {
result += getSize(fileName+"/"+FileList[i]); //迭代
}
}
return result;
}
}
关键字: 转
前几天仔细看了看java的I/O操作，呵呵。就写了一个操作文件的类包，功能有创建文件或目录，删除文件或目录，复制文件或目录，移动文件或目录，设置文件或目录属性，查看文件或目录大小。呵呵，功能比较简单，源代码为：
创建：
Java代码
package fileOperation;
import java.io.File;
/**创建一个新的文件或目录
* @author wakin
*
*/
public class Create
{
/**
* 根据路径名创建文件
* @param filePath 路径名
* @return 当创建文件成功后，返回true,否则返回false.
*
*/
public boolean createFile(String filePath) {
boolean isDone = false;
File file = new File(filePath);
if(file.exists())
throw new RuntimeException("File: "+filePath+" is already exist");
try {
isDone = file.createNewFile();
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
return isDone;
}
/**
* 根据路径名创建目录
* @param filePath 路径名
* @return 当创建目录成功后，返回true,否则返回false.
*/
public boolean createDir(String filePath) {
boolean isDone = false;
File file = new File(filePath);
if(file.exists())
throw new RuntimeException("FileDirectory: "+filePath+" is already exist");
isDone = file.mkdirs();
return isDone;
}
}
package fileOperation;
import java.io.File;
/**创建一个新的文件或目录
* @author wakin
*
*/
public class Create
{
/**
* 根据路径名创建文件
* @param filePath 路径名
* @return 当创建文件成功后，返回true,否则返回false.
*
*/
public boolean createFile(String filePath) {
boolean isDone = false;
File file = new File(filePath);
if(file.exists())
throw new RuntimeException("File: "+filePath+" is already exist");
try {
isDone = file.createNewFile();
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
return isDone;
}
/**
* 根据路径名创建目录
* @param filePath 路径名
* @return 当创建目录成功后，返回true,否则返回false.
*/
public boolean createDir(String filePath) {
boolean isDone = false;
File file = new File(filePath);
if(file.exists())
throw new RuntimeException("FileDirectory: "+filePath+" is already exist");
isDone = file.mkdirs();
return isDone;
}
}
删除：
Java代码
package fileOperation;
import java.io.File;
import java.io.IOException;
/**
* 删除一个文件或目录
* @author wakin
*
*/
public class Delete
{
/**
* 删除路径名所代表的文件。
* @param filePath 路径名
* @return 当文件成功删除，返回true,否则返回false.
*/
public boolean deleteFile(String filePath) throws IOException{
File file = new File(filePath);
if(file.exists()) {
file.delete();
//System.out.println(filePath+"文件已删除.");
return true;
}
else {
//System.out.println("逻辑错误："+filePath+"文件不存在.");
return false;
}
}
/**
* 删除路径名所代表的目录
* @param filePath 路径名
* @return 当目录成功删除，返回true,否则返回false.
*/
public boolean deleteDir(String filePath) throws IOException{
boolean isDone = false;
File file = new File(filePath);
//判断是文件还是目录
if(file.exists()&&file.isDirectory()){
if(file.listFiles().length==0){
file.delete();
isDone = true;
}
else {
File [] delFiles = file.listFiles();
for(int i=0;i<delFiles.length;i++){
if(delFiles[i].isDirectory()){
deleteDir(delFiles[i].getAbsolutePath()); //递归调用deleteDir函数
}
else {
delFiles[i].delete();
}
}
}
//删除最后剩下的目录名。
deleteDir(filePath);
isDone = true;
}
else
return false;
return isDone;
}
}
package fileOperation;
import java.io.File;
import java.io.IOException;
/**
* 删除一个文件或目录
* @author wakin
*
*/
public class Delete
{
/**
* 删除路径名所代表的文件。
* @param filePath 路径名
* @return 当文件成功删除，返回true,否则返回false.
*/
public boolean deleteFile(String filePath) throws IOException{
File file = new File(filePath);
if(file.exists()) {
file.delete();
//System.out.println(filePath+"文件已删除.");
return true;
}
else {
//System.out.println("逻辑错误："+filePath+"文件不存在.");
return false;
}
}
/**
* 删除路径名所代表的目录
* @param filePath 路径名
* @return 当目录成功删除，返回true,否则返回false.
*/
public boolean deleteDir(String filePath) throws IOException{
boolean isDone = false;
File file = new File(filePath);
//判断是文件还是目录
if(file.exists()&&file.isDirectory()){
if(file.listFiles().length==0){
file.delete();
isDone = true;
}
else {
File [] delFiles = file.listFiles();
for(int i=0;i<delFiles.length;i++){
if(delFiles[i].isDirectory()){
deleteDir(delFiles[i].getAbsolutePath()); //递归调用deleteDir函数
}
else {
delFiles[i].delete();
}
}
}
//删除最后剩下的目录名。
deleteDir(filePath);
isDone = true;
}
else
return false;
return isDone;
}
}
复制：
Java代码
package fileOperation;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* 复制文件和文件夹工具类，能判断源文件不存在，源文件不可读，目标文件已经存在，
* 目标路径不存在，目标路径不可写等情况
* @author wakin
*
*/
public class Copy
{
/**根据源路径名和目标路径名复制文件。
*
* @param source_name 源路径名
* @param dest_name 目标路径名
* @param type 值为判断如果目标路径存在是否覆盖，1为覆盖旧的文件，2为不覆盖，操作取消。
* @return 当复制成功时返回1， 当目标文件存在且type值为2时返回2，其他情况返回0
* @throws IOException 发生I/O错误
*/
public int copyFile(
String source_name,
String dest_name,
int type) throws IOException {
int result = 0;
int byte_read;
byte [] buffer;
File source_file = new File(source_name);
File dest_file = new File(dest_name);
FileInputStream source = null;
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
FileOutputStream dest = null;
try {
if(!source_file.exists() || !source_file.isFile()) //不存在
throw new RuntimeException("FileCopy: no such source file:"+source_name);
if(!source_file.canRead()) //不可读
throw new RuntimeException("FileCopy: source file"+source_name
+"is unreadable");
if(dest_file.exists()) {
if(dest_file.isFile()) {
if(type==1) {
dest_file.delete(); //覆盖
result = 1 ;
}
else if(type==2) {
result = 2;
return result; //不覆盖 ，程序返回。
}
}
else
throw new RuntimeException("FileCopy: destination"+dest_name
+"is not a file.");
}
else {
File parentDir = new File(dest_file.getParent()); //获得目录信息
if(!parentDir.exists()) {
throw new RuntimeException("FileCopy: destination"+dest_name
+"directory doesn't exist."); //目录不存在
}
if(!parentDir.canWrite())
throw new RuntimeException("FileCopy: destination"+dest_name
+"is unwriteable."); //目录不可写
}
//开始复制文件
//输入流
source = new FileInputStream(source_file);
bis = new BufferedInputStream(source);
//输出流
dest = new FileOutputStream(dest_file);
bos = new BufferedOutputStream(dest);
buffer = new byte[1024*5];
while((byte_read=bis.read(buffer))!=-1) {
bos.write(buffer, 0, byte_read);
}
result = 1;
} catch (IOException e) {
// TODO: handle exception
e.printStackTrace();
} finally {
if(source!=null){
bis.close();
source.close();
}
if(dest!=null) {
bos.flush();
bos.close();
dest.flush();
dest.close();
}
}
return result;
}
/**根据源路径名和目标路径名复制目录。
* 复制目录以复制文件为基础，通过递归复制子目录实现。
* @param source_name 源路径名
* @param dest_name 目标路径名
* @param type 值为判断如果目标路径存在是否覆盖，1为覆盖旧的目录，2为不覆盖，操作取消。
* @return 当复制成功时返回1， 当目标目录存在且type值为2时返回2，其他情况返回0
* @throws IOException 发生I/O错误
*/
public int copyDirectory(
String source_name,
String dest_name,
int type
) throws IOException {
File source_file = new File(source_name);
File dest_file = new File(dest_name);
int result = 0;
Delete del = new Delete(); //用于删除目录文件
if(!source_file.exists()||source_file.isFile()) //不存在
throw new RuntimeException("DirCopy: no such dir"+source_name);
if(!source_file.canRead()) //不可读
throw new RuntimeException("DirCopy: source file"+source_name
+"is unreadable");
if(dest_file.exists()) {
if(type==1) {
del.deleteDir(dest_name); //覆盖
result = 1;
}
if(type==2) {
result = 2; //不覆盖
return result;
}
}
if(!dest_file.exists()) {
new File(dest_name).mkdirs(); //创建目标目录
File[] fileList = source_file.listFiles();
for(int i=0;i<fileList.length;i++){
System.out.println(fileList[i].getName());
if(fileList[i].isFile()){
//用copyFile函数复制文件
this.copyFile(
source_name+"/"+fileList[i].getName(),
dest_name+"/"+fileList[i].getName(),
type);
}
else if(fileList[i].isDirectory()){
//递归
copyDirectory(
source_name+"/"+fileList[i].getName(),
dest_name+"/"+fileList[i].getName(), type);
}
}
result = 1;
}
return result;
}
}
package fileOperation;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* 复制文件和文件夹工具类，能判断源文件不存在，源文件不可读，目标文件已经存在，
* 目标路径不存在，目标路径不可写等情况
* @author wakin
*
*/
public class Copy
{
/**根据源路径名和目标路径名复制文件。
*
* @param source_name 源路径名
* @param dest_name 目标路径名
* @param type 值为判断如果目标路径存在是否覆盖，1为覆盖旧的文件，2为不覆盖，操作取消。
* @return 当复制成功时返回1， 当目标文件存在且type值为2时返回2，其他情况返回0
* @throws IOException 发生I/O错误
*/
public int copyFile(
String source_name,
String dest_name,
int type) throws IOException {
int result = 0;
int byte_read;
byte [] buffer;
File source_file = new File(source_name);
File dest_file = new File(dest_name);
FileInputStream source = null;
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
FileOutputStream dest = null;
try {
if(!source_file.exists() || !source_file.isFile()) //不存在
throw new RuntimeException("FileCopy: no such source file:"+source_name);
if(!source_file.canRead()) //不可读
throw new RuntimeException("FileCopy: source file"+source_name
+"is unreadable");
if(dest_file.exists()) {
if(dest_file.isFile()) {
if(type==1) {
dest_file.delete(); //覆盖
result = 1 ;
}
else if(type==2) {
result = 2;
return result; //不覆盖 ，程序返回。
}
}
else
throw new RuntimeException("FileCopy: destination"+dest_name
+"is not a file.");
}
else {
File parentDir = new File(dest_file.getParent()); //获得目录信息
if(!parentDir.exists()) {
throw new RuntimeException("FileCopy: destination"+dest_name
+"directory doesn't exist."); //目录不存在
}
if(!parentDir.canWrite())
throw new RuntimeException("FileCopy: destination"+dest_name
+"is unwriteable."); //目录不可写
}
//开始复制文件
//输入流
source = new FileInputStream(source_file);
bis = new BufferedInputStream(source);
//输出流
dest = new FileOutputStream(dest_file);
bos = new BufferedOutputStream(dest);
buffer = new byte[1024*5];
while((byte_read=bis.read(buffer))!=-1) {
bos.write(buffer, 0, byte_read);
}
result = 1;
} catch (IOException e) {
// TODO: handle exception
e.printStackTrace();
} finally {
if(source!=null){
bis.close();
source.close();
}
if(dest!=null) {
bos.flush();
bos.close();
dest.flush();
dest.close();
}
}
return result;
}
/**根据源路径名和目标路径名复制目录。
* 复制目录以复制文件为基础，通过递归复制子目录实现。
* @param source_name 源路径名
* @param dest_name 目标路径名
* @param type 值为判断如果目标路径存在是否覆盖，1为覆盖旧的目录，2为不覆盖，操作取消。
* @return 当复制成功时返回1， 当目标目录存在且type值为2时返回2，其他情况返回0
* @throws IOException 发生I/O错误
*/
public int copyDirectory(
String source_name,
String dest_name,
int type
) throws IOException {
File source_file = new File(source_name);
File dest_file = new File(dest_name);
int result = 0;
Delete del = new Delete(); //用于删除目录文件
if(!source_file.exists()||source_file.isFile()) //不存在
throw new RuntimeException("DirCopy: no such dir"+source_name);
if(!source_file.canRead()) //不可读
throw new RuntimeException("DirCopy: source file"+source_name
+"is unreadable");
if(dest_file.exists()) {
if(type==1) {
del.deleteDir(dest_name); //覆盖
result = 1;
}
if(type==2) {
result = 2; //不覆盖
return result;
}
}
if(!dest_file.exists()) {
new File(dest_name).mkdirs(); //创建目标目录
File[] fileList = source_file.listFiles();
for(int i=0;i<fileList.length;i++){
System.out.println(fileList[i].getName());
if(fileList[i].isFile()){
//用copyFile函数复制文件
this.copyFile(
source_name+"/"+fileList[i].getName(),
dest_name+"/"+fileList[i].getName(),
type);
}
else if(fileList[i].isDirectory()){
//递归
copyDirectory(
source_name+"/"+fileList[i].getName(),
dest_name+"/"+fileList[i].getName(), type);
}
}
result = 1;
}
return result;
}
}
移动：本来想用renameTo方法来实现的，但是发现这个方法有些问题。在我的博客里写明了，希望大家能指点一下。
Java代码
package fileOperation;
import java.io.File;
import java.io.IOException;
/**
* 移动文件/目录，利用Delete类和Copy类来实现。
* @author wakin
*
*/
public class Move {
/**
* 利用Copy类的函数和Delete类来完成移动文件/目录的操作。
* @param source_name 源路径名
* @param dest_name 目标路径名
* @param type type 值为判断如果目标路径存在是否覆盖，1为覆盖旧的文件/目录，2为不覆盖操作取消。
* @return 当移动成功后返回1，当目标目录存在且type值为2时返回2，其他情况返回0
* @throws IOException 发生I/O错误
*/
public int move(String source_name,String dest_name,int type) throws IOException{
int result = 0;
Copy copy = new Copy();
Delete delete = new Delete();
File source_file = new File(source_name);
//File dest_file = new File(dest_name);
if(!source_file.exists())
throw new RuntimeException("FileMove: no such source file:"+source_name);
if(source_file.isFile()){
result = copy.copyFile(source_name, dest_name, type); //调用Copy类的copyFile函数
if(result ==1)
delete.deleteFile(source_name); //调用Delete类的deleteFile函数删除源文件
}
else {
result = copy.copyDirectory(source_name, dest_name, type);//调用Copy类的copyDirectory函数
if(result == 1)
delete.deleteDir(source_name); //调用Delete类的deleteDir函数删除源目录
}
return result;
}
}
package fileOperation;
import java.io.File;
import java.io.IOException;
/**
* 移动文件/目录，利用Delete类和Copy类来实现。
* @author wakin
*
*/
public class Move {
/**
* 利用Copy类的函数和Delete类来完成移动文件/目录的操作。
* @param source_name 源路径名
* @param dest_name 目标路径名
* @param type type 值为判断如果目标路径存在是否覆盖，1为覆盖旧的文件/目录，2为不覆盖操作取消。
* @return 当移动成功后返回1，当目标目录存在且type值为2时返回2，其他情况返回0
* @throws IOException 发生I/O错误
*/
public int move(String source_name,String dest_name,int type) throws IOException{
int result = 0;
Copy copy = new Copy();
Delete delete = new Delete();
File source_file = new File(source_name);
//File dest_file = new File(dest_name);
if(!source_file.exists())
throw new RuntimeException("FileMove: no such source file:"+source_name);
if(source_file.isFile()){
result = copy.copyFile(source_name, dest_name, type); //调用Copy类的copyFile函数
if(result ==1)
delete.deleteFile(source_name); //调用Delete类的deleteFile函数删除源文件
}
else {
result = copy.copyDirectory(source_name, dest_name, type);//调用Copy类的copyDirectory函数
if(result == 1)
delete.deleteDir(source_name); //调用Delete类的deleteDir函数删除源目录
}
return result;
}
}
查看，设置属性：
Java代码
package fileOperation;
import java.io.File;
/**
* 查看，修改文件或目录的属性
* @author wakin
*
*/
public class Attribute {
/**
* 查看路径名所表示文件或目录的属性。
* @param fileName 路径名
*/
public void lookAttribute(String fileName) {
boolean canRead;
boolean canWrite;
boolean canExecute;
File file = new File(fileName);
if(!file.exists())
throw new RuntimeException("File:"+fileName+"is not exist");
canRead = file.canRead();
canWrite = file.canWrite();
canExecute = file.canExecute();
System.out.println("Can read:"+canRead+" Can write:"+canWrite+" Can Execute:"+canExecute);
}
/**
* 设置路径名所表示的文件或目录的的属性。？部分功能可能在windows下无效。
* @param fileName 路径名
* @param readable 是否可读
* @param writable 是否可写
* @param executable 是否可执行
* @param ownerOnly 是否用户独享
* @return 属性设置成功，返回true,否则返回false
*/
public boolean setAttribute(
String fileName,
boolean readable,
boolean writable,
boolean executable,
boolean ownerOnly)
{
boolean isDone = false;
File file = new File(fileName);
isDone = file.setReadable(readable, ownerOnly)
&& file.setWritable(writable, ownerOnly)
&& file.setExecutable(executable, ownerOnly);
return isDone;
}
}
package fileOperation;
import java.io.File;
/**
* 查看，修改文件或目录的属性
* @author wakin
*
*/
public class Attribute {
/**
* 查看路径名所表示文件或目录的属性。
* @param fileName 路径名
*/
public void lookAttribute(String fileName) {
boolean canRead;
boolean canWrite;
boolean canExecute;
File file = new File(fileName);
if(!file.exists())
throw new RuntimeException("File:"+fileName+"is not exist");
canRead = file.canRead();
canWrite = file.canWrite();
canExecute = file.canExecute();
System.out.println("Can read:"+canRead+" Can write:"+canWrite+" Can Execute:"+canExecute);
}
/**
* 设置路径名所表示的文件或目录的的属性。？部分功能可能在windows下无效。
* @param fileName 路径名
* @param readable 是否可读
* @param writable 是否可写
* @param executable 是否可执行
* @param ownerOnly 是否用户独享
* @return 属性设置成功，返回true,否则返回false
*/
public boolean setAttribute(
String fileName,
boolean readable,
boolean writable,
boolean executable,
boolean ownerOnly)
{
boolean isDone = false;
File file = new File(fileName);
isDone = file.setReadable(readable, ownerOnly)
&& file.setWritable(writable, ownerOnly)
&& file.setExecutable(executable, ownerOnly);
return isDone;
}
}
查看大小：
Java代码
package fileOperation;
import java.io.File;
import java.io.IOException;
/**
* 计算文件或目录的空间大小。
* @author wakin
*
*/
public class Size {
/**
* 计算路径名代表的文件或目录所占空间的大小。
* @param fileName 路径名
* @return 所占字节数
* @throws IOException 发生I/O错误
*/
public static long getSize(String fileName) throws IOException {
long result = 0;
File file = new File(fileName);
if(!file.exists())
throw new RuntimeException("No such source file:"+fileName);
if(file.isFile()){
return file.length();
}
else {
String [] FileList = file.list();
for(int i =0;i<FileList.length;i++) {
result += getSize(fileName+"/"+FileList[i]); //迭代
}
}
return result;
}
}
分享到：
发表评论
相关推荐
以上就是“用Java写的本地文件操作”这个项目涉及的主要技术点。通过理解并实践这些知识点，开发者可以熟练地在Java应用程序中进行文件操作，无论是简单的文本文件还是更复杂的二进制文件。在实际开发中，还需要考虑...
Java编程语言提供了丰富的API用于处理文件操作，包括创建、读取、写入和删除文件等。在Java中，写文件是通过`java.io`包中的类实现的，主要涉及File类、FileWriter类、BufferedWriter类等。下面将详细阐述Java写文件...
# java实现对文件的各种操作的工具类 ## 可以实现的操作有: 1. 删除单个文件 2. 删除文件夹及文件夹下的文件 3. 使用文件流对单个文件进行复制 4. 复制整个文件夹内容(包含子文件夹中的所有内容) 5. ...
例如，`java.util` 是一个标准库包，包含了集合框架、日期时间等实用工具类。创建新包时，通常会按照公司域名的反向顺序来命名，比如 `com.example.myapp`。 在Java中，我们使用 `package` 关键字声明包，如： ```...
根据提供的文件名，我们可以假设TIo.java是一个实现了上述功能的工具类。它可能包含如下代码片段： ```java public class TIo { public static void createFile(String filePath) throws IOException { // 实现...
1. **文件操作**：在Java中，`java.io`包提供了丰富的类来执行文件操作，如`File`类用于文件和目录的基本操作，`FileReader`和`FileWriter`用于读写文本文件，`BufferedReader`和`BufferedWriter`用于提高读写效率，...
假设我们有一个`File`对象，可以使用`GridFSBucket`类进行操作： ```java GridFSBucket gridFSBucket = GridFSBuckets.create(database); GridFSUploadSession session = gridFSBucket.openUploadSession("your_...
这里我们关注的是一个名为"TextFile"的Java类，它提供了对文本文件进行读写的功能。JavaBean是一种特殊类型的Java类，设计用于数据封装和组件重用，通常遵循特定的命名和编码规范。在这个场景下，`TextFile`可能就是...
本文介绍了Java实现多个wav文件合成一个的方法，涉及java文件流读写、编码转换、解析等相关操作技巧。 知识点1：Java中的文件流读写 在Java中，文件流读写是通过使用`FileInputStream`和`FileOutputStream`类来...
标题中的“用java写的日历class文件和jar文件”表明这是一个使用Java语言编写的日历应用，它包含了源代码以及编译后的可执行版本。这个程序可能是一个简单的命令行工具，也可能具有图形用户界面（GUI），用于展示和...
依赖类包在我的sftp包下载下提供 版权声明：本工具类为个人兴趣基于chnSftp编写的应用，个人版权在先，后因各个办公环境无相关软件也有相关的个人使用，和办公环境内的推广使用，也欢迎互联网使用，如涉及相关环境...
首先，压缩包中包含了一个项目，这个项目包含了用于操作XML文件的Java类以及实际的XML文件。在Java中，我们通常使用DOM（Document Object Model）、SAX（Simple API for XML）或StAX（Streaming API for XML）等API...
这个标题为“一个用JAVA写的清除EXE病毒文件的代码”的项目，显然是利用Java来编写的一种防病毒解决方案，主要针对的是可执行文件（EXE）的病毒清理。 描述中提到的“清除EXE病毒文件的代码”，意味着这个Java程序...
Java的`java.nio.file`包提供了丰富的文件操作接口，如`Files.setPosixFilePermissions()`和`Files.newFileChannel()`，可以用来设置权限和创建文件通道进行锁定。 7. **文件自动加密**：文件加密通常涉及对文件...
在Java编程中，处理文件和压缩包操作是常见的任务，特别是在软件开发和数据传输中。本文将详细讲解如何使用Java实现将多目录多层级的文件打...理解并掌握这些知识，对于进行Java相关的文件操作和数据打包工作至关重要。
5个目标文件，演示Address EJB的实现，创建一个EJB测试客户端，得到名字上下文，查询jndi名，通过强制转型得到Home接口，getInitialContext()函数返回一个经过初始化的上下文，用client的getHome()函数调用Home接口...
Apache POI是Java社区开发的一个开源项目，专门用于处理Microsoft Office格式的文件，包括Word、Excel和PowerPoint。 首先，我们需要了解xlsx文件的结构。xlsx文件实际上是基于Open XML标准的，由一系列XML文件打包...
根据给出的文件名“MyUtils”，我们可以推断这个JAR包的核心类库名为"MyUtils"，它很可能是一个包含各种工具方法的Java类。在Java编程中，工具类通常以静态方法为主，不包含实例化对象，方便直接调用。MyUtils类可能...