Java基础—集合框架（一）

集合框架（一）

一、概述

1. 1.集合出现的原因
   
   1. Java中，数据被封装成对象；对象完成了对数据的存储。而集合的出现，完成了对对象的存储，方便对对象进行操作。

1. 2.集合与数组的区别
   
   1. 1）数组虽然可以存储对象，但是长度固定，不利于后期扩展；只能存储同一类型对象；
      2）集合的长度是可变的；并且能存储不同类型对象

1. 3.集合的特点
   
   1. 1）长度可变；
      2）可以存储不同类型的对象；
      3）集合只用于存储对象，不能存储基本数据类型

二、Collection

1. 1.定义
   
   1. Collection是集合框架层次结构中的根接口。 Collection提供了具体的自接口（如 Set和 List）实现。这个根接口用来传递 collection，并提供共性方法，操作这些 collection。

1. 2.共性方法
   
   1. 1）添加操作

-boolean add(E e)：添加指定元素到集合中
-boolean addAll(Collection<？ extends E> c)：添加指定集合中的所有元素到当前集合中

1. 1. 2）判断操作

-boolean contains(Object o)：判断当前集合中是否包含指定元素
-booean isEmpty()：判断当前集合是否为空

1. 1. 3）删除操作

-void clear()：清空当前集合
-boolean remove(Object o)：移除指定元素
-boolean removeAll(Collection<？> c)：指定一个集合，将该集合中的元素从当前集合中移除

1. 1. 4）获取操作

-int size()：获取当前集合长度
-booean retianAll(Collection<？> c)：取当前集合与指定集合的交集
-Iterator iterator()：迭代器，用于取出集合中元素

1. 3.共性方法演示
   
   1. 演示 Collection中的共性方法。

示例代码：

package com.heisejiuhuche.Collection;

import java.util.ArrayList;

public class CollectionDemo {
    public static void main(String[] args) {
        method1();
        method2();
    }

    private static void  method2() {
        ArrayList al = new ArrayList();
        al.add("java01");
        al.add("java02");
        al.add("java03");
        al.add("java04");
        ArrayList a2 = new ArrayList();
        a2.add("java03");
        a2.add("java04");
        a2.add("java05");
        a2.add("java06");
        //取交集
        al.retainAll(a2);
        print(al);
    }

    private static void method1() {
        ArrayList al = new ArrayList();
        //添加操作
        al.add("java01");
        al.add("java02");
        al.add("java03");
        al.add("java04");

        //打印集合，结果为[java01, java02, java03, java04]
        print(al);
        //删除
        al.remove("java03");
        print(al);
        //是否包含指定对象
        print(al.contains("java-2"));
        //是否为空
        print(al.isEmpty());
        //清楚所有对象
        al.clear();
        print(al);
        print(al.size());
    }

    private static void print(Object obj) {
        System.out.println(obj);
    }
}

注意：
-add()方法的参数类型是Object，以便于接受任意类型对象；
-集合中存放的不是对象实体，存储的是对象内存地址

三、迭代器

1. 1.定义
   
   1. 迭代器是对 Iterator接口的实现，用于取出集合中的对象，以便于对对象进行操作。

容器的取出操作，不足以用一个方法描述。每个容器的取出操作过程，都有所不同。因此，容器将取出操作封装成一个对象，对象中提供了多个功能以实现容器对象的取出操作。 每个容器类的内部，都定义了做取出操作的内部类（便于直接访问容器内部的元素），用于取出各容器不同数据结构中的对象。这个取出操作被称为迭代器。无论是什么容器，其迭代器的操作都会有判断和取出的操作，将这些操作提取之后形成了Iterator接口。每个容器通过调用iterator()方法，获得自身的迭代器。

1. 2.迭代器的使用
   
   1. iterator()方法返回的是一个Iterator接口的子类对象
      1）获取 iterator迭代器： Iterator it = arraylist.iterator();
      2）调用 next()方法获取第一个元素并打印： System.out.println(it.next());
      3）调用 hasNext()方法，循环取出所有元素

