Java 获取与数组中的数字最接近的值

我有一个正/负整数数组

int[] numbers = new int[10];
numbers[0] = 100;
numbers[1] = -34200;
numbers[2] = 3040;
numbers[3] = 400433;
numbers[4] = 500;
numbers[5] = -100;
numbers[6] = -200;
numbers[7] = 532;
numbers[8] = 6584;
numbers[9] = -945;

现在，我想针对这个数组测试另一个int，并返回最接近int的数字

例如，如果我使用数字

490

，我会从数字

500

中返回第4项，这样做的最佳方式是什么

int myNumber = 490;
int distance = 0;
int idx = 0;
for(int c = 0; c < numbers.length; c++){
    int cdistance = numbers[c] - myNumber;
    if(cdistance < distance){
        idx = c;
        distance = cdistance;
    }
}
int theNumber = numbers[idx];

int myNumber=490；
整数距离=0；
int-idx=0；
for（int c=0；c

---

那不行。有什么好的建议吗？

你很接近了。我认为“距离”的初始值应该是一个大数字，而不是0。并使用绝对值作为距离

cdistance=number[c]-myNumber

。你没有得到差的绝对值。如果

myNumber

比

numbers[c]

大很多，或者

numbers[c]

为负数，则比较将记录为“最小差值”

以

数字[c]=-34200

为例<代码>数字[c]-myNumber将是-34690，比

距离要小得多

此外，您应该将距离初始化为一个大值，因为在开始时没有找到解决方案。
int myNumber=490；
int myNumber = 490;
int distance = Math.abs(numbers[0] - myNumber);
int idx = 0;
for(int c = 1; c < numbers.length; c++){
    int cdistance = Math.abs(numbers[c] - myNumber);
    if(cdistance < distance){
        idx = c;
        distance = cdistance;
    }
}
int theNumber = numbers[idx];

int distance=Math.abs（数字[0]-myNumber）；
int-idx=0；
for（int c=1；c

始终使用考虑的第一个元素初始化最小/最大函数。使用或之类的东西是获得答案的天真方式；如果您以后更改数据类型（哎哟，
MAX\u LONG
和
MAX\u INT
非常不同！），或者如果您将来想为任何数据类型编写一个通用的
min/MAX
方法，那么它就不起作用了

import javax.swing.JOptionPane;

