Java基础视频教程第14天_集合之List、HashSet

一、集合框架——体系概述

为什么出现集合类？面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。数据多了用对象存，对象多了用集合存。数组是固定长度的，集合是可变长度的；数组只能存储同中类型的数据，集合可以存储不同类型的数据。数组和集合类同是容器，有何不同？数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。数组中可以存储基本数据类型和对象，集合只能存储对象。集合类的特点：集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。Collection 体系(集合框架)：Collection-List-ArrayList-LinkedList-Vector-Set-HashSet-TreeSet为什么会出现这么多的容器呢？因为每一个容器对数据的存储方式都有不同。这个存储方式称之为——数据结构。
二、集合框架——共性方法
java.util.Collectionpublic interface Collection<E> extends Iterable Collection -List: 元素是有序的，元素可以重复，因为该集合体系有索引。-ArrayList: 底层的数据结构使用的是数组结构，特点：查询速度很快，但是增删稍慢。线程不同步。-LinkedList: 底层使用的是链表数据结构，特点：增删速度很快，查询稍慢-Vector: 底层是数组数据结构。线程同步。被ArrayList替代。-Set: 元素是无序的(元素存入和取出的顺序不一致)，元素不可以重复。-HashSet: 底层数据结构是哈希表。-TreeSet: 底层数据结构是二叉树。注意：1、add方法的参数类型是 Object ,以便于接收任意类型对象；2、集合中存储的都是对象的引用(地址)；常见方法：ArrayList al = new ArrayList();//创建一个集合容器al.add("java01");//添加元素al.add("java02");al.size();//获取个数，集合长度sop(al);//打印的是元素al.remove("java02");//删除元素//返回结果是boolean类型al.clear();//清空集合al.contains("java01");//是否包含元素al.isEmpty();//是否为空取交集：ArrayList al1 = new ArrayList();ArrayList al2 = new ArrayList();al1.add("java01");al1.add("java02");al2.add("java01");al2.add("java03");al1.retainAll(al2);结果：al1=[java01];al2=[java01,java03];删除交集：ArrayList al1 = new ArrayList();ArrayList al2 = new ArrayList();al1.add("java01");al1.add("java02");al2.add("java01");al2.add("java03");al1.removeAll(al2);结果：al1=["java02"];al2=["java01","java03"];代码：
import java.util.*;class CollectionDemo1 {public static void main(String[] args) {base_method();method_2();}public static void base_method(){//创建一个集合容器。ArrayList al = new ArrayList();//添加元素。al.add("java01");al.add("java02");al.add("java03");al.add("java04");//获取个数，集合长度sop("size: "+al.size());//4//打印集合sop("原集合: "+al);//[java01, java02, java03, java04]//判断元素sop("java03是否存在: "+al.contains("java03"));//truesop("集合是否为空？"+al.isEmpty());//false//删除元素sop(al.remove("java02"));//truesop("删除后集合: "+al);//[java01, java03, java04]//清空集合al.clear();sop("清空后: "+al);//[]}public static void method_2(){ArrayList al1 = new ArrayList();al1.add("java01");al1.add("java02");al1.add("java03");al1.add("java04");ArrayList al2 = new ArrayList();al2.add("java05");al2.add("java06");al2.add("java03");al2.add("java04");//al1.retainAll(al2);//取交集，al1中只会保留和al2中相同的元素al1.removeAll(al2);//删除交集，al1中删除和al2相同的元素sop("al1: "+al1);sop("al2: "+al2);}public static void sop(Object obj){System.out.println(obj);}}

三、集合框架——迭代器 Iterator 
java.util.Iterator 
public interface Iterator<E> 

什么是迭代器？
其实就是集合的取出元素的方式。
用于获取元素。

代码：
import java.util.*;class CollectionDemo2 {public static void main(String[] args) {ArrayList al = new ArrayList();al.add("java01");al.add("java02");al.add("java03");al.add("java04");Iterator it = al.iterator();//获取迭代器，用于取出集合中的元素。while(it.hasNext())sop(it.next());/*优化内存for (Iterator it=al.iterator() ;it.hasNext() ; ){sop(it.next());}*/}public static void sop(Object obj){System.out.println(obj);}}

Iterator 接口只有hasNext();next();remove();三个方法。

因为每一种集合的取出方式不一致，就把取出方式定义在集合内部，这样取出方式就可以直接访问集合内部的元素。那么取出方式就被定义成了内部类。
而每一个容器的数据结构不同，所以取出的动作细节也不一样。但是都有共性内容——判断和取出，那么可以将共性内容抽取形成一个接口。该接口是 Iterator 。
如何获取集合的取出对象呢？
集合通过一个对外提供的方法——iterator() 来获取该接口。
这就是内部类的设计在 Iterator 中的体现。

四、集合框架—— List 集合共性方法
List 集合的特有方法:
凡是可以操作角标的方法都是该体系特有的方法。

增: 在指定位置插入元素
void add(index, element);
boolean addAll(index, Collection);

删:
E remove(index);//返回的是该元素

改:
E set(index, element);

查:
E get(index);
List<E> subList(from, to);
ListIterator<E> listIterator();
int indexOf(Object obj);

代码：
import java.util.*;class ListDemo {public static void main(String[] args) {ArrayList al = new ArrayList();al.add("java01");al.add("java02");al.add("java03");sop("原集合: "+al);//原集合: [java01, java02, java03]//在指定位置添加元素，即插入al.add(1,"java09");sop("添加后集合: "+al);//添加后集合: [java01, java09, java02, java03]//删除指定位置元素sop(al.remove(2));//java02sop("删除后集合: "+al);//删除后集合: [java01, java09, java03]//修改元素al.set(2,"java007");sop("修改后集合: "+al);//修改后集合: [java01, java09, java007]//通过角标获取元素sop("al.get(1) : "+al.get(1));//al.get(1) : java09//通过for循环方式获取所有元素for (int x=0 ;x<al.size() ;x++ ){sop("al("+x+") : "+al.get(x));}//通过迭代器的方式获取所有元素Iterator it = al.iterator();while (it.hasNext()){sop("next() : "+it.next());}//通过indexOf获取对象的位置sop("index="+al.indexOf("java007"));//index=2List sub = al.subList(1,3);sop("sub="+sub);//sub=[java09, java007]}public static void sop(Object obj){System.out.println(obj);}}

五、集合框架—— ListIterator 
java.util.ListIterator 
public interface ListIterator<E> extends Iterator<E> 

List 集合特有的迭代器, ListIterator 是 Iterator 的子接口。

代码一：
class IteratorDemo{public static void main(String[] args){ArrayList al = new ArrayList();al.add("java01");al.add("java02");al.add("java03");Iterator it = al.iterator();while (it.hasNext()){Object obj = it.next();if(obj.equals("java02"))al.add();//ConcurrentModificationException//it.remove();//运行OKSystem.out.println(obj);}}}

在迭代时，不可以通过集合对象的方法操作集合中的元素。因为会发生 ConcurrentModificationException 异常。
所以，在迭代时，只能用迭代器的方法操作元素。可是 Iterator 方法是有限的，只能对元素进行判断、取出、删除的操作；如果想要其他的操作，如添加、修改等，就需要使用其子接口: ListIterator , 该接口只能通过 List 集合的 listIterator() 方法获取。

代码二：
import java.util.*;class ListDemo {public static void main(String[] args) {//演示列表迭代器ArrayList al = new ArrayList();al.add("java01");al.add("java02");al.add("java03");System.out.println(al);ListIterator li = al.listIterator();while (li.hasNext()){Object obj = li.next();if (obj.equals("java02")){//li.set("java006");li.add("java009");}}System.out.println(al);}}

hasPrevious(); previous(); 可用于反向遍历；(不常用) 

六、集合框架—— List 集合具体对象的特点
Collection
-List
-ArrayList 数组数据结构，线程不同步
-LinkedList 链表结构
-Vector数组数据结构，线程同步，被ArrayList替代。

ArrayList 长度可变原理：
ArrayList 默认长度为10，当元素超过10时, ArrayList 会new一个新的数组，该数组延长50%；然后把原来的元素copy到该数组，再把新元素添加到该数组中。 

Vector 是100%延长。

七、集合框架—— Vector 中的枚举
Vector 和 ArrayList 功能是一致的。

其特有方法：
elements()方法返回一个枚举 Enumeration 。

枚举是 Vector 特有的取出方式，其实枚举和迭代器是一样的。
因为枚举的名称以及方法的名称都过长，所以被迭代器取代了。

示例代码：
import java.util.*;class VectorDemo{public static void main(String[] args) {Vector v = new Vector();v.add("java01");v.add("java02");v.add("java03");v.add("java04");Enumeration en = v.elements();while (en.hasMoreElements()){System.out.println(en.nextElement());}}}

八、集合框架—— LinkedList 
Collection
-List
-LinkedList: 链表结构
特有方法：
add();
addFirst();
addLast();
offer();
offerFirst();
offerLast();

get(int index);
getFirst();
getLast();
获取元素；如果列表为空，抛出 NoSuchElementException 。
peek();
peekFirst();
peekLast();
获取元素；而且当列表为空时，不会抛出异常，而是返回null。

remove(int index/Object o);
removeFirst();
removeLast();
获取元素，并删除元素；如果列表为空，抛出 NoSuchElementException 。
poll();
pollFirst();
pollLast();
获取元素，并删除元素；而且当列表为空时，不会抛出异常，而是返回null。

代码：
import java.util.*;class LinkedListDemo{public static void main(String[] args){LinkedList link = new LinkedList();link.addFirst("java01");link.addFirst("java02");link.addFirst("java03");System.out.println(link);//结果[java03,02,01]//不用迭代器的取出方式：while (!(link.isEmpty())){System.out.println(link.remove());//删除第一个元素//removeFirst();//removeLast();//poll();}}}

九、集合框架—— LinkedList 练习
使用 LinkedList 模拟一个堆栈或者队列数据结构。
堆栈：先进后出
队列：先进先出 First in First out FIFO 

代码：
import java.util.*;class LinkedListTest {public static void main(String[] args) {DuiLie dl = new DuiLie();dl.myAdd("java01");dl.myAdd("java02");dl.myAdd("java03");while(!dl.isNull())System.out.println(dl.myGet());}}class DuiLie  {private LinkedList link;DuiLie(){link = new LinkedList();}public void myAdd(Object obj){link.addFirst(obj);}public Object myGet(){return link.removeLast();//改为removeFirst(),就是堆栈结构。}public boolean isNull(){return link.isEmpty();}}

十、集合框架—— ArrayList 练习 
需求：
取出 ArrayList 集合中的重复元素。
思路:
1、创建一个新的ArrayList集合，用于存储原集合中不重复的元素；
2、迭代原集合，并在迭代过程中判断新集合中是否包含迭代出的元素；
3、如果新集合不包含该元素，则将该元素存入新集合；
4、迭代完毕，返回新的集合。

代码：
import java.util.*;class ArrayListTest {public static void main(String[] args) {ArrayList al = new ArrayList();al.add("java01");al.add("java02");al.add("java01");al.add("java03");al.add("java01");al.add("java02");al = singleElement(al);System.out.println(al);}public static ArrayList singleElement(ArrayList al){//定义一个临时容器ArrayList newAl = new ArrayList();Iterator it = al.iterator();while (it.hasNext()){Object obj = it.next();if(!newAl.contains(obj))newAl.add(obj);}return newAl;}}

注意：在迭代时，next调用一次，就要hasNext调用一次。

十一、集合框架 —— ArrayList 练习2
需求：
将自定义对象作为元素存到 ArrayList 集合中，并去除重复元素。比如：存人对象，同姓名同年龄，视为同一个人，为重复元素。

思路：
1、对人描述，将数据封装进人对象；
2、定义容器，将人存入；
3、取出。

注意: 
List 集合contains()方法判断元素是否相同，调用的是元素的equals方法。 
remove(Object o),底层调用的也是equals方法。

定义一个对象时，如果该对象要放到 ArrayList 集合中，则该对象需要复写 Object 中的equals方法，自定义equals的比较方式。

代码：
import java.util.*;class ArrayListTest2 {public static void main(String[] args) {ArrayList al = new ArrayList();al.add(new Person("lisi01",30));al.add(new Person("lisi02",33));al.add(new Person("lisi03",34));al.add(new Person("lisi04",35));al.add(new Person("lisi03",34));al.add(new Person("lisi04",35));al = singleElement(al);Iterator it = al.iterator();while (it.hasNext()){Object obj = it.next();Person p = (Person)obj;System.out.println(p.getName()+"::"+p.getAge());}}public static ArrayList singleElement(ArrayList al){ArrayList newAl = new ArrayList();Iterator it = al.iterator();while (it.hasNext()){Object obj = it.next();if(!(newAl.contains(obj)))newAl.add(obj);}return newAl;}}class Person{private String name;private int age;Person(String name, int age){this.name = name;this.age = age;}public String getName(){return name;}public int getAge(){return age;}public boolean equals(Object obj){if(!(obj instanceof Person))return false;Person p = (Person)obj;System.out.println(this.name+"..."+p.name);return this.name.equals(p.name) && this.age == p.age;}}

十二、集合框架 —— HashSet 
-Set: 元素是无序的(元素存入和取出的顺序不一致)，元素不可以重复。
-HashSet: 底层数据结构是哈希表。
-TreeSet: 底层数据结构是二叉树。

Set 集合的功能和 Collection 的功能是一致的。

HashSet 集合中元素存储顺序是按照哈希值来存储。
当元素的哈希值不相同时，每一个元素都有自己的位置；
当两个元素的哈希值相同时，则判断两个元素是否是同一个对象，如果不是同一个对象，则会在前一个元素位置上顺延，用来存放另一个元素，两个元素的地址值相同。

add() 方法返回值类型是 boolean 类型，添加成功，结果是 true ; 添加失败，结果是 false 。

代码：
import java.util.*;class HashSetDemo{public static void main(String[] args){HashSet hs = new HashSet();hs.add("java01");hs.add("java02");System.out.println(hs.add("java03"));//trueSystem.out.println(hs.add("java03"));//false 添加失败System.out.println(hs);//[java02, java03, java01]}}

十三、集合框架 —— HashSet 存储自定义对象
HashSet 是如何保证元素的唯一性的呢？
是通过元素的两个方法，hashCode和equals来完成的。
如果元素的hashCode值相同，才会判断equals是否为true；
如果hashCode值不同，不会调用equals.

在自定义对象时，通常复写hashCode方法和equals方法。因为这个对象有可能放到 HashSet 集合中。

注意：比较对象是否相同，调用的是equals方法。

代码：
import java.util.*;class HashSetTest1{public static void main(String[] args) {HashSet hs = new HashSet();hs.add(new Person("a1",11));hs.add(new Person("a2",12));hs.add(new Person("a3",13));hs.add(new Person("a3",13));Iterator it = hs.iterator();while (it.hasNext()){Object obj = it.next();Person p = (Person)obj;System.out.println(p.getName()+"..."+p.getAge());}}}class Person{private String name;private int age;Person(String name, int age){this.name = name;this.age = age;}public int hashCode(){System.out.println(name+"..hashCode...");//return 60;return name.hashCode()+age*37;}public boolean equals(Object obj){if(!(obj instanceof Person))return false;Person p = (Person)obj;System.out.println(this.name+"...equals.."+p.name);return this.name.equals(p.name) && this.age == age;}public String getName(){return name;}public int getAge(){return age;}}

十四、集合框架 —— HashSet 判断和删除的依据 
对于判断元素是否存在 contains() ，以及删除 remove() 等操作，依赖的方法是hashCode和equals