Résumé de l'utilisation de base de la collection
1. Comment utiliser la collection ArrayList
Parlez du tri du tableau d'objets
Ici, je vais principalement utiliser le tri des enregistrements. Je recommande personnellement d'utiliser le comparateur de Comparetor pour faire le tri. L'exemple de code est le suivant:
import java.util.*;
/**
* @author jiangzl
*/
public class MyArrayList {
public static void main(String[] args){
ArrayList myListOfTask = new ArrayList<Arraytask>();
Scanner sc = new Scanner(System.in);
for(int i = 0;i < 5;++i){
String name = sc.next();
int prio = sc.nextInt();
myListOfTask.add(new Arraytask(name, prio));
}
sc.close();
System.out.println("---------排序前---------");
for(int i = 0;i < 5;++i){
System.out.println(myListOfTask.get(i));
}
System.out.println("---------排序后---------");
Collections.sort(myListOfTask, new Comparator<Arraytask>() {
@Override
public int compare(Arraytask tk1, Arraytask tk2) {
if(tk1.getTaskPriority() != tk2.getTaskPriority()){
return tk2.getTaskPriority() - tk1.getTaskPriority();
}
else{
return tk1.getTaskName().compareTo(tk2.getTaskName());
}
}
});
for(int i = 0;i < 5;++i){
System.out.println(myListOfTask.get(i));
}
}
}
/**
* @author jiangzl
*/
class Arraytask{
private String taskName;
private int taskPriority;
public Arraytask(String name, int prio){
this.taskName = name;
this.taskPriority = prio;
}
public String getTaskName(){
return taskName;
}
public int getTaskPriority(){
return taskPriority;
}
@Override
public String toString(){
return new String("任务名：" + taskName + " , 任务优先级：" + taskPriority);
}
}
Comment utiliser le comparateur Comparetor:
Après avoir écrit une classe, nous devons trier le tableau d'objets de cette classe. Nous pouvons utiliser la méthode de collecte:
Collection.sort(对象数组名（ArrayList 的对象名）, new Comparetor<类名（泛型）>(){
@Override
public int compare(类名 obj1, 类名 obj2) {
/……/
}
})
Points à noter:
① La valeur de retour de la fonction de comparaison ici est de type int. Si elle renvoie un nombre positif, cela signifie que l'objet précédent obj1 est supérieur à obj2 et qu'un nombre négatif est inférieur à. Bien sûr, 0 est égal.
② Si vous voulez afficher une certaine priorité, voici l'opposé complet de C ++, c'est que obj2 (le dernier) a une priorité plus élevée que obj1 (le premier) par défaut. Par exemple, dans mon exemple de code:
@Override
public int compare(Arraytask tk1, Arraytask tk2) {
if(tk1.getTaskPriority() != tk2.getTaskPriority()){
return tk2.getTaskPriority() - tk1.getTaskPriority();
}
else{
return tk1.getTaskName().compareTo(tk2.getTaskName());
}
}
La signification du représentant est:
(1) Si la priorité des deux tâches n'est pas la même, laissez celle avec la priorité la plus élevée se classer en premier. Parce que la valeur par défaut est que ce dernier est classé en premier, nous retournons donc: Lorsqu'il répond à la priorité de notre conception, renvoie un nombre supérieur à 0. Donc, s'il s'agit de la priorité la plus élevée à l'avant, le mécanisme de comparaison de Comparetor est ce dernier à l'avant, nous concevons donc cette dernière valeur pour être supérieure à l'avant, c'est-à-dire qu'elle est appelée lorsque la soustraction est supérieure à 1. ( Remarques : ce n'est peut-être pas facile à comprendre ici ... C'est parce que mon écriture n'est pas assez bonne pour écrire clairement)
(2) D'une manière générale, cela se résume à un point: si vous voulez trier par ordre croissant selon une certaine valeur de référence, rendez l'objet avant obj1 plus grand que ce dernier, c'est-à-dire obj1.val-obj2.val. Par exemple, lorsque nous voulons la même priorité, les noms sont triés par ordre lexicographique croissant, alors laissez le nom du premier objet moins le nom du deuxième objet, trier par plus de 0 (c'est-à-dire par ordre croissant)! Sinon, laissez le dos moins le devant.
Parlez brièvement de l'ajout, de la suppression et de la modification du tableau d'objets (ArrayList)
(1) Traverser et lire les éléments
C'est encore très simple. S'il ne s'agit que d'une opération de "lecture", la meilleure méthode (la plus efficace) est:
int len = (ArrayList对象) arrayObj.size();
for(int i = 0;i < len;++i){
/……/
类名 obj = arrayObj.get(i);
/……/
}
L'efficacité sous cette opération de "lecture" est la plus élevée, ce qui est supérieur à foreach (résultat de tests expérimentaux).
(2) Modifier les éléments
int len = (ArrayList对象) arrayObj.size();
for(int i = 0;i < len;++i){
/……/
类名 update = new 类名(……) // 你的新改的对象
类名 obj = arrayObj.set(i, update);
/……/
}
(3) Supprimer des éléments
int len = (ArrayList对象) arrayObj.size();
for(int i = 0;i < len;++i){
/……/
类名 remv = arrayObj.remove(i); // remv 就是你要删除的对象
/……/
}
Quelques explications et résumé des ajouts, suppressions et modifications:
Utilisez get (index) pour la lecture, set (index, newObj) pour la modification et remove (index) pour la suppression,
mais les valeurs de retour de tous les trois sont des objets! ! ! Cela nécessite une attention!
Et ArrayList est une structure de données vectorielle à laquelle on peut accéder de manière aléatoire! Donc, à partir de cette couche inférieure, il doit y avoir une efficacité de lecture et d'écriture élevée et une faible efficacité de suppression et d'ajout. Il y a donc la collection LinkedList suivante
2. Comment utiliser la collection LinkedList
Parlez de l'interface Iterator et du parcours LinkedList
Regardons d'abord un exemple de programme:
import java.util.*;
/**
* @author jiangzl
*/
public class MyLinkedList {
public static void main(String[] args){
LinkedList myList = new LinkedList<Student>();
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
for(int i = 0;i < n;++i){
String name = sc.next();
int age = sc.nextInt();
myList.add(new Student(name, age));
}
String delName = sc.next();
Iterator<Student> it = myList.iterator();
while(it.hasNext()){
if(it.next().getName().equals(delName)){
it.remove();
break;
}
}
while (it.hasNext()){
System.out.println(it.next());
}
}
}
/**
* @author jiangzl
*/
class Student{
private String name;
private int age;
public Student(String name, int age){
this.name = name;
this.age = age;
}
@Override
public String toString(){
return new String("姓名：" + name + " , 年龄：" + age);
}
public String getName(){
return name;
}
}
Parlez d'abord ici de la traversée de LinkedList
Nous utilisons la classe Iterator pour parcourir, utiliser la méthode hasNext () pour déterminer s'il existe une valeur suivante, puis utiliser next () pour obtenir l'objet actuellement parcouru! Alors faites ce que vous devez faire!
Iterator<类名> it = myList.iterator();
while(it.hasNext()){
类名 obj = it.next();
/……/
}
Laissez-moi dire les interfaces ListIterator, où la plus grande différence est, ListIterator prend en charge l'exécution simultanée, mais Iterator ne le prend pas en charge! Jetez un œil à un petit exemple:
import java.util.*;
import java.util.ListIterator;
public class MyListIterator {
public static void main(String[] args){
List myList = new ArrayList();
myList.add("stu1");
myList.add("stu2");
myList.add("stu3");
myList.add("stu4");
myList.add("stu5");
ListIterator it = myList.listIterator();
while(it.hasNext()){
if("stu2".equals(it.next())){
it.remove();
it.add("hello");
break;
}
}
it = myList.listIterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
Regardez la sortie de la console:
Évidemment, nous pouvons voir:
① L'interface ListIterator peut utiliser la méthode add () pour insérer des opérations à la position actuelle de l'itérateur.
② L'interface ListIterator, par exemple, après qu'un certain parcours est terminé, si vous devez parcourir à nouveau le tableau d'objets, vous devez re:
it = myList.listIterator();
③ L'interface Iterator est en lecture seule et est un attribut. Si vous souhaitez la modifier, vous devez toujours utiliser ListIterator pour modifier "stu2" pour devenir "hello".
Parlez ensuite d'ajout, de suppression, de modification et de vérification
C'est en fait très simple: si vous utilisez ListIterator, vous pouvez non seulement implémenter l'it.remove () d'Iterator; pour supprimer l'objet pointé par l'itérateur actuel. Vous pouvez également utiliser la méthode add (obj); pour insérer l'objet obj après la position pointée par l'itérateur actuel.
Tout comme ce code dans l'exemple:
while(it.hasNext()){
if(it.next().getName().equals(delName)){
it.remove();
break;
}
}
while (it.hasNext()){
System.out.println(it.next());
}
Toutes les opérations reposent sur: it.next (); pour récupérer l'objet actuellement parcouru, puis l'exploiter!
Enfin, résumez les méthodes étendues après que l'interface List hérite de Collection:
Je ne parlerai pas d’autres méthodes, la plupart d’entre elles sont très simples.