How to delete list elements in java

The method of deleting list elements in java is as follows:

1. Deletion in positive sequence

Delete in positive sequence. If you only delete at most 1 element, then You only need to use the break statement to jump out of the loop after deletion. If you need to delete multiple elements, if you do not pay attention to controlling the size of the current list and the index of the next element, it is easy to report a java.lang.IndexOutOfBoundsException exception

public static void remove(List<String> list, String target) {    
for(int i = 0, length = list.size(); i < length; i++){
        String item = list.get(i);        
        if(target.equals(item)){
            list.remove(item);
            length--;
            i--;
        }
    }
}

Free learning video tutorial recommendation: java video tutorial

2. Reverse deletion

Reverse deletion can overcome forward deletion The problem of requiring additional management of the list size and the index of the next element is also very convenient to use

public static void remove(List<String> list, String target) {    
for(int i = list.size() - 1; i >= 0; i--){
        String item = list.get(i);
        if(target.equals(item)){
            list.remove(item);
        }
    }
}

3. Iterator remove() method deletion (recommended)

public static void remove(List<String> list, String target) {
    Iterator<String> iter = list.iterator();
    while (iter.hasNext()) {
        String item = iter.next();
            if (item.equals(target)) {
            iter.remove();
        }
    }
}

4. CopyOnWriteArrayList thread safety Remove

using CopyOnWrite container. The CopyOnWrite container is a container that is copied on write. The popular understanding is that when we add elements to a container, we do not add them directly to the current container, but first copy the current container to create a new container, and then add elements to the new container. After adding the elements, Then point the reference of the original container to the new container.

The advantage of this is that we can perform concurrent reads on the CopyOnWrite container without locking, because the current container will not add any elements. Therefore, the CopyOnWrite container is also an idea of ​​separation of reading and writing, and reading and writing are different containers.

public static List<String> remove(ArrayList<String> list, String target) {
    CopyOnWriteArrayList<String> cowList = new CopyOnWriteArrayList<String>(list);
    for (String item : cowList) {
            if (item.equals(target)) {
            cowList.remove(item);
        }
    }
                return cowList;
}

Note:

1. The advantage of using CopyOnWriteArrayList is that we can not only delete, but also add new elements during traversal.

2. The above method does not modify the parameter list, but returns CopyOnWriteArrayList to the caller. That is to say, CopyOnWriteArrayList does not modify the List that constructs it, but maintains a List internally. This should be paid special attention to. .

3. CopyOnWriteArrayList is not a subclass of ArrayList, but it implements the List interface.

5. Enhanced for loop deletion

Enhancing the for loop to delete elements and continuing to loop will report a java.util.ConcurrentModificationException exception, because concurrent modifications occur when the elements are used, resulting in exceptions Throws, but if you use the break statement to jump out of the loop immediately after deletion, no error will be triggered, so it is suitable for deleting at most 1 element.

public static void remove(List<String> list, String target) {
    for (String item : list) {
            if (item.equals(target)) {
            list.remove(item);
                        break;
        }
    }
}

6. Stream API filter

The stream API introduced in Java8 brings a new and simpler method filter for deleting List elements. This method does not change the original List object and must return a new one. Object, the following example demonstrates how to use stream to delete the "*" element in the collection.

List<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("*");
list.add("c");
list.add("*");
List<String> result = list
                        .stream()
                        .filter(item -> !"*".equals(item))
                        .collect(Collectors.toList());

Recommended related articles and tutorials: java introductory tutorial

The above is the detailed content of How to delete list elements in java. For more information, please follow other related articles on the PHP Chinese website!