java 遍历list和删除重复的item及排序

一.List简单介绍

1.List继承了Collection接口，Collection集合中有的方法，List集合也都有继承过来，可参考java tutorial , java 教程, java 全栈知识体系，java书籍

Module java.base  //模块
Package java.util //包名
Interface List<E> //接口
Type Parameters: E - the type of elements in this list //参数
All Superinterfaces: Collection<E>, Iterable<E> //超类接口
All Known Implementing Classes: //所有已知的实现类
AbstractList, AbstractSequentialList, ArrayList, AttributeList, CopyOnWriteArrayList, LinkedList, RoleList, RoleUnresolvedList, Stack, Vector
public interface List<E>
extends Collection<E>

2.List 源码注释

public interface List<E> extends Collection<E> {
    // Query Operations

    int size();//list大小
    
    boolean isEmpty();//判断是否为空list 
    
    boolean contains(Object o);//是否包含某个对象
    
    Iterator<E> iterator();//遍历list中元素的迭代器
    
    Object[] toArray();//将list转换为array
    
    <T> T[] toArray(T[] a);

    // Modification Operations
    
    boolean add(E e);//往list中添加新的元素
  
    boolean remove(Object o);//从list中删除某个元素

    // Bulk Modification Operations

    boolean containsAll(Collection<?> c);//是否包含指定集合中的所有元素
    
    boolean addAll(Collection<? extends E> c);//添加指定集合中的所有元素
    
    boolean addAll(int index, Collection<? extends E> c);//在指定索引下添加指定集合中的所有元素
    
    boolean removeAll(Collection<?> c);//删除集合中的所有元素

    boolean retainAll(Collection<?> c);//删除集合中不存在的那些元素
    
    void clear();//删除集合中所有的元素，list变为空
    
    boolean equals(Object o);

    int hashCode();

    // Positional Access Operations
    
    E get(int index);
    
    E set(int index, E element);
    
    void add(int index, E element);//往集合指定索引中添加元素

    E remove(int index);//删除指定索引的元素
    
    int indexOf(Object o);//获取list中某个对象的索引

    int lastIndexOf(Object o);//获取list中某个对象最后出现的索引
    
    ListIterator<E> listIterator();//返回list迭代器
    
    ListIterator<E> listIterator(int index);//从某个索引开始返回list迭代器

    List<E> subList(int fromIndex, int toIndex);返回list中两个索引中的子集合
  
}

3. java集合框架图

二.Iterator迭代器框架及简单介绍

Iterator（迭代器）不是一个集合，它是一种用于访问集合的方法，可用于迭代ArrayListHashset 等集合。Iterator 是 Java 迭代器最简单的实现，ListIterator 是 Collection API 中的接口， 它扩展了 Iterator 接口，框架图及源码注释如下：

package java.util;


public interface ListIterator<E> extends Iterator<E> {
    // Query Operations

    boolean hasNext();//判断集合中是否还有元素

    
    E next();//返回迭代器的下一个元素

   
    boolean hasPrevious();//逆向遍历列表，列表迭代器前面还有元素，则返回 true，否则返回false

    
    E previous();//返回列表中ListIterator指向位置前面的元素

    
    int nextIndex();//返回列表中ListIterator所需位置后面元素的索引

    
    int previousIndex();//返回列表中ListIterator所需位置前面元素的索引


    // Modification Operations

    
    void remove();//将迭代器返回的元素删除

    
    void set(E e);//从列表中将next()或previous()返回的最后一个元素返回的最后一个元素更改为指定元素e

   
    void add(E e);// 将指定的元素插入列表，插入位置为迭代器当前位置之前
}

 三.遍历list并删除某个元素进行排序，可用Iterator进行循环遍历，eg:

import java.text.Collator;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;

public class ListTest {
    public static void main(String[] args) {

        //创建集合
        ArrayList<String> mNames = new ArrayList<String>();
        mNames.add("Jon");
        mNames.add("Linda");
        mNames.add("Harry");
        mNames.add("Mark");

        //获取迭代器
        Iterator<String> nameIterators = mNames.iterator();

        // 输出所有元素
        while(nameIterators.hasNext()) {
            System.out.println(nameIterators.next());
        }

        // 删除name为Mark的元素
        while(nameIterators.hasNext()) {
            String name=nameIterators.next();
            if(name.equals("Mark")){
                nameIterators.remove();
            }
        }

        // 删除Mark后，输出所有元素
        while(nameIterators.hasNext()) {
            System.out.println(nameIterators.next());
        }

        //对列表中元素进行排序
        Collections.sort(mNames, defaultComparator());

    }

    private static Comparator<String> defaultComparator() {
        final Collator collator = Collator.getInstance();
        return new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return collator.compare(s1,s2);
            }
        };
    }
}

四.删除list中重复的元素，删除重复的name，可将name作为Ma中的key进行保存，保持key的唯一性，则name不会重复，eg:

private static List<String> removeRepeatNames(List<String> listStrs){
        Map<String,String> hashMap=new HashMap<>();
        for (String str:  listStrs) {
            hashMap.put(str,str);
        }
        return Lists.newArrayList(hashMap.values());
    }

五.调用remove时，需要注意如下两点：

1.每调用一次iterator.next()方法，只能调用一次remove()方法

2.调用remove()方法前，必须调用过一次next()方法

以下是JDK-API中对于remove()方法的概述：

void remove()

从迭代器指向的集合中移除迭代器返回的最后一个元素（可选操作）。每次调用 next 只能调用一次此方法。如果进行迭代时用调用此方法之外的其他方式修改了该迭代器所指向的集合，则迭代器的行为是不明确的。

抛出：UnsupportedOperationException - 如果迭代器不支持 remove 操作。IllegalStateException - 如果尚未调用 next 方法，或者在上一次调用 next 方法之后已经调用了remove 方法。