Interface de collection Java Foundation-Collection (liste et ensemble)

1. Méthodes courantes de l'interface de collecte

1. Quels éléments
  peuvent être stockés dans la collection Avant que les génériques ne soient utilisés, tous les sous-types d'objets qui peuvent être stockés
  dans la collection Une fois que les génériques sont utilisés, la collection ne peut stocker qu'un type spécifique. La
  collection ne peut pas stocker de types de données de base, ni ne peut L'objet java ne peut stocker que l'adresse mémoire de l'objet java.

2. Méthodes couramment utilisées dans
Collection : Remarque: Les méthodes incluses dans la collection sont également incluses dans sa classe d'implémentation, peuvent également être utilisées et sont publiques.
boolean add (objet e)

// Collection c = new Collection (); // L'interface est abstraite et ne peut pas être instanciée
boolean add (Object e) Ajouter des éléments à la collection
int size (); Obtenir le nombre d'éléments dans la collection
void clear (); Clear la collection Tous les éléments en
booléen contiennent (Object o): Détermine si la collection courante contient l'élément o, y compris return true, non compris return false
boolean remove (Object o) supprime un élément de
la collection boolean isEmpty () Détermine si la collection est in
Indique si le nombre d'éléments est égal à 0 Obect [] toArray () Convertit la collection en tableau

public static void main(String[] args) {
    
    
    //Collection c=new Collection();      //接口是抽象的，无法实例化
    Collection c=new ArrayList();
    //测试collection接口中的常用方法
    c.add(1200);      //自动装箱，实际上是放进去了一个对象的内存地址。Integer i=new Integer(1200)
    c.add(3.14);      //自动装箱
    c.add(new Object());
    c.add(true);
    //获取集合中元素的个数
    System.out.println("集合中元素的个数"+c.size());
    //清空集合
    c.clear();
    System.out.println("集合中元素的个数"+c.size());
    //再向集合中添加元素
    c.add("hello");
    c.add("world");
    c.add("好客");
    c.add("绿巨人");
    //判断集合中是否包含绿巨人
    boolean flag=c.contains("绿巨人");
    System.out.println(flag);     //true
    boolean flag2=c.contains("绿巨人2");
    System.out.println(flag2);    //false

    System.out.println("集合中元素的个数"+c.size());

    //删除集合中某个元素
    c.remove("绿巨人");
    System.out.println("集合中元素的个数"+c.size());

    //判断集合是否为空
    System.out.println(c.isEmpty());      //false
    c.clear();
    System.out.println(c.isEmpty());      //true
}

Sortie
Le nombre d'éléments de l'
ensemble 4 Le nombre d'éléments de l' ensemble 0
vrai
faux
Le nombre
d'éléments de l'ensemble 4 Le nombre d'éléments de l'ensemble 3
faux
vrai

2. itération de collection de collection

public static void main(String[] args) {
    
    
          //注意：以下的遍历方式/迭代方式，是所有collection通用的一种方式
          //在Map集合中不能用，在所有的collection以及子类中使用
          //创建集合对象
          Collection c=new ArrayList();//后面的集合无所谓，主要是看前面的collection接口，怎么遍历/迭代
          //添加元素
          c.add("abc");
          c.add("def");
          c.add(100);
          c.add(new Object());
          //对集合Collection进行遍历/迭代
          //第一步:获取集合对象的迭代器对象Iterator
          //collection为什么能调用这个方法，因为继承了Iterable接口，可使用其父类的方法
          Iterator it=c.iterator();
          //第二步：通过以上获取的迭代器对象，开始迭代遍历集合
/*
 以下两个方法是迭代器Iterator中的方法
 boolean hasNext()如果仍有元素可以迭代，则返回true
 Object next() 返回迭代的下一个元素
 
 void remove() 从迭代器指向的collection中移除迭代器返回的最后一个元素（可选操作）
 * */
          while(it.hasNext()){
    
    
              //不管你当初存进去的是什么，取出来统一都是object
              Object obj=it.next();
              System.out.println(obj);
          }
  }

Sortie
abc
def
100
java.lang.Object@15db9742

Un itérateur est un objet avec deux méthodes hasnext () et next ().
Les itérateurs sont universels.

public static void main(String[] args) {
    
    
    //HashSet集合。无序不可重复
    //无序：存进去和取出的顺序不一定相同
    //不可重复:存进去100，不能再存100
    Collection c=new HashSet();
    c.add(100);
    c.add(200);
    c.add(90);
    c.add(300);
    c.add(600);
    c.add(30);
    c.add(100);
    Iterator it=c.iterator();
    while(it.hasNext()){
    
    
        System.out.println(it.next());
    }
}

Sortie
100
200
600
90
300
30

3. contient une analyse de méthode

La collection approfondie contient la méthode
boolean contains (Object o) pour
déterminer si la collection contient un objet o, si elle contient, renvoie true, si elle ne contient pas false
contient, la couche inférieure appelle la méthode equals.

Collection c=new ArrayList();
String s1=new String("abc");      //内存地址假设s1=0x1111
c.add(s1);
String s2=new String("def");      //内存地址假设s2=0x2222
c.add(s2);

String x=new String("abc");          //内存地址假设s3=0x3333
//c集合中是否包含x
//contains里面调用了equals方法
System.out.println(c.contains(x));

Sortie: La
méthode true contient est utilisée pour juger si un certain élément est contenu dans la collection.
C'est donc au niveau du bas de la couche comment juge-t-elle si un certain élément est contenu dans la collection?
La méthode equals est appelée pour comparer et la
méthode equals renvoie true, ce qui signifie que cet élément est inclus.
Pour certains types d'objets, vous devez réécrire sa méthode equals.

