黑马程序员——【Java基础】——集合框架

---------- android培训、java培训、期待与您交流！ ----------

 一、集合框架概述

　　（一）集合框架中集合类关系简化图

 

　　（二）为什么出现集合类？

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

　　（三）数组和集合类同是容器，有何不同？

　　、数组长度是固定的；集合长度是可变的。

　　2、数组中可以存储基本数据类型，集合只能存储对象。

　　（四）集合类的特点

　　集合可以存储不同类型的对象。集合只用于存储对象，集合长度是可变的。

　　（五）为什么会出现这么多容器？

　　因为每一个容器对数据的存储方式都有不同，这个存储方式称为数据结构。

二、Collection接口

　　（一）Collection概述

　　Collection是集合框架中的常用接口。其下有两个子接口：List（列表），Set（集）。

　　所属关系：Collection

            　　　　 |--List：元素是有序的，元素可以重复。因为有索引（index）。

             　　　　|--Set：元素是无序的，元素不可以重复，无索引。

　　（二）Collection接口的常见方法

　　1、添加

　　add(Object obj)：add方法的参数类型是Object。以便于接收任意类型对象。

　　addAll(Collection coll)：将指定 collection 中的所有元素都添加到此collection中。

　　2、删除

　　clear()：清空集合

　　remove(Object obj)：

　　removeAll(Collection col)：移除此 collection 与指定 collection 中的交集元素。

　　3、判断

　　boolean contains(Object obj)：判断collection是否包含obj这个元素

　　boolean isEmpty()：判断集合是否为空

　　4、获取

　　int size()：返回此collection中的元素数。

　　5、其他

　　retainAll(Collection coll)：保留两集合的交集元素。

　　注：集合中存储的都是对象的引用（地址）。

三、迭代器（iterater）

　　（一）概述

　　1、什么是迭代？迭代就是集合的取出元素种方式。

　　2、集合迭代原理：将“取出方式”定义在集合的内部，这样“取出方式”就可以直接访问集合内部的元素，那么“取出方式”就被定义成了内部类。不同的数据结构，“取出方式”的具体实现细节也不相同，但都有共性内容“判断”和“取出”，将共性的规则抽取出来，即是Iterator。

　　3、如何获取集合中的“对象”元素呢？

通过一个对外提供的方法：iterator()，来获取集合中存储的对象。因为Collection中有iterator方法，所以Collection的每一个子类集合对象都具备迭代器。

　　（二）迭代器的方法

　　1、hasNext()：有下一个元素，返回true

　　2、next()：取出下一个元素

　　3、remove()：从迭代器指向的 collection 中移除迭代器返回的最后一个元素

　　注：在迭代时循环中next调用一次，就要hasNext判断一次。

　　4、Iterator的使用方法示例：

　　ArrayList a = newArrayList();//创建一个集合

　　Iterator it = a.iterator();//获取一个迭代器，用于取出集合中的元素。

　　//方式一：for循环（老外的写法），好处在于it对象在迭代完成后就释放了，不占内存。

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

　　//方式二：while循环

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

　　（三）迭代器的注意事项

　　1、迭代器在Collcection接口中是通用的，它替代了Vector类中的Enumeration(枚举)。

　　2、迭代器的next()方法是自动向下取元素，要避免出现NoSuchElementException。

　　3、迭代器的next()方法返回值类型是Object，所以要记得类型转换。

四、List集合

　　（一）List集合作用

　　是可以完成对集合中元素的增、删、改、查。

　　* List集合组成

　　List:

　　　　|--Vector:内部是数组数据结构，是同步的。增删，查询都很慢！

　　　　|--ArrayList:内部是数组数据结构，是不同步的。替代了Vector。查询的速度快。

　　　　|--LinkedList:内部是链表数据结构，是不同步的。增删元素的速度很快。

　　（二）List集合常见方法

　　List特有的常见方法，有一个共性特点就是都可以操作角标。

　　1、添加（增）

　　void add(index , element)：指定位置添加元素

　　boolean add(index , collection)：

