JAVA实现大文件排序
java全排列递归算法
java全排列递归算法全排列是指将一组元素按照一定的顺序进行排列，使得每个元素都能够出现在每个位置上，且每个元素只能出现一次。
在Java中，可以使用递归算法来实现全排列。
递归算法是一种通过调用自身来解决问题的方法。
在全排列问题中，可以通过递归的方式来生成所有可能的排列。
首先，我们需要定义一个递归函数，该函数接受一个数组和两个整数作为参数。
其中，数组表示待排列的元素，第一个整数表示当前排列的起始位置，第二个整数表示当前排列的结束位置。
在递归函数中，我们首先判断当前排列是否已经完成。
如果起始位置等于结束位置，说明已经完成了一次排列，我们可以将当前排列输出。
否则，我们需要对当前排列进行递归调用。
在递归调用中，我们需要将当前排列的起始位置与结束位置进行交换，然后对剩余的元素进行递归调用。
递归调用完成后，我们需要将当前排列的起始位置与结束位置进行交换，以便进行下一次排列。
下面是一个使用递归算法实现全排列的Java代码示例：```javapublic class Permutation {public static void permute(int[] nums, int start, int end) {if (start == end) {for (int num : nums) {System.out.print(num + " ");}System.out.println();} else {for (int i = start; i <= end; i++) {swap(nums, start, i);permute(nums, start + 1, end);swap(nums, start, i);}}}public static void swap(int[] nums, int i, int j) { int temp = nums[i];nums[i] = nums[j];nums[j] = temp;}public static void main(String[] args) {int[] nums = {1, 2, 3};permute(nums, 0, nums.length - 1);}}```在上述代码中，我们定义了一个`permute`函数来实现全排列。
java倒序排序方法
java倒序排序方法java语言是一种面向对象的编程语言，具有强大的排序功能。
在java中，倒序排序是非常常见的操作，有多种实现方法。
一、使用Collections.reverseOrder()方法java中的Collections类提供了reverseOrder()方法，可以用于倒序排序，该方法返回一个比较器，可以将一个对象列表按照指定的顺序进行排序。
示例代码如下所示：```javaimport java.util.ArrayList;import java.util.Collections;import java.util.List;public class ReverseSortExample {public static void main(String[] args) {List<Integer> numbers = new ArrayList<>();numbers.add(5);numbers.add(2);numbers.add(9);numbers.add(1);numbers.add(7);System.out.println("排序前：" + numbers); Collections.sort(numbers, Collections.reverseOrder()); System.out.println("排序后：" + numbers);}}```输出结果如下所示：```排序前：[5, 2, 9, 1, 7]排序后：[9, 7, 5, 2, 1]```在这个示例中，我们创建了一个包含一些整数的列表，并使用Collections类的sort()方法对其进行排序。
通过传递`Collections.reverseOrder()`作为比较器参数，可以实现倒序排序。
值得注意的是，reverseOrder()方法返回的是一个比较器，它会根据元素的自然顺序进行排序。
java 基于文件行数据对比算法
java 基于文件行数据对比算法
基于文件行数据对比的算法在Java中可以采用多种方式实现，这取决于文件的大小、数据的格式以及对比的要求。
以下是一些常见的方法：
1. 逐行对比，这是最简单的方法，可以使用Java的文件读取和字符串比较功能逐行读取两个文件的数据，然后逐行进行比较。
这种方法适用于文件较小且对比要求不太严格的情况。
2. 使用哈希算法，可以通过计算文件每行数据的哈希值，然后将哈希值进行比较，以确定文件是否相同。
Java中有多种哈希算法可供选择，如MD5、SHA-1等。
这种方法适用于大文件的对比，可以快速确定文件是否相同，但不能确定具体哪些行不同。
3. 排序后对比，可以将文件的数据读入内存，然后对数据进行排序，最后逐行对比。
这种方法适用于需要找出文件中不同行的情况，但对于大文件可能会占用较多的内存。
4. 使用Apache Commons FileUtils库，Apache Commons FileUtils库提供了方便的方法来比较两个文件的内容，可以使用
该库来实现文件行数据的对比。
5. 使用第三方库，除了Apache Commons FileUtils库外，还有其他一些第三方库可以用来实现文件对比，例如Guava库、Apache POI等。
在实际应用中，需要根据具体的需求和文件特点选择合适的对比算法。
同时，需要注意处理文件读取和比较过程中可能出现的异常情况，如文件不存在、文件格式错误等。
希望以上信息能够帮助到你。
Java大规模数据处理解析海量数据的技巧
Java大规模数据处理解析海量数据的技巧在处理大规模数据时，Java是一种常用的编程语言。
然而，由于海量数据的处理可能涉及到效率、内存管理以及算法优化等方面的挑战，开发人员需要掌握一些技巧来解析这些数据。
本文将介绍一些Java大规模数据处理的技巧，帮助开发人员更好地处理海量数据。
一、数据分块处理在处理大规模数据时，内存管理是一个重要的问题。
当数据量超过内存限制时，我们需要将数据分块处理，以避免内存溢出。
可以使用Java的流式处理机制，通过迭代的方式读取数据，每次处理一块数据，减少内存的消耗。
例如，可以使用BufferedReader的readLine()方法逐行读取文件，然后对每行数据进行处理。
二、并行处理并行处理是指同时处理多个数据块的技术，可以显著提高处理大规模数据的效率。
Java提供了多线程和线程池的机制，可以将数据分成多个部分，并行地处理每个部分。
通过合理设置线程池的大小，可以充分利用计算资源，提高程序的运行效率。
三、使用适当的数据结构在处理大规模数据时，选择适当的数据结构非常重要。
不同的数据结构对于不同的操作具有不同的时间复杂度，选择合适的数据结构可以提高程序的效率。
例如，如果需要频繁地插入和删除数据，可以选择链表或树等数据结构；如果需要随机访问数据，可以选择数组或哈希表等数据结构。
根据不同的需求，选择合适的数据结构可以提高程序的性能。
四、优化算法算法的选择也是解析海量数据的关键。
优化算法可以提高程序的效率，减少资源的消耗。
例如，对于排序操作，可以选择高效的排序算法，如快速排序或归并排序，而不是简单的冒泡排序。
另外，可以使用适当的数据结构和算法来进行数据过滤、去重等操作，减少不必要的计算。
五、使用缓存缓存是提高程序性能的有效方式之一。
当程序需要频繁地访问某些数据时，可以使用缓存将这些数据存储起来，避免重复计算和访问。
在Java中，可以使用HashMap等数据结构来实现缓存。
通过在内存中存储一部分数据，可以提高程序的响应速度和效率。
java快速排序简单代码
java快速排序简单代码快速排序是一种非常高效的排序算法，它利用了分治的思想，可以在O(n log n)的时间复杂度内完成排序，比其他排序算法的速度要快得多。
在Java中，快速排序的实现并不复杂，下面就来详细介绍。
1. 选取基准点快速排序的第一步是选取基准点，在我们的代码中，我们选取数组的第一个元素为基准点，可以根据需要进行修改。
2. 分区接下来，我们需要将数组中的元素按照基准点进行分区，将比基准点小的元素放置到基准点的左边，比基准点大的元素放置到基准点的右边。
我们可以用两个指针 i 和 j 分别从左边和右边扫描数组，比较大小并交换元素，直到 i >= j。
3. 递归排序分区完成后，我们需要对左右两个分区再次进行快速排序。
我们可以使用递归的方式来实现这一过程，对左分区和右分区分别调用快速排序函数，直到所有分区都变得有序。
下面是快速排序的Java实现代码：public static void quickSort(int[] arr, int left, int right) {if (left >= right) {return;}int pivot = arr[left];int i = left, j = right;while (i < j) {while (i < j && arr[j] >= pivot) {j--;}arr[i] = arr[j];while (i < j && arr[i] <= pivot) {i++;}arr[j] = arr[i];}arr[i] = pivot;quickSort(arr, left, i - 1);quickSort(arr, i + 1, right);}在代码中，我们首先判断了左右指针是否相遇，防止出现越界的情况。
接着，我们选取了左边第一个元素作为基准点，并使用指针 i 和 j 进行分区操作，最后对左右两个分区进行递归排序。
Java中List排序的三种实现方法实例
Java中List排序的三种实现⽅法实例⽬录前⾔1.使⽤ Comparable 排序2.使⽤ Comparator 排序2.1 新建 Comparator ⽐较器2.2 匿名类⽐较器3.使⽤ Stream 流排序总结前⾔在某些特殊的场景下，我们需要在 Java 程序中对 List 集合进⾏排序操作。
⽐如从第三⽅接⼝中获取所有⽤户的列表，但列表默认是以⽤户编号从⼩到⼤进⾏排序的，⽽我们的系统需要按照⽤户的年龄从⼤到⼩进⾏排序，这个时候，我们就需要对 List 集合进⾏⾃定义排序操作了。
L ist 排序的常见⽅法有以下 3 种：1. 使⽤ Comparable 进⾏排序；2. 使⽤ Comparator 进⾏排序；3. 如果是 JDK 8 以上的环境，也可以使⽤ Stream 流进⾏排序。
下⾯我们分别来看各种排序⽅法的具体实现。
1.使⽤ Comparable 排序按照本⽂设计的场景，我们需要创建⼀个包含了⽤户列表的 List 集合，并按⽤户的年龄从⼤到⼩进⾏排序，具体实现代码如下：public class ListSortExample {public static void main(String[] args) {// 创建并初始化 ListList<Person> list = new ArrayList<Person>() {{add(new Person(1, 30, "北京"));add(new Person(2, 20, "西安"));add(new Person(3, 40, "上海"));}};// 使⽤ Comparable ⾃定的规则进⾏排序Collections.sort(list);// 打印 list 集合list.forEach(p -> {System.out.println(p);});}}// 以下 set/get/toString 使⽤的是 lombok 的注解@Getter@Setter@ToStringclass Person implements Comparable<Person> {private int id;private int age;private String name;public Person(int id, int age, String name) {this.id = id;this.age = age; = name;}@Overridepublic int compareTo(Person p) {return p.getAge() - this.getAge();}}以上代码的执⾏结果，如下图所⽰：本⽅法的核⼼代码如下：2.使⽤ Comparator 排序Comparable 是类内部的⽐较⽅法，⽽ Comparator 是排序类外部的⽐较器。
javaCollections排序--多条件排序实例
javaCollections排序--多条件排序实例我就废话不多说了，⼤家还是直接看代码吧~// 告警排序Collections.sort(domesticAirport, comparator);// 告警排序Comparator<AirportRtWeatherWarningBeanForTable> comparator = new Comparator<AirportRtWeatherWarningBeanForTable>() { @Overridepublic int compare(AirportRtWeatherWarningBeanForTable a1, AirportRtWeatherWarningBeanForTable a2) {// ⾸先根据是否过期排序if(a1.isMetarExpired() && !a2.isMetarExpired()){return 1;}else if (!a1.isMetarExpired() && a2.isMetarExpired()) {return -1;} else if ((a1.isMetarExpired() && a2.isMetarExpired()) || (!a1.isMetarExpired() && !a2.isMetarExpired())) {//同时过期，或者都不过期，则按告警类型排序if (a1.getWarningColor() != a2.getWarningColor()) {return compareColor(a1.getWarningColor(), a2.getWarningColor());}}//告警类型相同，按字母排序return a1.getCode4().compareTo(a2.getCode4());}};// 告警类型⽐较排序public int compareColor(Color color1, Color color2) {int i = 0;int j = 0;if (color1.equals(MeteoWeatherWarningPanel.RED)) {i = 3;} else if (color1.equals(MeteoWeatherWarningPanel.YELLOW)) {i = 2;} else if (color1.equals(MeteoWeatherWarningPanel.GREEN)) {i = 1;}if (color2.equals(MeteoWeatherWarningPanel.RED)) {j = 3;} else if (color2.equals(MeteoWeatherWarningPanel.YELLOW)) {j = 2;} else if (color2.equals(MeteoWeatherWarningPanel.GREEN)) {j = 1;}int k = i - j;if (k > 0) {return -1;} else if (k < 0) {return 1;} elsereturn 0;}补充知识：Collections.sort多字段排序-指定排序⽅式-指定排序字段看代码吧~1、创建需要排序的字段数组String [] sortNameArr = {“one”, “tow”,“startDate”};2、为每个字段执⾏排序规则boolean[] isAs = {false, false, false};3、重写sort⽅法进⾏排序ListUtils.sort(list, sortNameArr, isAs);public static <E> void sort(List<E> list, final String[] sortnameArr, final boolean[] typeArr) {if (sortnameArr.length != typeArr.length) {throw new RuntimeException("属性数组元素个数和升降序数组元素个数不相等");}Collections.sort(list, new Comparator<E>() {public int compare(E a, E b) {int ret = 0;try {for (int i = 0; i < sortnameArr.length; i++) {ret = pareObject(sortnameArr[i], typeArr[i], a, b);if (0 != ret) {break;}}} catch (Exception e) {e.printStackTrace();}return ret;}});}private static <E> int compareObject(final String sortname, final boolean isAsc, E a, E b) throws Exception { int ret;Object value1 = ListUtils.forceGetFieldValue(a, sortname);Object value2 = ListUtils.forceGetFieldValue(b, sortname);// 两个字段都不为空进⾏排序if (null != value1 && null != value2) {String str1 = value1.toString();String str2 = value2.toString();if (value1 instanceof Number && value2 instanceof Number) {int maxlen = Math.max(str1.length(), str2.length());str1 = ListUtils.addZero2Str((Number) value1, maxlen);str2 = ListUtils.addZero2Str((Number) value2, maxlen);} else if (value1 instanceof Date && value2 instanceof Date) {// ⽇期排序long time1 = ((Date) value1).getTime();long time2 = ((Date) value2).getTime();int maxlen = Long.toString(Math.max(time1, time2)).length();str1 = ListUtils.addZero2Str(time1, maxlen);str2 = ListUtils.addZero2Str(time2, maxlen);}if (isAsc) {ret = pareTo(str2);} else {ret = pareTo(str1);}return ret;} else if (null == value1 && null != value2) {// ⽐值为空被⽐值⼤ret = 1;} else {// 被⽐值为空⽐值打ret = -1;}return ret;}public static String addZero2Str(Number numObj, int length) {NumberFormat nf = NumberFormat.getInstance();// 设置是否使⽤分组nf.setGroupingUsed(false);// 设置最⼤整数位数nf.setMaximumIntegerDigits(length);// 设置最⼩整数位数nf.setMinimumIntegerDigits(length);return nf.format(numObj);}public static Object forceGetFieldValue(Object obj, String fieldName) throws Exception {Field field = obj.getClass().getDeclaredField(fieldName);Object object = null;boolean accessible = field.isAccessible();if (!accessible) {// 如果是private,protected修饰的属性，需要修改为可以访问的field.setAccessible(true);object = field.get(obj);// 还原private,protected属性的访问性质field.setAccessible(accessible);return object;}object = field.get(obj);return object;}以上这篇java Collections 排序--多条件排序实例就是⼩编分享给⼤家的全部内容了，希望能给⼤家⼀个参考，也希望⼤家多多⽀持。
java list string排序方法
java list string排序方法Java List String排序方法本文将详细介绍Java中对List进行排序的各种方法。
方法一：使用()方法使用Collections类中的sort()方法，可以很方便地对List 进行排序。
List<String> list = new ArrayList<>();// 添加元素到List中(list);方法二：使用Comparator接口如果需要根据特定的规则对List进行排序，可以使用Comparator接口。
List<String> list = new ArrayList<>();// 添加元素到List中(new Comparator<String>() {@Overridepublic int compare(String s1, String s2) {// 按照自定义规则比较s1和s2的大小return (s2);}});方法三：使用Lambda表达式使用Lambda表达式可以更加简洁地实现List的排序。
List<String> list = new ArrayList<>();// 添加元素到List中((s1, s2) -> (s2));方法四：使用Stream API使用Java 8引入的Stream API，也可以对List进行排序。
List<String> list = new ArrayList<>();// 添加元素到List中list = ().sorted().collect(());方法五：使用自定义排序规则可以根据业务需求自定义排序规则，例如按照字符串长度进行排序。
List<String> list = new ArrayList<>();// 添加元素到List中((String::length));注意事项•使用以上方法时，需要确保List中的元素实现了Comparable接口，或者在使用Comparator时传入自定义的比较器。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
package com.scott.util;import java.io.*;import java.util.ArrayList;import parator;import java.util.Iterator;import java.util.List;/*** Created by Scott on 2017/11/1.*/public class LargeFileDataSort {// 测试大文件路径public final static String testFilePath = "E:/dataTest/largeFileData.txt";public final static String resultFilePath = "E:/dataTest/largeFileResult.txt";// 切分大文件的小文件大小MB, 默认为100MBprivate final static int size = 200;private static int byteSize = size * 1024 * 1024;public static void main(String[] args) throws IOException {// 生成测试文件createTestData();Long start = System.currentTimeMillis();work();Long end = System.currentTimeMillis();System.out.println((end - start) / 1000/ 60);}/*** 切分文件每份大小*/public static void work() throws IOException {File file = new File(testFilePath);if (!file.exists()) {return;}// 2.1 得到文件大小MBdouble mbsize = file.length() / 1024 / 1024;// 2.2 计算得到切分的文件数double fileNum = Math.ceil(mbsize / size);// 2.3 临时文件List<File> tempFileList = createTempFileList(file, fileNum);// 2.3 切分文件divAndFirstSort(file, tempFileList);// 2.4 递归排序(每个文件读取多少数据放到内存排序后合并到结果文件)// 排序合并开始mergeLargeFile(tempFileList);// 2.5 TODO 把临时文件删除}/*** 生成测试文件*/public static void createTestData() {StringBuffer sb = new StringBuffer();BufferedWriter bw = null;try {File testFile = new File(testFilePath);if (!testFile.exists()) {testFile.createNewFile();}bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(testFile)));for (long i = 1; i <= 27777777; i++) {sb.setLength(0);sb.append(i).append("@@");// sb.append(random.nextInt(100000)).append("@@");sb.append(i).append("调用BufferedWriter的flush()方法").append("@@");sb.append(i).append("调用BufferedWriter的flush()方法").append("@@");sb.append(i).append("调用BufferedWriter的flush()方法").append("@@");sb.append(i).append("调用BufferedWriter的flush()方法").append("@@");sb.append(i).append("调用BufferedWriter的flush()方法").append("@@");sb.append(i).append("调用BufferedWriter的flush()方法").append("@@");sb.append(i).append("调用BufferedWriter的flush()方法").append("@@");sb.append(i).append("调用BufferedWriter的flush()方法").append("@@");sb.append(i).append("调用BufferedWriter的flush()方法").append("@@");sb.append(i).append("调用BufferedWriter的flush()方法").append("@@");sb.append(i).append("调用BufferedWriter的flush()方法").append("@@");sb.append(i).append("调用BufferedWriter的flush()方法").append("@@");sb.append(i).append("调用BufferedWriter的flush()方法").append("@@");sb.append(i).append("调用BufferedWriter的flush()方法").append("@@");sb.append(i).append("调用BufferedWriter的flush()方法").append("@@");sb.append(i).append("调用BufferedWriter的flush()方法").append("@@");sb.append("\n");bw.write(sb.toString());if ((i + 1) % 5000 == 0) {bw.flush();}System.out.println(i);}} catch (IOException e) {System.out.println("生成测试文件失败！" + e.getMessage());} finally {try {if (bw != null) {bw.close();}} catch (IOException e) {}}}/*** 把临时文件合并到结果文件* @param tempFileList* @throws IOException*/public static void mergeLargeFile(List<File> tempFileList) throws IOException {List<FileEntity> bwList = new ArrayList<FileEntity>();for(int i=0; i< tempFileList.size(); i++) {FileEntity le = new FileEntity(new BufferedReader(new InputStreamReader(new FileInputStream(tempFileList.get(i)))));bwList.add(le);}BufferedWriter resultBw = null;try {resultBw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(resultFilePath)));Long count = 0L;FileEntity fe = null;while ((fe = getFirstFileEntity(bwList)) != null) {System.out.println("--- 写文件id: " + fe.getId());// 写入符合条件的一行数据resultBw.write(fe.getLine() + "\n");// 准备下一行fe.nextLine();// 清缓冲流if (count % 1000 == 0) {resultBw.flush();}}} catch (Exception e) {} finally {if (resultBw != null) {try {resultBw.close();} catch (IOException e) {}}}// 关闭for(int i=0; i< bwList.size(); i++) {bwList.get(i).close();}}/*** 从切分的文件中按序行读取（因为切分文件时已经做好了排序）* @param bwList* @return*/private static FileEntity getFirstFileEntity(List<FileEntity> bwList) { if (bwList.size() == 0) {return null;}Iterator<FileEntity> it = bwList.iterator();while (it.hasNext()) {FileEntity fe = it.next();// 如果文件读到完就关闭流和删除在集合的文件流if (fe.getLine() == null) {fe.close();it.remove();}}if (bwList.size() == 0) {return null;}// 排序获取一行数据bwList.sort(new FileEntityComparator());// 返回第一个符合条件的文件对象return bwList.get(0);}/*** 切分文件并做第一次排序* @param file* @param tempFileListprivate static void divAndFirstSort(File file, List<File> tempFileList) {BufferedReader br = null;try {// 读取大文件br = new BufferedReader(new InputStreamReader(new FileInputStream(file)));// 行数据保存对象String line = null;// 临时文件索引int index = tempFileList.size() - 1;// 第一个临时文件File tempFile = tempFileList.get(index);List<String> lineList = new ArrayList<>();int byteSum = 0;// 循环临时文件并循环大文件while ((line = br.readLine()) != null) {line += "\n";byteSum += line.getBytes().length;// 如果长度达到每个文件大小则重新计算if (byteSum >= byteSize) {// 写入到文件putLineListToFile(tempFileList.get(index), lineList);index--;byteSum = line.getBytes().length;lineList.clear();}lineList.add(line);}if (lineList.size() > 0) {// 写入到文件putLineListToFile(tempFileList.get(0), lineList);}} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();} finally {try {if (br != null) {br.close();}} catch (IOException e) {}}/*** 把数据写到临时文件* @param lineList*/private static void putLineListToFile(File file, List<String> lineList) throws IOException { FileOutputStream tempFileFos = null;try {// 很关键的一步，第一次写入文件必须排序lineList.sort(new LineComparator());tempFileFos = new FileOutputStream(file);for(int i=0; i< lineList.size(); i++) {tempFileFos.write(lineList.get(i).getBytes());}} finally {if (tempFileFos != null) {tempFileFos.close();}}}/*** 生成临时文件* @param fileNum* @return*/private static List<File> createTempFileList(File file, double fileNum) {List<File> tempFileList = new ArrayList<File>();String fileFolder = file.getParent();String name = file.getName();for (int i = 0; i < fileNum; i++) {File tempFile = new File(fileFolder + "/" + name + ".temp_" + i + ".txt");if (tempFile.exists()) {tempFile.delete();}try {tempFile.createNewFile();} catch (IOException e) {e.printStackTrace();}tempFileList.add(tempFile);}return tempFileList;}public static int compare(String o1, String o2) {String o1Id = o1.substring(0, o1.indexOf("@@"));String o2Id = o2.substring(0, o2.indexOf("@@"));// 从小到大return Integer.parseInt(o1Id) - Integer.parseInt(o2Id);// 从大到小// return Integer.parseInt(o2Id) - Integer.parseInt(o1Id);}}/*** 排序*/class LineComparator implements Comparator<String> {@Overridepublic int compare(String o1, String o2) {return pare(o1, o2);}}/*** 排序类*/class FileEntityComparator implements Comparator<FileEntity> { @Overridepublic int compare(FileEntity o1, FileEntity o2) {return pare(o1.getLine(), o2.getLine());}}class FileEntity {private Long id = null;private String line = null;private BufferedReader br;public FileEntity(BufferedReader br) throws IOException {this.br = br;// 初始化读取第一行setLineId();}/*** 使用来排序的数据* @throws IOException*/private void setLineId() throws IOException {line = br.readLine();if (line != null) {try {id = Long.parseLong(line.substring(0, line.indexOf("@@")));} catch (NumberFormatException e) {id = null;}}}/*** 关闭流*/public void close() {if (this.br != null) {try {this.br.close();} catch (Exception e) {}}}/*** 读取下一行* @return*/public FileEntity nextLine() {try {setLineId();} catch (IOException e) {}return this;}public Long getId() {return id;}public void setId(Long id) {this.id = id;}public String getLine() {return line;}}。