Obtenez ListIterator en une minute

Introduction

En programmation Java, ListIterator est une interface très utile, qui est une version étendue de l'itérateur de l'interface List, qui peut être utilisée pour réaliser le parcours et la modification de la structure de données de la liste chaînée.

arrière-plan

ListIterator est une interface de classe interne fournie par Java, qui encapsule le parcours et la modification des éléments dans la liste, et fournit une série de méthodes pour prendre en charge ces opérations. Il fournit plus de fonctions que les itérateurs ordinaires, telles que la suppression ou le remplacement d'éléments pendant l'itération et l'itération vers l'avant. En raison des caractéristiques de ListIterator, cette interface est principalement applicable au fonctionnement de la structure de données de liste chaînée, telle que la classe LinkedList. Lorsque nous devons parcourir et modifier les éléments de la liste liée, nous devons utiliser ListIterator.

usage

1. Traversée vers l'avant

• L'objet ListIterator est obtenu via la méthode listIterator() de la liste et sa position initiale est définie au début de la liste. Vous pouvez également utiliser la méthode listIterator(int index) pour spécifier la position de ListIterator pour commencer à parcourir la liste :

List<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
ListIterator<String> listIterator = list.listIterator();
while(listIterator.hasNext()){
    String element = listIterator.next();
    System.out.println(element);
}

2. Traversée inverse

• Outre le parcours vers l'avant, ListIterator fournit également une méthode pour parcourir la liste en sens inverse. Utilisez les méthodes hasPrevious() et previous() pour parcourir la liste de l'arrière vers l'avant. L'exemple de code est le suivant :

while(listIterator.hasPrevious()){
    String element = listIterator.previous();
    System.out.println(element);
}

3. définir, ajouter, supprimer des opérations

• En plus de parcourir la liste, ListIterator fournit également des méthodes pour modifier les éléments de la liste : remove(), set() et add()

while(listIterator.hasNext()){
    String element = listIterator.next();
    if("c".equals(element)){
        listIterator.set("d");
    }
    if("b".equals(element)){
        listIterator.add("e");
    }
    if("a".equals(element)){
        listIterator.remove();
    }
}

Pratique de développement

• Supprimer certaines clés inutiles

if (Objects.nonNull(publishObject)) {
    JSONObject pageJson = JSONObject.parseObject(publishObject);
    JSONObject pageRetJson = pageJson.getJSONObject(RECEIPT_PUBLISH_INFO_PAGE_JSON);
    List<TemplateFieldDTO> templateFieldDTOS = pageRetJson.getJSONArray("fields").toJavaList(TemplateFieldDTO.class);
    boolean flag = menuId.equals(MYRECEIPTMENU);
    ListIterator<TemplateFieldDTO> listIterator = templateFieldDTOS.listIterator();
    while (listIterator.hasNext()) {
        TemplateFieldDTO templateFieldDTO = listIterator.next();
        if (templateFieldDTO.getFieldName().equals("purchaser")) {
            listIterator.remove();
        }
        if (flag) {
            if (templateFieldDTO.getFieldName().equals("remarksDescribe")) {
                listIterator.remove();
            }
            if (templateFieldDTO.getFieldName().equals("remarksStatusName")) {
                listIterator.remove();
            }
        }
    }
    pageRetJson.put("fields", templateFieldDTOS);
    // 通过nacos获取配置的uri
    String listUriStr = menusListUriJson.getString(menuId);
    if (Func.isNotEmpty(listUriStr)) {
        pageRetJson.put("uri", listUriStr);
    }
    menuJson.put(COMMON_PAGE_MENU_ID, pageRetJson);
}

La différence entre Iterator et ListIterator :

1. Iterator peut parcourir les collections Set et List ; ListIterator ne peut parcourir que List.

2. Iterator ne peut être parcouru que dans un sens ; ListIterator peut être parcouru dans les deux sens (avant/arrière).

3. ListIterator hérite de l'interface Iterator, ajoutant de nouvelles fonctions, telles que l'ajout d'un élément, le remplacement d'un élément et l'obtention de la position d'index de l'élément précédent ou suivant.

itérateur

package java.util;
 
import java.util.function.Consumer;
 
public interface Iterator<E> {
   
    boolean hasNext();
   
    E next();
    
    default void remove() {
        throw new UnsupportedOperationException("remove");
    }
 
    default void forEachRemaining(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        while (hasNext())
            action.accept(next());
    }
}

Itérateur de liste

package java.util;
 
public interface ListIterator<E> extends Iterator<E> {
   
    boolean hasNext();
 
    E next();
 
    boolean hasPrevious();
 
    E previous();
  
    int nextIndex();
 
    int previousIndex();
 
    void remove();
 
    void set(E e);
 
    void add(E e);
}