Java 如何使用基于优先级的元素填充数组？

我试图尽快解决这个问题，但我知道这不会那么容易

我有一个映射，其中键是Unit type，值是

Integer

，表示在屏幕上显示单位时的单位优先级

所以我需要用单元类型填充

列表

在基本单词中，如果list=
[A，B，C，D]
这是显示它们的顺序

A -> B -> C -> D.

我写了基本类，它的工作如预期

public class MonsterSort2 {

/**
 * @param args
 */
public static void main(String[] args) {

    int elementCount = 20;

    List<String> list = new ArrayList<String>(elementCount);

    Map<String, Integer>  map = new LinkedHashMap<String, Integer>();

    map.put("A", 1);
    map.put("C", 2);
    map.put("D", 2);
    map.put("B", 3);



    Iterator<String> it = map.keySet().iterator();

    int shift = 0;


    while(it.hasNext()){
        String unitName = it.next();

        for(int i=shift; i<elementCount; i++){
            list.add(unitName);

            if(i == elementCount/map.size() -1 + shift){
                shift = i;
                break;
            }
        }       

    }//while

    System.out.println(list);

}
} 

但是问题是，如果2个或3个或4个单元具有相同的优先级怎么办？

我的想法是随机显示它们。以下优先事项：

map.put("A", 1);
map.put("C", 2);
map.put("D", 2);
map.put("B", 3);

预期产出应为：

 [A, A, A, A, A, C, D, D, C, C, D, D, C, D, C, B, B, B, B, B]

如您所见，
C
和
D
停留在随机位置，但在
A
之后和
B
之前

我怎样才能达到这个逻辑

谢谢，
我建议为你的怪物创建一个类，如下所示：

class Monster implements Comparable<Monster> {
  public String name;
  public int priority;

  public int compareTo(Monster o) {
     if (priority != o.priority )
       return priority - o.priority;
     return (Math.random() > 0.5)?1:-1;
  }
}

类怪物实现了可比较的{
公共字符串名称；
公共优先权；
公共整数比较（怪物o）{
如果（优先级！=o.priority）
返回优先级-o.priority；
返回值（Math.random（）>0.5）？1:-1；
}
}

将你的怪物添加到
树丛中，瞧。
我创建了：

Map<String, Double> pseudoMap = new HashMap<String, Double>(elementCount);

我得到：

{B_15=3.1016031962291204, B_14=3.4563893967442123, B_16=3.11280085831218,
 B_12=3.2976658355169466, C_8=2.6491871264729765, D_6=2.223351148643601, 
 B_13=3.577597012082142, C_9=2.541821826106959, D_5=2.4389896004212637, 
 D_4=2.2044652083865226, D_8=2.7914089043360315, D_7=2.2760755825849546, 
 A_1=1.6863051487791398, A_0=1.0879832608200397, C_11=2.552343819848361, 
 C_12=2.6759559071285404, C_10=2.7712147590013814, A_4=1.9764299942651913,
 A_3=1.973038652207146, A_2=1.1844902000282258}

接下来，创建类：

public class PriorityComparator  implements Comparator<String> {

Map<String, Double> base;
public PriorityComparator(Map<String, Double> base) {
    this.base = base;
}


public int compare(String a, String b) {
    if (base.get(a) <= base.get(b)) {
        return -1;
    } else {
        return 1;
    } 
  }
}

这是一个完整的示例代码：

public class MonsterSort2 {

/**
 * @param args
 */
public static void main(String[] args) {

    int elementCount = 23;

    List<String> list = new ArrayList<String>(elementCount);

    Map<String, Integer>  unitMap = new LinkedHashMap<String, Integer>();

    unitMap.put("A", 1);
    unitMap.put("C", 2);
    unitMap.put("D", 2);
    unitMap.put("B", 3);

    Random rand = new Random();

    ValueComparator bvc =  new ValueComparator(unitMap);

    TreeMap<String,Integer> sorted_map = new TreeMap<String,Integer>(bvc);

    Map<String, Double> pseudoMap = new HashMap<String, Double>(elementCount);


    sorted_map.putAll(unitMap);

    unitMap = new LinkedHashMap<String, Integer>(sorted_map);

    Iterator<String> it = unitMap.keySet().iterator();

    int shift = 0;

    while(it.hasNext()){
        String unitName = it.next();

        //prevPrior = unitList.get(unitName);

        for(int i=shift; i<elementCount; i++){
            //list.add(unitName);

            double d = 0.0;

            // generate double <> 0 or 1
            while(d == 0.0 || d == 1.0){
                d = rand.nextDouble();
            }

            pseudoMap.put(unitName + "_" + i, (double)(unitMap.get(unitName) + d));

            if(i == elementCount/unitMap.size() -1 + shift){
                shift = i;
                break;
            }
        }       

    }//while


    PriorityComparator prComp =  new PriorityComparator(pseudoMap);

    TreeMap<String,Double> sorted_map_total = new TreeMap<String,Double>(prComp);

    sorted_map_total.putAll(pseudoMap);

    list = new ArrayList<String>(elementCount);

    it = sorted_map_total.keySet().iterator();

    while(it.hasNext()){
        String unitName = it.next();

        list.add(unitName.split("_")[0]);


    }//while

    System.out.println(list);

}
}

