Java 当X不'；不存在于列表中

我试图从列表中找到大于某个值的值（在我的例子中已知）

例如：

给定

list = [1, 2, 5, 10, 15];  //list is sorted

查找大于

X

（本例中

=7

）的值

所需结果=返回一个带有值的列表=

[10,15]

我尝试使用java二进制搜索，比如

int index = Collections.binarySearch(list, X);

我的计划是找到索引（of

X

），然后返回索引后的所有元素

但是索引返回负数，我理解这一点，因为

7

不在列表中

List<Integer> list;
List<Intger> out;

int v = 7;
for int i : list
    if i > v
        out.add(i)

还有别的办法吗？请推荐某人。

请参阅：

返回：

搜索键的索引（如果它包含在列表中）；否则，

（（插入点）

-1）。插入点定义为将键插入列表的点：大于键的第一个元素的索引，或

list.size（）

（如果列表中的所有元素都小于指定键）。注意，这保证了当且仅当找到键时，返回值将>=0

即使元素不在列表中，该方法仍然返回有意义的内容，这正是您想要的。如果返回值

r

为负值，则插入点为

-（r+1）

。当然，如果

r

为正，则元素包含在列表中。

列表；
List<Integer> list;
List<Intger> out;

int v = 7;
for int i : list
    if i > v
        out.add(i)

列出；
int v=7；
对于int i：列表
如果i>v
加上（i）

如果这是一个小列表，则暴力方法将起作用

您也可以使用一些可用于列表的方法，例如subList->

用于int i；i7
return list.subList（i，list.size（））
return new List（）//返回空列表

如果您的列表已排序，则将返回搜索键的索引（如果它包含在列表中）；否则，（（插入点）-1）。您可以按如下方式计算插入点的开始索引：

     index= -(insertion_point) - 1
     -(insertion_point)= index+1
     insertion_point=-(index+1)

在获得

List

的开始索引后，可以应用方法获得大于X的结果列表

    Integer[] values = {1, 2, 5, 10, 15};
    List<Integer> list = new ArrayList<>(Arrays.asList(values));
    int X = 7;
    int index = Collections.binarySearch(list, X);

    int insertion_point = -(index+1); // As calculated above.

    List<Integer> res = list.subList(insertion_point, list.size());
    System.out.println(res);

Integer[]值={1,2,5,10,15}；
List List=newarraylist（Arrays.asList（values））；
int X=7；
int index=Collections.binarySearch（列表，X）；
int插入_点=-（索引+1）；//如上所述。
List res=List.subList（插入点，List.size（））；
系统输出打印项次（res）；

---

输出：[10,15]

一种大致的方法是使用传统的上、下和中点引用实现您自己的二进制搜索算法。通常，在下面的方法中，当下限值大于上限值时，表示您要查找的数字不在列表中，但在您的情况下，您可以将其用作列表中其余项目的索引值的参考

public int find(int searchKey){
    int lowerBound = 0;
    int upperBound = nElems-1;
    int check;

    while(true){
       check = (lowerBound + upperBound ) / 2;
       if(myArray[check]==searchKey){
           return check; // found it
        }else if(lowerBound > upperBound){
              //lowerbound is now the first index of the remaining values in the list.
              // I think. You might want to test it...

        }else{ // divide range
              if(myArray[check] < searchKey){
                 lowerBound = check + 1; // it's in upper half
              }else{
                   upperBound = check - 1; // it's in lower half
           }
        } // end else divide range
      } // end while
   } // 

public int-find（int-searchKey）{
int lowerBound=0；
int上限=nElems-1；
整数检查；
while（true）{
检查=（下限+上限）/2；
if（myArray[check]==searchKey）{
返回检查；//找到了
}else if（下限>上限）{
//lowerbound现在是列表中剩余值的第一个索引。
//我想，你可能想测试一下。。。
}else{//划分范围
if（myArray[check]

自Java 8以来，您可以使用流

import java.util.ArrayList;
import java.util.List;
import java.util.Arrays;
import java.util.stream.Collectors;

public class So1 {

   public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 5, 10, 15);
        List result = list.stream().filter(s -> s > 7).collect(Collectors.toList());
        System.out.println(result);
    }
}

---

另一种方法：创建一个新的列表，并从原始列表中添加大于X的元素。@RyanStewart，谢谢。这家伙问了一个如何用java而不是clojure实现的问题。也许他在工作中需要它，因为他不能去老板那里请求允许开始用Clojure写作。

(filter
    #(> % 7) 
    [1 2 5 10 15])