Java——集合框架

一、Java——集合框架介绍

java.util包中提供了一些集合，这些集合被称为容器。
集合是一种工具类，就像是容器，存储任意数量的具有共同属性的对象

Java集合框架主要包括两种类型的容器，一种是collection（集合），存储一个元素集合。另一种是Map，存储键值对映射

1、集合的作用：

• 在类的内部，对数据进行组织
• 简单而快速的搜索大量的条目
• 有的集合接口，提供了一系列排列有序的元素，并且可以在序列中间快速的插入或者删除有关元素
• 有的集合接口，提供了映射关系，可以通过关键字（key）去快速查找到对应的唯一对象，而这个关键字可以是任意类型

2、与数组对比——为何选择集合而不是数组

• 数组的长度是固定的，集合长度可变
• 数组只要通过下标访问元素，类型固定，而有的集合可以通过任意类型查找所映射的具体对象

3、集合框架

---

二、Collection接口

Collection接口是层次结构中的接口。构成Collection的单位称为元素。Collection接口通常不能直接使用，但该接口提供了添加、删除元素、管理数据的方法。
- 是List、Set和Queue接口的父接口
- 定义了可以用于操作List、Set和Queue的方法——增删改查

Collection接口的常用方法

方法	功能描述
add(Object)	将指定的对象添加到该集合中
remove(Object)	将指定的对象从该集合中移除
isEmpty()	返回boolean，用于判断当前集合是否为空
iterator()	返回在此Collection的元素上进行迭代的迭代器，用于遍历集合中的对象
size()	返回int型，获取该集合中元素的个数

测试Collection的常用方法

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

public class TestCollection {
    public static void main(String[] args) {
        //实例化集合对象
        Collection list=new ArrayList();
        //添加元素
        list.add("1");
        list.add("2");
        list.add("3");
        //创建迭代器
        Iterator listout=list.iterator();
        //判断是否有下一个元素
        while(listout.hasNext()) {
        //获取集合中的元素
            String str=(String)listout.next();
            System.out.println(str);    
        }
    }
}

三、List的集合

List集合包括List接口和List接口的实现类。List集合中的元素允许重复，各元素的顺序就是对象插入顺序。类似Java数组，用户可通过使用索引来访问集合中的元素。实现List接口集合有ArrayList、LinkedList、Vector、Stack

1、List接口

List接口实现了Collection接口，因此包含了Collection中的所有方法，此外List接口还提供了两个重要的方法

• get（int index）：获得指定索引位置的元素
• set（int index，Object obj）：将集合中指定索引位置的对象修改为指定对象

• List是元素有序并且可以重复的集合，被称为序列
• List可以精确的控制每个元素的插入位置，或删除某个位置的元素，同时根据元素的索引获取元素

2、实现List的接口集合

|-——-Vector 线程同步，增删查询都很慢。

|-——- ArrayList 线程不同步，动态数组，ArrayList代替了Vector，允许插入null值，初始大小为10，根据索引位置对集合进行随机访问。缺点是向指定的索引位置插入对象或删除对象的速度较慢。

|-——- LinkedList采用链表结构保存对象。优点是便于向集合中插入和删除对象，经常需要向集合中插入、删除对象时，效率快。随机访问集合中对象会较慢。

|-——-Stack 继承自Vector,实现一个后进先出的堆栈。Stack在Vector的基础上增加了5个方法，使得其变为栈。Push、Pop、peek(获取栈顶)、empty、search(检测一个元素是否在堆中).

使用List如下

        //实例化，创建集合对象
        List list1=new ArrayList();
        List list2=new LinkedList();

测试用法

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

public class TestCollection {
    public static void main(String[] args) {
         // 创建集合对象
        Listlist = new ArrayList();
        // 向集合添加元素
        list.add("a"); 
        list.add("b");
        list.add("c");
        // 获得0~1之间的随机数
        int i = (int) (Math.random() * (list.size() - 1)); 
        System.out.println("随机获取数组中的元素：" + list.get(i));
        list.remove(2); // 将指定索引位置的元素从集合中移除
        System.out.println("将索引是'2'的元素从数组移除后，数组中的元素是：");
        // 循环遍历集合
        for (int j = 0; j < list.size(); j++) { 
            System.out.println(list.get(j));
        }
    }
}

四、Set的集合