公共类SORT2{
/**
*@param args
*/
公共静态void main（字符串[]args）{
int元素计数=23；
列表列表=新的ArrayList（elementCount）；
Map unitMap=newlinkedhashmap（）；
单位地图。放置（“A”，1）；
单位图.put（“C”，2）；
单位图。放置（“D”，2）；
单位图.put（“B”，3）；
Random rand=新的Random（）；
ValueComparator bvc=新的ValueComparator（unitMap）；
TreeMap sorted_map=新的TreeMap（bvc）；
Map pseudoMap=新HashMap（elementCount）；
排序图putAll（unitMap）；
unitMap=新的LinkedHashMap（已排序的映射）；
迭代器it=unitMap.keySet（）.Iterator（）；
int-shift=0；
while（it.hasNext（））{
字符串unitName=it.next（）；
//prevPrior=unitList.get（unitName）；
对于（inti=shift；你能解释一下这段代码是如何产生[A，A，A，A，C，D，D，C，D，D，C，D，C，B，B，B，B]我看不出来！你想要它们以随机顺序排列，因为它们的优先级相同？我一共有4个单元：A、B、CD。因为C和D具有相同的优先级2，我随机将它们放入
列表中，但每个单元在列表中只有5个位置
你想要它们以随机顺序排列，因为它们的优先级相同
是的我使用了
可比
之前，我将优先排序，但您的示例为我指明了方向。我在上面发布了我的方法，谢谢
{B_15=3.1016031962291204, B_14=3.4563893967442123, B_16=3.11280085831218,
 B_12=3.2976658355169466, C_8=2.6491871264729765, D_6=2.223351148643601, 
 B_13=3.577597012082142, C_9=2.541821826106959, D_5=2.4389896004212637, 
 D_4=2.2044652083865226, D_8=2.7914089043360315, D_7=2.2760755825849546, 
 A_1=1.6863051487791398, A_0=1.0879832608200397, C_11=2.552343819848361, 
 C_12=2.6759559071285404, C_10=2.7712147590013814, A_4=1.9764299942651913,
 A_3=1.973038652207146, A_2=1.1844902000282258}

public class PriorityComparator  implements Comparator<String> {

Map<String, Double> base;
public PriorityComparator(Map<String, Double> base) {
    this.base = base;
}


public int compare(String a, String b) {
    if (base.get(a) <= base.get(b)) {
        return -1;
    } else {
        return 1;
    } 
  }
}

[A, A, A, A, A, C, C, C, D, D, D, C, C, D, D, B, B, B, B, B]

public class MonsterSort2 {

/**
 * @param args
 */
public static void main(String[] args) {

    int elementCount = 23;

    List<String> list = new ArrayList<String>(elementCount);

    Map<String, Integer>  unitMap = new LinkedHashMap<String, Integer>();

    unitMap.put("A", 1);
    unitMap.put("C", 2);
    unitMap.put("D", 2);
    unitMap.put("B", 3);

    Random rand = new Random();

    ValueComparator bvc =  new ValueComparator(unitMap);

    TreeMap<String,Integer> sorted_map = new TreeMap<String,Integer>(bvc);

    Map<String, Double> pseudoMap = new HashMap<String, Double>(elementCount);


    sorted_map.putAll(unitMap);

    unitMap = new LinkedHashMap<String, Integer>(sorted_map);

    Iterator<String> it = unitMap.keySet().iterator();

    int shift = 0;

    while(it.hasNext()){
        String unitName = it.next();

        //prevPrior = unitList.get(unitName);

        for(int i=shift; i<elementCount; i++){
            //list.add(unitName);

            double d = 0.0;

            // generate double <> 0 or 1
            while(d == 0.0 || d == 1.0){
                d = rand.nextDouble();
            }

            pseudoMap.put(unitName + "_" + i, (double)(unitMap.get(unitName) + d));

            if(i == elementCount/unitMap.size() -1 + shift){
                shift = i;
                break;
            }
        }       

    }//while


    PriorityComparator prComp =  new PriorityComparator(pseudoMap);

    TreeMap<String,Double> sorted_map_total = new TreeMap<String,Double>(prComp);

    sorted_map_total.putAll(pseudoMap);

    list = new ArrayList<String>(elementCount);

    it = sorted_map_total.keySet().iterator();

    while(it.hasNext()){
        String unitName = it.next();

        list.add(unitName.split("_")[0]);


    }//while

    System.out.println(list);

}
}