for(Iterator it = arraylist.iterator();it.hasNext();) {
    System.out.println(it.next());
}

四、List

1. 1.List集合的特点
   
   1. List集合中的元素是有序的，并可以重复。该集合体系有索引。

1. 2.List集合特有方法
   
   1. 凡是操作索引的方法都是该体系特有的方法。
      1）添加操作

-void add(int index, E element)：添加指定元素
-boolean addAll(int index, Collection<？ extends E> c)：在指定位置插入指定collection中的元素

1. 1. 2）获取操作

-get(int index)：返回集合中指定位置元素
-int indexOf(Object o)：获取元素的索引，不存在返回-1
-int lastIndexOf(Object o)：反向索引
-ListIterator listIterator()：List集合特有迭代器
-List subList(int fromIndex, int toIndex)：返回子集合

1. 1. 3）删除操作

-remove(int index)：按索引移除元素

1. 1. 4）修改操作

-set(int index, E element)：用指定元素替换指定位置的元素

1. 3.特有方法演示

示例代码：

package com.heisejiuhuche.Collection;

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

public class ListDemo {
    public static void main(String[] args) {
        ArrayList arr = new ArrayList();

        arr.add("java01");
        arr.add("java02");
        arr.add("java03");
        arr.add(1, "java04");

    ArrayList arr2 = new ArrayList();

        arr2.add("java05");
        arr2.add("java06");
        arr2.add("java07");

        arr.addAll(3, arr2);

        arr.remove(0);
        arr.set(1, "java10");
        System.out.println(arr.get(0));
        System.out.println(arr.indexOf("java07"));
        System.out.println(arr.lastIndexOf("java01"));

        for(Iterator it = arr.iterator(); it.hasNext(); ) {
            System.out.println(it.next());
        }

        List list = arr.subList(1, 5);

        for(Iterator it = list.iterator(); it.hasNext();) {
            System.out.println("---" + it.next());
        }
    }
}

1. 3.ListIterator列表迭代器
   
   1. 1）定义
      
      1. List集合特有迭代器， ListIterator，是 Iterator的子接口。迭代器和集合不能对同一组元素进行两种不同的操作（取和增），会发生 ConcurrentModificationException异常；因此，在迭代时，只能用迭代器的方法操作元素。但是Iterator的方法是有限的，只有判断，取出和删除操作。如果需要添加或者修改的操作，就需要使用 ListIterator。该接口只能通过 List集合的 listIterator()方法获取。

1. 1. 2）列表迭代器特有方法

-void add(E e)：添加指定元素
-set(E e)：修改指定元素
-boolean hasPrevious()：指针位之前有没有元素

五、List子类对象

1. 1.List子类对象组成

• List
  
  • ArrayList
  • LinkedList
  • Vector

1. List子类对象包括 ArrayList， LinkedList和 Vector。

1. 2.List子类对象的特点
   
   1. 1）ArrayList
      ArrayList底层数据结构使用的是数组结构；特点在于查询速度块，但是增加删除操作速度较慢

1. 1. 2）LinkedList
      LinkedList底层数据结构使用的是链表结构；特点在于增加删除操作较快，查询速度较慢

1. 1. 3）Vector
      Vector底层数据结构使用的是数组结构； Vector是最早的容器，其特点在与， Vector是线程同步的

1. 3.Vector中的枚举
   
   1. 枚举（ Enumeration）是 Vector的迭代器，是其特有的取出元素方式。枚举和迭代是一样的，选用迭代的原因是，枚举的代码过长。

示例代码：

package com.heisejiuhuche.Collection;

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

public class VectorDemo {
    public static void main(String[] args) {
        //创建Vector对象
        Vector v = new Vector();
        //添加元素
        v.add("java01");
        v.add("java02");
        v.add("java03");
        v.add("java04");

        //使用枚举遍历元素
        for(Enumeration e = v.elements();e.hasMoreElements();) {
            System.out.println(e.nextElement());
        }
    }
}

程度输出结果：

java01
java02
java03
java04

1. 4.LinkedList
   
   1. 1）LinkedList中的特有方法

JDK6.0之前方法：