Set集合中的对象不按特定的方式排序，只是简单地把对象加入集合中，Set集合中不能包含重复对象。Set集合由Set接口和Set实现类组成。包含了Collection接口的所有方法。实现Set接口集合由EnumSet、HashSet、TreeSet、LinkedHashSet

1、Set接口

|-——-HashSet类实现Set接口，由哈希表（HashMap实例）支持。不保证Set的迭代器顺序，特别是它不保证该顺序恒久不变。该类允许使用null元素。
|-——-TreeSet类不仅实现了Set接口，同时实现java.util.SortedSet接口，因此TreeSet类实现的Set集合，在遍历集合时按照自然顺序和递增顺序。

2、测试

import java.util.*;
public class UpdateStu implements Comparable<Object> {
    String name;
    long id;
    //构造方法
    public UpdateStu(String name, long id) {
        this.id = id;
        this.name = name;
    }
    //重写compreTo（）方法：存入TreeSet类实现的Set集合必须实现Comparable接口，该接口中的compareTo（Object o）方法比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。
    public int compareTo(Object o) {
        UpdateStu upstu = (UpdateStu) o;
        int result = id > upstu.id ? 1 : (id == upstu.id ? 0 : -1);
        return result;
    }
    public long getId() {
        return id;
    }
    public void setId(long id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }


    public static void main(String[] args) {
        UpdateStu stu1 = new UpdateStu("李同学", 01011);
        UpdateStu stu2 = new UpdateStu("陈同学", 01021);
        UpdateStu stu3 = new UpdateStu("王同学", 01051);
        UpdateStu stu4 = new UpdateStu("马同学", 01012);
        TreeSet<UpdateStu> tree = new TreeSet<>();
        tree.add(stu1);
        tree.add(stu2);
        tree.add(stu3);
        tree.add(stu4);
        Iterator<UpdateStu> it = tree.iterator();
        System.out.println("Set集合中的所有元素：");
        while (it.hasNext()) {
            UpdateStu stu = (UpdateStu) it.next();
            System.out.println(stu.getId() + " " + stu.getName());
        }

        //截取前面部分的集合
        it = tree.headSet(stu2).iterator();
        System.out.println("截取前面部分的集合：");
        while (it.hasNext()) {
            UpdateStu stu = (UpdateStu) it.next();
            System.out.println(stu.getId() + " " + stu.getName());
        }


         //截取中间部分的集合
        it = tree.subSet(stu2, stu3).iterator();
        System.out.println("截取中间部分的集合");
        while (it.hasNext()) {
            UpdateStu stu = (UpdateStu) it.next();
            System.out.println(stu.getId() + " " + stu.getName());
        }
    }
}

五、Map的集合

Map没有继承Collection接口，提供的是key到value的映射。Map中不能包含相同的key，每个key只能映射一个value。访问时只能根据每项元素的key来访问其value

1、Map接口

|-——-HashTable 底层哈希表，线程同步，不能存在Null键，Null值。线程同步，以哈希表的数据结构实现，解决冲突时与HashMap一样也是采用散列表的形式，不过性能比HashMap要低。

|-——-HashMap 底层哈希表，线程不同步，不能存在Null键，Null值。 以哈希表数据结构实现，查找对象时通过hash值计算其位置，它是为快速查询而设计的，内部定义了一个Hash表数组(Entry[] table),元素会通过hash转化函数转为在数组中的索引，如果有冲突的，则用散列链表的形式串起来。

|-——-LinkedHashMap Map接口的哈希表和链接列表实现，具有预知的迭代顺序。

|-——-TreeMap 底层二叉树，可以对Map集合中的键进行制定顺序的排序。键以某种排序规则排序，内部以Red-balck(红-黑树)数据结构实现。实现了SortedMap接口。

import java.util.*;

public class UpdateStu {
    public static void main(String[] args) {
        Map<String> map = new HashMap<String>(); // 创建Map实例
        // 向集合中添加对象(key,value)
        map.put("01", "李同学"); 
        map.put("02", "魏同学");
        Set<String> set = map.keySet(); // 构建Map集合中所有key对象的集合
        Iterator<String> it = set.iterator(); // 创建集合迭代器
        System.out.println("key集合中的元素：");
        while (it.hasNext()) { // 遍历集合
            System.out.println(it.next());
        }
        Collection<String> coll = map.values(); // 构建Map集合中所有values值集合
        it = coll.iterator();
        System.out.println("values集合中的元素：");
        while (it.hasNext()) { // 遍历集合
            System.out.println(it.next());
        }
    }
}