4. Suppression d'éléments de la collection

public static void main(String[] args) {
    
    
    //创建集合
    Collection c=new ArrayList();
    //注意：此时获取的迭代器，指向的是那是集合中没有元素状态下的迭代器 
    //一定要注意：集合结构只要发生改变，迭代器必须重新获取
    Iterator it=c.iterator();
    //添加元素
    c.add(1);
    c.add(2);
    c.add(3);
    while(it.hasNext()){
    
    
        Object obj=it.next();
        System.out.println(obj);
    }
}

Lorsque la structure de la collection a changé, l'itérateur ne réacquiert pas, l'appel de la méthode next (), une exception se produit

Clé:
Lorsqu'un ensemble de changements structurels, l'itérateur doit réacquérir, si vous utilisez toujours l'itérateur précédent, il y aura une
suppression anormale Une fois l'élément, la structure de la collection change, l'itérateur doit être réacquis, mais la prochaine fois que la boucle, l'itérateur n'est pas réacquis, donc une exception se produira

public static void main(String[] args) {
    
    
    //创建集合
    Collection c=new ArrayList();

    //添加元素
    c.add("abc");
    c.add("def");
    c.add("ghi");
    Iterator it=c.iterator();
    while(it.hasNext()){
    
    
        Object obj=it.next();
        //删除元素之后，集合的结构发生变化，应该重新获取迭代器，但是循环下一次的时候，并没有重新获取迭代器，所以会出现异常
        c.remove(obj);
        System.out.println(obj);
    }
}

Dans le processus d'itération des éléments de collection, vous ne pouvez pas appeler la méthode remove de l'objet de collection, sinon une exception se produira.
Vous pouvez utiliser la méthode remove de l'itérateur

//创建集合
Collection c=new ArrayList();

//添加元素
c.add("abc");
c.add("def");
c.add("ghi");
Iterator it=c.iterator();
while(it.hasNext()){
    
    
    Object obj=it.next();
    it.remove();
    //c.remove(obj);
    System.out.println(obj);
}
System.out.println(c.size());

Sortie 0;

5. Méthodes uniques de l'interface de liste

Méthodes courantes de test de l'interface de liste 1.
Caractéristiques des éléments de stockage de la collection de listes : ordonnés et répétés
Ordre: les éléments de la collection de listes ont des indices, commençant à 0 et augmentant de 1.
Répétable: stockez un 1, et vous pouvez continuer à stocker 1.
2. La liste étant une sous-interface de l'interface de collecte, elle doit avoir ses propres méthodes "en vedette"
dans l'interface de la liste. Voici uniquement les méthodes courantes spécifiques à list interface
void add (int index, E element);
E get (int index);
E remove (int index);
E set (int index, E element);
void add (int index, E element); Insère l'élément spécifié à la position spécifiée de la liste (les premiers paramètres sont des indices)

public static void main(String[] args) {
    
    
    //创建list类型的集合
    List myList=new ArrayList();
    //添加元素
    myList.add("A");      //默认是向集合末尾添加元素
    myList.add("B");
    myList.add("C");
    myList.add("D");
    //在列表的指定位置插入指定元素(第一个参数是下标)
    //效率有点低。
    myList.add(1,"king");
    //迭代
    Iterator it=myList.iterator();
    while(it.hasNext()){
    
    
        Object et1=it.next();
        System.out.println(et1);
    }
}

E get (index int); Récupère les éléments selon l'indice

//根据下标获取元素
Object firstObj = myList.get(0);
System.out.println(firstObj);
//因为有下标，所以List集合有自己比较特殊的遍历方式
//通过下标遍历,list集合特有的方式，set没有
for(int i=0;i<myList.size();i++){
    
    
    Object obj = myList.get(i);
    System.out.println(obj);
}

E remove (int index);
supprime l'élément à la position d'index spécifiée

//删除指定下标位置的元素
//删除下标为0的元素
System.out.println(myList.size());
myList.remove(0);
System.out.println(myList.size());

//修改指定位置的元素
myList.set(2, "soft");

Les méthodes ci-dessus n'ont pas besoin d'être mémorisées, de comprendre et de trouver des fichiers d'aide.

6.Set interface

Les caractéristiques de HashSet: désordre et non répétable

//演示HashSset的特点
Set<String> strs=new HashSet<>();
//添加元素
strs.add("hello3");
strs.add("hello4");
strs.add("hello1");
strs.add("hello2");
strs.add("hello3");
strs.add("hello3");
//遍历
for(String s:strs){
    
    
    System.out.println(s);
}

Sortie
hello1
hello4
hello2
hello3
1. L'ordre de stockage est différent de l'ordre de sortie
2. Non répétable
3. Les éléments placés dans la collection hashSet sont en fait placés dans la partie clé de la collection HashMap.
Les caractéristiques des éléments de stockage de la collection TreeSet ne sont pas
ordonnées et non répétables, mais les éléments stockés peuvent être automatiquement triés par ordre de taille, ce que l'on appelle une collection triable

//创建集合对象
Set<String> strs=new TreeSet<>();
//添加元素
strs.add("A");
strs.add("B");
strs.add("Z");
strs.add("Y");
strs.add("Z");
strs.add("K");
strs.add("M");
//遍历set集合
//从小到大自动排序
for(String s:strs){
    
    
    System.out.println(s);
}

Sortie
A
B
K
M
Y
Z

Le désordre fait référence à la différence entre l'ordre dans lequel ils sont stockés et l'ordre dans lequel ils sont sortis. Les éléments n'ont pas d'indice. Le
tri est trié par ordre croissant