-void addFirst(E e)：将指定元素插入链表开头
-void addLast(E e)：将指定元素插入链表结尾
-getFirst()：获取第一个元素
-getLast()：获取最后一个元素
-removeFirst()：移除第一个元素，并获取该元素，如果元素不存在，抛出NoSuchElementException
-removeLast()：移除最后一个元素，并获取该元素，如果元素不存在，抛出NoSuchElementException

JDK6.0之后新方法：

-E pollFirst():移除第一个元素，并获取该元素，如果元素不存在，返回null
-E pollLast():移除最后一个元素，并获取该元素，如果元素不存在，返回null
-offerFirst():将指定元素插入链表开头
-offerLast():将指定元素插入链表结尾

1. 1. 2）LinkedList练习
      
      1. 使用 LinkedList模拟堆栈或队列数据结构
         堆栈数据结构：先进后出；如同一个桶
         队列数据结构：先进先出（ FIFO）如果水管

队列数据结构示例代码：

package com.heisejiuhuche.Collection;

import java.util.LinkedList;

public class LinkedListTest {
    public static void main(String[] args) {
        MyList ml = new MyList();
        ml.myAdd("java01");
        ml.myAdd("java02");
        ml.myAdd("java03");
        ml.myAdd("java04");

        for(;!ml.myEmpty();) {
            System.out.println(ml.myGet());
        }
    }
}

class MyList {
    private LinkedList list;

    /*
     * 初始化MyList
     */
    MyList() {
        list = new LinkedList();
    }

    /*
     * 声明MyList添加方法，添加到MyList头部
     */
    public void myAdd(Object obj) {
        list.offerFirst(obj);
    }

    /*
     * 声明MyList获取方法，获取MyList尾部元素
     */
    public Object myGet() {
        return list.pollLast();
    }

    /*
     * 声明判断MyList是否为空的方法
     */
    public boolean myEmpty() {
        return list.isEmpty();
    }
}

程序输出结果：

java01
java02
java03
java04

堆栈数据结构，只需修改如下代码：

/*
 * 声明MyList获取方法，获取MyList头部元素
 */
public Object myGet() {
    return list.pollFirst();
}

程序运行结果：

java04
java03
java02
java01

1. 5.ArrayList练习
   
   1. 1）练习1
      
      1. 去除 ArrayList中的重复元素

示例代码：

package com.heisejiuhuche.Collection;

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

public class ArrayListTest {
    public static void main(String[] args) {
        ArrayList arrList = new ArrayList();

        arrList.add("java01");
        arrList.add("java01");
        arrList.add("java02");
        arrList.add("java02");
        arrList.add("java03");
        arrList.add("java01");
        arrList.add("java03");
        arrList.add("java04");

        System.out.println("原列表： " + arrList);
        arrList = singleElement(arrList);
        System.out.println("新列表： " + arrList);
    }

    private static ArrayList singleElement(ArrayList list) {
        ArrayList arrList = new ArrayList();

        /* 遍历ArrayList，如果新的容器中没有旧容器中的元素，就将这个元素添加到新容器 */
        for(Iterator it = list.iterator(); it.hasNext(); ) {
            Object obj = it.next();
            if(!arrList.contains(obj)) {
                arrList.add(obj);
            }
        }
        /* 返回新容器 */
        return arrList;
    }
}

程序输出结果：

原列表： [java01, java01, java02, java02, java03, java01, java03, java04]
新列表： [java01, java02, java03, java04]

1. 1. 2）练习2
      
      1. 将自定义元素添加到 ArrayList集合中，并去除重复元素。例如，存人对象；同姓名同年龄，视为重复元素。

示例代码：

package com.heisejiuhuche.Collection;

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

public class ArrayListTest2 {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();

        arrayList.add(new Person("lisi01", 30));
        arrayList.add(new Person("lisi02", 31));
        arrayList.add(new Person("lisi01", 30));
        arrayList.add(new Person("lisi03", 36));
        arrayList.add(new Person("lisi03", 36));
        arrayList.add(new Person("lisi02", 31));
        arrayList.add(new Person("lisi04", 31));

