android 文件处理类超完整
FileHelper.java类
package com.east.framework.file;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import android.content.Context;
import android.os.Environment;
import android.os.StatFs;
public class FileHelper {
private Context context;
private String SDPATH; //SD卡路径
private String FILESPATH; //文件路径
public FileHelper(Context context) {
this.context = context;
SDPATH = Environment.getExternalStorageDirectory().getPath() + "//";
FILESPATH = this.context.getFilesDir().getPath() + "//";
}
/**判断SDCard是否存在？是否可以进行读写*/
public boolean SDCardState(){
i f(Environment.getExternalStorageState().equals(
Environment.MEDIA_MOUNTED)){//表示SDCard存在并且可以读写return true;
}else{
return false;
}
}
/**获取SDCard文件路径*/
public String SDCardPath(){
i f(SDCardState()){//如果SDCard存在并且可以读写
SDPATH = Environment.getExternalStorageDirectory().getPath();
return SDPATH;
}else{
return null;
}
}
/**获取SDCard 总容量大小(MB)*/
public long SDCardTotal(){
i f(null != SDCardPath()&&SDCardPath().equals("")){
StatFs statfs = new StatFs(SDCardPath());
//获取SDCard的Block总数
long totalBlocks = statfs.getBlockCount();
//获取每个block的大小
long blockSize = statfs.getBlockSize();
//计算SDCard 总容量大小MB
long SDtotalSize = totalBlocks*blockSize/1024/1024;
return SDtotalSize;
}else{
return 0;
}
}
/**获取SDCard 可用容量大小(MB)*/
public long SDCardFree(){
i f(null != SDCardPath()&&SDCardPath().equals("")){
StatFs statfs = new StatFs(SDCardPath());
//获取SDCard的Block可用数
long availaBlocks = statfs.getAvailableBlocks();
//获取每个block的大小
long blockSize = statfs.getBlockSize();
//计算SDCard 可用容量大小MB
long SDFreeSize = availaBlocks*blockSize/1024/1024;
return SDFreeSize;
}else{
return 0;
}
}
/**
* 在SD卡上创建目录
*
* @param dirName
* 要创建的目录名
* @return创建得到的目录
*/
public File createSDDir(String dirName) {
File dir = new File(SDPATH + dirName);
dir.mkdir();
return dir;
}
* 删除SD卡上的目录
*
* @param dirName
*/
public boolean delSDDir(String dirName) {
File dir = new File(SDPATH + dirName);
return delDir(dir);
}
/**
* 在SD卡上创建文件
*
* @throws IOException
*/
public File createSDFile(String fileName) throws IOException { File file = new File(SDPATH + fileName);
file.createNewFile();
return file;
}
/**
* 判断文件是否已经存在
*
* @param fileName
* 要检查的文件名
* @return boolean, true表示存在，false表示不存在
*/
public boolean isFileExist(String fileName) {
File file = new File(SDPATH + fileName);
return file.exists();
}
/**
* 删除SD卡上的文件
*
* @param fileName
*/
public boolean delSDFile(String fileName) {
File file = new File(SDPATH + fileName);
if (file == null || !file.exists() || file.isDirectory()) return false;
file.delete();
return true;
/**
* 修改SD卡上的文件或目录名
*
* @param fileName
*/
public boolean renameSDFile(String oldfileName, String newFileName) {
File oleFile = new File(SDPATH + oldfileName);
File newFile = new File(SDPATH + newFileName);
return oleFile.renameTo(newFile);
}
/**
* 拷贝SD卡上的单个文件
*
* @param path
* @throws IOException
*/
public boolean copySDFileTo(String srcFileName, String destFileName) throws IOException {
File srcFile = new File(SDPATH + srcFileName);
File destFile = new File(SDPATH + destFileName);
return copyFileTo(srcFile, destFile);
}
/**
* 拷贝SD卡上指定目录的所有文件
*
* @param srcDirName
* @param destDirName
* @return
* @throws IOException
*/
public boolean copySDFilesTo(String srcDirName, String destDirName) throws IOException {
File srcDir = new File(SDPATH + srcDirName);
File destDir = new File(SDPATH + destDirName);
return copyFilesTo(srcDir, destDir);
}
* 移动SD卡上的单个文件
*
* @param srcFileName
* @param destFileName
* @return
* @throws IOException
*/
public boolean moveSDFileTo(String srcFileName, String destFileName) throws IOException {
File srcFile = new File(SDPATH + srcFileName);
File destFile = new File(SDPATH + destFileName);
return moveFileTo(srcFile, destFile);
}
/**
* 移动SD卡上的指定目录的所有文件
*
* @param srcDirName
* @param destDirName
* @return
* @throws IOException
*/
public boolean moveSDFilesTo(String srcDirName, String destDirName) throws IOException {
File srcDir = new File(SDPATH + srcDirName);
File destDir = new File(SDPATH + destDirName);
return moveFilesTo(srcDir, destDir);
}
/**
* 将文件写入sd卡。如:writeSDFile("test.txt");
*/
public Output writeSDFile(String fileName) throws IOException {
File file = new File(SDPATH + fileName);
FileOutputStream fos = new FileOutputStream(file);
return new Output(fos);
}
/**
* 在原有文件上继续写文件。如:appendSDFile("test.txt");
*/
public Output appendSDFile(String fileName) throws IOException { File file = new File(SDPATH + fileName);
FileOutputStream fos = new FileOutputStream(file, true);
return new Output(fos);
}
/**
* 从SD卡读取文件。如:readSDFile("test.txt");
*/
public Input readSDFile(String fileName) throws IOException {
File file = new File(SDPATH + fileName);
FileInputStream fis = new FileInputStream(file);
return new Input(fis);
}
/**
* 建立私有文件
*
* @param fileName
* @return
* @throws IOException
*/
public File creatDataFile(String fileName) throws IOException { File file = new File(FILESPATH + fileName);
file.createNewFile();
return file;
}
/**
* 建立私有目录
*
* @param dirName
* @return
*/
public File creatDataDir(String dirName) {
File dir = new File(FILESPATH + dirName);
dir.mkdir();
return dir;
}
/**
* 删除私有文件
*
* @param fileName
* @return
*/
public boolean delDataFile(String fileName) {
File file = new File(FILESPATH + fileName);
return delFile(file);
}
/**
* 删除私有目录
*
* @param dirName
* @return
*/
public boolean delDataDir(String dirName) {
File file = new File(FILESPATH + dirName);
return delDir(file);
}
/**
* 更改私有文件名
*
* @param oldName
* @param newName
* @return
*/
public boolean renameDataFile(String oldName, String newName) { File oldFile = new File(FILESPATH + oldName);
File newFile = new File(FILESPATH + newName);
return oldFile.renameTo(newFile);
}
/**
* 在私有目录下进行文件复制
*
* @param srcFileName
* ：包含路径及文件名
* @param destFileName
* @return
* @throws IOException
*/
public boolean copyDataFileTo(String srcFileName, String destFileName)
throws IOException {
File srcFile = new File(FILESPATH + srcFileName);
File destFile = new File(FILESPATH + destFileName);
return copyFileTo(srcFile, destFile);
}
/**
* 复制私有目录里指定目录的所有文件
*
* @param srcDirName
* @param destDirName
* @return
* @throws IOException
*/
public boolean copyDataFilesTo(String srcDirName, String destDirName)
throws IOException {
File srcDir = new File(FILESPATH + srcDirName);
File destDir = new File(FILESPATH + destDirName);
return copyFilesTo(srcDir, destDir);
}
/**
* 移动私有目录下的单个文件
*
* @param srcFileName
* @param destFileName
* @return
* @throws IOException
*/
public boolean moveDataFileTo(String srcFileName, String destFileName)
throws IOException {
File srcFile = new File(FILESPATH + srcFileName);
File destFile = new File(FILESPATH + destFileName);
return moveFileTo(srcFile, destFile);
}
/**
* 移动私有目录下的指定目录下的所有文件
*
* @param srcDirName
* @param destDirName
* @return
* @throws IOException
*/
public boolean moveDataFilesTo(String srcDirName, String
destDirName)
throws IOException {
File srcDir = new File(FILESPATH + srcDirName);
File destDir = new File(FILESPATH + destDirName);
return moveFilesTo(srcDir, destDir);
}
/**
* 将文件写入应用私有的files目录。如:writeFile("test.txt");
*/
public Output wirteFile(String fileName) throws IOException { OutputStream os = context.openFileOutput(fileName,
Context.MODE_WORLD_WRITEABLE);
return new Output(os);
}
/**
* 在原有文件上继续写文件。如:appendFile("test.txt");
*/
public Output appendFile(String fileName) throws IOException { OutputStream os = context.openFileOutput(fileName,
Context.MODE_APPEND);
return new Output(os);
}
/**
* 从应用的私有目录files读取文件。如:readFile("test.txt");
*/
public Input readFile(String fileName) throws IOException {
InputStream is = context.openFileInput(fileName);
return new Input(is);
}
/**
* 将一个输入流中的内容写入到SD卡上生成文件
*
* @param path
* 文件目录
* @param fileName
* 文件名
* @param inputStream
* 字节输入流
* @return得到的文件
*/
public File writeToSDCard(String path, String fileName,
InputStream inputStream) {
File file = null;
OutputStream output = null;
try{
createSDDir(path);
file = createSDFile(path + fileName);
output = new FileOutputStream(file);
byte buffer [] = new byte[4 * 1024];
while((inputStream.read(buffer)) != -1){ output.write(buffer);
}
output.flush();
}
catch(Exception e){
e.printStackTrace();
}
finally{
try{
output.close();
}
catch(Exception e){
e.printStackTrace();
}
}
return file;
}
/**
* 删除一个文件
*
* @param file
* @return
*/
public boolean delFile(File file) {
if (file.isDirectory())
return false;
return file.delete();
}
/**
* 删除一个目录（可以是非空目录）
*
* @param dir
*/
public boolean delDir(File dir) {
if (dir == null || !dir.exists() || dir.isFile()) { return false;
}
for (File file : dir.listFiles()) {
if (file.isFile()) {
file.delete();
} else if (file.isDirectory()) {
delDir(file);// 递归
}
}
dir.delete();
return true;
}
/**
* 拷贝一个文件,srcFile源文件，destFile目标文件
*
* @param path
* @throws IOException
*/
public boolean copyFileTo(File srcFile, File destFile) throws IOException {
if (srcFile.isDirectory() || destFile.isDirectory()) return false;// 判断是否是文件
FileInputStream fis = new FileInputStream(srcFile);
FileOutputStream fos = new FileOutputStream(destFile);
int readLen = 0;
byte[] buf = new byte[1024];
while ((readLen = fis.read(buf)) != -1) {
fos.write(buf, 0, readLen);
}
fos.flush();
fos.close();
fis.close();
return true;
}
/**
* 拷贝目录下的所有文件到指定目录
*
* @param srcDir
* @param destDir
* @return
* @throws IOException
*/
public boolean copyFilesTo(File srcDir, File destDir) throws IOException {
if (!srcDir.isDirectory() || !destDir.isDirectory()) return false;// 判断是否是目录
if (!destDir.exists())
return false;// 判断目标目录是否存在
File[] srcFiles = srcDir.listFiles();
for (int i = 0; i < srcFiles.length; i++) {
if (srcFiles[i].isFile()) {
// 获得目标文件
File destFile = new File(destDir.getPath() + "//"
+ srcFiles[i].getName());
copyFileTo(srcFiles[i], destFile);
} else if (srcFiles[i].isDirectory()) {
File theDestDir = new File(destDir.getPath() + "//" + srcFiles[i].getName());
copyFilesTo(srcFiles[i], theDestDir);
}
}
return true;
}
/**
* 移动一个文件
*
* @param srcFile
* @param destFile
* @return
* @throws IOException
*/
public boolean moveFileTo(File srcFile, File destFile) throws IOException {
boolean iscopy = copyFileTo(srcFile, destFile);
if (!iscopy)
return false;
delFile(srcFile);
return true;
}
/**
* 移动目录下的所有文件到指定目录
*
* @param srcDir
* @param destDir
* @return
* @throws IOException
*/
public boolean moveFilesTo(File srcDir, File destDir) throws IOException {
if (!srcDir.isDirectory() || !destDir.isDirectory()) { return false;
}
File[] srcDirFiles = srcDir.listFiles();
for (int i = 0; i < srcDirFiles.length; i++) {
if (srcDirFiles[i].isFile()) {
File oneDestFile = new File(destDir.getPath() + "//" + srcDirFiles[i].getName());
moveFileTo(srcDirFiles[i], oneDestFile);
delFile(srcDirFiles[i]);
} else if (srcDirFiles[i].isDirectory()) {
File oneDestFile = new File(destDir.getPath() + "//" + srcDirFiles[i].getName());
moveFilesTo(srcDirFiles[i], oneDestFile);
delDir(srcDirFiles[i]);
}
}
return true;
}
}
Input.java帮助类
package com.sinous.framework.file;
import java.io.ByteArrayOutputStream;
import java.io.EOFException;
import java.io.IOException;
import java.io.InputStream;
import java.io.UTFDataFormatException;
public class Input extends InputStream {
private static final int DEFAULT_BUFFER_SIZE = 1024;
private byte[] buf;
private int pos;
private int count;
private InputStream in;
public Input(InputStream in) {
this(in, DEFAULT_BUFFER_SIZE);
}
public Input(InputStream in, int bufferSize) {
this.in = in;
buf = new byte[bufferSize];
}
public void close() throws IOException {
buf = null;
in.close();
}
public int read() throws IOException {
if (pos >= count || pos >= buf.length) {
pos = 0;
count = in.read(buf, 0, DEFAULT_BUFFER_SIZE);
}
if (pos >= count) {
return -1;
}
return buf[pos++] & 0xff;
}
public int read(byte[] b) throws IOException {
return read(b, 0, b.length);
}
public int read(byte[] b, int off, int len) throws IOException { int remain = count - pos;
if (remain >= (len - off)) {
System.arraycopy(buf, pos, b, off, len);
pos += len;
return len;
} else {
if (remain > 0) {
System.arraycopy(buf, pos, b, off, remain);
pos += remain;
int newRemain = len - remain;
byte[] remainData = new byte[newRemain];
int rd = in.read(remainData, 0, newRemain);
System.arraycopy(remainData, 0, b, off + remain,
rd);
return remain + rd;
} else {
int rd = in.read(b, off, len);
return rd;
}
}
}
public boolean readBoolean() throws IOException { int ch = read();
if (ch < 0) {
throw new EOFException();
}
return (ch != 0);
}
public int readUnsignedByte() throws IOException { int ch = read();
if (ch < 0) {
throw new EOFException();
}
return ch;
}
public int readUnsignedShort() throws IOException { int ch1 = read();
int ch2 = read();
if ((ch1 | ch2) < 0) {
throw new EOFException();
}
return (ch1 << 8) + (ch2 << 0);
}
public short readShort() throws IOException {
int ch1 = read();
int ch2 = read();
if ((ch1 | ch2) < 0) {
throw new EOFException();
}
return (short) ((ch1 << 8) + (ch2 << 0));
}
public char readChar() throws IOException {
int ch1 = read();
int ch2 = read();
if ((ch1 | ch2) < 0) {
throw new EOFException();
}
return (char) ((ch1 << 8) + (ch2 << 0));
}
public int readInt() throws IOException {
int ch1 = read();
int ch2 = read();
int ch3 = read();
int ch4 = read();
if ((ch1 | ch2 | ch3 | ch4) < 0) {
throw new EOFException();
}
return ((ch1 << 24) + (ch2 << 16) + (ch3 << 8) + (ch4 << 0)); }
public long readLong() throws IOException {
return((long) (readInt()) << 32) + (readInt() & 0xFFFFFFFFL); }
public float readFloat() throws IOException {
return Float.intBitsToFloat(readInt());
}
public double readDouble() throws IOException {
return Double.longBitsToDouble(readLong());
}
public String readUTF8() throws IOException {
int utflen = readUnsignedShort();
if (utflen <= 0) {
return"";
}
char str[] = new char[utflen];
byte bytearr[] = new byte[utflen];
int c, char2, char3;
int count = 0;
int strlen = 0;
read(bytearr);
while (count < utflen) {
c = (int) bytearr[count] & 0xff;
switch (c >> 4) {
case 0:
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
case 7:
/* 0xxxxxxx */
count++;
str[strlen++] = (char) c;
break;
case 12:
case 13:
/* 110x xxxx 10xx xxxx */
count += 2;
if (count > utflen) {
throw new UTFDataFormatException();
}
char2 = (int) bytearr[count - 1];
if ((char2 & 0xC0) != 0x80) {
throw new UTFDataFormatException();
}
str[strlen++] = (char) (((c & 0x1F) << 6) | (char2 & 0x3F));
break;
case 14:
/* 1110 xxxx 10xx xxxx 10xx xxxx */
count += 3;
if (count > utflen) {
throw new UTFDataFormatException();
}
char2 = (int) bytearr[count - 2];
char3 = (int) bytearr[count - 1];
if(((char2 & 0xC0) != 0x80) || ((char3 & 0xC0) != 0x80)) {
throw new UTFDataFormatException();
}
str[strlen++] = (char) (((c & 0x0F) << 12)
| ((char2 & 0x3F) << 6) | ((char3 & 0x3F) << 0));
break;
default:
/* 10xx xxxx, 1111 xxxx */
throw new UTFDataFormatException();
}
}
// The number of chars produced may be less than utflen
return new String(str, 0, strlen);
}
public Serializable readSerializable() throws IOException {
String className = readUTF8();
Serializable serializable = null;
try {
serializable = (Serializable)
Class.forName(className).newInstance();
serializable.deserialize(this);
} catch (Exception e) {
throw new IOException(e.toString());
}
return serializable;
}
public byte[] readAll() throws IOException {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
int ch;
byte[] buffer = new byte[1024];
while ((ch = in.read(buffer)) != -1) {
baos.write(buffer, 0, ch);
}
byte[] ret = baos.toByteArray();
baos.close();
return ret;
}
}
Output.java帮助类
package com.sinous.framework.file;
import java.io.IOException;
import java.io.OutputStream;
import java.io.UTFDataFormatException;
public class Output extends OutputStream {
private static final int DEFAULT_BUFFER_SIZE = 1024;
private byte[] buf;
private int count;
private OutputStream out;
public Output(OutputStream out) {
this(out, DEFAULT_BUFFER_SIZE);
}
public Output(OutputStream out, int bufferSize) {
this.out = out;
buf = new byte[bufferSize];
}
private void flushBuffer() throws IOException {
if (count > 0) {
out.write(buf, 0, count);
count = 0;
}
}
public void flush() throws IOException {
flushBuffer();
out.flush();
}
public void close() throws IOException {
flush();
buf = null;
out.close();
}
public void write(int b) throws IOException {
if (count >= buf.length) {
flushBuffer();
}
buf[count++] = (byte) b;
}
public void write(byte[] b) throws IOException {
write(b, 0, b.length);
}
public void write(byte[] b, int off, int len) throws IOException {
if (len >= buf.length) {
flushBuffer();
out.write(b, off, len);
return;
} else if (len > buf.length - count) {
flushBuffer();
}
System.arraycopy(b, off, buf, count, len);
count += len;
}
public void writeBoolean(boolean v) throws IOException {
write(v ? 1 : 0);
}
public void writeShort(int v) throws IOException {
write((v >>> 8) & 0xFF);
write(v & 0xFF);
}
public void writeChar(int v) throws IOException {
write((v >>> 8) & 0xFF);
write(v & 0xFF);
}
public void writeInt(int v) throws IOException {
write((v >>> 24) & 0xFF);
write((v >>> 16) & 0xFF);
write((v >>> 8) & 0xFF);
write(v & 0xFF);
}
public void writeLong(long v) throws IOException {
write((int) (v >>> 56) & 0xFF);
write((int) (v >>> 48) & 0xFF);
write((int) (v >>> 40) & 0xFF);
write((int) (v >>> 32) & 0xFF);
write((int) (v >>> 24) & 0xFF);
write((int) (v >>> 16) & 0xFF);
write((int) (v >>> 8) & 0xFF);
write((int) v & 0xFF);
}