如何在 int 数组中查找元素的索引？
Posted
技术标签:
【中文标题】如何在 int 数组中查找元素的索引？【英文标题】：How to find the index of an element in an int array? 【发布时间】：2011-09-04 12:38:09 【问题描述】：如何在 int 类型的 Java 数组中找到某个值的索引？
我尝试在未排序的数组上使用Arrays.binarySearch，但它有时会给出正确的答案。
【问题讨论】：
二进制搜索永远不会对未排序的数组起作用。 那你能给我一些建议吗，我该怎么做。因为如果我对数组进行排序，我会丢失索引，我需要知道值来自哪个索引？？ 编辑：我忘了添加，我还需要找到双值的数组索引。 如果您不想对数组进行排序，只需使用简单的 for 循环查找值即可。 阅读函数文档通常很好:) 来自binarySearch: "使用二进制搜索算法在...的指定数组中搜索指定值。数组必须是在进行此调用之前已排序（如通过 sort(long[]) 方法）。如果未排序，则结果未定义。 ..."
【参考方案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 torange 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;
【讨论】：
重复的答案。以上是关于如何在 int 数组中查找元素的索引？的主要内容，如果未能解决你的问题，请参考以下文章