        arrayList = singleElement(arrayList);

        for(Iterator it = arrayList.iterator(); it.hasNext(); ) {
            /*
             * 将obj向下转型成Person类型
             */
            Person p = (Person)it.next();
            System.out.println(p.getName() + "..." + p.getAge());
        }
    }

    private static ArrayList singleElement(ArrayList list) {
        ArrayList arrList = new ArrayList();

        for(Iterator it = list.iterator(); it.hasNext(); ) {
            Object obj = it.next();
            if(!arrList.contains(obj)) {
                arrList.add(obj);
            }
        }
        return arrList;
    }
}

/*
 * 声明Person类，以加入ArrayList
 */
class Person {
    private String name;
    private int age;

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return this.name;
    }

    public int getAge() {
        return this.age;
    }

    /* 复写Object类中的equals方法，判断年龄和姓名相等，就是同一对象 */
    /* 列表的contains方法会调用equals()方法进行比较 */
    public boolean equals(Object obj) {
        if(!(obj instanceof Person)) {
            return false;
        }
        Person p = (Person)obj;
        return (this.name.equals(p.name)) && (this.age == p.age);
    }
}

程序输出结果：

lisi01...30
lisi02...31
lisi03...36
lisi04...31

结论：
-List集合判断元素是否相同，依据的是元素的equals()方法；
-List集合删除元素的时候，依据的是原色的equals()方法判断List中是否有该元素

六、HashSet

1. 1.Set集合的特点
   
   1. Set集合的元素是无序的，指的是存入和取出的顺序不一定以致，并且元素不可以重复。

1. 2.Set集合常见子类对象特点

• Set
  
  • HashSet
  • TreeSet

1. 1. 1）HashSet
      
      1. HashSet底层数据结构是哈希表

1. 1. 2）TreeSet
      
      1. TreeSet底层数据结构是二叉树

1. 3.HashSet使用

示例代码：

package com.heisejiuhuche.Collection;

import java.util.HashSet;
import java.util.Iterator;

public class HashSetDemo {
    public static void main(String[] args) {
        /*
         * 创建HashSet对象
         */
        HashSet hs = new HashSet();
        /*
         * 添加元素
         */
        hs.add("java01");
        hs.add("java02");
        hs.add("java02");
        hs.add("java03");
        hs.add("java04");
        hs.add("java04");
        hs.add("java05");

        /*
         * 打印所有元素
         */
        for(Iterator it = hs.iterator(); it.hasNext(); ) {
            System.out.println(it.next());
        }
    }
}

程序运行结果：

java05
java04
java03
java02
java01

高能：
-HashSet集合在存储对象的时候，为保证元素的唯一性，是以对象的哈希值为标准进行判断；如果哈希值不同，则直接进行存储；如果哈希值相同，HashSet集合则启动第二套比较机制，用两个对象equals()方法，对两个对象的属性进行比较，如果此时比较结果不同，则进行存储，相同，则不存储；
-开发时，如果要讲对象存入HashSet，一定要复写hashCode()和equals()方法，以确保对象唯一性

以存储Person类为例，要确保存储的Person对象的唯一性，要复写hashCode()和equals()方法；Person类代码如下：

class Person {
    private String name;
    private int age;

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return this.name;
    }

    public int getAge() {
        return this.age;
    }

    /*
     * 复写hashCode()方法，以姓名和年龄为依据，计算Person对象的哈希值，并确保唯一
     */
    public int hashCode() {
        return name.hashCode() + age * 37;
    }

    /* 复写Object类中的equals方法，判断年龄和姓名相等，就是同一对象 */
    public boolean equals(Object obj) {
        if(!(obj instanceof Person)) {
            return false;
        }
        Person p = (Person)obj;
        return (this.name.equals(p.name)) && (this.age == p.age);
    }
}

程序输出结果：

lisi01....20
lisi03....21
lisi02....22

注意：
HashSet在进行判断元素是否存在和删除元素操作的时候，同样依据的是hashCode()方法和equals()方法来保证元素的唯一性