Comment trouver l'index d'un élément dans un tableau en Java?
Je cherche à trouver l'index d'un élément donné, connaissant son contenu, en Java.
J'ai essayé l'exemple suivant, qui ne fonctionne pas:
class masi {
public static void main( String[] args ) {
char[] list = {'m', 'e', 'y'};
// should print 1
System.out.println(list[] == "e");
}
}
Quelqu'un peut-il s'il vous plaît expliquer ce qui ne va pas avec cela et ce que je dois faire pour y remédier?
Dans ce cas, vous pouvez créer une nouvelle chaîne à partir de votre tableau de caractères, puis faire un indeoxOf ("e") sur cette chaîne:
System.out.println(new String(list).indexOf("e"));
Mais dans les autres cas de types de données primitifs, vous devrez itérer dessus.
Alternativement, vous pouvez utiliser Commons Lang ArrayUtils class:
int[] arr = new int{3, 5, 1, 4, 2};
int indexOfTwo = ArrayUtils.indexOf(arr, 2);
Il existe des variantes surchargées de la méthode indexOf() pour différents types de tableaux.
Ce n'est même pas une syntaxe valide. Et vous essayez de comparer à une chaîne. Pour les tableaux, vous devez parcourir le tableau vous-même:
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);
}
}
Si vous utilisez une collection, telle que ArrayList<Character>, Vous pouvez également utiliser la méthode indexOf():
ArrayList<Character> list = new ArrayList<Character>();
list.add('m');
list.add('e');
list.add('y');
System.out.println(list.indexOf('e'));
Il y a aussi la classe Arrays qui raccourcit le code ci-dessus:
List list = Arrays.asList(new Character[] { 'm', 'e', 'y' });
System.out.println(list.indexOf('e'));
Pour les tableaux primitifs
À partir de Java 8, solution polyvalente pour un tableau primitif arr et une valeur pour la recherche val:
public static int indexOf(char[] arr, char val) {
return IntStream.range(0, arr.length).filter(i -> arr[i] == val).findFirst().orElse(-1);
}
Ce code crée un flux sur les index du tableau avec IntStream.range , filtre les index pour ne conserver que ceux où l'élément du tableau à cet index est égal à la valeur recherchée et conserve finalement le premier correspondant à findFirst . findFirst renvoie un OptionalInt , car il est possible qu'aucun index ne soit trouvé. Nous invoquons donc orElse(-1) pour renvoyer la valeur trouvée ou -1 Si aucune n'a été trouvée.
Des surcharges peuvent être ajoutées pour int[], long[], Etc. Le corps de la méthode restera le même.
Pour les tableaux d'objets
Pour les tableaux d'objets, comme String[], Nous pourrions utiliser la même idée et passer l'étape de filtrage à l'aide de la méthode equals , ou Objects.equals à considérer deux null éléments égaux, au lieu de == .
Mais nous pouvons le faire de manière plus simple avec:
public static <T> int indexOf(T[] arr, T val) {
return Arrays.asList(arr).indexOf(val);
}
Cela crée un wrapper de liste pour le tableau d'entrée en utilisant Arrays.asList et recherche l'index de l'élément avec indexOf .
Cette solution ne fonctionne pas pour les tableaux primitifs, comme indiqué ici : un tableau primitif tel que int[] N'est pas un Object[] Mais un Object; en tant que tel, l'invocation de asList crée une liste d'un seul élément, qui est le tableau donné, et non une liste des éléments du tableau.
Je crois le seulement La meilleure façon de le faire est de parcourir manuellement le tableau.
for (int i = 0; i < list.length; i++) {
if (list[i] == 'e') {
System.out.println(i);
break;
}
}
Le problème avec votre code est que quand vous le faites
list[] == "e"
vous demandez si l'objet de tableau (pas le contenu) est égal à la chaîne "e", ce qui n'est clairement pas le cas.
Vous aurez envie de parcourir le contenu afin de faire la vérification que vous voulez:
for(String element : list) {
if (element.equals("e")) {
// do something here
}
}
Solution la plus simple:
Convertissez un tableau en liste et vous pouvez obtenir la position d'un élément.
List<String> abcd = Arrays.asList(yourArray);
int i = abcd.indexOf("abcd");
Autre solution, vous pouvez itérer un tableau:
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;
}
}
Maintenant, il imprime 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;
}
}
Gardez à l'esprit que
"e"
est un littéral d'objet de chaîne (qui représente un objet de chaîne qui est)
Tandis que
'e'
Est un littéral de caractère (qui représente un type de données primitif de caractère)
Même quand
list[]
Serait valide Java (ce qui n'est pas le cas)). Comparer l'élément caractère avec un élément chaîne renverrait de toute façon faux.
Utilisez simplement cette fonction de chaîne indexOf et vous pourrez trouver n'importe quel caractère dans n'importe quel alphabet (ou tableau de caractères)
Très lourdement édité. Je pense que non plus tu veux ça:
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'];
}
}
(Notez que vous devrez peut-être ajuster la méthode init si vous souhaitez utiliser 1-26 au lieu de 0-25)
ou tu veux ceci:
int getLetterPossitionInAlphabet(char c) {
return c - 'a' + 1
}
La seconde est si vous voulez toujours a = 1, z = 26. Le premier vous laissera mettre une chaîne comme "qwerty" et assigner q = 0, w = 1, e = 2, r = 3 ...
voici un autre exemple et comment fonctionne indexOf.
public int indexOf(Object target) {
for (int i = 0; i < array.length; i++) {
if (equals(target, array[i])) {
return i;
}
}
return -1;
}
Pour que cela fonctionne, remplacez "char" par "Character":
public static void main(String[] args){
Character[] list = {'m', 'e', 'y'};
System.out.println(Arrays.asList(list).indexOf('e')); // print "1"
}
Si l'ordre initial des éléments n'est pas vraiment important, vous pouvez simplement trier le tableau, puis binarySearch le:
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') );
}
}
Je fournis la méthode appropriée pour faire celui-ci
/**
* 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;
}