Question

如何在int类型的Java数组中找到某个值的索引？

我尝试在我的未排序数组上使用Arrays.binarySearch，它有时只给出正确的答案。

Answer 1

Integer[] array = {1,2,3,4,5,6};

Arrays.asList(array).indexOf(4);

请注意，此解决方案是线程安全的，因为它会创建一个List类型的新对象。

你也不想在循环中或类似的东西中调用它，因为你每次都要创建一个新对象

Answer 2

如果您使用番石榴收藏品，另一个选项是Ints.indexOf

// Perfect storm:
final int needle = 42;
final int[] haystack = [1, 2, 3, 42];

// Spoiler alert: index == 3
final int index = Ints.indexOf(haystack, needle);

当空间，时间和代码重用非常宝贵时，这是一个很好的选择。它也非常简洁。

Answer 3

查看API，它说您必须先对数组进行排序

所以：

Arrays.sort(array);
Arrays.binarySearch(array, value);

如果您不想对数组进行排序：

public int find(double[] array, double value) {
    for(int i=0; i<array.length; i++) 
         if(array[i] == value)
             return i;
}

Answer 4

将此方法复制到您的班级

 public int getArrayIndex(int[] arr,int value) {

        int k=0;
        for(int i=0;i<arr.length;i++){

            if(arr[i]==value){
                k=i;
                break;
            }
        }
    return k;
}

使用传递两个参数Array和value调用此方法，并将其返回值存储在整数变量中。

int indexNum = getArrayIndex(array,value);

谢谢

Answer 5

您可以将其转换为列表，然后使用indexOf方法：

Array.asList(array).indexOf(1);

http://download.oracle.com/javase/1.5.0/docs/api/java/util/Arrays.html#asList(T ...） http://download.oracle.com/javase/1.5.0/docs/api/java/util/List.html#indexOf(java.lang.Object）

Answer 6

您需要在使用二进制搜索之前对值进行排序。否则，手动方式是尝试选项卡中的所有整数。

public int getIndexOf( int toSearch, int[] tab )
{
  for( int i=0; i< tab.length ; i ++ )
    if( tab[ i ] == toSearch)
     return i;

  return -1;
}//met

另一种方法可以是映射地图中每个值的所有索引。

tab[ index ] = value;
if( map.get( value) == null || map.get( value) > index )
    map.put( value, index );

然后使用map.get（value）来获取索引。

此致斯特凡

@pst，感谢您的评论。你能发布另一种替代方法吗？

Answer 7

您可以使用现代Java解决此问题。请使用以下代码：

static int findIndexOf(int V, int[] arr) {
        return IntStream.range(1, arr.length).filter(i->arr[i]==V).findFirst().getAsInt();
    }

Answer 8

简单：

public int getArrayIndex(int[] arr,int value) {
    for(int i=0;i<arr.length;i++)
        if(arr[i]==value) return i;
    return -1;
}

Answer 9

最简单的方法是进行迭代。例如，我们要查找数组及其索引的最小值：

