Question

非常难以使它变得有趣，因为一旦使用比较器排序的列表无法再次排序，但这是我们需要将数组值更改为以下方式进行排序 // ALL应始终在TOP

//如果取1，那么// SortTech的主列表将被排序为ALL，B，A，C，D，E，F，G
// 1现在被采取4然后采取 //要对SortTech的mainList进行排序ALL，B，E，A，C，D，F，G
//现在1,4被删除，然后获取6,5 // SortTech的主列表将被排序为ALL，G，F，A，B，C，D，E
// 6,5现在采取-1然后采取//主要的SortTech列表进行排序ALL，A，B，C，D，E，F，G

package com.test;

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

public class SortTech {

    private  long id;
    private String name ;


    public static void main(String[] args) {

        List<SortTech> mainList = new ArrayList<>();

        SortTech S1 = new SortTech();
        S1.setName("ALL");
        S1.setId(-1);
        mainList.add(S1);

        SortTech S2 = new SortTech();
         S2.setName("A");
        S2.setId(0);
        mainList.add(S2);


        SortTech S3 = new SortTech();
        S3.setName("B");
        S3.setId(1);
        mainList.add(S3);

        SortTech S4 = new SortTech();
        S4.setName("C");
        S4.setId(2);
        mainList.add(S4);

        SortTech S5 = new SortTech();
        S5.setName("D");
        S5.setId(3);
        mainList.add(S5);

        SortTech S6 = new SortTech();
        S6.setName("E");
        S6.setId(4);
        mainList.add(S6);

        SortTech S7 = new SortTech();
        S7.setName("F");
        S7.setId(5);
        mainList.add(S7);

        SortTech S8 = new SortTech();
        S8.setName("G");
        S8.setId(6);
        mainList.add(S8);


/*     //tried with comparator but it give unmodifiable list in return so could not modify any further 
 *    Collections.sort(mainList, new Comparator<SortTech>() {
            public int compare(SortTech t1, SortTech t2) {
                if (t1.getName().equals("ALL"))
                    return -1;
                if (t2.getName().equals("ALL"))
                    return 1;
                return t2.getName().compareTo(t2.getName());
            }
        });*/


        //ALL should always on TOP 

        //if 1 is taken 
        Long[] taken = new Long[]{(long) 1};
        //mainList of  SortTech to be sorted as ALL , B , A , C, D, E, F ,G
        //system out 

        //1 was taken now 4 is taken  
        taken = new Long[]{(long) 1, (long) (4)};
        //mainList of  SortTech to be sorted as  ALL, B , E, A , C, D,  F ,G
        //system out 

        //now 1,4 are dropped and 6,5 taken 
        taken = new Long[]{(long) 6, (long) (5)};
        //mainList of  SortTech to be sorted as  ALL, G, F, A , B,  C, D, E  
        //system out 

        //now 6,5 was taken now -1 is taken 
        taken = new Long[]{(long) 6, (long) (5), (long) (-1)};
        //mainList of  SortTech to be sorted as  ALL, A , B,  C, D, E , F, G 
        //system out 








    }



    /**
     * @return the id
     */
    public long getId() {
        return id;
    }



    /**
     * @param id the id to set
     */
    public void setId(long id) {
        this.id = id;
    }



    /**
     * @return the name
     */
    public String getName() {
        return name;
    }



    /**
     * @param name the name to set
     */
    public void setName(String name) {
        this.name = name;
    }



}

Answer 1

首先，为比较器创建一个单独的类。这是必需的，因为您需要一种方法将“采用”列表提供给比较器。

public class SortTechComparator implements Comparator<SortTech> {

    Array<Long> taken;

    public SortTechComparator<SortTech>(Long[] takenArray) {
        taken = Arrays.asList(takenArray);
    }

    public int compare(SortTech t1, SortTech t2) {
        // 1. if t1 is 'ALL'
        if (t1.getName().equals("ALL"))
            return -1;

        // 2. if t2 is 'ALL'
        if (t2.getName().equals("ALL"))
            return 1;

        // 3. if 'ALL' is not taken
        if (!isItemTaken(-1)) {

            // 4. if one item is in 'taken' list but the other is not
            if (isItemTaken(t1.getId()) != isItemTaken(t2.getId())) {
                return isItemTaken(t1.getId()) ? -1 : 1;
            }

            // 5. if both items are 'taken'
            if (isItemTaken(t1.getId()) && isItemTaken(t2.getId())) {
                return itemPosition(t1.getId()) < itemPosition(t2.getId()) ? -1 : 1;
            }
        }

        // 6. sort based on name
        return t2.getName().compareTo(t2.getName());
    }

    private boolean isItemTaken(long itemId) {
        return taken.contains(itemId);
    }

    private long itemPosition(long itemId) {
        return taken.indexOf(itemId);
    }
}

然后当你想使用比较器进行排序时：

Long[] taken = ...
Collections.sort(mainList, new SortTechComparator(taken));

工作原理

如果它在t1中，则将'ALL'放在第一位。
如果它在t2中，则将'ALL'放在第一位。
如果采取'ALL'，那么其他一切的排序顺序应该是基于名称的，所以跳过'基于'的排序。如果'ALL'不，我们只会对此测试进行反转，以便我们只进行“采取”排序。
如果一个项目在“已采用”列表中但另一个项目不在，则我们可以根据第一项是否在“已采用”列表中进行排序。
如果同时拍摄了两个项目，则在“拍摄”列表中对位置进行排序。
这是万能的。如果我们到这里，那么我们只需要一个名字排序。

Java |基于数组值重复排序列表，并更改数组中的值

1 个答案: