在java中，如何在数组中查找最近的大小数？

如何在

数组中找到最近的较小和较大的数字

我有一张号码表：

[3.4, 5.8, 1.2, 7.9, 9.6, 2.7, 6.2, 4.7, 0.6, 4.1] 

我想从数组中找出比5.0更小和更大的。在这种情况下，我需要最接近的较小数字，即4.7，最接近的较大数字为5.8到5.0

可以不分类吗？因为我必须去。在一个数组中，我有x轴值，在另一个数组中，我有yAxis值。如果我对数组进行排序，那么我将无法获得x对应的y值。
一旦您正确定义了“最近的”：当索引I的abs（ai-v）在数组的所有元素中最小时，数组中的值ai最接近值v，您就可以解决这个问题

使用
Math.abs（x）
计算绝对值。存储最小值以及生成它的元素的索引

对于v以上和v以下的值分别执行此操作。
考虑到您确实需要从两个数组值构建坐标，这将使用Guava的Zip功能压缩两个流。需要进行一些排序，但是因为我们对坐标进行排序，而不是对实际数组进行排序，所以您仍然能够获得所需的最终坐标

import com.google.common.collect.Streams;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.stream.Stream;


public class ZipTest {

    public static void main(String[] args) {
        Double[] xCoordinates = {3.4, 5.8, 1.2, 7.9, 9.6, 2.7, 6.2, 4.7, 0.6, 4.1};
        Double[] yCoordinates = {4.3, 8.5, 2.1, 9.7, 6.9, 7.2, 2.6, 7.4, 6.0, 1.4};
        List<Double> xValues = Arrays.asList(xCoordinates);
        List<Double> yValues = Arrays.asList(yCoordinates);

       // Get coordinate whose x value is less than and closest to 5.0
       Optional<Coordinate> coord1 = getCoords(xValues, yValues)
               .filter(coord -> coord.x < 5.0)
               .sorted((c1, c2) -> Double.compare(c2.x, c1.x))
               .findFirst();
        System.out.println(coord1);

       // Get coordinate whose x value is greater than and closest to 5.0
       Optional<Coordinate> coord2 = getCoords(xValues, yValues)
               .filter(coord -> coord.x > 5.0)
               .sorted((c1, c2) -> Double.compare(c1.x, c2.x))
               .findFirst();
        System.out.println(coord2);
    }

    private static Stream<Coordinate> getCoords(List<Double> xValues, List<Double> yValues) {
        return Streams.zip(xValues.stream(), yValues.stream(), (x,y) -> new Coordinate(x,y));
    }

    private static class Coordinate {
        private final Double x;
        private final Double y;

        Coordinate(Double x, Double y) {
            this.x = x;
            this.y = y;
        }

        @Override
        public String toString() {
            return "(" + x + "," + y + ")";
        }
    }
}

import com.google.common.collect.Streams；
导入java.util.array；
导入java.util.List；
导入java.util.Optional；
导入java.util.stream.stream；
公共类ZipTest{
公共静态void main（字符串[]args）{
双[]x坐标={3.4,5.8,1.2,7.9,9.6,2.7,6.2,4.7,0.6,4.1}；
双[]yCoordinates={4.3,8.5,2.1,9.7,6.9,7.2,2.6,7.4,6.0,1.4}；
List xValues=Arrays.asList（xCoordinates）；
List yValues=Arrays.asList（yCoordinates）；
//获取x值小于并最接近5.0的坐标
可选coord1=getCoords（xValues，yValues）
.filter（坐标->坐标x<5.0）
.sorted（（c1，c2）->Double.compare（c2.x，c1.x））
.findFirst（）；
系统输出打印LN（coord1）；
//获取x值大于并最接近5.0的坐标
可选coord2=getCoords（xValues，yValues）
.filter（坐标->坐标.x>5.0）
.sorted（（c1，c2）->Double.compare（c1.x，c2.x））
.findFirst（）；
系统输出打印LN（coord2）；
}
私有静态流getCoords（列表xValues，列表yValues）{
返回Streams.zip（xValues.stream（），yValues.stream（），（x，y）->新坐标（x，y））；
}
私有静态类坐标{
私人决赛双x；
私人决赛双y；
坐标（双x，双y）{
这个.x=x；
这个。y=y；
}
@凌驾
公共字符串toString（）{
返回“（“+x+”、“+y+”）”；
}
}
}
排序可能是最简单的方法，如果你想保持它们的原始索引，你可以简单地将两个列表合并成对，或者创建一个元组列表，比如（key，index）。通过这种方式，您可以按键进行排序，并且仍然保持对原始索引的了解，未来的查找速度要快得多（假设您多次进行此检查）
对数组排序，然后检查
5.0
下面的第一个值和
5.0
上面的第一个值。假设您首先尝试对数组排序，然后找到解决问题的方法。您可以使用
Arrays.sort（intArr）对数组进行排序