JAVAEE细细看 进阶 07 - 集合、ArrayList、LinkedList

集合、ArrayList、LinkedList

一. 针对Collection集合我们应该怎么使用

1. 是否元素唯一
    a. 是：Set
     1. 是否排序
      a 是：TreeSet
      b 否：HashSet
     如果不知道用哪个Set就用HashSet
    b. 否：List
     1. 是否对安全性有要求
      a 是：Vector
      b 否：
        查询多：ArrayList
        增删多：LinkedList
   2.如果不知道用哪个List用ArrayList
   3.如果知道是用集合但不知道用哪个用ArrayList
   
   

二. Collection

概述：
a. 是单列集合的顶层接口，它表示一组对象，这些对象也称为Collection元素
b. JDK不提供此接口的任何直接实现，它提供更具体的子接口，如Set、List

Collection<String> c = new  ArrayList<String>();
c.add("hello");
c.add("world");
c.add("java");

System.out.println(c);

方法：

add(E e)                 添加
remove(Object o)  删除
clear                       清空
contains(Object o) 包含
isEmpty()                是否为空
int size()                长度

Iterator 遍历集合

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

//添加元素
c.add("hello");
c.add("world");
c.add("java");

Iterator<String> iterator = c.iterator();

// 遍历
while (iterator.hasNext()){
    String s =  iterator.next();
    System.out.println(s);
}

三. List 集合

有序，有索引，可重复
特点:
有序：存储和取出的元素顺序一致
可重复：存储的元素可以重复

List<String> li = new ArrayList<>();

li.add("hello");
li.add("world");
li.add("hello");
li.add("java");

final Iterator<String> iterator = li.iterator();

while (iterator.hasNext()) {
    String s = iterator.next();
    System.out.println(s);
}

特有方法：

add(int index, E element);       插入指定的元素
E remove(int index)                  删除指定索引处的元素
set(int index, E element)          修改
get(int index)                            查询

并发修改异常

ConcurrentModificationException
原因：
         使用迭代器(Interator)遍历数组的时候，如果做了修改数组行为(remove/add) 就会出现预期修改值和实际修改值不一致的情况
解决方案：
          用for循环

ListIterator

a. 通过List集合的ListIterator() 方法得到，所有它是List集合特有的迭代器
b. 用于允许沿任意方向遍历数组，迭代期间可以修改列表，可以获取迭代的当前位置
hasNext()
hasPrevious()      前面还有元素
next()                    下一个
previous()            上一个
add(E e)                迭代器向列表中添加元素

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

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

ListIterator<String> lit = list.listIterator(list.size());

while (lit.hasPrevious()){
    String s = lit.previous();
    if (s.equals("java")) {
        lit.add("javaee");
    }
    System.out.println(s);
}
System.out.println("-------");
System.out.println(list);

增强for循环
简化数组和Collection集合的遍历
a. 实现iterable接口的类，允许使用
b. jdk5.0之后，内部原理是iterator 迭代器

格式：

for(类型 变量名： 集合/数组){
}

int[] arr = new int[]{1,2,3,4,5};
for (int i: arr) {
   // System.out.println(i);
    System.out.println(arr[i-1]);
}
System.out.println("--------");

String[] arr1 = new String[]{"www","ttt","sss","ddd"};
for (String s: arr1){
    System.out.println(s);
}
System.out.println("--------");

Collection<String> col = new ArrayList<>();
col.add("www");
col.add("ttt");
col.add("ddd");

for (String s: col) {
    if (s.equals("www")) {
        col.add("sss");         //ConcurrentModificationException, 只有ListIterator迭代器才能add
    }
}

四. 总结例子

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

//创建学生对象
Student s1 = new Student("林青霞", 30);
Student s2 = new Student("张曼玉", 35);
Student s3 = new Student("王祖贤", 33);

//把学生添加到集合
list.add(s1);
list.add(s2);
list.add(s3);

// Iterator迭代器
Iterator<Student> iterator = list.iterator();
while (iterator.hasNext()){
    Student s = iterator.next();
    System.out.println(s);
}
System.out.println("--------");

// for循环
for (int i = 0; i < list.size(); i++) {
    Student s = list.get(i);
    System.out.println(s);
}
System.out.println("--------");

// 可以改变数组长度的遍历器
ListIterator<Student> studentListIterator = list.listIterator(list.size());
while (studentListIterator.hasPrevious()) {
    Student s = studentListIterator.previous();
    System.out.println(s);
}
System.out.println("--------");

// 增强for循环，内部是Iterator迭代器
for (Student s: list) {
    System.out.println(s);
}

五. List集合的子类特点

子类：Arraylist，LinkedList
数组和链表
特点：
数组：查询快，增删慢
链表：查询慢，增删快
ArrayList：底层数据结构是数组，查询快，增删慢
LinkedList：底层数据结构是链表，查询慢，增删快
练习：
分别使用ArrayList和LinkedList完成存储字符串并遍历

public static void main(String[] args) {

   // ArrayList
  arraylistTest();

// LinkedList
   linkedListTest();


}

public static void arraylistTest(){
    ArrayList<String> arr = new ArrayList<>();
    arr.add("hello");
    arr.add("world");
    arr.add("java");

    // 遍历1
    for (int i = 0; i < arr.size();i ++) {
        System.out.println(arr.get(i));
    }
    System.out.println("--------");

    // 遍历2
    Iterator<String> iterator = arr.iterator();
    while (iterator.hasNext()){
        String s = iterator.next();
        System.out.println(s);
    }
    System.out.println("--------");

    ListIterator<String> listIterator = arr.listIterator(arr.size());
    while (listIterator.hasPrevious()){
        String s = listIterator.previous();
        System.out.println(s);
    }
    System.out.println("--------");

    for (String s: arr) {
        System.out.println(s);
    }

}

public static void linkedListTest(){
    LinkedList<String> li = new LinkedList<>();
    li.add("hello");
    li.add("world");
    li.add("java");

    // 遍历1
    for (int i = 0; i <li.size() ; i++) {
        String s = li.get(i);
        System.out.println(s);
    }
    System.out.println("--------");

    // 遍历2
    Iterator<String> iterator = li.iterator();
    while (iterator.hasNext()){
        String s = iterator.next();
        System.out.println(s);
    }
    System.out.println("--------");

    // 遍历3
    ListIterator<String> listIterator = li.listIterator(li.size());
    while (listIterator.hasPrevious()){
        String previous = listIterator.previous();
        System.out.println(previous);
    }
    System.out.println("--------");

    // 最快的遍历
    for (String s: li) {
        System.out.println(s);
    }
}

LinkedList集合的特有功能
因为它是链式的

addFirst() 在开头插入
addLast() 在结尾插入
getFirst()  获取第一个元素
getEnd() 获取最后一个元素
removeFirst() 删除第一个
removeLast() 删除最后一个

六. 总结：