Java 集合框架 01

集合框架· ArrayList 和 Vector

 对象数组的概述和使用

 * A：案例演示
　　* 需求：我有5个学生，请把这5个学生的信息存储到数组中，并遍历数组，获取到每个学生的信息

Student[] arr = new Student[5];
arr[0] = new Student("张三", 23);
arr[1] = new Student("李四", 24);
arr[2] = new Student("王五", 25);
arr[3] = new Student("赵六", 26);
arr[4] = new Student("周七", 27);

for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);    
}

* B：画图演示
　　* 把学生数组的案例画图讲解
　　* 数组和集合存储引用数据类型，存的都是地址值

package com.heima.collection;

import com.heima.bean.Student;

public class Demo1_Array {
    public static void main(String[] args) {
        // int[] arr = new int[5]; // 创建基本数据类型数组
        Student[] arr = new Student[5]; // 创建引用数据类型数组
        arr[0] = new Student("张三", 23); // 创建一个学生对象，存储在数组的第一个位置
        arr[1] = new Student("李四", 24);
        arr[2] = new Student("王五", 25);
        
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]); // 默认调用toString的方法，如果Student类没有重写toString方法，则默认调用Object类的方法
        }
    }
}

集合的由来及集合继承体系图

 * A：集合的由来
　　* 数组的长度是固定的，当添加的元素超过了数组的长度时需要对数组重新定义
　　* Java内部给我们提供了集合类，能存储任意对象，长度可以改变，随着元素的增加而增加

* B：数组和集合的区别
　　* 区别一：
　　　　* 数组 既可以存储基本数据类型，又可以存储引用数据类型；基本数据类型存储的是值，引用数据类型存储的是地址值
　　　　* 集合 只能存储引用数据类型；如果要存储基本数据类型，就需要进行装箱

　　* 区别二：
　　　　* 数组的长度是固定的，不能自动增长
　　　　* 集合的长度是可变的，可以根据元素的增加而增长

* C：数组和集合什么时候用
　　* 如果元素的个数是固定的，推荐用数组
　　* 如果元素的个数不是固定的，推荐用集合

* D：集合继承体系图

Collection集合的基本功能测试

* A：案例演示

基本功能演示

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

* B：注意
　　* collectionXxx.java 使用了未经检查或不安全的操作
　　　　* 要了解详细信息，请使用 -Xlint:inchecked 重新编译
　　　　* java编译器认为该程序存在安全隐患

    public String toString() {
        Iterator<E> it = iterator();
        if (! it.hasNext())
            return "[]";

        StringBuilder sb = new StringBuilder();
        sb.append('[');
        for (;;) {
            E e = it.next();
            sb.append(e == this ? "(this Collection)" : e);
            if (! it.hasNext())
                return sb.append(']').toString();
            sb.append(',').append(' ');
        }
    }

package com.heima.collection;

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

import com.heima.bean.Student;

@SuppressWarnings({ "rawtypes", "unchecked" })

public class Demo2_Collection {
    public static void main(String[] args) {
        Collection c = new ArrayList(); // 父类引用指向子类对象
        // demo1(c);
         demo2(c);
    }

    public static void demo2(Collection c) {
        c.add("a");
        c.add("b");
        c.add("c");
        c.add("d");

        c.remove("c"); // 删除指定元素
        System.out.println(c);

        System.out.println(c.contains("a")); // 判断是否包含指定元素

        c.clear(); // 彻底清空集合
        System.out.println(c);
        System.out.println(c.isEmpty()); // 判断是否是空集合
        System.out.println(c.size()); // 获取集合中包含的元素的个数,类似于字符串中的length()方法
    }

    public static void demo1(Collection c) {
        // add方法： 如果是List集合，一直都返回true，因为List集合中是可以存储重复元素的
        //                如果是set 集合，当存储重复元素时，就会返回false

        boolean b1 = c.add("abc"); // 可以添加任意对象，任意对象都是Object的子类
        boolean b2 = c.add(true); // 自动装箱 new Boolean(true);
        boolean b3 = c.add(100); // 自动装箱 new Integer(100);
        boolean b4 = c.add(new Student("张三", 23));
        boolean b5 = c.add("abc");
        
        // 都是true
        System.out.println(b1);
        System.out.println(b2);
        System.out.println(b3);
        System.out.println(b4);
        System.out.println(b5);
        
        System.out.println(c);    // ArrayList的爷爷类重写了toString方法
    }
}

集合转数组遍历

* A：集合的遍历
　　* 其实就是依次获取集合中的每一个元素

* B：案例演示
　　* 把集合转换成数组，可以实现集合的遍历
　　* toArray()