　　2、删除（删）

　　Object remove(index): 删除指定位置的元素

　　3、修改（改）

　　Object set(index,element)：修改指定位置的元素

　　4、获取（查）

　　Object get(index)：获取指定角标的元素

　　int indexOf(object)：获取元素第一次出现的位置，如果没有则返回-1

　　int lastIndexOf(object)：返回此列表中最后出现的指定元素的索引

　　List subList(from , to)：返回列表中指定的from (包括)到to(不包括)之间的部分。

　　注：List集合判断元素是否相同，移除等操作，依据的是元素的equals方法。

　　（三）ListIterator

　　1、概述

　　（1）ListIterator是List集合特有的迭代器，是Iterator的子接口。

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

　　（3）为什么ListIterator才可以增、删、改、查？因为List集合中的元素都带角标。

　　2、ListIterator特有的方法

　　void add(obj)：为list增加元素

　　void set(obj)：用指定元素替换 next 或 previous 返回的最后一个元素。

　　boolean hasPrevious()：判断前面有没有元素

　　Object previous()：返回列表中的前一个元素。

　　（四）Enumeration

　　1、枚举是Vector类特有的取出方式。

　　2、Vector取出元素的方式：（1）迭代器方式取出；（2）for循环遍历，get方式取；（3）按角标索引取出；（4）枚举方式取出。

　　3、特有方法

　　addElement(obj)：添加元素，相当于add(obj);

　　Enumeration elements()：Vector特有取出方式(枚举)

　　hasMoreElements()：是否还有元素，相当于Iterator的hasNext()方法

　　nextElements()：取出下一个元素，相当于Iterator的next()方法

　　4、枚举方法示例：

Vector v=new Vector();
for ( Enumeration en = v.elements() ; e.hasMoreElements() ; ){
　　System.out.println(en.nextElements());
}

　　（五）LinkedList（实现不同步）

　　1、LinkedList底层：使用的是“链表”结构。

　　2、特点：增删速度很快，查询稍慢。

　　3、特有方法：

　　（1）添加：addFirst();       addLast();

　　（2）获取：获取元素，但不删除元素。

　　包括：getFirst();   getLast();

　　（3）删除：获取元素，并删除元素。

　　包括：removeFirst();   removeLast();

　　4、JDK1.6后，出现了替代方法。

　　（1）添加：offerFirst();     offLast();

　　（2）获取：获取元素，但是不删除。如果集合中没有元素，会返回null。包括：peekFirst();       peekLast();

　　（3）删除：获取元素，并删除元素。如果集合中没有元素，会返回null。包括：pollFirst();     pollLast();

　　5、LinkList示例练习

　　/* 使用LinkedList模拟一个堆栈或者队列数据结构。

　　堆栈：先进后出  如同一个杯子。

　　队列：先进先出 First in First out  FIFO 如同一个水管。 */

import java.util.*;
class LinkedListTest{
    public static void main(String[] args) {
        LinkedList link = new LinkedList();
              link.addFirst("java01");
              link.addFirst("java02");
              l.addFirst("java03");
            　link.addFirst("java04");
            　link.addFirst("java05");
              //堆栈输出
　　　　　　　　stack(link);
　　　　　　　　//队列输出
　　　　　　　　queue(link);
        }
    //堆栈
    public static void stack(LinkedList link) {
               while (!link.isEmpty()) {
            sop(link.removeFirst());
            }
    }
  
    //队列
    public static void queue(LinkedList link){
        while(!link.isEmpty()){
            sop(link.removeLast());
        }
    }

    //输出
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}

五、Set集合

　　（一）概述

　　　　Set：元素是无序（存入和取出的顺序不一定一致），元素不可以重复。

　　　　　　|--HashSet：底层数据结构是哈希表，线程不同步。

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

　　（二）HashSet

　　1、HashSet：保证元素唯一性的原理：判断元素的hashCode值是否相同。如果相同，还会继续判断元素的equals方法，是否为true。

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

　　3、练习：HashSet代码示例