public class NearestNumber {

public static void main(String[] arg)
{
    int[] array={100,-3420,3040,400433,500,-100,-200,532,6584,-945};

    String myNumberString =JOptionPane.showInputDialog(null,"Enter the number to test:");
    int myNumber = Integer.parseInt(myNumberString);

    int nearestNumber = findNearestNumber(array,myNumber);

    JOptionPane.showMessageDialog(null,"The nearest number is "+nearestNumber);
}

public static int findNearestNumber(int[] array,int myNumber)
{

    int min=0,max=0,nearestNumber;

    for(int i=0;i<array.length;i++)
    {
        if(array[i]<myNumber)
        {
            if(min==0)
            {
                min=array[i];
            }
            else if(array[i]>min)
            {
                min=array[i];
            }
        }
        else if(array[i]>myNumber)
        {
            if(max==0)
            {
                max=array[i];
            }
            else if(array[i]<max)
            {
                max=array[i];
            }
        }
        else
        {
            return array[i];
        }
    }

    if(Math.abs(myNumber-min)<Math.abs(myNumber-max))
    {
        nearestNumber=min;
    }
    else
    {
        nearestNumber=max;
    }

    return nearestNumber;
}

import javax.swing.JOptionPane；
公共类最近数{
公共静态void main（字符串[]arg）
{
int[]数组={100，-342030404040403500，-100，-2005326584，-945}；
字符串myNumberString=JOptionPane.showInputDialog（null，“输入要测试的数字：”）；
int myNumber=Integer.parseInt（myNumberString）；
int nearestNumber=findNearestNumber（数组，myNumber）；
showMessageDialog（null，“最近的数字是”+最近的数字）；
}
公共静态int findNearestNumber（int[]数组，int myNumber）
{
int min=0，max=0，最接近的数字；
for（int i=0；imyNumber）
{
如果（最大==0）
{
max=数组[i]；
}
否则，如果（array[i]我把它作为我课程的一项作业，并用Ready to Program Java编程，如果有点混乱，那么很抱歉

// The "Ass_1_B_3" class.
import java.awt.*;
import hsa.Console;

public class Ass_1_B_3
{
    static Console c;           // The output console

    public static void main (String[] args)
    {
        c = new Console ();

        int [] data = {3, 1, 5, 7, 4, 12, -3, 8, -2};
        int nearZero = 0;
        int temp = 0;
        int temp2 = data[0];

        for (int i = 0; i < data.length; i++)
        {
            temp = Math.abs (data[i]);
            nearZero = temp2;   
            if (temp < temp2)
            {
                temp2 = temp;
                nearZero = data[i];
            }


        }

        c.println ("The number closest to zero is: " + nearZero);

        // Place your program here.  'c' is the output console
    } // main method
} // Ass_1_B_3 class

//“Ass\u 1\u B\u 3”类。
导入java.awt.*；
导入hsa.Console；
公共类ASSU_1_B_3
{
静态控制台c；//输出控制台
公共静态void main（字符串[]args）
{
c=新控制台（）；
int[]数据={3,1,5,7,4,12，-3,8，-2}；
int接近零=0；
内部温度=0；
int temp2=数据[0]；
对于（int i=0；i
一个语句块用于初始化和设置最接近的匹配项。此外，如果未找到最接近的匹配项（空数组），则返回-1

受保护的int getClosestIndex（最终int[]值，int值）{
类最近{
整数dif；
int指数=-1；
};
最近的最近的=新的最近的（）；
对于（int i=0；i
public int getClosestToTarget（int-target，int[]值）{
如果（值。长度<1）
抛出新的IllegalArgumentException（“值应至少为一个元素”）；
如果（values.length==1）{
返回值[0]；
}
int closestValue=值[0]；
int leastDistance=Math.abs（值[0]-目标）；
对于（int i=0；i
在Java 8中：

List<Integer> list = Arrays.stream(numbers).boxed().collect(Collectors.toList());

int n = 490;

int c = list.stream()
            .min(Comparator.comparingInt(i -> Math.abs(i - n)))
            .orElseThrow(() -> new NoSuchElementException("No value present"));

List List=Arrays.stream（numbers）.boxed（）.collect（Collectors.toList（））；
int n=490；
int c=list.stream（）
.min（Comparator.comparingit（i->Math.abs（i-n）））
.OrelsThrow（（）->新的NoTouchElementException（“无值存在”）；

最初，您可以使用
列表
而不是
数组
（列表有更多的功能）。
公共类Main
{
公共静态void main（字符串[]args）
{   
int[]数={6,5,10,1,3,4,2,14,11,12}；
对于（inti=0；i，您可以调整良好的旧二进制搜索并有效地实现它

Arrays.sort(numbers);
nearestNumber = nearestNumberBinarySearch(numbers, 0, numbers.length - 1, myNumber);

private static int nearestNumberBinarySearch(int[] numbers, int start, int end, int myNumber) {
    int mid = (start + end) / 2;
    if (numbers[mid] == myNumber)
        return numbers[mid];
    if (start == end - 1)
        if (Math.abs(numbers[end] - myNumber) >= Math.abs(numbers[start] - myNumber))
            return numbers[start];
        else
            return numbers[end];
     if(numbers[mid]> myNumber)
        return nearestNumberBinarySearch(numbers, start,mid, myNumber);
     else
         return nearestNumberBinarySearch(numbers,mid, end, myNumber);

}

int-valueToFind=490；
Map Map=newhashmap（）；
对于（int i=0，i
Kotlin非常有帮助

fun List.closestValue（value:Int）=minBy{abs（value-it）}
val值=listO
List<Integer> list = Arrays.stream(numbers).boxed().collect(Collectors.toList());

int n = 490;

int c = list.stream()
            .min(Comparator.comparingInt(i -> Math.abs(i - n)))
            .orElseThrow(() -> new NoSuchElementException("No value present"));

public class Main    
{
    public static void main(String[] args)
    {   
        int[] numbers = {6,5,10,1,3,4,2,14,11,12};

        for(int i =0; i<numbers.length; i++)
        {
            sum(numbers, i, numbers[i], 12, String.valueOf(numbers[i]));
        }
    }

    static void sum(int[] arr, int i, int sum, int target, String s)
    {

        int flag = 0;

        for(int j = i+1; j<arr.length; j++)
        {

            if(arr[i] == target && flag==0)
            {
                System.out.println(String.valueOf(arr[i]));
                flag =1;

            }
            else if(sum+arr[j] == target)
            { 
                System.out.println(s+" "+String.valueOf(arr[j]));

            }
            else
            {
                sum(arr, j, sum+arr[j], target, s+" "+String.valueOf(arr[j]));
            }
        }        
    }
}

Arrays.sort(numbers);
nearestNumber = nearestNumberBinarySearch(numbers, 0, numbers.length - 1, myNumber);

private static int nearestNumberBinarySearch(int[] numbers, int start, int end, int myNumber) {
    int mid = (start + end) / 2;
    if (numbers[mid] == myNumber)
        return numbers[mid];
    if (start == end - 1)
        if (Math.abs(numbers[end] - myNumber) >= Math.abs(numbers[start] - myNumber))
            return numbers[start];
        else
            return numbers[end];
     if(numbers[mid]> myNumber)
        return nearestNumberBinarySearch(numbers, start,mid, myNumber);
     else
         return nearestNumberBinarySearch(numbers,mid, end, myNumber);

}

int valueToFind = 490;

Map<Integer, Integer> map = new HashMap();

for (int i = 0, i < numbers.length; i++){
    map.put(Math.abs(numbers[i] - valueToFind), numbers[i]);
}

List<Integer> keys = new ArrayList(map.keySet());
Collections.sort(keys);

return map.get(keys.get(0));

import java.util.*

fun printLowest(number: Int) {
    val numbers = listOf(100, 90, 50, -100, -200, 532, 6584, -945)
    val lower = TreeSet(numbers).lower(number)
    println(lower)
}

printLowest(100) // Prints 90