黑马程序员--集合框架：List、Set和Map体系

------- Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

1、为什么出现集合类？

面向对象对事物的体现都是以对象的形式，为了方便对多个对象的操作，就对对象进行存储。

集合就是存储对象最常用的一种方式.

2、数组和集合都是容器，两者有何不同？

数组长度固定，而集合长度是可变的

数组值可以存储对象，还可以存储基本数据类型;而集合只能存储对象

数组存储数据类型是固定的，而集合存储的数据类型不固定

3、集合类的特点：

集合只能存储对象

集合的长度是可变的

集合可以存储不同类型的对象

4、常用集合类之间的层次、继承关系

Collection
|--List：元素是有序的，元素可以重复。因为飞机和体系有索引。
|--ArrayList：底层的数据结构使用的是数组结构。特点：查询速度快，但是增删稍慢。
|--LinkedList：底层使用的是链表数据结构。特点：增删速度很快，查询稍慢。
|--Vector：底层是数组结构，线程同步，被ArrayList替代了，因为效率低。
|--Set：元素是无序的（存入和取出的顺序不一定一致），元素不可以重复。
|--HashSet：底层数据结构是哈希表HashSet通过hashCode和equals判断元素是否重复。如果元素的hashCode值相同，才会判断equals是否为true。如果元素的hashCode值不同，不会调用equals。对于判断元素是否存在，以及删除等操作依赖的方法是元素的hashCode和equals方法。
|--TreeSet：可以对Set集合中的元素进行排序，底层数据结构是二叉树。它保证元素唯一性的依据是compareTo方法的return。TreeSet允许自定义排序方式：当元素自身不具备比较性时，或者具备的比较性不是所需的，这是就需要让集合自身具备比较性，在集合初始化时就让其具有比较性方式。
|--Map：用于保存具有映射关系的数据。

|--HashTable：底层是哈希表数据结构允许使用null键和null值；线程不同步，效率高；保证元素唯一性的:原理：先判断元素的hashCode值是否相同，再判断两元素的equals方法是否为true

|--HashMap：底层数据结构是哈希表。HashMap通过hashCode和equals判断元素是否重复。如果元素的hashCode值相同，才会判断equals是否为true。如果元素的hashCode值不同，不会调用equals。

|--TreeMap：可以对Map集合中的元素进行排序，底层数据结构是二叉树。它保证唯一性的依据是compareTo方法的return。TreeSet允许自定义排序方式：当元素自身不具备比较性时，或者具备的比较性不是所需的，这是就需要让集合自身具备比较性，在集合初始化时就让其具有比较性。

List:

特有方法，凡是可以操作角标的方法都是该体系特有的方法

增

add(intindex,Eelement);

addAll(index,Collection);

删

remove(index);

改

set(index,element);

查

get(index);

subList(form,to);

listIterator();

List集合特有的迭代器:ListIterator是Iterator的子接口在迭代时，不可以通过集合对象的方法操作集合中的元素

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