//（1）HashSet示例
import java.util.HashSet;
import java.util.Iterator;
public class HashSetDemo {
    public static void main(String[] args) {
        HashSet hs = new HashSet();
        hs.add("hehe");
//        hs.add("heihei");
        hs.add("hahah");
        hs.add("xixii");
        hs.add("hehe");
        Iterator it = hs.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
}
//（2）LinkedHashSet代码示例
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
public class LinkedHashSetDemo {
public static void main(String[] args) {
        HashSet hs = new LinkedHashSet();
        hs.add("hahah");
        hs.add("hehe");
        hs.add("heihei");
        hs.add("xixii");
//        hs.add("hehe");
        Iterator it = hs.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
}

　　（三）TreeSet

　　1、TreeSet：默认按照字母的自然排序。底层数据结构是二叉树。保证元素唯一性的依据：compareTo方法return 0。

　　TreeSet排序有两种方式：

　　（1）第一种方式：让元素自身具备比较性，元素要实现Comparable接口，覆盖CompareTo方法，这种方式也称为元素的自然顺序，也叫默认顺序。代码示例如下：

import java.util.*;
//学生类
class Student implements Comparable{
    private String name;
    private int age;
    Student(String name,int age){
        this.name=name;
        this.age=age;
    }
    public String getName(){
        return name;
    }
  
    public int getAge(){
        return age;
    }
    //复写hashCode 方法
    public int hashCode(){
        return name.hashCode()+age*39;
    }
    //覆写equals方法 
    public boolean equals(Object obj){
        if(!(obj instanceof Student))
            throw new RuntimeException();
        Student s = (Student)obj;
        return this.name.equals(s.name)&&this.age==s.age;
    }
    //覆写compareTo方法 
    public int compareTo(Object obj){
        Student s = (Student)obj;
        if(this.age==s.age)
            return this.name.compareTo(s.name);
        return this.age-s.age;
    }
}

class TreeSetTest{
    public static void main(String[] args){
        TreeSet<Student> t=new TreeSet<Student>();
        t.add(new Student("zhangsan",22));
        t.add(new Student("lisi",20));
        t.add(new Student("wangwu",19));
        t.add(new Student("zhouliu",19));
        t.add(new Student("zhaoqi",28));

        for (Iterator<Student> it=t.iterator(); it.hasNext(); ){
            Student s=it.next();
            System.out.println(s.getName()+"....."+s.getAge());
        }
    }
}

　　（2）第二种方式：当元素自身不具备比较性时，或者具备的比较性不是所需要时，这时就需要让集合自身具备比较性，就需要定义比较器，即定义一个类，实现Comparator接口，覆盖compare方法。比较器示例代码如下：

　　/* 需求： 往TreeSet集合中存储自定义对象学生， 想按照学生的年龄进行排序。 */

import java.util.*;
//学生类
class Student implements Comparable{
    private String name;
    private int age;
    Student(String name,int age){
        this.name=name;
        this.age=age;
    }
    public String getName(){
        return name;
    }
  
