JavaDay08-集合Collection、List、ArrayList、LinkedList

集合

可变长度的数组

• Collection 单列集合的祖宗接口
  • List 有序、可重复、有索引
    • ArrayList
    • LinkedList
  • Set 无序、不重复、无索引
    • HashSet
    • TreeSet
• 双列Map
  • HashMap

Collection的方法

• public boolean add(E e);
• public boolean remove(Object o);
• public void clear();
• public boolean contains(Object o);
• public boolean isEmpty();
• public int size();

import java.util.ArrayList;
import java.util.Collection;
//Collection的方法 add clear remove contains isEmpty size
public class CollectionDemo01 {
    public static void main(String[] args) {
        Collection<String> coll=new ArrayList<>();//多态
        coll.add("aaa");
        System.out.println(coll);
        System.out.println("------------------");
        coll.clear();
        System.out.println(coll);
        System.out.println("------------------");
        coll.add("aaa");
        coll.add("aaa");
        coll.add("aaa");
        System.out.println(coll);
        coll.remove("aaa");
        System.out.println(coll);
        System.out.println("------------------");
        System.out.println(coll.contains("aaa"));
        System.out.println("------------------");
        System.out.println(coll.isEmpty());
        System.out.println("------------------");
        System.out.println(coll.size());
        System.out.println("------------------");
    }
}

Collection-contains()

• 如果集合中存储的是自定义对象，如果要通过contains方法判断是否包含某个对象，那么需要在JavaBean类中重写equals方法。

import java.util.ArrayList;
import java.util.Collection;
import java.util.Objects;

//Collection-contains()
public class CollectionDemo02 {
    public static void main(String[] args) {
        Collection<Student> coll=new ArrayList<>();
        Student stu1=new Student("张三");
        Student stu2=new Student("李四");
        coll.add(stu1);
        coll.add(stu2);
        Student stu3=new Student("张三");
        System.out.println(coll.contains(stu3));
    }
}
class Student{
    String name;
    int age;

    public Student(String name) {
        this.name = name;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }
}

Collection集合遍历的三种方式：

1、迭代器(可以删除元素)
2、增强for循环（仅遍历）
3、lambda表达式（仅遍历）

迭代器Iterator

1、集合对象调用迭代器
2、hasNext()判断当前位置是否有元素
3、next()获取当前位置的元素并移动到下一位置

注意：
1、Iterator不依赖索引，报错NoSuchElementException
2、迭代器遍历完毕，指针不会复位
3、迭代器遍历时不能用Collection中的remove方法删除元素，要用Iterator中的remove方法

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.function.Consumer;

//Collection集合遍历的三种方式
public class CollectionDemo03 {
    public static void main(String[] args) {
        Collection<String> coll=new ArrayList<>();
        coll.add("aaa");
        coll.add("bbb");
        coll.add("ccc");
        //1.集合对象调用迭代器
        Iterator<String> it = coll.iterator();
        while (it.hasNext()){//2、hasNext()判断当前位置是否有元素
            String str=it.next();
            //if (str.equals("aaa")) coll.remove("aaa");//报错ConcurrentModificationException
            if (str.equals("aaa")){
                it.remove();
            }
            System.out.println(str);//3、next()获取当前位置的元素并移动到下一位置
        }
        //System.out.println(it.next());//报错NoSuchElementException
        System.out.println(coll);
        //2.增强for循环
        for (String s : coll) {
            System.out.println(s);
        }
        //匿名内部类-for循环遍历集合，对元素进行accept操作
        coll.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });
        //lambda表达式
        coll.forEach(s-> System.out.println(s));
        //其他方式
        coll.forEach(System.out::println);
    }
}

List-有索引

方法：

• public void add(int index, E element)
• public E remove(int index)
• public E set(int index, E element) 修改索引处的值
• public E get(int index) 取值

细节:

• remove 当方法出现了重载现象时，会优先调用实参和形参类型一致的那个方法

public class ListDemo01 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        //public void add(int index, E element)
        list.add(0,"Snow");
        list.add(1,"Spring");
        list.add(1,"Swim");
        System.out.println(list);
        //public E remove(int index)
        String ind=list.remove(1);
        System.out.println(ind);
        //remove()细节
        List<Integer> list2=new ArrayList<>();
        list2.add(1);
        list2.add(2);
        list2.add(3);
        list2.remove(1);//删除的是索引1位置的元素
        list2.remove(Integer.valueOf(1));//把基本数据类型1手动装箱，变成了包装类的对象，然后删除了1这个对象
        System.out.println(list2);
        //public E set(int index, E element)  修改索引处的值
        list.set(1,"morning");
        System.out.println(list);
        //public E get(int index)  取值
        String str=list.get(0);
        System.out.println(str);
    }
}

List集合的遍历方式:

• 包括Collection集合的三种（1迭代器2增强for3lambda表达式）、普通for、列表迭代器

遍历方式的选择：
1、遍历过程中需要删除元素：迭代器
2、遍历过程中需要添加元素：列表迭代器
3、仅遍历：增强for、lambda表达式
4、操作索引：普通for

public class ListDemo02 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("new");
        list.add("day");
        list.add("tomorrow");
        list.add("better");
        list.add("betterr");
        System.out.println(list);
        //Iterator
        System.out.println("Iterator:::::::::::::::::::::::::::::::");
        Iterator<String> iter = list.iterator();
        while (iter.hasNext()){
            String res=iter.next();
            if (res.equals("betterr")) iter.remove();//删除元素
            System.out.println(res);
        }
        //增强for
        System.out.println("增强for:::::::::::::::::::::::::::::::::");
        for (String s : list) {
            System.out.println(s);
        }
        //lambda表达式
        System.out.println("lambda表达式:::::::::::::::::::::::::::::");
        list.forEach(s-> System.out.println(s));
        //普通for
        System.out.println("普通for::::::::::::::::::::::::::::::::::");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        //列表迭代器
        System.out.println("列表迭代器::::::::::::::::::::::::::::::::::");
        ListIterator<String> siter = list.listIterator();
        while (siter.hasNext()){
            String str2=siter.next();
            if (str2=="new") siter.add("Fighting!");//ListIterator继承了Iterator，新增了add方法
            System.out.println(str2);
        }
    }
}

ArrayList

• 元素可重复

//ArrayList构造方法、add()
public class ArrayListDemo01 {
    public static void main(String[] args) {
        ArrayList<String> array = new ArrayList<>();
        array.add("hello");
        System.out.println(array);

        ArrayList<int[]> ints = new ArrayList<>();
        int[] ints1 = new int[2];
        int[] ints2 = new int[2];
        ints.add(ints1);
        ints.add(ints2);
        System.out.println(ints);
    }
}

ArrayList底层原理：

1、ArrayList底层是数组结构
2、ArrayList有两个添加方法：
- add()一次添加一个元素
- addAll()一次添加一个list
3、利用空参创建的集合，底层创建一个默认长度为0的数组，数组的名字为elementData，有一个成员变量size记录数组的大小
4、添加第一个元素时，创建一个新的长度为10的数组
5、存满时，扩容1.5倍
6、如果添加的多，1.5倍放不下，那么扩容的大小以实际为准

LinkedList

LinkedList是双向链表