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

Question

我希望在Java中找到给定元素的索引，知道它的内容。

我尝试了以下示例，但不起作用：

class masi { 
    public static void main( String[] args ) { 
        char[] list = {'m', 'e', 'y'};

        // should print 1
        System.out.println(list[] == "e");                    
    } 
}

任何人都可以解释这有什么问题以及我需要做些什么来解决它？

Answer 1

在这种情况下，你可以从你的字符数组中创建一个新的字符串，然后在该字符串上做一个indeoxOf（“e”）：

System.out.println(new String(list).indexOf("e")); 

但在原始数据类型的其他情况下，您将不得不迭代它。

Answer 2

这甚至不是有效的语法。 和你正在尝试与字符串进行比较。对于数组，您必须自己走数组：

public class T {
  public static void main( String args[] ) {
    char[] list = {'m', 'e', 'y'};

    int index = -1;

    for (int i = 0; (i < list.length) && (index == -1); i++) {
        if (list[i] == 'e') {
            index = i;
        }
    }

    System.out.println(index);
  }
}

如果您使用的是集合，例如ArrayList<Character>，您还可以使用indexOf()方法：

ArrayList<Character> list = new ArrayList<Character>();
list.add('m');
list.add('e');
list.add('y');

System.out.println(list.indexOf('e'));

还有Arrays类缩短了上面的代码：

List list = Arrays.asList(new Character[] { 'm', 'e', 'y' });
System.out.println(list.indexOf('e'));

Answer 3

或者，您可以使用Commons Lang ArrayUtils类：

int[] arr = new int{3, 5, 1, 4, 2};
int indexOfTwo = ArrayUtils.indexOf(arr, 2);

对于不同的数组类型，存在indexOf()方法的重载变体。

Answer 4

对于原始数组

从Java 8开始，基本数组arr的通用解决方案和搜索val的值是：

public static int indexOf(char[] arr, char val) {
    return IntStream.range(0, arr.length).filter(i -> arr[i] == val).findFirst().orElse(-1);
}

此代码使用IntStream.range，filters the indexes在数组的索引上创建一个流，以仅保留该索引处的数组元素等于搜索值的那些，并最终保持第一个匹配与findFirst。 findFirst返回OptionalInt，因为可能找不到匹配的索引。因此，我们调用orElse(-1)来返回找到的值，如果没有找到，则调用-1。

可以为int[]，long[]等添加重载。方法的主体将保持不变。

对于对象数组

对于像String[]这样的对象数组，我们可以使用相同的想法并使用equals方法进行过滤步骤，或Objects.equals考虑​​两个null元素相等，instead of ==。

但我们可以通过以下方式更简单地完成：

public static <T> int indexOf(T[] arr, T val) {
    return Arrays.asList(arr).indexOf(val);
}

这将使用Arrays.asList为输入数组创建一个列表包装器，并使用indexOf搜索元素的索引。

此解决方案不适用于原始数组as shown here：int[]之类的原始数组不是Object[]而是Object;因此，在其上调用asList会创建一个单个元素的列表，它是给定的数组，而不是数组元素的列表。

Answer 5

我相信 only 这样做的方法是手动迭代数组。

for (int i = 0; i < list.length; i++) {
  if (list[i] == 'e') {
    System.out.println(i);
    break;
  }
}

Answer 6

您的代码存在的问题是，当您执行

时

 list[] == "e"

你问的是数组对象（不是内容）是否等于字符串“e”，显然不是这样。

您需要迭代内容以进行所需的检查：

 for(String element : list) {
      if (element.equals("e")) {
           // do something here
      }
 }

Answer 7

最简单的解决方案：

  

将数组转换为列表，您可以获取元素的位置。

List<String> abcd  = Arrays.asList(yourArray);
int i = abcd.indexOf("abcd");

其他解决方案，您可以使用迭代器数组：

int position = 0;
for (String obj : yourArray) {
    if (obj.equals("abcd") {
    return position;
    }
    position += 1;
} 

//OR
for (int i = 0; i < yourArray.length; i++) {
    if (obj.equals("abcd") {
       return i;
    }
}

Answer 8

现在打印1

class Masi {
    public static void main( String [] args ) {
         char [] list = { 'm', 'e', 'y' };

         // Prints 1
         System.out.println( indexOf( 'e', list ) );
    }

    private static int indexOf( char c , char [] arr ) {
        for( int i = 0 ; i < arr.length ; i++ ) {
            if( arr[i] == c ) { 
                return i;
            }
         }
         return -1;
     }
 }

请记住

"e"

是一个字符串对象文字（表示一个字符串对象）

虽然

'e' 的

是字符文字（表示字符原始数据类型）

即使

list[]

有效的Java（不是）将字符元素与字符串元素进行比较，无论如何都会返回false。

只需使用indexOf字符串函数，您就可以在任何字母表（或字符数组）中找到任何字符

Answer 9

非常沉重的编辑。我想要么你想要这个：

class CharStorage {
    /** set offset to 1 if you want b=1, o=2, y=3 instead of b=0... */
    private final int offset=0;
    private int array[]=new int[26];

    /** Call this with up to 26 characters to initialize the array.  For 
      * instance, if you pass "boy" it will init to b=0,o=1,y=2.
      */
    void init(String s) {
        for(int i=0;i<s.length;i++)
            store(s.charAt(i)-'a' + offset,i); 
    }

    void store(char ch, int value) {
        if(ch < 'a' || ch > 'z') throw new IllegalArgumentException();
        array[ch-'a']=value;
    }

    int get(char ch) {
        if(ch < 'a' || ch > 'z') throw new IllegalArgumentException();
        return array[ch-'a'];
    }
}

（请注意，如果要使用1-26而不是0-25，则可能需要调整init方法）

或者你想要这个：

int getLetterPossitionInAlphabet(char c) {
    return c - 'a' + 1
}

第二个是你总是想要a = 1，z = 26。第一个会让你输入一个像“qwerty”这样的字符串并指定q = 0，w = 1，e = 2，r = 3 ...

Answer 10

这种方式应该有效，改变＆＃34; char＆＃34;到＆＃34;字符＆＃34;：

public static void main(String[] args){
  Character[] list = {'m', 'e', 'y'};
  System.out.println(Arrays.asList(list).indexOf('e')); // print "1"
}

Answer 11

这是另一个示例以及sudo apt-get install gcc-aarch64-linux-gnu export CROSS_COMPILE aarch64-linux-gnu- 的工作原理。

indexOf

Answer 12

如果元素的初始顺序不是很重要，你可以只对数组进行排序，然后二元搜索它：

import java.util.Arrays;

class masi { 
    public static void main( String[] args ) { 
        char[] list = {'m', 'e', 'y'};
        Arrays.sort(list);

        // should print 0, as e is now sorted to the beginning
        // returns negative number if the result isn't found
        System.out.println( Arrays.binarySearch(list, 'e') );
    } 
}

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

这样你就可以使用N＆＃39; N＆＃39;字母。

char[] a={ 'a', 'b', 'c', 'd', 'e' };
int indexOf=0;
for(int i=0;i<a.length;i++){
  if(a[i] != 'b'){
    indexOf++;
    }else{
    System.out.println("index of given: "+indexOf);
 }}

Answer 15

int i = 0;
int count = 1;
        while ('e'!= list[i] ) {
            i++;
            count++;
        }

        System.out.println(count);