    public int getAge(){
        return age;
    }
    //覆写hashCode方法
    public int hashCode(){
        return name.hashCode()+age*39;
    }
//覆写equals方法
    public boolean equals(Object obj){
        if(!(obj instanceof Student))
            throw new RuntimeException();
        Student s = (Student)obj;
        return this.name.equals(s.name)&&this.age==s.age;
    }
    //复写compareTo以便TreeSet集合调用
    public int compareTo(Object obj){
        Student s=(Student)obj;
        if(this.age==s.age)
            return this.name.compareTo(s.name);
        return this.age-s.age;
        //return new Integer(this.age).compareTo(new Integer(s.age)); 
    }
}

class  TreeSetTest{
    public static void main(String[] args){
        TreeSet<Student> t=new TreeSet<Student>(new LenCompare());
        t.add(new Student("zhangsan",22));
        t.add(new Student("lisi",20));
        t.add(new Student("wangwu",19));
        t.add(new Student("zhouliu",19));
        t.add(new Student("zhaoqi",28));

        for (Iterator<Student> it=t.iterator(); it.hasNext(); ){
            Student s=it.next();
            System.out.println(s.getName()+"....."+s.getAge());
        }
    }
  
}
//定义比较器，以姓名长度为主要比较
class LenCompare implements Comparator<Student>{
    public int compare(Student s1,Student s2){
        int num=new Integer(s1.getName().length()).compareTo(new Integer(s2.getName().length()));
        if (num==0){
            return new Integer(s1.getAge()).compareTo(s2.getAge());
        }
        return num;
    }
}

六、Map集合

　　（一）概述

　　　　Map<K,V>集合是一个接口，和List集合及Set集合不同的是，它是双列集合。

　　（二）Map集合子类体系

　　Map:

　　　　|--Hashtable：底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。JDK1.0，效率低。

　　　　|--HashMap：底层是哈希表数据结构。允许使用null键null值，该集合是不同步的。JDK1.2，效率高。

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

　　　　Map和Set很像。其实Set底层就是使用了Map集合。

　　（三）Map特点

　　该集合存储键值对，一对一对往里存，而且要保证键的唯一性。

　　（四）Map集合的常用方法

　　1、添加

　　value put(K key,V value)：添加元素，如果出现添加时，相同的键，那么后添加的值会覆盖原有键对应值，并put方法会返回被覆盖的值。

　　void putAll(Map <? extends K,? extends V> m)：添加一个集合

　　2、删除

　　clear()：清空

　　value remove(Object key)：删除指定键值对

　　3、判断

　　containsKey(Object key)：判断键是否存在

　　containsValue(Object value)：判断值是否存在

　　isEmpty()：判断是否为空

　　4、获取

　　get(Object key)：通过键获取对应的值

　　size()：获取集合的长度

　　values()：获取Map集合中所以得值，返回一个Collection集合

　　5、两个取出方法

　　Set<Map.Entry<K , V>>  entrySet();

　　Set<K> keySet();

　　注：HashMap集合可以通过get()方法的返回值来判断一个键是否存在，通过返回null来判断。

　　（五）Map集合的两种取出方式

　　Map集合的取出原理：将Map集合转成Set集合，再通过迭代器取出。

　　1、Set<K> keySet()：将Map集合中所有的键存入Set集合。因为Set具备迭代器。所以可以通过迭代方式取出所有键，再通过get方法获取每一个键对应的值。示例代码如下:

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
public class MapDemo{
    public static void main(String[] args){
        Map<Integer,String> map = new HashMap<Integer,String>();
        map.put(1, "zhangsan");
        map.put(2, "lisi");
        map.put(3, "wangwu");
        map.put(4, "zhaoliu");
        map.put(5, "zhouqi");
        keyset(map);
    }
//keySet取出方式
    public static void keyset(Map<Integer,String> hm){
        Iterator<Integer> it = hm.keySet().iterator();
        while(it.hasNext()){
            Integer key = it.next();
            String value = hm.get(key);
            System.out.println(key+":"+value);
        }
    }
}

　　2、Set<Map.Entry<K,V>> entrySet()：将Map集合中的映射关系存入到Set集合中，而这个关系的数据类型就是：Map.Entry。关于Map.Entry：其实Entry也是一个接口，它是Map的接口中的一个内部接口。示例代码如下： 

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class MapDemo{
    public static void main(String[] args){
        Map<Integer,String> map = new HashMap<Integer,String>();
        map.put(1, "zhangsan");
        map.put(2, "lisi");
        map.put(3, "wangwu");
        map.put(4, "zhaoliu");
        map.put(5, "zhouqi");
        keyset(map);
    }
    //Map.Entry取出方式
    public static void keyset(Map<Integer,String> hm){
        Set<Map.Entry<Integer,String>> entrySet = hm.entrySet();
        Iterator<Map.Entry<Integer,String>> it = entrySet.iterator();
        
        while(it.hasNext()){
            Map.Entry<Integer, String> me = it.next();
            Integer key = me.getKey();
            String value = me.getValue();
            System.out.println(key+":"+value);
        }
    }
}

　　（六）Map集合存储自定义对象

　　/*  每一个学生都有对应的归属地。

       学生Student，地址String。

       学生属性：姓名，年龄。

       注意：姓名和年龄相同的视为同一个学生。

       保证学生的唯一性。

       思路： 1、描述学生类； 2、定义一个Map集合，存储学生对象和地址值；3、获取Map中的元素。*/

import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
public class MapDemo {    
    public static void main(String[] args) {
        /*将学生对象和学生的归属地通过键与值存储到map集合中。*/    
        HashMap<Student,String> hm = new HashMap<Student,String>();
        hm.put(new Student("lisi",38),"北京");
        hm.put(new Student("zhaoliu",24),"上海");
        hm.put(new Student("xiaoqiang",31),"沈阳");
        hm.put(new Student("wangcai",28),"大连");
        hm.put(new Student("zhaoliu",24),"铁岭");
        Iterator<Student> it = hm.keySet().iterator();    
        while(it.hasNext()){
            Student key = it.next();
            String value = hm.get(key);
            System.out.println(key.getName()+":"+key.getAge()+"---"+value);
        }
    }
}
//定义学生类，继承Person类
class Student extends Person {
    public Student() {
        super();
    }
    public Student(String name, int age) {
        super(name, age);
    }
    @Override
    public String toString() {
        return "Student:"+getName()+":"+getAge();
    }
}
//定义Person类，实现Comparable接口
class Person implements Comparable<Person> {
    private String name;
    private int age;    
    public Person() {
        super();
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public int compareTo(Person p){
        int temp = this.age - p.age;
        return temp==0?this.name.compareTo(p.name):temp;
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Person other = (Person) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person:"+getName()+":"+getAge();
    }
}

　　（七）Map练习

　　/* 获取该字符串“jsdfjliwernsdfmxcjfoj”中的每个字母出现的次数，希望打印的结果是：a(1)b(2)..... */

import java.util.*;
class CharCount {
    public static void main(String[] args) {
        String str = "jsdfjliwernsdfmxcjfoj";
        System.out.println("str中各字母出现的次数：" + charCount(str));
    }
    // 定义一个方法获取字符串中字母出现的次数
    public static String charCount(String str) {
        char[] cha = str.toCharArray();// 转换为字符数组
        // 定义一个TreeMap集合，因为TreeMap集合会给键自动排序
        TreeMap<Character, Integer> tm = new TreeMap<Character, Integer>();
        int count = 0;// 定义计数变量
        for (int x = 0; x < cha.length; x++) {
            if (!(cha[x] >= 'a' && cha[x] <= 'z' || cha[x] >= 'A'
                    && cha[x] <= 'Z'))
                continue;// 如果字符串中非字母，则不计数
            Integer value = tm.get(cha[x]);// 获取集合中的值
            if (value != null)// 如果集合中没有该字母，则存入
                count = value;
            count++;
            tm.put(cha[x], count);// 存入键值对
            count = 0;// 复位计数变量
        }
        StringBuilder sb = new StringBuilder();// 定义一个容器
        // 遍历集合，取出并以题目格式存入容器中
        for (Iterator<Character> it = tm.keySet().iterator(); it.hasNext();) {
            Character ch = it.next();
            Integer value = tm.get(ch);
            sb.append(ch + "(" + value + ")");
        }
        return sb.toString();// 返回字符串
    }
}

 七、集合的一些技巧 

　　需要唯一吗？ 

　　　　|——需要：Set 

　　　　|             需要制定顺序吗？ 

　　　　|                    |——需要：TreeSet 

　　　　|                    |——不需要：HashSet 

　　　　|                    但是要想要一种存储一致的顺序，用LinkedHashSet。 

　　　　| 

　　　　|——不需要：List 

　　　　|                    需要频繁增删吗？ 

　　　　|                           |——需要：LinkedList 

　　　　|                           |——不需要：ArrayList 

---------- android培训、java培训、期待与您交流！ ----------