J'ai utilisé Collections.sort(playersList);
pour trier un List
. Donc, je pense que playersList
est trié maintenant. Mais comment puis-je obtenir le premier élément de la liste? playersList[0]
ne fonctionne pas.
playersList.get(0)
Java a un polymorphisme d'opérateur limité. Vous utilisez donc la méthode get()
sur des objets List
et non l'opérateur d'opérateur de tableau ([]
).
Vous devez accéder aux listes un peu différemment des tableaux en Java. Voir le javadocs pour l'interface List
pour plus d'informations.
playersList.get(0)
Toutefois, si vous voulez trouver le plus petit élément dans playersList
, vous ne devez pas le trier et obtenir le premier élément. Cela se fait très lentement par rapport à une simple recherche dans la liste pour trouver le plus petit élément.
Par exemple:
int smallestIndex = 0;
for (int i = 1; i < playersList.size(); i++) {
if (playersList.get(i) < playersList.get(smallestIndex))
smallestIndex = i;
}
playersList.get(smallestIndex);
Le code ci-dessus trouvera le plus petit élément dans O(n)
au lieu de O(n log n)
time.
Cela dépend du type de votre liste. Pour ArrayList
, utilisez:
list.get(0);
pour LinkedList
utiliser:
list.getFirst();
si vous aimez l'approche array
:
list.toArray()[0];
En utilisant les flux Java 8, vous pouvez transformer votre liste en flux et obtenir le premier élément d'une liste à l'aide de la méthode .findFirst()
.
List<String> stringsList = Arrays.asList("zordon", "alpha", "tommy");
Optional<String> optional = stringsList.stream().findFirst();
optional.get(); // "zordon"
La méthode .findFirst()
renverra un Facultatif qui peut ou non contenir une valeur de chaîne (il peut ne pas contenir de valeur si la variable stringsList
est vide).
Ensuite, pour décompresser l'élément de la méthode Optional, utilisez la méthode .get()
.
La réponse de Matthew est correcte:
list.get(0);
Pour faire ce que tu as essayé:
list[0];
vous devrez attendre la sortie de Java 7:
devoxx conference http://img718.imageshack.us/img718/11/capturadepantalla201003cg.png
Voici une intéressante presentation de Mark Reinhold sur Java 7
Il semble que le site des discussions soit en panne, essayez plus tard :(
Si vous voulez juste obtenir le minimum d'une liste, au lieu de la trier puis d'obtenir le premier élément (O(N log N)
), vous pouvez utiliser le faire en temps linéaire en utilisant min
:
<T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll)
Cela semble étrange au début, mais si vous examinez vos questions précédentes, vous avez un List<String>
. En bref: min
fonctionne dessus.
Pour la réponse longue: tout ce que super
et extends
dans les contraintes de type génériques est ce que Josh Bloch appelle le principe PECS (généralement présenté à côté d'une image d'Arnold - je ne plaisante pas!)
Le producteur étend, Consumer Super
Cela rend essentiellement les génériques plus puissants, car les contraintes sont plus flexibles tout en préservant la sécurité des types (voir: quelle est la différence entre ‘super’ et ‘étend’ dans Java Generics )
Si votre collection n'est pas une List
(et que vous ne pouvez donc pas utiliser get(int index)
), vous pouvez utiliser l'itérateur:
Iterator iter = collection.iterator();
if (iter.hasNext()) {
Object first = iter.next();
}
public class Main {
public static List<String> list = new ArrayList();
public static void main(String[] args) {
List<Integer> l = new ArrayList<>();
l.add(222);
l.add(100);
l.add(45);
l.add(415);
l.add(311);
l.sort(null);
System.out.println(l.get(0));
}
}
sans l.sort (null) retourné 222
avec l.sort (null) renvoyé 45