Java 如何保持N的最大值？

我正在使用

double getDelay（）

从许多对象获取值。但我需要一些帮助，因为我不知道如何保存6个更高的值。我想做一个循环并将值保存在数组中，但我不知道如何插入新值并删除最小值并重新排列数组。有没有保存和排序这些值的建议

编辑：

---

感谢大家，我忘了说我也必须保存对象（或者用getName（）将名称保存在字符串中，我不在乎）。我本想使用队列，但我不太能控制它们。我怎么点？因为如果我使用Array.sort，我不知道这个值是什么对象，你可以使用Array.sort（yourArr），然后取最后N个条目

---

请参阅答案：

您可以只使用数组。排序（yourArr），然后获取最后N个条目

---

请参阅答案：

您可以只使用数组。排序（yourArr），然后获取最后N个条目

---

请参阅答案：

您可以只使用数组。排序（yourArr），然后获取最后N个条目

---

请参阅答案：

您可以在

双[]数组中添加所有值。然后像这样使用
Arrays.sort（）
：

Arrays.sort(array,Collections.reverseOrder()); // this will sort array in descending order

List<Object> highest = new ArrayList<Object>;  
for(int i=0; i<6; i++){
    Double last = treemap.getLastKey();
    Object objLast = treemap.get(last);
    hightest.put(objLast);
    treemap.remove(last);

}

现在您可以访问该数组的前6个元素以获得最大的6个值

编辑：如果您还想保留对象，可以使用
TreeMap
。用ID和对象填充它。
TreeMap
中的元素按此处为双精度的键排序

然后可以在
TreeMap
中检索最后6个元素，如下所示：

Arrays.sort(array,Collections.reverseOrder()); // this will sort array in descending order

List<Object> highest = new ArrayList<Object>;  
for(int i=0; i<6; i++){
    Double last = treemap.getLastKey();
    Object objLast = treemap.get(last);
    hightest.put(objLast);
    treemap.remove(last);

}

List highest=new ArrayList；
对于（int i=0；i您可以将所有值添加到
double[]数组中
。然后像这样使用
Arrays.sort（）
：

Arrays.sort(array,Collections.reverseOrder()); // this will sort array in descending order

List<Object> highest = new ArrayList<Object>;  
for(int i=0; i<6; i++){
    Double last = treemap.getLastKey();
    Object objLast = treemap.get(last);
    hightest.put(objLast);
    treemap.remove(last);

}

现在您可以访问该数组的前6个元素以获得最大的6个值

编辑：如果您还想保留对象，可以使用
TreeMap
。用ID和对象填充它。
TreeMap
中的元素按键排序，这里的键是双精度的

然后可以在
TreeMap
中检索最后6个元素，如下所示：

Arrays.sort(array,Collections.reverseOrder()); // this will sort array in descending order

List<Object> highest = new ArrayList<Object>;  
for(int i=0; i<6; i++){
    Double last = treemap.getLastKey();
    Object objLast = treemap.get(last);
    hightest.put(objLast);
    treemap.remove(last);

}

List highest=new ArrayList；
对于（int i=0；i您可以将所有值添加到
double[]数组中
。然后像这样使用
Arrays.sort（）
：

Arrays.sort(array,Collections.reverseOrder()); // this will sort array in descending order

List<Object> highest = new ArrayList<Object>;  
for(int i=0; i<6; i++){
    Double last = treemap.getLastKey();
    Object objLast = treemap.get(last);
    hightest.put(objLast);
    treemap.remove(last);

}

现在您可以访问该数组的前6个元素以获得最大的6个值

编辑：如果您还想保留对象，可以使用
TreeMap
。用ID和对象填充它。
TreeMap
中的元素按键排序，这里的键是双精度的

然后可以在
TreeMap
中检索最后6个元素，如下所示：

Arrays.sort(array,Collections.reverseOrder()); // this will sort array in descending order

List<Object> highest = new ArrayList<Object>;  
for(int i=0; i<6; i++){
    Double last = treemap.getLastKey();
    Object objLast = treemap.get(last);
    hightest.put(objLast);
    treemap.remove(last);

}

List highest=new ArrayList；
对于（int i=0；i您可以将所有值添加到
double[]数组中
。然后像这样使用
Arrays.sort（）
：

Arrays.sort(array,Collections.reverseOrder()); // this will sort array in descending order

