Java学习 DAY16 列表、迭代器

List

实现类：ArrayList、LinkedList、Vector、Stack

***ArrayList：***底层由数组实现数据存储，默认初始容量为10，数组底层扩容根据右移运算每次扩容一半

***ArrayList（顺序表）***：底层由数组实现的数据，，默认初始容量为10，内存连续，需要扩容底层根据右移运算进行扩容，每次扩容都是在原容量的基础上增加一半。增删效率较低、查询效率较高。线程不安全的集合。
小练习：用数组实现ArrayList

package cn.tedu.collection.list;

import java.util.ArrayList;
import java.util.List;

public class ListDemo {
    public static void main(String[] args) {
        //创建集合对象
        //向上造型的对象
        List<String> list=new ArrayList<>();
        //添加元素
        list.add("abc");
        list.add("bc");
        list.add("ac");
        list.add("ab");
        //插入元素
        //最大支持的插入下标是元素个数
        //IndexOutOfBoundsException---下标越界异常
        //list.add(5,"123");

        //根据下标来删除元素
        //最大支持删除下标是元素个数减1
        //list.remove(2);

        //根据指定内容来删除元素
        //如果指定内容没有出现在元素中就不做任何操作
        list.remove("a1b");

        //清空集合
        //list.clear();

        //判断指定内容是否包含在元素中
        //System.out.println(list.contains("ac"));

        //根据指定下标来获取元素
        //System.out.println(list.get(0));

        //返回指定内容第一次出现的下标值
        //System.out.println(list.indexOf("ab"));

        //判断是否是一个空集合
        //System.out.println(list.isEmpty());

        //替换元素
        /*list.remove(0);
        list.add(0,"123");*/
        //list.set(0,"123");

        //返回元素个数
        //System.out.println(list.size());

        //截取子列表
        //指定下标含头不含尾
        //System.out.println(list.subList(1,3));

        //把集合元素放到数组当中来返回
        /*Object[] os=list.toArray();
        for (Object o:os) {
            String s=(String) o;
        }*/
        //传入数组对象返回对应类型的数组
        //给定数组长度只要大于等于零即可
        String[] ss=list.toArray(new String[1]);


        //保证数据存放有序
        System.out.println(list);
    }
}

LinkedList（链表）
底层基于节点（静态内部类）来存储数据，通过地址值的指向来维系节点的。内存不连续，不需要扩容。增删效率较高、查询效率较低。线程不安全的集合。
**思考：**当场景里增删操作和查询操作相当，选用ArrayList还是LinkedList？

Vector（向量）：
最早的集合类
底层基于数组实现数据存储，默认的初始容量为10
底层根据三目运算符进行扩容，如果增量值大于0每次扩容的值就是增量的值，如果增量不大于0每次扩容的值就是原容量的大小。
线程安全的集合

package cn.tedu.collection.list;

import java.util.Vector;

public class VectorDemo {
    public static void main(String[] args) {
        //如果指定的值每次扩容的值就是增量的值
        //如果不指定增量，每次扩容就是在原来的基础上增加一倍
        Vector<String> vector=new Vector<>(10,5);
        //添加元素
        for (int i = 0; i < 84; i++) {
            vector.add("a");
        }
        //返回当前容量值
        System.out.println(vector.capacity());
    }
}

Stack（栈结构）：
遵循先进后出
栈顶元素：最后一个存放元素
栈底元素：第一个存放元素
入栈/压栈：往栈里存放元素
出栈/弹栈：从栈里获取元素
继承Vector类

package cn.tedu.collection.list;

import java.util.Stack;

public class StackDemo {
    public static void main(String[] args) {
        //创建栈结构对象
        Stack<String> s=new Stack<>();
        //入栈
        s.push("abc");
        s.push("ab");
        s.push("bc");
        s.push("ac");
        //返回栈顶元素并不删除
        //如果是空栈---EmptyStackException(空栈异常)
        //System.out.println(s.peek());
        //返回栈顶元素并且删除
        //System.out.println(s.pop());
        //判断是否是空栈
        System.out.println(s.empty());
        //从栈顶往栈底来查找指定内容来查找指定内容的位置（从1开始计数）
        //没有找到返回-1
        System.out.println(s.search("ac"));
        //保证和List接口的特点保持一致
        //保证数据存放有序
        System.out.println(s);
    }
}

迭代器（Itrator接口）

底层根据指针挪动到进行迭代遍历
在遍历期间不能直接增删原集合元素
Itrator方法定义在Itrator接口里
类实现Itrator接口产生的对象就能被增强for循环来进行操作—增强for循环底层由迭代器实现–增强for虚幻是jdk1.5新特性

package cn.tedu.collection.list;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class IteratorDemo {
    public static void main(String[] args) {
        //创建集合对象
        List<String> list=new ArrayList<>();
        //添加元素
        list.add("abc");
        list.add("bc");
        list.add("ab");
        list.add("ac");
        //调用方法返回迭代器
        Iterator<String> it=list.iterator();
        //通过循环实现
        while (it.hasNext()){//判断下一位是否有元素
            //获取下一个元素
            String s=it.next();
            //System.out.println(s);
            //调用的是迭代器提供的remove方法
            //改变标记值间接的删除原集合元素
            //it.remove();
            //调用集合的remove方法
            //调用集合的remove方法直接删除原集合元素，但是需要和默认的标记值进行比较
            //此时就会报错
            //list.remove(s);
        }
        //输出集合对象存储数据
        System.out.println(list);
    }
}

package cn.tedu.collection.list;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

public class ComparatorDemo {
    public static void main(String[] args) {
        //创建集合对象
        List<String> list=new ArrayList<>();
        //添加元素
        list.add("abc");
        list.add("bc");
        list.add("1ab");
        list.add("ac");
        //调用sort对集合元素进行排序
        //Comparator接口代表比较器,需要指定比较规则其他的都不用操心
        list.sort(new Comparator<String>() {
            //重写方法---指定比较规则
            //根据首字母来进行升序排序
            @Override
            public int compare(String o1, String o2) {
                //如果返回值是整数表面前面对象大于后面对象
                //如果返回值是整数表面前面对象小于后面对象
                //如果返回值是0表面前面对象等于后面对象
                return o2.charAt(0)-o1.charAt(0);
            }
        });
        System.out.println(list);
    }
}