如何在 int 数组中查找元素的索引？答案

【问题标题】：How to find the index of an element in an int array?如何在 int 数组中查找元素的索引？
【发布时间】：2011-09-04 12:38:09
【问题描述】：

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

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

【问题讨论】：

二进制搜索永远不会对未排序的数组起作用。
那你能给我一些建议吗，我该怎么做。因为如果我对数组进行排序，我会丢失索引，我需要知道值来自哪个索引？？
编辑：我忘了添加，我还需要找到双值的数组索引。
如果您不想对数组进行排序，只需使用简单的 for 循环查找值即可。
阅读函数文档通常很好:) 来自binarySearch: "使用二进制搜索算法在...的指定数组中搜索指定值。数组必须是在进行此调用之前已排序（如通过 sort(long[]) 方法）。如果未排序，则结果未定义。 ..."

标签： java arrays search indexing

【解决方案1】：

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

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

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

您也不想在循环或类似的情况下调用它，因为您每次都会创建一个新对象

【讨论】：

谢谢，但它适用于 double 类型吗？抱歉，我忘了在问题中提及，但我也需要为 double 值工作。不过它适用于整数。
是的，你不需要改变任何东西（但显然是数组类型）
实际上代码不起作用。检查Why is indexOf failing to find the object?
您需要将数组转换为 Integer[] 而不是 int[]。原始数组未自动装箱。
这真的是线程安全的吗？当我单击源时，List.asList() 创建一个 ArrayList，它将 int 数组直接作为数据容器（不复制）

【解决方案2】：

如果您使用 Guava Collections，另一个选项是 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);

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

【讨论】：

【解决方案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;
}

【讨论】：

+1 不过需要注意的是Arrays.sortmutates输入和原始数组都会被修改。
谢谢，在为具有不同索引的重复值添加了一些逻辑之后，第二种方法对我有用。

【解决方案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;
}

通过传入两个参数数组和值调用该方法，并将其返回值存储在一个整数变量中。

int indexNum = getArrayIndex(array,value);

谢谢

【讨论】：

【解决方案5】：

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

【讨论】：

虽然此代码可以解决问题，including an explanation 说明如何以及为什么解决问题将真正有助于提高您的帖子质量，并可能导致更多的赞成票。请记住，您正在为将来的读者回答问题，而不仅仅是现在提问的人。请edit您的回答添加解释并说明适用的限制和假设。

【解决方案6】：

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

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

【讨论】：

太棒了！感谢分享。它有助于了解语言功能上下文中新的（优化的）内置解决方案。
@Simplicity's_Strength 您的编辑一半正确，一半错误。数组确实从 0 开始，但 second parameter to range is exclusive.不过，很好地抓住了第一个错误。
@RyanM 这解释了我使用此代码的java.util.NoSuchElementException。打得好先生

【解决方案7】：

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

Arrays.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)

【讨论】：

它是数组。即Arrays.asList(array).indexOf(1);

【解决方案8】：

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

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，感谢您的 cmets。你能发布其他替代方法吗？

【讨论】：

这是一种方式，是的。然而，它不是唯一的方法。此处使用布尔变量found 是无用的（并且未使用），应该删除。一个 +1 用于显示“手动循环方法”（除了风格和格式问题）。

【解决方案9】：

简单：

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

【讨论】：

【解决方案10】：

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

【讨论】：

注意，数组必须是 Integer[]，而不是 int[]。至少， indexOf() 仅适用于 Integer

【解决方案11】：

如果有人还在寻找答案-

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

如果您使用的是 Java 8，您还可以使用 Stean 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)

【讨论】：

【解决方案12】：

最简单的方法是迭代。例如我们想找到数组的最小值和它的索引：

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;
    }

【讨论】：

【解决方案13】：

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

【讨论】：

【解决方案14】：

/**
     * 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;
    }

【讨论】：

clear 和new ArrayList 是不必要的操作。分配一个新的ArrayList 会复制整个数组，这是没有意义的，因为Arrays.asList 已经返回了一个List，它有一个indexOf 方法。清空列表的副本是不必要的，反正GC会把它拿走。

【解决方案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;

}

}

添加了 XOR :)

【讨论】：

tab.equals(toSearch) 将数组与 int 进行比较。也许tab[i] == toSearch 代替。
感谢 Mike...Google 的二进制搜索，一些不错的文章和它的一个有趣的方法
@Andre 如果你想证明一个观点，给他们一个公平的竞争环境（相同的顺序，相同的控制流程）：while (tab[i] != toSearch) i++; VS while ((tab[i] ^ toSearch) != 0) i++;。
无论如何这种计时方式是行不通的，对我来说bitSearch总是比getIndexOf快；而如果我只是简单地将调用交换为getIndexOf 这两种方法会比bitSearch 更快。这清楚地表明，由于 JVM 内部的某些原因，第二个总是更快。您应该多次重复实验（可能是数百万次），取平均值，丢弃极值并进行与测试非常相似的预热。

【解决方案16】：

在使用 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);
    }
}

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

【讨论】：

【解决方案17】：

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;
}

【讨论】：

【解决方案18】：

二分查找：二分查找也可用于查找数组元素在数组中的索引。但是二分查找只有在数组排序后才能使用。 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; 
}

【讨论】：

【解决方案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;
    }
}

【讨论】：

重复的答案。