爪哇 |根据数组值重复排序列表，并更改数组中的值

Question

它

非常困难，因为它也很有趣，因为一旦使用比较器排序的列表无法再次排序，但这就是我们需要的数组值的变化，以排序为波纹管
所有人都应该始终在顶部

//
1. 如果取 1 则//mainList of SortTech 要排序 all ， b ， a ， c， d， e， f ，g
/
2. /1 现在被拿走了 4 被拿走了 主要排序技术列表 ALL， B ， E， A ， C， D， F ，G
//
3. 现在删除了 1,4 个，然后取了 6,5 个//主要排序技术列表 ALL， G， F， A ， B， C， D， E
4. //6,5 现在被取 -1 被取然后//主要排序技术列表 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));

工作原理

1. 如果 "ALL"在 t1 中，这会将它放在第一位。
2. 如果 "ALL"在 t2 中，这会将它放在第一位。
3. 如果采用"ALL"，则其他所有内容的排序顺序应基于名称，因此请跳过基于"已获取"的排序。我们反转此测试，以便在不采用"ALL"的情况下仅执行基于"已采取"的排序。
如果一个项目在"已采取"列表中
4. ，而另一个不在，那么我们可以根据第一个项目是否在"已采取"列表中进行排序。
5. 如果两个项目都被占用，则按"已采取"列表中的位置排序。
6. 这是包罗万象的。如果我们到达这里，那么我们只需要一个名称排序。