List<Object> highest = new ArrayList<Object>;  
for(int i=0; i<6; i++){
    Double last = treemap.getLastKey();
    Object objLast = treemap.get(last);
    hightest.put(objLast);
    treemap.remove(last);

}

现在您可以访问该数组的前6个元素以获得最大的6个值

编辑：如果您还想保留对象，可以使用
TreeMap
。用ID和对象填充它。
TreeMap
中的元素按键排序，这里的键是双精度的

然后可以在
TreeMap
中检索最后6个元素，如下所示：

Arrays.sort(array,Collections.reverseOrder()); // this will sort array in descending order

List<Object> highest = new ArrayList<Object>;  
for(int i=0; i<6; i++){
    Double last = treemap.getLastKey();
    Object objLast = treemap.get(last);
    hightest.put(objLast);
    treemap.remove(last);

}

List highest=new ArrayList；
对于（int i=0；i您实际上需要创建一个
比较器
，并直接对
MyObject
数组进行排序：

Comparator<MyObject> myComparator = (o1, o2) -> {
    o1.getDelay() > o2.getDelay() ? -1 : (o1.getDelay() < o2.getDelay()  ? 1 : 0);
} // Reverse order by getDelay()
MyObject[] stuff;
Arrays.sort(stuff, myComparator);
for (int i = 0; i < 6; i++) {
    doSomething(stuff[i]);
}

Comparator myComparator=（o1，o2）->{
o1.getDelay（）>o2.getDelay（）？-1:（o1.getDelay（）
您实际上需要创建一个
比较器
并直接对
MyObject的数组进行排序：

Comparator<MyObject> myComparator = (o1, o2) -> {
    o1.getDelay() > o2.getDelay() ? -1 : (o1.getDelay() < o2.getDelay()  ? 1 : 0);
} // Reverse order by getDelay()
MyObject[] stuff;
Arrays.sort(stuff, myComparator);
for (int i = 0; i < 6; i++) {
    doSomething(stuff[i]);
}

Comparator myComparator=（o1，o2）->{
o1.getDelay（）>o2.getDelay（）？-1:（o1.getDelay（）
您实际上需要创建一个
比较器
并直接对
MyObject的数组进行排序：

Comparator<MyObject> myComparator = (o1, o2) -> {
    o1.getDelay() > o2.getDelay() ? -1 : (o1.getDelay() < o2.getDelay()  ? 1 : 0);
} // Reverse order by getDelay()
MyObject[] stuff;
Arrays.sort(stuff, myComparator);
for (int i = 0; i < 6; i++) {
    doSomething(stuff[i]);
}

Comparator myComparator=（o1，o2）->{
o1.getDelay（）>o2.getDelay（）？-1:（o1.getDelay（）
您实际上需要创建一个
比较器
并直接对
MyObject的数组进行排序：

Comparator<MyObject> myComparator = (o1, o2) -> {
    o1.getDelay() > o2.getDelay() ? -1 : (o1.getDelay() < o2.getDelay()  ? 1 : 0);
} // Reverse order by getDelay()
MyObject[] stuff;
Arrays.sort(stuff, myComparator);
for (int i = 0; i < 6; i++) {
    doSomething(stuff[i]);
}

Comparator myComparator=（o1，o2）->{
o1.getDelay（）>o2.getDelay（）？-1:（o1.getDelay（）
听起来您需要排序算法（易于谷歌搜索和实现）然后，如果按递增顺序排序，可以只取最后六个。也可以查看ArrayList以查找可调整大小的数组。@BenKnoble我不这么认为。您可能只想存储N个最高值并使用它们，而不是执行所有这些工作。我想，但要跟踪检查检索到的所有值是否都更大到目前为止，比六个存储值中的任何一个都多？对我来说，听起来像是很多if语句。@BenKnoble您可以使用
PriorityQueue
或
TreeSet
来实现它，而不是手动使用大量的
if
s。使用PriorityQueue：听起来您需要排序算法（易于谷歌搜索和实现）然后，如果按递增顺序排序，可以只取最后六个。也可以查看ArrayList以查找可调整大小的数组。@BenKnoble我不这么认为。您可能只想存储N个最高值并使用它们，而不是执行所有这些工作。我想，但要跟踪检查检索到的所有值是否都更大比目前为止存储的六个值中的任何一个都要多