将一组带有_下划线区分图片大中小图属性的文件排序

不带"_"的在前，带"_"的"_"之前的名字一样的认为是一组要紧挨着，同时按照list、大、中、小排序，支持缺失个别。

方法一是最初的一版，规则都写死了，方法三是是方法一的抽象，高度灵活，比较适合封装调用，效率跟一一样，应该也不高。

方法二就是个比较器，效率应该是比较高，比较推荐，缺点是规则写死在比较器里了。

package com.jfly.common;

import java.io.File;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class TEST {

// 将图片按照如下规则排序 ：普通图片+分组图片，普通图片按时间逆序，
// 分组图片，不同组按照组的时间逆序,组内图片按照列表图、大图、中图、小图排序（支持缺失个别）
public static void main(String[] args) {

TEST t = new TEST();

File[] files = t.getFiles();

System.out.println("-------------排序方法1 前------------");

for(File file:files)
{
System.out.println(file.getName());
}

//方法一
System.out.println("-------------排序方法1 后------------");

files = t.newSortFile(files);

for(File file:files)
{
System.out.println(file.getName());
}

System.out.println("-------------排序方法2 前------------");

files = t.getFiles();

for(File file:files)
{
System.out.println(file.getName());
}

System.out.println("-------------排序方法2 后------------");

files = t.newSortFile2(files);

for(File file:files)
{
System.out.println(file.getName());
}

System.out.println("-------------排序方法3 前------------");

files = t.getFiles();

for(File file:files)
{
System.out.println(file.getName());
}
System.out.println("-------------排序方法3 后------------");

List<String> sortKey = new ArrayList<String>();
sortKey.add("_list");
sortKey.add("_big");
sortKey.add("_middle");
sortKey.add("_small");
files = t.newSortFile3(files,sortKey);
for(File file:files)
{
System.out.println(file.getName());
}
}

/**
* 比较器按照文件名逆序排序
*/
class FileComparator implements Comparator<File>
{
@Override
public int compare(File o1, File o2)
{
return o2.getName().compareTo(o1.getName());
}
}

/**
* 比较器按照文件名逆序排序
*/
class FileComparator2 implements Comparator<File>
{
@Override
public int compare(File o1, File o2)
{
if(o1.getName().indexOf("_") == -1 && o2.getName().indexOf("_") != -1)
{
return -1;
}
else if(o1.getName().indexOf("_") != -1 && o2.getName().indexOf("_") == -1)
{
return 1;
}
else if(o1.getName().indexOf("_") == -1 && o2.getName().indexOf("_") == -1)
{
return o2.getName().compareTo(o1.getName());
}
else if(o1.getName().indexOf("_") != -1 && o2.getName().indexOf("_") != -1)
{
String name1 = o1.getName().substring(0,o1.getName().indexOf("_"));
String type1 = o1.getName().substring(o1.getName().indexOf("_"),o1.getName().indexOf("."));

String name2 = o2.getName().substring(0,o2.getName().indexOf("_"));
String type2 = o2.getName().substring(o2.getName().indexOf("_"),o2.getName().indexOf("."));

if(name1.equals(name2))
{
if("_list".equals(type1))
{
return -1;
}
else if("_big".equals(type1))
{
if("_list".equals(type2))
{
return 1;
}
else
{
return -1;
}
}
else if("_middle".equals(type1))
{
if("_list".equals(type2) || "_big".equals(type2))
{
return 1;
}
else
{
return -1;
}
}
else if("_small".equals(type1))
{
return 1;
}
else
{
return 1;
}
}
else
{
return name2.compareTo(name1);
}
}

return 0;
}
}

/**
* 新排序算法，将图片按照如下规则排序 ：普通图片+分组图片，普通图片按时间逆序，
* 分组图片，不同组按照组的时间逆序,组内图片按照列表图、大图、中图、小图排序（支持缺失个别）
*
* @param files
* @return
* @remark create ZJF
*/
private File[] newSortFile2(File[] files)
{
List<File> tmp = new ArrayList<File>();

for(File file :files)
{
tmp.add(file);
}

Collections.sort(tmp, new FileComparator2());

File[] sortedFiles = tmp.toArray(new File[tmp.size()]);

// 返回排好序的list
return sortedFiles;
}

/**
* 新排序算法，将图片按照如下规则排序 ：普通图片+分组图片，普通图片按时间逆序，
* 分组图片，不同组按照组的时间逆序,组内图片按照列表图、大图、中图、小图排序（支持缺失个别）
*
* @param files
* @return
* @remark create ZJF
*/
private File[] newSortFile3(File[] files,List<String> sortKey)
{
Map<String,List<File>> map = new HashMap<String,List<File>>();

for(String key: sortKey)
{
map.put(key,new ArrayList<File>());
}

List<File> commonFile = new ArrayList<File>();

for(File file:files)
{
if(file.getName().indexOf("_")==-1)
{
commonFile.add(file);
}
else
{
String type = file.getName().substring(file.getName().indexOf("_"),file.getName().indexOf("."));
List<File> curFiles = map.get(type);
if(curFiles != null)
{
curFiles.add(file);
}
}
}

Collections.sort(commonFile, new FileComparator());

List<File> leftList = map.get(sortKey.get(0));

Collections.sort(leftList, new FileComparator());

for(int i=1; i<sortKey.size(); i++)
{
List<File> rightList = map.get(sortKey.get(i));

mergeFile2(leftList, rightList, sortKey, i,sortKey.get(i-1));
}

commonFile.addAll(leftList);

File[] sortedFiles = commonFile.toArray(new File[commonFile.size()]);

// 返回排好序的list
return sortedFiles;

}

/**
* 将右侧list合并到左侧list上
*
* @param leftList
* @param rightList
* @param type
* @remark create ZJF
*/
private void mergeFile2(List<File> leftList, List<File> rightList, List<String> sortKey,int index,String type)
{
List<File> FileTmp = new ArrayList<File>();

for (File right : rightList)
{
String rightName = right.getName().substring(0, right.getName().indexOf("_"));

boolean isfind = false;

// 在当前type下，寻找左侧是否有名字相同的
for (int i = 0; i < leftList.size(); i++)
{
String leftName = leftList.get(i).getName().substring(0, leftList.get(i).getName().indexOf("_"));

// 如果找到则插入左侧list
if (rightName.equals(leftName) && leftList.get(i).getName().indexOf(type) != -1)
{
leftList.add(i + 1, right);

isfind = true;

break;
}
}

//没有找到放入临时list
if (!isfind)
{
FileTmp.add(right);
}
}

// 找到list图级别还找不到，则追加到最后
if (index == 1)
{
Collections.sort(FileTmp, new FileComparator());
leftList.addAll(FileTmp);
}
// 找不到越一级往上找
else
{
mergeFile2(leftList,FileTmp,sortKey,index-1,sortKey.get(index-2));
}
}

/**
* 新排序算法，将图片按照如下规则排序 ：普通图片+分组图片，普通图片按时间逆序，
* 分组图片，不同组按照组的时间逆序,组内图片按照列表图、大图、中图、小图排序（支持缺失个别）
*
* @param files
* @return
* @remark create ZJF
*/
private File[] newSortFile(File[] files)
{
List<File> commonFile = new ArrayList<File>();
List<File> bigFile = new ArrayList<File>();
List<File> middleFile = new ArrayList<File>();
List<File> smallFile = new ArrayList<File>();
List<File> listFile = new ArrayList<File>();

// 将图片分组
for (File file : files)
{
if (file.getName().indexOf("_") == -1)
{
commonFile.add(file);
}
else if (file.getName().indexOf("_big") != -1)
{
bigFile.add(file);
}
else if (file.getName().indexOf("_middle") != -1)
{
middleFile.add(file);
}
else if (file.getName().indexOf("_small") != -1)
{
smallFile.add(file);
}
else if (file.getName().indexOf("_list") != -1)
{
listFile.add(file);
}
}

// 排好普通图
Collections.sort(commonFile, new FileComparator());

// 排好大图
Collections.sort(listFile, new FileComparator());

// 将大图list往list图list上合并
mergeFile(listFile, bigFile, "_list");

// 将中图list往list图list上合并（由于大图已经合并，中图优先放在大图后面）
mergeFile(listFile, middleFile, "_big");

// 将小图往中图list上合并（由于中图已经合并，小图优先放在中图图后面）
mergeFile(listFile, smallFile, "_middle");

commonFile.addAll(listFile);

File[] sortedFiles = commonFile.toArray(new File[commonFile.size()]);

// 返回排好序的list
return sortedFiles;

}

/**
* 将右侧list合并到左侧list上
*
* @param leftList
* @param rightList
* @param type
* @remark create ZJF
*/
private void mergeFile(List<File> leftList, List<File> rightList, String type)
{
List<File> FileTmp = new ArrayList<File>();

for (File right : rightList)
{
String rightName = right.getName().substring(0, right.getName().indexOf("_"));

boolean isfind = false;

// 在当前type下，寻找左侧是否有名字相同的
for (int i = 0; i < leftList.size(); i++)
{
String leftName = leftList.get(i).getName().substring(0, leftList.get(i).getName().indexOf("_"));

// 如果找到则插入左侧list
if (rightName.equals(leftName) && leftList.get(i).getName().indexOf(type) != -1)
{
leftList.add(i + 1, right);

isfind = true;

break;
}
}

//没有找到放入临时list
if (!isfind)
{
FileTmp.add(right);
}
}

// 找到list图级别还找不到，则追加到最后
if ("_list".equals(type))
{
Collections.sort(FileTmp, new FileComparator());
leftList.addAll(FileTmp);
}

// 找不到越一级往上找
else if ("_big".equals(type))
{
mergeFile(leftList, FileTmp, "_list");
}

// 找不到越一级往上找
else if ("_middle".equals(type))
{
mergeFile(leftList, FileTmp, "_big");
}
}

private File[] getFiles()
{
List<File> list = new ArrayList<File>();

File[] files = new File[10];

File file1 = new File("p1.jpg");
File file2 = new File("p2.jpg");
File file3 = new File("p3_list.jpg");
File file4 = new File("p4_big.jpg");
File file5 = new File("p3_middle.jpg");
File file6 = new File("p3_big.jpg");
File file7 = new File("p3_small.jpg");
File file8 = new File("p4_list.jpg");
File file9 = new File("p4_small.jpg");
File file10 = new File("p5_middle.jpg");
File file11 = new File("p5_list.jpg");

list.add(file1);
list.add(file2);
list.add(file3);
list.add(file4);
list.add(file5);
list.add(file6);
list.add(file7);
list.add(file8);
list.add(file9);
list.add(file10);
list.add(file11);

files = list.toArray( new File[list.size()]);

return files;
}

}