public static Pair<Integer, Integer> getMinimumAndIndex(int[] array) {
        int min = array[0];
        int index = 0;
        for (int i = 1; i < array.length; i++) {
            if (array[i] < min) {
                min = array[i];
                index = i;
            }

            return new Pair<min, index>;

这样，您可以测试所有数组值，如果其中一些值是最小值，您还将知道最小值索引。搜索某些值可以相同：

public static int indexOfNumber(int[] array) {
        int index = 0;
        for (int i = 0; i < array.length; i++) {
            if (array[i] == 77) {        // here you pass some value for example 77
                index = i;
            }
        }
        return index;
    }

Answer 10

    Integer[] arr = { 0, 1, 1, 2, 3, 5, 8, 13, 21 };
    List<Integer> arrlst = Arrays.asList(arr);
    System.out.println(arrlst.lastIndexOf(1));

Answer 11

在使用for循环的main方法中： - 我的例子中的第三个for循环就是这个问题的答案。 - 在我的例子中，我创建了一个由20个随机整数组成的数组，为变量分配了最小的数字，并在计算循环次数时，当数组的位置达到最小值时停止循环。

import java.util.Random;
public class scratch {
    public static void main(String[] args){
        Random rnd = new Random();
        int randomIntegers[] = new int[20];
        double smallest = randomIntegers[0];
        int location = 0;

        for(int i = 0; i < randomIntegers.length; i++){             // fills array with random integers
            randomIntegers[i] = rnd.nextInt(99) + 1;
            System.out.println(" --" + i + "-- " + randomIntegers[i]);
        }

        for (int i = 0; i < randomIntegers.length; i++){            // get the location of smallest number in the array 
            if(randomIntegers[i] < smallest){
                smallest = randomIntegers[i];                 
            }
        }

        for (int i = 0; i < randomIntegers.length; i++){                
            if(randomIntegers[i] == smallest){                      //break the loop when array location value == <smallest>
                break;
            }
            location ++;
        }
        System.out.println("location: " + location + "\nsmallest: " + smallest);
    }
}

代码输出所有数字及其位置，以及最小数字的位置，后跟最小数字。

Answer 12

如果有人还在寻找答案 -

您可以使用[Apache Commons Library] [1]中的ArrayUtils.indexOf（）。

如果您使用的是Java 8，还可以使用Strean API：

public static int indexOf(int[] array, int valueToFind) {
    if (array == null) {
        return -1;
    }
    return IntStream.range(0, array.length)
            .filter(i -> valueToFind == array[i])
            .findFirst()
            .orElse(-1);
}

[1]：https://commons.apache.org/proper/commons-lang/javadocs/api-3.1/org/apache/commons/lang3/ArrayUtils.html#indexOf(int[],%20int)

Answer 13

/**
     * Method to get the index of the given item from the list
     * @param stringArray
     * @param name
     * @return index of the item if item exists else return -1
     */
    public static int getIndexOfItemInArray(String[] stringArray, String name) {
        if (stringArray != null && stringArray.length > 0) {
            ArrayList<String> list = new ArrayList<String>(Arrays.asList(stringArray));
            int index = list.indexOf(name);
            list.clear();
            return index;
        }
        return -1;
    }

Answer 14

static int[] getIndex(int[] data, int number) {
    int[] positions = new int[data.length];
    if (data.length > 0) {
        int counter = 0;
        for(int i =0; i < data.length; i++) {
            if(data[i] == number){
                positions[counter] = i;
                counter++;
            }
        }
    }
    return positions;
}

Answer 15

你可以这样做：

 public class Test {

public static int Tab[]  = {33,44,55,66,7,88,44,11,23,45,32,12,95};
public static int search = 23;

public static void main(String[] args) {
    long stop = 0;
    long time = 0;
    long start = 0;
    start = System.nanoTime();
    int index = getIndexOf(search,Tab);
    stop = System.nanoTime();
    time = stop - start;
    System.out.println("equal to took in nano seconds ="+time);
    System.out.println("Index  of searched value is: "+index);
    System.out.println("De value of Tab with searched index is: "+Tab[index]);
    System.out.println("==========================================================");
    start = System.nanoTime();
    int Bindex = bitSearch(search,Tab);
    stop = System.nanoTime();
    time = stop - start;
    System.out.println("Binary search took nano seconds ="+time);
    System.out.println("Index  of searched value is: "+Bindex);
    System.out.println("De value of Tab with searched index is: "+Tab[Bindex]);
}



public static int getIndexOf( int toSearch, int[] tab ){
     int i = 0;
     while(!(tab[i] == toSearch) )
     {  i++; }
       return i; // or return tab[i];
   }
public static int bitSearch(int toSearch, int[] tab){
    int i = 0;
    for(;(toSearch^tab[i])!=0;i++){
    }
    return i;

}

}

添加了异或：）

Answer 16

二进制搜索：二进制搜索还可用于查找数组中数组元素的索引。但是只有在对数组排序后才能使用二进制搜索。 Java为我们提供了一个内置函数，可以在Java的Arrays库中找到该函数，如果存在元素，它将返回索引，否则返回-1。复杂度将为O（log n）。下面是二进制搜索的实现。

public static int findIndex(int arr[], int t) { 
   int index = Arrays.binarySearch(arr, t); 
   return (index < 0) ? -1 : index; 
}

Answer 17

ArrayUtils.indexOf(array, value);
Ints.indexOf(array, value);
Arrays.asList(array).indexOf(value);

Answer 18

您可以遍历数组，直到找到所需的索引，或使用List代替。请注意，您可以使用asList()将数组转换为列表。

Answer 19

Integer[] array = {1, 2, 3, 4, 5, 6};

for (int i = 0; i < array.length; i++) {
    if (array[i] == 4) {
        system.out.println(i);
        break;
    }
}

如何在int数组中找到元素的索引？

19 个答案: