ensemble détaillé de Java-List

Liste présentation de la collection

Liste des collections Vue d'ensemble

  Liste ordonnée ensemble est un élément (index de chaque élément a une séquence correspondant au premier index de l'élément est égal à 0) et des données reproductibles.

Liste l'ensemble des méthodes communes

  Liste est une collection Interface Collection sous-interface a toutes les méthodes, il existe des méthodes d'exploitation de l'indice.

• void add(int index, E element);: L'élément de l'élément inséré dans l'indice de Liste d'Ensemble;
• boolean addAll(int index, Collection<? extends E> c);: L'ensemble de tous les éléments c sont insérés dans le début de l'indice de Liste d'Ensemble;
• E remove(int index);: Retire et renvoie l'élément à l'index;
• int indexOf(Object o);: Renvoie la position d'index dans l'objet de la liste o la première occurrence de la collection;
• int lastIndexOf(Object o);: Retourne l'index de la dernière position de l'objet o dans la collection de la liste se produire;
• E set(int index, E element);: L'élément à l' index de l' index et remplacé par un nouvel élément de l'objet, et 返回被替换的旧元素;
• E get(int index);: Retourne l'index de l'ensemble d'indices;
• List<E> subList(int fromIndex, int toIndex);: Retourne le sous-ensemble d'index de fromIndex (inclus) à l'index toIndex (exclusive contiennent) constitué de tous les éléments;
• void sort(Comparator<? super E> c) : Liste des éléments de collecte de tri selon paramètre Comparator;
• void replaceAll(UnaryOperator<E> operator) : pour réinitialiser tous les éléments de l'ensemble selon les règles de calcul opérateur spécifié.
• ListIterator<E> listIterator();: Renvoie un objet ListIterator qui hérite l'interface de l' interface itérateur, un procédé d'augmentation de l'interface itérateur basé sur les fonctions et les éléments avant itératives peuvent être augmentées:
  bookean hasPrevious(): il faut retourner un itérateur associé à un là ensemble d'éléments;
  E previous();: affiche un itérateur un élément supérieur; un
  void add(E e);: l'élément est inséré dans l'emplacement spécifié;

Exemples

1) Exécuter principal

public class DemoApplication {

    public static void main(String[] args) {

        List<String> list = new ArrayList();
        list.add(new String("book001"));
        list.add(new String("book002"));
        list.add(new String(" book003 "));
        System.out.println("原列表：" + list);

        //将新字符串插入第二个位置
        list.add(1, new String("newBook002"));
        System.out.println("新增第二个位置元素后列表：" + list);

        //删除第三个元素
        list.remove(2);
        System.out.println("删除第三个元素后列表：" + list);

        //判断指定元素在List集合的位置
        System.out.println("判断newBook002的位置：" + list.indexOf(new String("newBook002")));

        //将第二元素替换新的字符串
        System.out.println("替换的旧值：" + list.set(1, new String("book002")));
        System.out.println("替换第二个元素后的列表：" + list);

        //返回第二个元素
        System.out.println("回第二个元素：" + list.get(1));

        List<String> newList = new ArrayList<>();
        newList.add("book001");
        newList.add("book004");
        newList.add("book002");

        //新增集合
        list.addAll(1, newList);
        System.out.println("新增一个集合后的列表：" + list);

        //返回元素最后一次出现的位置索引
        System.out.println("返回\"book001\"最后一次出现的位置：" + list.lastIndexOf("book001"));

        //截取子集合
        System.out.println("返回一个范围子集合列表：" + list.subList(0, 3));

        list.sort(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                //逆序
                return o2.compareTo(o1);
            }
        });

        //lambda表达式输出
        list.forEach(book -> System.out.println(book));

        list.replaceAll(String::trim);
        System.out.println("replaceAll去除两端空格" + list);

        list.replaceAll(t -> t.replace("book00", "书籍系列"));
        System.out.println("replaceAll替换字符串：" + list);

        System.out.println("正向迭代输出：");
        ListIterator listIterator = list.listIterator();
        while (listIterator.hasNext()) {
            System.out.println(listIterator.next());
            //添加元素，会影响list元素
            listIterator.add("book");
        }
        System.out.println("反向迭代输出：");
        while(listIterator.hasPrevious()) {
            System.out.println(listIterator.previous());
        }

        System.out.println(list);
    }

}

2) Exécuter les résultats:

原列表：[book001, book002,  book003 ]
新增第二个位置元素后列表：[book001, newBook002, book002,  book003 ]
删除第三个元素后列表：[book001, newBook002,  book003 ]
判断newBook002的位置：1
替换的旧值：newBook002
替换第二个元素后的列表：[book001, book002,  book003 ]
回第二个元素：book002
新增一个集合后的列表：[book001, book001, book004, book002, book002,  book003 ]
返回"book001"最后一次出现的位置：1
返回一个范围子集合列表：[book001, book001, book004]
book004
book002
book002
book001
book001
 book003 
replaceAll去除两端空格[book004, book002, book002, book001, book001, book003]
replaceAll替换字符串：[书籍系列4, 书籍系列2, 书籍系列2, 书籍系列1, 书籍系列1, 书籍系列3]
正向迭代输出：
书籍系列4
书籍系列2
书籍系列2
书籍系列1
书籍系列1
书籍系列3
反向迭代输出：
book
书籍系列3
book
书籍系列1
book
书籍系列1
book
书籍系列2
book
书籍系列2
book
书籍系列4
[书籍系列4, book, 书籍系列2, book, 书籍系列2, book, 书籍系列1, book, 书籍系列1, book, 书籍系列3, book]

  Vu des résultats d'exploitation ci - dessus, System.out.println("判断newBook002的位置：" + list.indexOf(new String("newBook002")));nous sommes une nouvelle « newBook002 » pour la position d'index est déterminé, ou peut revenir à la position d'index, liste importante collection d'objets est déterminée uniquement par les deux equals()méthodes, si le remplacement d'objets equals()méthodes sont vraies, dépôt liste des objets de la collection sont en fait égal.