import java.util.*;/* 1.add方法的参数类型是Object，以便于接受任意类型对象 2.方法中存储的都是对象的引用或者地址 什么是迭代器呢？ 其实就是集合的取出元素的方式 */class CollectionDemo {public static void main(String[] args) {// method_2();// base_method();get_method();}public static void sop(Object obj) {System.out.println(obj);}public static void base_method() {// 创建一个集合容器，使用Collection接口的子类：ArrayListArrayList al = new ArrayList();// 1,添加元素al.add("java01");// add()参数类型是Object类型的，因为可以是任意对象al.add("java02");al.add("java03");al.add(4);sop("原集合：" + al);// 2.获取个数，集合长度size();sop("size=" + al.size());// 3.删除元素al.remove("java02");sop("改变后的集合：" + al);al.clear();// 清空集合sop(al);// 4.判断集合是否为空sop("判断元素是否存在" + al.contains("java01"));sop("判断集合是否为空" + al.isEmpty());}public static void method_2() {ArrayList al1 = new ArrayList();al1.add("java01");// add()参数类型是Object类型的，因为可以是任意对象al1.add("java02");al1.add("java03");ArrayList al2 = new ArrayList();al2.add("java05");// add()参数类型是Object类型的，因为可以是任意对象al2.add("java06");al2.add("java04");al2.retainAll(al1);// 取交集，al1中只会保留和al2中相同的元素sop("al1:" + al1);sop("al2:" + al2);}public static void get_method() {ArrayList al = new ArrayList();al.add("java01");al.add("java02");al.add("java03");al.add(4);/* * Iterator it = al.iterator();//返回的是Iterator接口类型的对象，Iterator是一个集合的内部类 * while (it.hasNext()) { sop(it.next()); } */for (Iterator it = al.iterator(); it.hasNext();)// 这样写不用在迭代结束后还保留it对象，因为it是for循环的一个内部变量，便于内存管理{sop(it.next());}}}

import java.util.*;class ListDemo {public static void main(String[] args) {// method();// 演示列表迭代器ArrayList al = new ArrayList();// 添加元素al.add("java01");al.add("java02");al.add("java03");al.add(4);sop("原集合是：" + al);ListIterator li = al.listIterator();while (li.hasNext()) {Object obj = li.next();if (obj.equals("java02"))li.set("java006");if (obj.equals("java03"))li.add("new");sop("obj=" + obj);}sop(li.hasNext());sop(li.hasPrevious());sop("改变后的集合：" + al);// 在迭代过程中，准备添加或者删除元素/* * Iterator it = al.iterator(); while (it.hasNext()) { Object obj = * it.next(); if (obj.equals("java02")) * //al.add("java008");//这步操作可能会引起并发访问异常，因为al有两种操作方式，容易产生安全隐患 * it.remove(); * sop("obj="+obj);//迭代过程中即使删除的元素也会被obj引用，所以也能打印出来，而且Iterator只有三个方法，有局限性 * } */}public static void method() {ArrayList al = new ArrayList();// 添加元素al.add("java01");al.add("java02");al.add("java03");al.add(4);sop("原集合是：" + al);// 在指定位置添加元素al.add(1, "java09");// 删除指定位置的元素// all.remove(2);// 修改元素al.set(2, "java007");// 通过角标获取元素// sop("get(1):"+al.get(1));// sop(al);// 获取所有元素for (int x = 0; x < al.size(); x++) {sop("al(" + x + ")=" + al.get(x));}Iterator it = al.iterator();while (it.hasNext()) {sop(it.next());}// 通过indexOf获取对象的位置sop("index=" + al.indexOf("java09"));List sub = al.subList(1, 4);sop("sub=" + sub);}public static void sop(Object obj) {System.out.println(obj);}}

import java.util.*;class ListDemo {public static void main(String[] args) {// method();// 演示列表迭代器ArrayList al = new ArrayList();// 添加元素al.add("java01");al.add("java02");al.add("java03");al.add(4);sop("原集合是：" + al);ListIterator li = al.listIterator();while (li.hasNext()) {Object obj = li.next();if (obj.equals("java02"))li.set("java006");if (obj.equals("java03"))li.add("new");sop("obj=" + obj);}sop(li.hasNext());sop(li.hasPrevious());sop("改变后的集合：" + al);// 在迭代过程中，准备添加或者删除元素/* * Iterator it = al.iterator(); while (it.hasNext()) { Object obj = * it.next(); if (obj.equals("java02")) * //al.add("java008");//这步操作可能会引起并发访问异常，因为al有两种操作方式，容易产生安全隐患 * it.remove(); * sop("obj="+obj);//迭代过程中即使删除的元素也会被obj引用，所以也能打印出来，而且Iterator只有三个方法，有局限性 * } */}public static void method() {ArrayList al = new ArrayList();// 添加元素al.add("java01");al.add("java02");al.add("java03");al.add(4);sop("原集合是：" + al);// 在指定位置添加元素al.add(1, "java09");// 删除指定位置的元素// all.remove(2);// 修改元素al.set(2, "java007");// 通过角标获取元素// sop("get(1):"+al.get(1));// sop(al);// 获取所有元素for (int x = 0; x < al.size(); x++) {sop("al(" + x + ")=" + al.get(x));}Iterator it = al.iterator();while (it.hasNext()) {sop(it.next());}// 通过indexOf获取对象的位置sop("index=" + al.indexOf("java09"));List sub = al.subList(1, 4);sop("sub=" + sub);}public static void sop(Object obj) {System.out.println(obj);}}

Set:无序，不可以重复元素

--HashSet：数据结构是哈希表，线程是非同步的

保证元素唯一性的原理，判断元素的hashCode值是否相同

如果相同，还会继续判断元素的equals方法，是否为true

--TreeSet：可以对Set集合中的元素进行排序

底层数据结构是二叉树

1，保证元素唯一性的依据compareTo方法return()。

2，当元素不具备比较性时，或者具备的比较性不是所需要的

这时就需要让集合自身具备比较性

在集合初始化时，就有了比较方式

需求；

往TreeSet集合中存储自定义对象学生

想按照学生的年龄进行排序

记住：排序时，当主要条件相同时，一定判断次要条件

import java.util.*;class TreeSetDemo {public static void main(String[] args) {TreeSet ts = new TreeSet();ts.add(new Student("lisi02", 22));ts.add(new Student("lisi007", 20));ts.add(new Student("lisi09", 19));ts.add(new Student("lisi08", 19));Iterator it = ts.iterator();while (it.hasNext()) {Student stu = (Student) it.next();System.out.println(stu.getName() + "::" + stu.getAge());}}}class Student implements Comparable// 该接口强制让学生具备比较性{private String name;private int age;Student(String name, int age) {this.name = name;this.age = age;}public int compareTo(Object obj) {if (!(obj instanceof Student))throw new RuntimeException("不是学生对象");Student s = (Student) obj;System.out.println(this.name + "::compare to::" + s.name);if (this.age > s.age)return 1;if (this.age == s.age) {return this.name.compareTo(s.name);}return -1;}public String getName() {return name;}public int getAge() {return age;}}

Map集合：

1.添加

put(Kkey,Vvalue)

putAll(Map<?extendsK,?extendsV>m)

2.删除

clear()

remove(Objectkey)

3.判断

containsKey(Objectvalue)

containsValue(Objectvalue)

isEmpty()

4.获取

size()

values()

get(Objectkey)

keySet()

entrySet()

Hashtable:底层是哈希表数据结构，不可以存入null键null值,该集合是线程同步的

HashMap:底层是哈希表数据结构允许使用null值和null键该集合是不同步的

TreeMap:底层是二叉树数据结构，线程不同步，可以用于给Map集合中的键进行排序

map集合的两种取出方式:

 第一种：Set<K> keySet()

返回此映射中包含的键的Set视图，将Map集合中所有的键存入Set集合，然后再通过Set集合的

迭代器取出所有的键，再根据get方法获取每个键的值；

 第二种：Set<Map.Entry<K,V>> entrySet() 

返回此映射中包含的映射关系的Set视图，将Map集合中的映射关系存入到Set集合中，

这个映射关系的数据类型是Map.entry,再通过Map.Entry类的方法再要取出关系里面的键和值

第一种：

import java.util.*;public class MapDemo2 {public static void main(String[] args) {Map<String, String> map = new HashMap<String, String>();map.put("02", "zhangshan02");map.put("03", "zhangshan03");map.put("01", "zhangshan01");map.put("04", "zhangshan04");// 先获取map集合的所有键的Set集合，keySet();Set<String> keySet = map.keySet();// 有了Set集合，就可以获取其迭代器Iterator<String> it = keySet.iterator();while (it.hasNext()) {String key = it.next();// 有了键可以通过map集合的get方法获取其对应的值String value = map.get(key);System.out.println("key--" + key + ",value" + value);}}}

第二种：

import java.util.*;public class MapDemo2 {public static void main(String[] args) {Map<String, String> map = new HashMap<String, String>();map.put("02", "zhangshan02");map.put("03", "zhangshan03");map.put("01", "zhangshan01");map.put("04", "zhangshan04");Set entrySet = map.entrySet();Iterator it = entrySet.iterator();while(it.hasNext()) {Map.Entry  me = (Map.Entry)it.next();System.out.println(me.getKey()+"::::"+me.getValue());}<span style="white-space:pre"></span>}}

Collection和Collections关系：
Collections是个java.util下的类，是针对集合类的一个工具类,提供一系列静态方法,实现对集合的查找、排序、替换、线程安全化（将非同步的集合转换成同步的）等操作。
 Collection是个java.util下的接口，它是各种集合结构的父接口，继承于它的接口主要有Set和List,提供了关于集合的一些操作,如插入、删除、判断一个元素是否其成员、遍历等。

集合框架中的工具类

Collections
对集合进行查找
取出集合中的最大值，最小值
对List集合进行排序
……
Arrays
将数组转成List集合
对数组进行排序