Collection c = new ArrayList();
c.add(new Student("张三", 23));  // Object obj = new Student("张三", 23)
c.add(new Student("李四", 24));
c.add(new Student("王五", 25));
c.add(new Student("赵六", 26));

Object[] arr = coll.toArray;  // 将集合转换为数组
for (int i = 0; i < arr.length; i++) {
　　Student s = (Student)arr[i];  // 强转成Student
　　System.out.println(s.getName() + "," + s.getAge());    
}

package com.heima.collection;

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

import com.heima.bean.Student;

@SuppressWarnings({ "rawtypes", "unchecked" })
public class Demo3_Collection {
    public static void main(String[] args) {
        // demo1();
        // demo2();

    }

    public static void demo2() {
        Collection c = new ArrayList();
        c.add(new Student("张三", 23)); // 向数组内存入自定义的引用对象
        c.add(new Student("李四", 24));
        c.add(new Student("王五", 25));
        c.add(new Student("赵六", 26));

        Object[] arr = c.toArray(); // 向上转型 提升为Object类
        for (int i = 0; i < arr.length; i++) {
            // System.out.println(arr[i]);
            Student s = (Student) arr[i]; // 强制向下转型
            System.out.println(s.getName() + "..." + s.getAge());
        }
    }

    public static void demo1() {
        Collection c = new ArrayList();
        c.add("a");
        c.add("b");
        c.add("c");
        c.add("d");

        Object[] arr = c.toArray(); // 将集合转换成数组
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

Collection集合的带All功能测试

* A：案例演示

带All的功能演示

boolean addAll(Collection c)
boolean removeAll(Collection c)
boolean containsAll(Collection c)
boolean retainAll(Collection c)

package com.heima.collection;

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

public class Demo4_Collection {
    public static void main(String[] args) {
        // demo1(); // 整体添加
        // demo2(); // 删除交集
        // demo3(); // 是否包含
        // demo4(); // 取交集
    }

    public static void demo4() {
        Collection c1 = new ArrayList();
        c1.add("a");
        c1.add("b");
        c1.add("c");
        c1.add("d");

        Collection c2 = new ArrayList();
        c2.add("a");
        c2.add("b");
        c2.add("z");
        c2.add("c");
        c2.add("d");

        boolean b = c1.retainAll(c2); // 取交集，如果调用的集合改变就返回true，如果调用的集合不变就返回false
        System.out.println(b);
        System.out.println(c1);
    }

    public static void demo3() {
        Collection c1 = new ArrayList();
        c1.add("a");
        c1.add("b");
        c1.add("c");
        c1.add("d");

        Collection c2 = new ArrayList();
        c2.add("a");
        c2.add("b");
        c2.add("z");

        boolean b = c1.containsAll(c2); // 判断调用的集合是否包含传入的集合，如果出现一个元素不包含就返回false，可以有重复
        System.out.println(b);
    }

    public static void demo2() {
        Collection c1 = new ArrayList();
        c1.add("a");
        c1.add("b");
        c1.add("c");
        c1.add("d");

        Collection c2 = new ArrayList();
        c2.add("a");
        c2.add("b");
        c2.add("z");

        boolean b = c1.removeAll(c2); // 如果有交集，就删除并返回true; 如果没有交集就不删除并且返回false
        System.out.println(b);
        System.out.println(c1);
    }

    public static void demo1() {
        Collection c1 = new ArrayList();
        c1.add("a");
        c1.add("b");
        c1.add("c");
        c1.add("d");

        Collection c2 = new ArrayList(); // alt + shift + r 可以整体改名
        c2.add("a");
        c2.add("b");
        c2.add("c");
        c2.add("d");

        c1.addAll(c2); // 将c2中的每一个元素都 添加到c1中
        c1.add(c2); // 将c2整个集合看成 一个对象 添加到c1中
        System.out.println(c1);
    }
}

迭代器遍历

* A：迭代器概述
　　* 集合是用来存储元素的，存储的元素要查看，那么就需要迭代（遍历）

* 案例演示

迭代器的使用

Collection c = new ArrayList();
c.add("a");
c.add("b");
c.add("c");
c.add("d");

Iterator it = c.iterator();

while (it.hasNext()) {
    System.out.println(it.next());
}

package com.heima.collection;

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

import com.heima.bean.Student;

public class Demo5_Collection {
    public static void main(String[] args) {
        // demo1();
        // demo2();
    }

    public static void demo2() {
        // 迭代自定义类
        Collection c = new ArrayList();
        c.add(new Student("张三", 23)); // 自动提升为Object类
        c.add(new Student("李四", 24));
        c.add(new Student("王五", 25));
        c.add(new Student("赵六", 26));
        // 获取迭代器
        Iterator it = c.iterator();
        while (it.hasNext()) {
            // System.out.println(it.next());
            Student s = (Student) it.next();  // 向下转型，注意next方法调用时的指针位置变化
            System.out.println(s.getName() + "..." + s.getAge());
        }
    }

    public static void demo1() {
        Collection c = new ArrayList();
        c.add("a");
        c.add("b");
        c.add("c");
        c.add("d");

        // 对集合中的元素进行迭代（遍历）
        Iterator it = c.iterator(); // 获取迭代器
        /*
         * boolean b1 = it.hasNext(); // 判断集合中是否有元素
         * System.out.println(b1); //
         * Object obj1 = it.next(); // next方法获取相应元素，并且将指针向后移动一位
         * System.out.println(obj1);
         */

        while (it.hasNext()) {
            System.out.println(it.next());
        }
    }
}

迭代器的原理和源码解析

* A：迭代器原理
　　* 迭代器是对集合进行遍历，而每一个集合内部的存储结构都是不同的，所以没一个集合的存和取的方式都是不一样的
　　* 那么这就需要在每一个类中定义hasNext() 和 next() 方法，这样做可以但是会使集合体系过于臃肿
　　* 迭代器就是将这样的方法向上抽取出接口，然后在每个类的内部，定义自己的迭代方法
　　* 好处：1、规定了整个集合体系的遍历方式都是hasNext() 和next() 方法；2、代码由底层内部实现，使用者不用管怎么实现，会用即可

* B：迭代器源码分析
　　* 1、在eclipse 中ctrl + shift + t 找到ArrayList类
　　* 2、ctrl + o 查找 iterator() 方法
　　* 3、查看返回值类型是new Itr(), 说明Itr这个类实现 Iterator接口
　　* 4、查找 Itr这个内部类，发现重写了 Iterator中的所有抽象方法

    private class Itr implements Iterator<E> {
        int cursor;       // index of next element to return
        int lastRet = -1; // index of last element returned; -1 if no such
        int expectedModCount = modCount;

        // prevent creating a synthetic constructor
        Itr() {}

        public boolean hasNext() {
            return cursor != size;
        }

        @SuppressWarnings("unchecked")
        public E next() {
            checkForComodification();
            int i = cursor;
            if (i >= size)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i + 1;
            return (E) elementData[lastRet = i];
        }

        public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();

            try {
                ArrayList.this.remove(lastRet);
                cursor = lastRet;
                lastRet = -1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }

List集合的特有功能概述和测试

* A：List集合的特有功能概述

void add(int index, E element)
E remove(int index)
E get(int index)
E set(int index, E element)

package com.heima.list;

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

public class Demo1_List {
    public static void main(String[] args) {
        // demo1();    // 元素添加
        // demo2();    // 元素删除
        // demo3();    // remove 注意点
        // demo4();    // 通过索引获取元素
        // demo5(); // 指定元素修改
    }

    public static void demo5() {
        List list = new ArrayList();
        list.add(0, "a");
        list.add(0, "b");
        list.add(0, "c");
        list.add(0, "d");

        list.set(1, "z"); // 将指定位置的元素修改
        System.out.println(list);
    }

    public static void demo4() {
        List list = new ArrayList();
        list.add(0, "a");
        list.add(0, "b");
        list.add(0, "c");
        list.add(0, "d");

        // Object obj1 = list.get(0);
        // System.out.println(obj1);
        // 通过索引遍历List集合
        for (int i = 0; i < list.size(); i++) { // 用 size() 方法
            System.out.println(list.get(i));
        }
    }

    public static void demo3() {
        List list = new ArrayList();
        list.add(111);
        list.add(222);
        list.add(333);
        list.add(444);

        Object obj1 = list.remove(111); // 删除的时候不会自动装箱，111被当成索引，下标就越界了
        System.out.println(obj1);
    }

    public static void demo2() {
        List list = new ArrayList();
        list.add(0, "a");
        list.add(0, "b");
        list.add(0, "c");
        list.add(0, "d");

        Object obj1 = list.remove(0); // 通过索引删除元素，将被删除的元素返回
        System.out.println(obj1);
        System.out.println(list);
    }

    public static void demo1() {
        List list = new ArrayList(); // 多态，有弊端，不能访问子类的特有属性
        list.add("a");
        list.add("b");
        list.add(0, "c"); // index是元素添加后所在的位置
        list.add(0, "d");
        // list.add(5, "e"); // 注意索引越界异常，0<=index<=size
        System.out.println(list);
    }
}

List集合存储学生对象并遍历

* A：案例演示
　　* 通过size() 和get() 方法结合使用遍历

package com.heima.list;

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

import com.heima.bean.Student;

public class Demo2_List {

    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(new Student("张三", 23)); // 自动向上转型为Object
        list.add(new Student("李四", 24));
        list.add(new Student("王五", 25));
        list.add(new Student("赵六", 26));

        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i)); // 通过索引获取每一个元素
            Student stu = (Student) list.get(i);
            System.out.println(stu.getName() + "..." + stu.getAge());
        }
    }
}

