有一个集合 内部保存了N个对象，对象内部有一个int类型属性。。。

有一个集合 内部保存了N个对象，对象内部有一个int类型属性，
其中必定有三个对象的属性相邻且相等
例如：{5，7，8，8，8，10，11}
现在要求排列为这种类型{8，8，8，11，10，7，5}
三个相等属性的对象排列在最前面 其他的以从大到小方式排序，
如何计算？

先用排序法将数组以从大到小的方式排列，一个for循环开始相邻两个字符创匹配，没有就加1，相同则把位置和值记下来，对前面的用位移，右移3位，然后将记录下来的值赋给前三个，大概思路就这样

算法思路：
1、列表的元素需要实现 Comparable 可以使用工具类继续排序。
2、重写 toString 方法。
3、先用普通排序对列表进行排序
4、再查找属性相同的元素的下标
5、定义一个最终的列表，先放入属性相同的三个元素，在将剩余的元素加入。
完整代码：

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class DataNum implements Comparable<DataNum>{

    int count = 0;

    /**
     * 
     * @param count
     */
    public DataNum(int count) {
        this.count = count;
    }

    @Override
    public int compareTo(DataNum o) {

        return  o.count - this.count;
    }

    public void setCount(int count) {
        this.count = count;
    }

    @Override
    public String toString() {
        return count + "";
    }

    public static void main(String[] args) {
        List<DataNum> list = new ArrayList<DataNum>();
        DataNum n1 = new DataNum(5);
        DataNum n2 = new DataNum(7);
        DataNum n3 = new DataNum(8);
        DataNum n4 = new DataNum(8);
        DataNum n5 = new DataNum(8);
        DataNum n6 = new DataNum(10);
        DataNum n7 = new DataNum(11);

        list.add(n1);
        list.add(n2);
        list.add(n3);
        list.add(n4);
        list.add(n5);
        list.add(n6);
        list.add(n7);

        Collections.sort(list);
        System.out.println("First sort result:"+list);

        //再查找属性相同的下标
        int tempIndex =0;
        for(int i=0;i<list.size()-3;i++) {
            DataNum first = list.get(i);
            DataNum second = list.get(i+1);
            DataNum third = list.get(i+2);

            if(first.compareTo(second)==0 && first.compareTo(third)==0) {
                tempIndex = i;
                break;
            }
        }

        System.out.println("same index is:"+tempIndex);

        //重新定义一个列表，先放入相邻的三个，再将剩余的放入
        List<DataNum> last = new ArrayList<DataNum>();
        last.add(list.get(tempIndex));
        last.add(list.get(tempIndex+1));
        last.add(list.get(tempIndex+2));
        for(int i=0;i<tempIndex;i++) {
            last.add(list.get(i));
        }

        for(int i=tempIndex+3;i<list.size();i++) {
            last.add(list.get(i));
        }

        //打印
        System.out.println("Last sort result:"+last);
    }
}

运行结果：

First sort result:[11, 10, 8, 8, 8, 7, 5]
same index is:2
Last sort result:[8, 8, 8, 11, 10, 7, 5]

        String string = "5，7，8，8，8，10，11";
        List<Integer> list = new ArrayList<>();
        if (!StringUtils.isEmpty(string)) {
            String[] strs = string.split("，");
            for (String s : strs) {
                list.add(Integer.valueOf(s.trim()));
            }
        }
        System.out.println(list);
        Collections.sort(list);
        System.out.println(list);
        List<Integer> numList= new ArrayList<>();
        for (int i = 0; i < list.size(); i++) {
            int num = list.get(i);
            if (list.indexOf(num) != list.lastIndexOf(num)) {
                numList.add(num);
            }
        }

        for (int i = 0; i < list.size(); i++) {
            int num = list.get(i);
            if(!numList.contains(num)) {
                numList.add(num);
            }
        }
        System.out.println(numList);