List集合

List接口继承Collection

List集合特点:

有序(存储元素和取出元素一致)
允许元素重复
具备Collection相关的功能
       	Object [] toArray()
       	Iterator iterator()

特有功能

 void add(int index,Object element):在指定的索引处插 入元素
 Object get(int index):获取指定位置处的元素    + int size():一种新的集合遍历方式
 Object remove(int index):删除指定位置处的元素
 Object set(int index,E element):修改指定位置处的元素(替换)

List集合的遍历方式

  Object[] toArray()
  Iterator iterator()
  Object get(int index):获取指定位置处的元素    + int size():一种新的集合遍历方式
  ListIterator<E> listIterator():列表迭代器  :List集合专有遍历方式存储String,并进行遍历
  		<?>:任意类型包括Object  <? extends E>  <? super E> 泛型高级:通配符

//正向遍历:ListIterator<E> listIterator():列表迭代器  :List集合专有遍历方式
        ListIterator<Student> lit = stuList.listIterator();
        /**
         * ListIterator extends Iterator{}
         *
         * class ArrayList{
         *  List具体ArrayList子实现类重写了Iterator listiterator(){
         *
         *      return new ListItr(0) ;
         *  }
         *
         *          private class ListItr extends Itr implements Iterator{
         *
         *                      //具备hasNext()
         *                      //next()
         *          }
         *
         *  }
         */
        while(lit.hasNext()){
            Student student = lit.next();
            System.out.println(student.getName()+"---"+student.getAge());
        }

        System.out.println("-----------------------------------------");

        //逆向遍历:前提:必须有正向遍历
        //ListIterator<E> listIterator()
        //ListIterator:特有功能:
        //boolean hasPrevious():是否有上一个元素可以迭代
        //Object previous():获取上一个元素
        while(lit.hasPrevious()){
            Student student = lit.previous();
            System.out.println(student.getName()+"---"+student.getAge());
        }

注意：

集合在使用迭代器会经常出现的问题:并发修改异常,
当集合的元素正在被迭代器进行遍历,那么集合对象是不能够对元素进行增加或者删除 (一个线程正在遍历,一个线程在修改元素)

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

        //创建List集合对象
        List<String> list = new ArrayList<>() ;

        //给添加元素
        list.add("hello") ;
        list.add("world") ;
        list.add("javaee") ;

        //使用迭代器遍历
        //Iterator iterator()
      /*  Iterator<String> it = list.iterator();  //"hello","world","javaee"
        while(it.hasNext()){
            String s = it.next() ;//"hello","world","javaee"

            //判断
            if("world".equals(s)){
                list.add("javaEE") ;//集合对象添加的元素,迭代器不知道
            }
        }

        System.out.println(list);*/

      //解决方案1:  1)要么就是迭代器去遍历集合的元素,迭代器去添加元素  :列表迭代器才具备添加的动作
        //ListIterator
        //void add(E e)
        /*ListIterator<String> lit = list.listIterator();
        while(lit.hasNext()){
            //获取
            String s = lit.next();
            //判断是否存在"world"元素
            if("world".equals(s)){
                //列表迭代器添加
                lit.add("javaEE");
            }
        }*/

        //方案2:要么集合遍历,集合添加
        //size()+get(int index)
        for(int x = 0 ; x < list.size(); x ++){
            String s = list.get(x);
            if("world".equals(s)){//将常量放前面,防止出现NullPointerException
                list.add("javaEE");
            }
        }
        System.out.println(list);

    }
}

解决方案:

1.要么就是迭代器去遍历集合的元素,迭代器去添加元素  :列表迭代器才具备添加的动作
2.要么集合遍历,集合添加

List集合如何去重?

方式1

  新建空集合思想
  存储字符串类型并保证集合的元素唯一!

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

        //创建List集合
        List<String> list = new ArrayList<>() ;

        //现在给集合中添加重复的字符串数据
        list.add("hello") ;
        list.add("hello") ;
        list.add("world") ;
        list.add("world") ;
        list.add("javaEE") ;
        list.add("world") ;
        list.add("javaEE") ;
        list.add("android") ;
        list.add("android") ;
        list.add("ios") ;

        //新建一个空的集合List
        List<String> newList = new ArrayList<>() ;
        //遍历以前的集合
        for(String s :list){
            //使用新集合判断,不包含这个元素,说明该元素没有重复,就可以添加
            if(!newList.contains(s)){
                newList.add(s) ;
            }
        }
        //遍历新的集合
        for(String s:newList){
            System.out.println(s);
        }
    }
}

注意

集合中Collection/List→→→contains(Object o)底层依赖于Object的equals方法
而List现在存储的是String类型,本身重写Object的equals,所以比较的是内容是否相同

若存储对象是一个具体的类  例如：学生类（Student）...必须在该类中 重写equals方法

方式二

利用选择排序的思想去完成
选择排序的思想:
使用0角标对应的元素依次和后面角标对应的元素进行比较,小的往前方法.依次这样比较

List集合----集合列表角标从0开始
遍历当前集合
然后使用0角标对应的元素依次和后面对应的元素进行比较,如果后面的元素和前面的相同了,那么将后面的元素删除掉

//利用选择排序的思想完成
        for(int x = 0 ; x < list.size()-1 ; x ++){
            for(int y = x +1 ; y < list.size() ; y++){
                //如果后面的元素和前面的元素相同
                if(list.get(y).equals(list.get(x))){
                    //通过集合remove掉
                    list.remove(y) ; // public Object remove(int index)
                    //角标--
                    y -- ;
                }
            }
        }
//遍历修改后的集合
        for(String s:list){
            System.out.println(s);
        }