一个关于数据大小比较的业务需求不知道如何实现

问题描述：
1、现在随机生成1-10这10个数，不重复的。
例：5, 8，4, 6，3, 7, 1 , 9, 10 , 2
然后把他们按从左到右两两做为一组拆开，也就是五组数
分别是：
第一组：{5,8}， 5+8=13
第二组：{4,6}， 4+6=10
第三组：{3,7}, 3+7=10
第四组：{1,9}， 1+9= 10
第五组：{10,2} 10+2= 12
2、现在有业务需求：计算每组数据的两数之和，
并比较它们的大小，然后按两数之和大小进行排名。
补充：假如出现最后计算结果相等的情况，
例如：
现在就是第二、三、四组的最后计算结果相同，
那他们的排名规则是：取每组数中的最大数进行比较，哪组的最大数是最大的，
则该组在它们最后计算结果一样的情况下，它的排名最大。
例：第二、三、四组中；
第二组最大数为：6，
第三组最大数为：7，
第四组最大数为：9

那在它们三组最后计算结果相同的情况下，
它们的排序为：
第四组>第三组>第二组

那最后的排名结果是：
第一组>第五组>第四组>第三组>第二组

困难描述：如何用java代码实现这个功能，
新手码农求java老司机载一程，非常感谢！
我着实是不知道怎么弄。

看了一下这个不难啊，楼主，但是代码得等一下贴上来。

 package baokexiao.test;

import java.util.Arrays;
import java.util.Random;

public class Test {
    public static void main(String[] args) {
        int [] array = getRandomArray();
        System.out.println(Arrays.toString(array));
        int [][] arrayGruop = splitArray(array);
        System.out.println("------排序前--------");
        printArrayGroup(arrayGruop);
        sortArrayGroup(arrayGruop);
        System.out.println("------排序后--------");
        printArrayGroup(arrayGruop);

    }

    //数组排序
    public static void sortArrayGroup(int [][] arrayGruop){
        //冒泡排序
        for (int i = 0; i < arrayGruop.length -1; i++){    //最多做n-1趟排序
            for(int j = 0 ;j < arrayGruop.length - i - 1; j++){    //对当前无序区间score[0......length-i-1]进行排序(j的范围很关键，这个范围是在逐步缩小的)
                if(compareArray(arrayGruop[j],arrayGruop[j + 1]) == -1){    //把小的值交换到后面
                    int [] temp = arrayGruop[j];
                    arrayGruop[j] = arrayGruop[j + 1];
                    arrayGruop[j + 1] = temp;
               }
           }            
        }
    }

    //数组比较大小
    public static int compareArray(int [] array1,int [] array2){
        int sum1 = getArraySum(array1);
        int sum2 = getArraySum(array2);
        if(sum1 > sum2) return 1;
        if(sum2 < sum2) return -1;
        int max1 = getArrayMaxVal(array1);
        int max2 = getArrayMaxVal(array2);
        if(max1 > max2) return 1;
        if(max1 < max2) return -1;
        throw new RuntimeException("can not compareArray,array1:"+Arrays.toString(array1)+" array2:"+Arrays.toString(array2));
    }

    //打印数组
    public static void printArrayGroup(int [][] array){
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j]+"\t");
            }
            System.out.println();
        }
    }

    //拆分数组
    public static int[][] splitArray(int [] array){
        int groupSize = array.length/2;
        int [][] result = new int[groupSize][2];
        int foot = 0 ;
        for (int i = 0; i < groupSize; i++) {
            int [] tmp = new int[2];
            tmp[0] = array[foot++];
            tmp[1] = array[foot++];
            result[i] = tmp;
        }
        return result;
    }

    //求数组中的最大值
    public static int getArrayMaxVal(int [] array){
        int max = array[0];
        for (int i = 1; i < array.length; i++) {
            if(array[i] > max) max = array[i];
        }
        return max;
    }

    //求数组的和
    public static int getArraySum(int [] array){
        int result = 0;
        for (int i = 0; i < array.length; i++) {
            result += array[i];
        }
        return result;
    }

    //创建数组
    public static int [] getRandomArray(){
        int [] result = new int [10];
        Random r=new java.util.Random();
        for (int i = 0; i < result.length; i++) {
            int t = r.nextInt(10)+1;//[1,10)
            while(checkRepeat(result,t)){
                t = r.nextInt(10)+1;
            }
            result[i] = t;
        }
        return result;
    }
    //查看是否重复
    public static boolean checkRepeat(int [] array,int t){
        for (int i = 0; i < array.length; i++) {
            if(t == array[i]) return true;
        }
        return false;
    }
}

用TreeSet是不是也可以 但是这个代码有很多bug

import java.util.Comparator;
import java.util.Random;
import java.util.TreeSet;

public class Test4Sort {


    private TreeSet< int[]> treeSet = new TreeSet<int[]>(new Comparator<int[]>() {
        @Override
        public int compare(int[] o1, int[] o2) {
            int sum1 = o1[0] + o1[1];
            int sum2 = o2[0] + o2[1];
            if(sum1 > sum2){
                return 1;
            }else if(sum1 == sum2){
                int max1 = o1[0] > o1[1] ? o1[0] : o1[1];
                int max2 = o2[0] > o2[1] ? o2[0] : o2[1];
                if(max1 > max2){
                    return 1;
                }else{
                    return -1;
                }
            }else{
                return -1;
            }
        }
    });

    public static void main(String[] args) {
        Test4Sort sort = new Test4Sort();

        for(int i=0;i<5;i++){
            int[] temp = new int[2];
            for(int j=0;j<2;j++){
                temp[j] = new Random().nextInt(10)+1;
            }
            sort.treeSet.add(temp);
        }

        for (int[] ints : sort.treeSet) {
            System.out.print(ints[0]+","+ints[1]+"<");
        }
    }

}