并发修改异常

* A：案例演示
　　* 需求：如果有一个集合，判断集合内是否有 "world" 这个元素，如果有，就添加一个 "javaee" 元素

List list = new ArrayList();
list.add("a");
list.add("b");
list.add("world");
list.add("c");
list.add("d");
list.add("e");

ListIterator it = list.listIterator(); 
while (it.hasNext()) {
    Object object = it.next();
    System.out.println(object);
    if (object.equals("world")) {    
            list.add("javaee");    
        it.add("javaee");
    }    
            
}    

* B：ConcurrentModificationException出现
　　* 迭代器遍历，集合修改集合

* C：解决方案
　　* a：迭代器迭代元素，迭代器修改元素 (ListIterator的特有功能 add)
　　* b：集合遍历元素，集合修改元素

ListIterator lit = list.listIterator;　　// 如果向在遍历的过程中添加元素，可以用ListIterator中的add方法
while(lit.hasNext()) {
　　String str = (String)lit.next;
 　 if(str.equals("world")) {
    　　lit.add("javaee");
  　}        
}    

package com.heima.list;

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

public class Demo3_List {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("world");
        list.add("c");
        list.add("d");
        list.add("e");

        ListIterator it = list.listIterator(); // 获取迭代器
        while (it.hasNext()) { // 判断集合中是否有元素
            String object = (String) it.next();    // 向下转型
            if (object.equals("world")) {
                // list.add("javaee");    // 遍历的同时在增加元素,产生并发修改异常
                it.add("javaee");
            }
        }
        System.out.println(list);

    }
}

