JAVA 集合——2.List

List

java.util.list:
线性表，是一类可以存放重复元素并且有序的集合，可以通过下标操作元素

可重复，有序，下标操作
E get(int index)
获取指定下标处对应的元素
E set（int index ,E e）给定元素设置到指定位置，返回值为原位置对应的元素，所以
set是替换操作
实现了get ，set方法

Arratlist（线）：

java.util.ArrayList：

ArrayList的底层是数组的原理。
查询性能更好
（是有序的集合，长度不固定，不是线程安全的）

LinkedList（链，链头，链尾）：

java.util.LinkedList:
内部由链表实现，增删性能更好
（Linked也不是线程安全的。队列：先进先出
栈：先进后出）

对性能不是极端苛刻要求的话，一般使用ArrayList即可

list重载了一对add，remove方法，也是通过下标操作

ArrayList：

 	    List<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        System.out.println(list);
        //void add(int index,E e) 将给定元素插入到指定位置
        list.add(1, "hello");
        System.out.println(list);
        //E remove(int i)删除指定位置的元素并返回其对应的元素
        String old = list.remove(2);
        System.out.println(old);

集合重写了tostring方法，并且集合中每个元素输出的内容就是元素自身tostring的内容

containsAll

判断集合是否包含某个中的所有元素

 List<String> list=new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        List<String> list1=new ArrayList<>();
        list1.add("e");
        list1.add("f");
        list1.add("g");
        list.addAll(list1);
        System.out.println(list);
        //containsAll判断集合是否包含某个中的所有元素
        boolean flag=list.containsAll(list1);

        list.removeAll(list1);

迭代器模式

Iterator iterator（）该方法会获取一个可以遍历当前集合的迭代器实现类
java.util.Iterator接口 迭代器接口，规定了迭代器实现类遍历集合的操作，
我们无需记住每种集合的迭代器名字，只需当他们是迭代器即可，

迭代器遍历集合遵循的模式：问→取→删 其中删除元素不是必要操作

 Collection c = new ArrayList();
        c.add("one");
        c.add("two");
        c.add("three");
        c.add("four");
        c.add("five");
        c.add("#");
        c.add("a");
        c.add("e");
        System.out.println(c);
        Iterator iterator = c.iterator();
        //boolean hasNext()判断是否还有元素可以遍历
        while (iterator.hasNext()) {
            //E next()遍历下一个元素
            // 问一次，取一次，下面代码取了两次，会报错
            String str = (String) iterator.next();//one three five
//            System.out.println(iterator.next());//two four  无法输出第三个数报错
            /*
            迭代器只能问值，取值不能使用元素自身增删元素，否则会报异常
             */
            if ("#".equals(str)){
//                c.remove("#");
                /*
                迭代器的remove方法不需要传入参数，删除的是本次迭代时通过next获取的元素
                必须用Iterator删除
                 */
                iterator.remove();
            }
        }
        System.out.println(c);

ListIterator从后往前输出的条件是必须先实现从前往后

//ListIterator hasPervious() 判断是否有上一个元素 previous取出当前元素
            //与hasNext判断是否有下一个值 next取出当前元素相反
ListIterator<String> lis=l.listIterator();
//从前往后
while(lis.hasNext()){
    String s=lis.next();
    System.out.println(s);
}
//从后往前
while (lis.hasPrevious()){
    String s=lis.previous();
    System.out.println(s+" ");
}

foreach新循环遍历：

新循环是编译器认可的语法，在编译为字节码文件时会将它改为普通for循环遍历数组
新循环在遍历集合时会被编译器改为迭代器，拥有迭代器的属性

   //创建集合时指定泛型（这里用于约束元素类型
        Collection<String> c=new ArrayList<>();
        //此时向当前集合添加元素时编译器会检查元素类型
        c.add("one");
        c.add("two");
        c.add("three");

        //使用新循环遍历时，可以直接使用String接收了
        for (String s:c
             ) {
            System.out.println(s);
        }

toArray：

集合转换为数组 Collection提供了方法：toArray，可以将集合转换为数组

 	    List<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        String[] a=  list.toArray(new String[list.size()]);

        System.out.println(Arrays.toString(a));

aslist：

数组转换为集合 数组的工具类Arrays有一个静态方法aslist，可将数组转换为list集合

  String[] array = {"one", "two", "three", "four"};
//        Arrays.sort(array);
//        System.out.println(Arrays.toString(array));
        List<String> list = Arrays.asList(array);
        System.out.println(list);

        list.set(1, "2");
        //再次强调集合只保存引用地址
        //对该集合元素操作就是对数组元素操作,相当于一个栈内存
        System.out.println(list);
        System.out.println(Arrays.toString(array));

        //由于数组是定长的，因此从数组转出来的集合是不能增删元素的，否则抛出异常
//        list.add("five");
//        System.out.println(list);
//        System.out.println(Arrays.toString(array));
        List<String> list1 = new ArrayList<>(list);
        list1.add("five");
        System.out.println(list1);

Queue：

java.util.Queue队列接口 Queue继承自Collection。 队列是经典的数据结构之一
可以存放一组元素，但是存放元素必须遵循先进先出原则
常用实现类：LinkedList
offer方法：入队操作，元素会追加到队列末尾 （add）
peek()获取取队首元素不删除，无则返回null
poll()出队操作，获取取队首元素并从队列中删除，无则返回null
remove()获取取队首元素并从队列中删除,无则抛出异常

Queue<String> q = new LinkedList<>();
        //offer方法：入队操作，元素会追加到队列末尾
        q.offer("a");
        q.offer("b");
        q.offer("c");
        System.out.println(q);
        //集合的详情方法也可以使用
        System.out.println(q.size());
        //peek()获取取队首元素不删除，无则返回null
        String a = q.peek();
        System.out.println(a);
        System.out.println(q);

        //poll()出队操作，获取取队首元素并从队列中删除，无则返回null
        System.out.println("poll()出队操作");
        String b = q.poll();
        System.out.println(b);
        System.out.println(q);
        while (q.size()>0){
            String s=q.poll();
            System.out.println(s);
        }

        //remove()获取取队首元素并从队列中删除,无则抛出异常
        System.out.println("remove()获取取队首元素并从队列中删除,无则抛出异常");
        String c = q.remove();
        System.out.println(c);
        System.out.println(q);

        Iterator<String> it=q.iterator();
        while (it.hasNext()){
            String d=it.next();
            System.out.println(d);
            it.remove();
        }
        System.out.println(q);

        String t=q.poll();
        System.out.println(t);
        String g=q.remove();
        System.out.println(g);

Deque：

java.util.Deque接口
双端队列 Deque接口继承自Queue接口，双端队列是两端多可以出入对的队列 实现类同样是：LinkedList

  Deque<String> d = new LinkedList<>();
        LinkedList<String> s = new LinkedList<>();

        //offer添加数据，第一个为队头
        d.offer("a");
        d.offer("b");
        d.offer("c");

        //offerFirst向队头添加数据
        d.offerFirst("我是队头");

        //offerLast向队尾添加数据
        d.offerLast("我是队尾");

        //peek()检索队头并返回值

        String x1=d.peek();
        System.out.println(x1);
        System.out.println(d);

        System.out.println();

        //检索队头
        String x2=d.peekFirst();
        System.out.println(x2);
        System.out.println(d);

        System.out.println();
        //检索队尾
        String x3=d.peekLast();
        System.out.println(x3);
        System.out.println(d);