FileUtils web工具类

package com.company;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.CharArrayWriter;
import java.io.Closeable;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.LineNumberReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import javax.swing.filechooser.FileSystemView;

/**
* 描述: 文件工具类
*
* @author miweiqiang
* @create 2018-11-14 11:01
*/
public class FileUtils {

public final static String FILE_SUFFIX_SEPARATOR = ".";

/**
* 创建文件夹
*
* @param filePath 文件夹路径
* @return 创建文件夹是否成功
*/
public static boolean createDir(String filePath) {
File dir = new File(filePath);
if (dir.exists()) {
System.out.println("创建目录" + filePath + "失败，目标目录已经存在");
return false;
}
if (!filePath.endsWith(File.separator)) {
filePath = filePath + File.separator;
}
//创建目录
if (dir.mkdirs()) {
System.out.println("创建目录" + filePath + "成功！");
return true;
} else {
System.out.println("创建目录" + filePath + "失败！");
return false;
}
}

/**
* 文件是否存在
*
* @param filePath 文件路径
* @return 文件是否存在
*/
public static boolean exists(String filePath) {
File file = new File(filePath);
return file.exists();
}

/**
* 创建文件
*
* @param filePath 文件路径
* @return 创建文件是否成功
*/
public static boolean createFile(String filePath) {
File file = new File(filePath);
if (!file.exists()) {
try {
return file.createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
}
return false;
}


/*----------------------------------------------------------------------------------------------------------------------*/
public static void fileMove(String from, String to) throws Exception {
try {
File dir = new File(from);
File[] files = dir.listFiles();
if (files == null) {
return;
}
File moveDir = new File(to);
if (!moveDir.exists()) {
moveDir.mkdirs();
}
for (File file : files) {
if (file.isDirectory()) {
fileMove(file.getPath(), to + "\\" + file.getName());
file.delete();
}
File moveFile = new File(moveDir.getPath() + "\\"
+ file.getName());
if (moveFile.exists()) {
moveFile.delete();
}
file.renameTo(moveFile);
System.out.println(file + " 移动成功");
}
} catch (Exception e) {
throw e;
}
}

/**
* 复制文件到指定文件夹下
*
* @param fromFilePath 源文件路径<带文件名>
* @param toPath 目标路径
* @param fileName 重命名文件
*/
public static void copyFileToDir(String fromFilePath, String toPath, String fileName) {
File file = new File(fromFilePath);
try {
FileInputStream input = new FileInputStream(file);
createDir(toPath);
String dirFile = toPath + "/" + ("".equals(fileName) ? file.getName() : fileName);
int index;
byte[] bytes = new byte[1024];
FileOutputStream downloadFile = new FileOutputStream(dirFile);
while ((index = input.read(bytes)) != -1) {
downloadFile.write(bytes, 0, index);
downloadFile.flush();
}
downloadFile.close();
input.close();
System.out.print("复制文件到指定目录下成功");
} catch (IOException e) {
e.printStackTrace();
System.out.print("复制文件到指定目录下失败");
}
}

/**
* 文件重命名 FileUtils.reName("F:\\BEYOND - 海阔天空[weiyun].mp3", "海阔天空.mp3");
*
* @param filePath 文件路径(带文件后缀名)
* @param reName 新名称(必须有后缀名)
*/
public static void reNameSelf(String filePath, String reName) {
String oldName = getFileName(filePath);
String newName = getFileName(reName);
File file1 = new File(filePath);
File file2 = new File(filePath.replace(oldName, reName));
boolean reNameSuccess = file1.renameTo(file2);
if (reNameSuccess) {
System.out.println("文件重命名成功");
} else {
System.out.println("文件重命名失败");
}
}

public static String[] listFile(File dir) {// 获取文件绝对路径
String absolutPath = dir.getAbsolutePath();// 声获字符串赋值为路传入文件的路径
String[] paths = dir.list();// 文件名数组
String[] files = new String[paths.length];// 声明字符串数组，长度为传入文件的个数
for (int i = 0; i < paths.length; i++) {// 遍历显示文件绝对路径
files[i] = absolutPath + "/" + paths[i];
}
return files;
}

public static void createFile(String path, boolean isFile) {// 创建文件或目录
createFile(new File(path), isFile);// 调用方法创建新文件或目录
}

public static void createFile(File file, boolean isFile) {
if (!file.exists()) {// 如果文件不存在
if (!file.getParentFile().exists()) {// 如果文件父目录不存在
createFile(file.getParentFile(), false);
} else {// 存在文件父目录
if (isFile) {// 创建文件
try {
file.createNewFile();// 创建新文件
} catch (IOException e) {
e.printStackTrace();
}
} else {
file.mkdir();// 创建目录
}
}
}
}

/**
* 获取文件夹下所有文件大小或文件大小
*
* @param path 文件路径
*/
public static void getFilesSize(String path) {
File file = new File(path);
if (file.isDirectory()) {
File[] files = file.listFiles();
if (files != null) {
for (File file1 : files) {
// int fileSize = (int) (file1.length() / 1024);
double fileSize = file1.length() / 1024 / 1024;
double bytes = file.length();
double kilobytes = (bytes / 1024);
double megabytes = (kilobytes / 1024);
double gigabytes = (megabytes / 1024);
String outInfo = "文件名:[" + file1.getName() + "] 文件大小:[" + fileSize + "兆]";
System.out.println(outInfo);
}
}
} else {
// int fileSize = (int) (file.length() / 1024);
long fileSize = file.length() / 1024 / 1024;
String outInfo = "文件名:[" + file.getName() + "] 文件大小:[" + fileSize + "兆]";
double bytes = file.length();
double kilobytes = (bytes / 1024);
double megabytes = (kilobytes / 1024);
double gigabytes = (megabytes / 1024);
System.out.println(outInfo);
}
}

/**
* 递归删除(推荐)
*/
public static void deleteDir(File dir) {
if (dir.isDirectory()) {
File[] files = dir.listFiles();
if (files != null) {
for (File file : files) {
deleteDir(file);
}
}
}
boolean delete = dir.delete();
}

/**
* Read file
*
* @param filePath 路径
*/
public static String readFile(String filePath, String charsetName) {
File file = new File(filePath);
StringBuilder fileContent = new StringBuilder();
if (!isFileExist(filePath)) {
return null;
}

BufferedReader reader = null;
try {
InputStreamReader is = new InputStreamReader(new FileInputStream(file), charsetName);
reader = new BufferedReader(is);
String line = null;
while ((line = reader.readLine()) != null) {
if (!isEmpty(fileContent.toString())) {
fileContent.append("\r\n");
}
fileContent.append(line);
}
return fileContent.toString();
} catch (IOException e) {
// throw new RuntimeException("IOException", e);
return null;
} finally {
close(reader);
}
}

/**
* Write file
*/
public static boolean writeFile(String filePath, String content, boolean append) {
if (isEmpty(content)) {
return false;
}
FileWriter fileWriter = null;
try {
makeDirs(filePath);
fileWriter = new FileWriter(filePath, append);
fileWriter.write(content);
return true;
} catch (IOException e) {
throw new RuntimeException("IOException occurred. ", e);
} finally {
close(fileWriter);
}
}

/**
* write file, the string will be written to the begin of the file
*/
public static boolean writeFile(String filePath, String content) {
return writeFile(filePath, content, false);
}

/**
* Write file
*/
public static boolean writeFile(String filePath, InputStream is) {
if (filePath == null) {
return false;
}
return writeFile(filePath, is, false);
}

/**
* 写文件
*
* @param filePath 路径
* @param is 输入流
* @param append 追加
*/
public static boolean writeFile(String filePath, InputStream is, boolean append) {

return writeFile(filePath != null ? new File(filePath) : null, is, append);
}

/**
* Write file
*/
public static boolean writeFile(File file, InputStream is) {
return writeFile(file, is, false);
}


/**
* Write file
*
* @param file .
* @param is 输入流 .
* @param append .
* @return .
*/
public static boolean writeFile(File file, InputStream is, boolean append) {
OutputStream o = null;
try {
makeDirs(file.getAbsolutePath());
o = new FileOutputStream(file, append);
byte[] data = new byte[1024];
int length = -1;
while ((length = is.read(data)) != -1) {
o.write(data, 0, length);
}
o.flush();
return true;
} catch (FileNotFoundException e) {
throw new RuntimeException("FileNotFoundException", e);
} catch (IOException e) {
throw new RuntimeException("IOException", e);
} finally {
close(o);
close(is);
}
}

/**
* 读取源文件内容
*
* @param filename String 文件路径
* @return byte[] 文件内容
* @throws IOException .
*/
public static byte[] readFile(String filename) throws IOException {

File file = new File(filename);
if (isEmpty(filename)) {
throw new NullPointerException("无效的文件路径");
}
long len = file.length();
byte[] bytes = new byte[(int) len];

BufferedInputStream bufferedInputStream = new BufferedInputStream(
new FileInputStream(file));
int r = bufferedInputStream.read(bytes);
if (r != len) {
throw new IOException("读取文件不正确");
}
bufferedInputStream.close();
return bytes;

}

/**
* Move file
*/
public static void moveFile(String srcFilePath, String destFilePath)
throws FileNotFoundException {
if (isEmpty(srcFilePath) || isEmpty(destFilePath)) {
throw new RuntimeException("Both srcFilePath and destFilePath cannot be null.");
}
moveFile(new File(srcFilePath), new File(destFilePath));
}

/**
* Move file
*/
public static void moveFile(File srcFile, File destFile) throws FileNotFoundException {
boolean rename = srcFile.renameTo(destFile);
if (!rename) {
copyFile(srcFile.getAbsolutePath(), destFile.getAbsolutePath());
deleteFile(srcFile.getAbsolutePath());
}
}

/**
* Copy file
*/
public static boolean copyFile(String srcFilePath, String destFilePath)
throws FileNotFoundException {
InputStream inputStream = new FileInputStream(srcFilePath);
return writeFile(destFilePath, inputStream);
}

/**
* rename file
*
* @param filePath 源文件路径
* @param newFileName 新文件名(不需要加路径和后缀)
*/
public static boolean renameFile(String filePath, String newFileName) {
return renameFile(new File(filePath), newFileName);
}

/**
* rename file
*
* @param file 源文件
* @param newFileName 新文件名(不需要加路径和后缀)
*/
public static boolean renameFile(File file, String newFileName) {
File newFile = null;
if (file.isDirectory()) {
newFile = new File(file.getParentFile(), newFileName);
} else {
String temp = newFileName
+ file.getName().substring(
file.getName().lastIndexOf('.'));
newFile = new File(file.getParentFile(), temp);
}
boolean renameSuccess = file.renameTo(newFile);
System.out.println("重命名" + (renameSuccess ? "成功" : "失败"));
return renameSuccess;
}

/**
* 获取没有后缀的文件名 Get file name without suffix
*
* @param filePath .
* @return 获取没有后缀的文件名
*/
public static String getFileNameWithoutSuffix(String filePath) {
if (isEmpty(filePath)) {
return filePath;
}
int suffix = filePath.lastIndexOf(FILE_SUFFIX_SEPARATOR);
int fp = filePath.lastIndexOf(File.separator);
if (fp == -1) {
return (suffix == -1 ? filePath : filePath.substring(0, suffix));
}
if (suffix == -1) {
return filePath.substring(fp + 1);
}
return (fp < suffix ? filePath.substring(fp + 1, suffix) : filePath.substring(fp + 1));
}

/**
* 获取文件名(包含后缀) Get file name
*
* @param filePath 路径
*/
public static String getFileName(String filePath) {
if (isEmpty(filePath)) {
return filePath;
}
int fp = filePath.lastIndexOf(File.separator);
return (fp == -1) ? filePath : filePath.substring(fp + 1);
}

/**
* Get folder name
*/
public static String getFolderName(String filePath) {
if (isEmpty(filePath)) {
return filePath;
}
int fp = filePath.lastIndexOf(File.separator);
return (fp == -1) ? "" : filePath.substring(0, fp);
}

/**
* 获取文件后缀
*
* @param filePath 文件路径
* @return 文件后缀(不包含 " . ")
*/
public static String getFileSuffix(String filePath) {
if (isEmpty(filePath)) {
return filePath;
}
if (!filePath.contains(FILE_SUFFIX_SEPARATOR)) {
String[] path = filePath.split(File.separator);
return path[path.length - 1];
}
int suffix = filePath.lastIndexOf(FILE_SUFFIX_SEPARATOR);
int fp = filePath.lastIndexOf(File.separator);
if (suffix == -1) {
return "";
}
return (fp >= suffix) ? "" : filePath.substring(suffix + 1);
}

/**
* 创建目录
*
* @param filePath 路径
*/
public static boolean makeDirs(String filePath) {
String folderName = getFolderName(filePath);
if (isEmpty(folderName)) {
return false;
}
File folder = new File(folderName);
return (folder.exists() && folder.isDirectory()) || folder.mkdirs();
}

/**
* 判断一个文件是否存在
*
* @param filePath 路径
* @return .
*/
public static boolean isFileExist(String filePath) {
if (isEmpty(filePath)) {
return false;
}
File file = new File(filePath);
return (file.exists() && file.isFile());
}

/**
* Judge whether a Directory is exist
*/
public static boolean isFileDirExist(String filePath) {
if (isEmpty(filePath)) {
return false;
}
File file = new File(filePath);
return (file.exists() && file.isDirectory());
}


/**
* 判断文件夹是否存在
*
* @param directoryPath 路径
* @return .
*/
public static boolean isFolderExist(String directoryPath) {
if (isEmpty(directoryPath)) {
return false;
}
File dire = new File(directoryPath);
return (dire.exists() && dire.isDirectory());
}

/**
* Delete file or folder
*/
public static boolean deleteFile(String path) {
if (isEmpty(path)) {
return true;
}

File file = new File(path);
if (!file.exists()) {
return true;
}
if (file.isFile()) {
return file.delete();
}
if (!file.isDirectory()) {
return false;
}
if (file.isDirectory()) {
for (File f : file.listFiles()) {
if (f.isFile()) {
f.delete();
} else if (f.isDirectory()) {
deleteFile(f.getAbsolutePath());
}
}
}
return file.delete();
}

/**
* Delete file or folder
*/
public static boolean deleteFile(File file) {
if (!file.exists()) {
return true;
}
if (file.isFile()) {
return file.delete();
}
if (!file.isDirectory()) {
return false;
}
if (file.isDirectory()) {
File[] childFile = file.listFiles();
if (childFile == null || childFile.length == 0) {
return file.delete();
}
for (File f : childFile) {
deleteFile(f);
}
}
return file.delete();
}

/**
* Get file size
*/
public static long getFileSize(String path) {

if (isEmpty(path)) {
return -1;
}
File file = new File(path);
return (file.exists() && file.isFile() ? file.length() : -1);
}

private static boolean isEmpty(CharSequence s) {
if (s == null) {
return true;
} else {
return s.length() == 0;
}
}

/**
* Get folder size
*/
public static long getFolderSize(File file) {
long size = 0;
try {
File[] fileList = file.listFiles();
for (int i = 0; i < fileList.length; i++) {
if (fileList[i].isDirectory()) {
size = size + getFolderSize(fileList[i]);
} else {
size = size + fileList[i].length();
}
}
} catch (Exception e) {
e.printStackTrace();
}
return size;
}

/**
* byte(字节)根据长度转成kb(千字节)和mb(兆字节)
*
* @param bytes 字节
* @return 返回长度信息信息
*/
public static String bytes2mb(long bytes) {
BigDecimal filesize = new BigDecimal(bytes);
BigDecimal kilobyte = new BigDecimal(1024 * 1024);
float returnValue = filesize.divide(kilobyte, 2, BigDecimal.ROUND_UP).floatValue();
return (returnValue + "MB");
}

/**
* @return 获取到的文件md5值
*/
public static String getFileMD5(String filePath) {
return getFileMD5(new File(filePath));
}

/**
* @return 获取到的文件md5值
*/
public static String getFileMD5(File file) {
if (!file.exists() || !file.isFile()) {
return null;
}
MessageDigest digest = null;
FileInputStream in = null;
byte buffer[] = new byte[8192];
int len;
try {
digest = MessageDigest.getInstance("MD5");
in = new FileInputStream(file);
while ((len = in.read(buffer)) != -1) {
digest.update(buffer, 0, len);
}
BigInteger bigInt = new BigInteger(1, digest.digest());
return bigInt.toString(16);
} catch (Exception e) {
e.printStackTrace();
return null;
} finally {
close(in);
}
}
//==================================================================================================

/**
* 递归读取文件路径
*/
public static void readFileNames(String path, ReadLines readLines) {
File file = new File(path);
if (file.exists() && file.isFile()) {
readLines.onReadLine(file,file.getPath());
} else if (file.exists() && file.isDirectory()) {
File[] files = file.listFiles();
for (int i = 0; i < files.length; i++) {
readFileNames(files[i].getPath(), readLines);
}
}
}

/**
* 获取文件的Sha1值
*/
public static String getFileSha1(File file) {
FileInputStream in = null;
try {
in = new FileInputStream(file);
MessageDigest digest = MessageDigest.getInstance("SHA-1");
byte[] buffer = new byte[1024 * 1024 * 10];

int len = 0;
while ((len = in.read(buffer)) > 0) {
digest.update(buffer, 0, len);
}
String sha1 = new BigInteger(1, digest.digest()).toString(16);
int length = 40 - sha1.length();
if (length > 0) {
for (int i = 0; i < length; i++) {
sha1 = "0" + sha1;
}
}
return sha1;
} catch (IOException | NoSuchAlgorithmException e) {
e.printStackTrace();
} finally {
try {
if (in != null) {
in.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
return "";
}

/**
* 遍历读取文件获取文件内容(主要用于索引文件内的文件是否包含某些关键词)
*
* @param path 文件或文件夹路径
* @param readLines 读取到的行回调
*/
public static void indexKeyForFile(String path, final ReadLines readLines) {
readFileNames(path, new ReadLines() {
@Override
public void onReadLine(File file, String linStr) {
readTextFileLines(linStr, new ReadLines() {
@Override
public void onReadLine(File file, String linStr) {
readLines.onReadLine(file, linStr);
}
});
}
});
}

/**
* 逐行读取
*
* @param path 路径
* @param readLines 读取行接口
* @throws IOException .
*/
public static void readTextFileLines(String path, ReadLines readLines) {
try {
File file = new File(path);
file.exists();
//BufferedReader是可以按行读取文件
FileInputStream inputStream = new FileInputStream(file);
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));

String str = null;
while ((str = bufferedReader.readLine()) != null) {
if (readLines != null) {
readLines.onReadLine(file, str);
}
}
inputStream.close();
bufferedReader.close();
} catch (IOException e) {
e.printStackTrace();
}
}


/**
* 获取文件总行数
*
* @param filePath 文件路径
* @return 文件总行数
*/
public static int getFlieTotalLines(String filePath) {
BufferedReader in = null;
try {
in = new BufferedReader(new InputStreamReader(new FileInputStream(filePath)));
LineNumberReader reader = new LineNumberReader(in);
String s = reader.readLine();
int lines = 0;
while (s != null) {
lines++;
s = reader.readLine();
}
reader.close();
in.close();
return lines;
} catch (IOException e) {
e.printStackTrace();
}
return -1;
}

/**
* 方法:按行获取指定内容 使用的时候注意测试,该方法未试验过
*
* @param startLine 起始行
* @return 指定内容内容
*/
public static String getSpecifyLinesContent(String filePath, int startLine, int endLine) {
BufferedReader br = null;
try {
br = new BufferedReader(new FileReader(new File(filePath)));
StringBuilder sb = new StringBuilder();
String temp = null;
int count = 0;
while ((temp = br.readLine()) != null) {
count++;
if (count >= startLine && count <= endLine) {
sb.append(temp).append("\n");
}
}
return sb.toString();
} catch (IOException e) {
e.printStackTrace();
}
return "获取失败";
}

/**
* 方法一:按行获取指定内容(至末尾)
*
* @param startLine 起始行
* @return 指定内容内容
* @throws Exception .
*/
public static String getSpecifyContent1(String filePath, int startLine) throws Exception {
BufferedReader br = new BufferedReader(new FileReader(new File(filePath)));
StringBuilder sb = new StringBuilder();
String temp = null;
int count = 0;
while ((temp = br.readLine()) != null) {
count++;
if (count >= startLine) {
sb.append(temp).append("\n");
}
}
return sb.toString();
}

/**
* 替换文件内的文本信息<因为是一行一行读的,所以只能替换单词一类的字符串>
*
* @param path 文件路径
* @param olderArg 旧参数
* @param newArg 新参数
* @throws IOException .
*/
public static void replacetext(String path, String olderArg, String newArg) throws IOException {
// 读
File file = new File(path);
FileReader in = new FileReader(file);
BufferedReader bufIn = new BufferedReader(in);
// 内存流, 作为临时流
CharArrayWriter tempStream = new CharArrayWriter();
// 替换
String line = null;
while ((line = bufIn.readLine()) != null) {
// 替换每行中, 符合条件的字符串
line = line.replaceAll(olderArg, newArg);
// 将该行写入内存
tempStream.write(line);
// 添加换行符
tempStream.append(System.getProperty("line.separator"));
}
// 关闭 输入流A
bufIn.close();
// 将内存中的流 写入 文件
FileWriter out = new FileWriter(file);
tempStream.writeTo(out);
out.close();
}

/**
* 在文件里面的指定行插入数据<如果插入后要换行的话在插入内容的结尾加 /n >
*
* @param filePath 文件路径
* @param insertLineNumber 要插入的行号
* @param lineToBeInserted 要插入的数据
* @throws Exception IO操作引发的异常
*/
public static void insertContentToFile(String filePath, int insertLineNumber,
String lineToBeInserted) throws Exception {
File inFile = new File(filePath);
// 临时文件
File outFile = File.createTempFile("name", ".tmp");
// 输入
FileInputStream fis = new FileInputStream(inFile);
BufferedReader in = new BufferedReader(new InputStreamReader(fis));
// 输出
FileOutputStream fos = new FileOutputStream(outFile);
PrintWriter out = new PrintWriter(fos);
// 保存一行数据
String thisLine;
// 行号从1开始
int i = 1;
while ((thisLine = in.readLine()) != null) {
// 如果行号等于目标行，则输出要插入的数据
if (i == insertLineNumber) {
out.println(lineToBeInserted);
}
// 输出读取到的数据
out.println(thisLine);
// 行号增加
i++;
}
out.flush();
out.close();
in.close();
// 删除原始文件
inFile.delete();
// 把临时文件改名为原文件名
outFile.renameTo(inFile);
}

/**
* Close closeable object 关闭可以关闭的对象
*/
private static void close(Closeable closeable) {
if (closeable != null) {
try {
closeable.close();
} catch (IOException e) {
e.printStackTrace();
// LogUtils.d("IOUtils",e.toString());
}
}
}

/**
* 扫描路径下的文件
*
* @param file 文件路径
*/
public static void scanningFilesName(File file) {
if (file == null) {
return;
}
File[] fs = file.listFiles();
if (fs != null) {
for (File f : fs) {
if (f.isDirectory()) { //若是目录，则递归打印该目录下的文件
System.out.println("文件夹:" + f.getPath());
scanningFilesName(f);
}
if (f.isFile()) //若是文件，直接打印
{
System.out.println("文件:" + f.getPath());
}
}
}
}

/**
* windows下文件名中不能含有：\ / : * ? " < > | 英文的这些字符 ，这里使用"."、"'"进行替换。
*
* \/:?| 用.替换
*
* "<> 用'替换
*/
public static String getConversionFileName(String dirPath) {
dirPath = dirPath.replaceAll("[/\\\\:*?|]", ".");
dirPath = dirPath.replaceAll("[\"<>]", "'");
return dirPath;
}

/**
* 获取桌面路径
*/
public static String getDesktopPath() {
return FileSystemView.getFileSystemView().getHomeDirectory().getPath() + File.separator;
}

/**
* 方法二:按行获取指定内容(至末尾)
*
* @param startLine 起始行
* @return 指定内容内容
* @throws Exception .
*/
public String getSpecifyContent2(String filePath, int startLine) throws Exception {
StringBuilder sb = new StringBuilder();
LineNumberReader lnr = new LineNumberReader(new FileReader(filePath));
String buff = lnr.readLine();
while (buff != null) {
if (lnr.getLineNumber() >= startLine) {
sb.append(buff);
sb.append("\r\n");
}
buff = lnr.readLine();
}
return sb.toString();
}


public interface ReadLines {

void onReadLine(File file, String linStr);
}


}