如何在
int我尝试在未排序的数组上使用
Arrays.binarySearchInteger[] array = {1,2,3,4,5,6};
Arrays.asList(array).indexOf(4);
请注意，此解决方案是线程安全的，因为它创建了一个 List 类型的新对象。
你也不想在循环或类似的东西中调用它，因为你每次都会创建一个新对象
如果您使用 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);
当空间、时间和代码重用都非常宝贵时，这是一个不错的选择。它也非常简洁。
看看 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;
}
将此方法复制到您的类中
public int getArrayIndex(int[] arr,int value) {
int k = -1;
for(int i = 0;i < arr.length; i++){
if(arr[i] == value){
k = i;
break;
}
}
return k;
}
通过传递两个参数数组和值来调用此方法，并将其返回值存储在整数变量中。
int indexNum = getArrayIndex(array,value);
谢谢你
ArrayUtils.indexOf(array, value);
Ints.indexOf(array, value);
Arrays.asList(array).indexOf(value);
你可以使用现代Java来解决这个问题。请使用以下代码：
static int findIndexOf(int V, int[] arr) {
return IntStream.range(0, arr.length)
.filter(i->arr[i]==V)
.findFirst()
.getAsInt();
}
使用二分查找之前需要对值进行排序。否则，手动方法是尝试选项卡中的所有整数。
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，感谢您的评论。您可以发布其他替代方法吗？
您可以将其转换为列表，然后使用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)
简单：
public int getArrayIndex(int[] arr,int value) {
for(int i=0;i<arr.length;i++)
if(arr[i]==value) return i;
return -1;
}
如果有人仍在寻找答案-
您可以使用 [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);
}
Integer[] arr = { 0, 1, 1, 2, 3, 5, 8, 13, 21 };
List<Integer> arrlst = Arrays.asList(arr);
System.out.println(arrlst.lastIndexOf(1));
最简单的方法是迭代。例如我们想要找到数组的最小值及其索引：
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;
}
我在这里看到很多解决方案都不起作用。获得最多支持的解决方案使用了 Integer 数组，而不是提供 int 数组的解决方案。就这么简单：
Arrays.stream(yourArray).boxed().toList().indexOf(number)
/**
* 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;
}
你可以这样做：
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;
}
}
添加了异或:)
在使用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);
}
}
代码输出所有数字及其位置，以及最小数字的位置紧随最小数字。
二分查找：二分查找还可以用于查找数组中数组元素的索引。但二分查找只有在数组已排序的情况下才能使用。 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;
}
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;
}
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;
}
}