ListIterator

boolean hasNext()
boolean hasPrevious()

Object next()
Object previous()

package com.heima.list;

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

public class Demo4_ListIterator {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("world");
        list.add("c");
        list.add("d");
        list.add("e");

        ListIterator lit = list.listIterator(); // 获取迭代器
        while (lit.hasNext()) {
            System.out.println(lit.next()); // 获取元素，并将指针向后移动
        }
        
        System.out.println("-----------");

        while (lit.hasPrevious()) {
            System.out.println(lit.previous()); // 获取元素，并将指针向前移动
        }

    }
}

Vector的特有功能

* A：Vector类概述

* B：Vector类特有功能

public void addElements(E obj)
public E elementAt(int index)
public Enumeration elements()

* C：案例演示
　　* Vector迭代

package com.heima.list;

import java.util.Enumeration;
import java.util.Vector;

public class Demo5_Vector {

    public static void main(String[] args) {
        Vector v = new Vector();
        v.addElement("a");
        v.addElement("b");
        v.addElement("c");
        v.addElement("d");

        Enumeration en = v.elements(); // 获取枚举
        while (en.hasMoreElements()) { // 判断集合中是否有元素
            System.out.println(en.nextElement()); // 获取集合中的元素
        }
    }
}

数据结构之数组和链表

* A：数组
　　* 查询快，修改也快
　　* 增删慢

* B：链表
　　* 查询慢，修改野蛮
　　* 增删快

Node<E> node(int index) {
        // assert isElementIndex(index);

        if (index < (size >> 1)) {
            Node<E> x = first;
            for (int i = 0; i < index; i++)
                x = x.next;
            return x;
        } else {
            Node<E> x = last;
            for (int i = size - 1; i > index; i--)
                x = x.prev;
            return x;
        }
    }

List的三个子类的特点

* A：List的三个子类的特点

　　* ArrayList：
　　　　底层数据结构是数组，查询快，增删慢
　　　　线程不安全，效率高

　　* Vector：
　　　　底层数据结构是数组，查询快，增删慢
　　　　线程安全，效率低
　　　　Vector相对ArrayList查询慢（线程安全）
　　　　Vector相对LinkedList增删满（数据结构）

　　* LinkedList：
　　　　底层数据结构是链表，查询慢，增删快
　　　　线程不安全，效率高

　　* Vector和ArrayList的区别
　　　　Vector是线程安全的，效率低
　　　　ArrayList是线程不安全的，效率高
　　　　共同的：都是数组实现的

　　* ArrayList和LinkedList的区别
　　　　ArrayList底层是数组结构，查询和修改快
　　　　LinkedList底层是链表结构，查询慢修改快
　　　　共同的：都是线程不安全的

* List的三个儿子的使用
　　* 查询多  -> ArrayList
　　* 增删多  -> LinkedList
　　* 都多     -> ArrayList

　　* Vector一般只在面试的时候会问