Java 集合框架

集合框架被设计成要满足以下几个目标。 该框架必须是高性能的。基本集合（动态数组，链表，树，哈希表）的实现也必须是高效的。 该框架允许不同类型的集合，以类似的方式工作，具有高度的互操作性。对一个集合的扩展和适应必须是简单的。为此，整个集合框架就围绕一组标准接口而设计。你可以直接使用这些接口的标准实现，诸如F1a; LinkedList, HashSet, 和 TreeSet 等,除此之外你也可以通过这些接口实现自己的集合。

Collection集合@H_304_145@

Collection集合的简单概述

是单例集合的顶层接口，它表示一组对象，这些对象也称为Collection的元素 JDK不提供此接口的任何直接实现，它提供更具体的子接口（如Set和List）实现 代码举例:

public class CollectionDemo01 {
    public static void main(String[] args) {
        //创建Collection集合的对象
        Collection<String> c = new ArrayList<String>();
        //添加元素：boolean add(E e)
        c.add("hello");
        c.add("world");
        c.add("java");

        //输出集合对象
        System.out.PRintln(c);//重写了ToString方法
    }
}

Collection集合常用方法

方法名	说明
boolean add(E e)	添加元素
boolean remove(Object o)	从集合中移除指定的元素
void clear()	清空集合中的元素
boolean contains(Object o)	判断集合中是否存在指定的元素
boolean iSEMpty()	判断集合是否为空
int size()	集合的长度，也就是集合中元素的个数

List集合

List集合的基本概述

有序集合(也称为序列)，用户可以精确控制列表中每个元素的插入位置。用户可以通过整数索引访问元素，并搜索列表中的元素,与Set集合不同，列表通常允许重复的元素。

List集合的特点

1. 有索引(有索引意味着可以通过普通for循环通过索引来对集合遍历)
2. 存取有序(集合元素添加的顺序和取出的顺序一致)
3. 集合中的元素可以重复

List集合特有方法

方法名	描述
void add(int index,E element)	在此集合中的指定位置插入指定的元素
E remove(int index)	删除指定索引处的元素，返回被删除的元素
E set(int index,E element)	修改指定索引处的元素，返回被修改的元素
E get(int index)	返回指定索引处的元素

ArrayList集合&LinkedList集合

ArrayList集合

ArrayList底层是用数组实现的，可以认为ArrayList是一个可改变大小的数组。随着越来越多的元素被添加到ArrayList中，其规模是动态增加的。 集合的创建： ArrayList<Integer> arrayList = new ArrayList<Integer>();

LinkedList集合

LinkedList底层是通过双向链表实现的。 集合的创建： LinkedList<Integer> linkedList = new LinkedList<Integer>();

LinkedList集合的特有功能

因为LinkedList集合的底层是双向链表所以具有链表结构的一些特定操作

方法名	说明
public void addFirst(E e)	在该列表开头插入指定的元素
public void addLast(E e)	将指定的元素追加到此列表的末尾
public E getFirst()	返回此列表中的第一个元素
public E getLast()	返回此列表中的最后一个元素
public E removeFirst()	从此列表中删除并返回第一个元素
public E removeLast()	从此列表中删除并返回最后一个元素

ArrayList集合 VS LinkedList集合

LinkedList和ArrayList的区别主要就是数组和链表的区别。 数组中查询比较快，因为可以直接通过数组索引访问 链表中删除和增加比较快，因为可以直接通过节点的变量指定进行元素的增删。 LinkedList和ArrayList相比，增删的速度较快。但是查询的速度较慢

Set集合

Set集合的特点

1. 存取无序(集合元素添加的顺序和取出的顺序不一致)
2. 没有索引,只能通过迭代器或增强for循环遍历.
3. 不能存储重复元素()

基本使用

public class SetDemo {
    public static void main(String[] args) {
        //创建集合对象
        Set<String> set = new HashSet<String>();//多态
        //添加元素
        set.add("hello");
        set.add("world");
        set.add("java");
        //不包含重复元素的集合
        set.add("world");
        //增强for遍历
        for(String s : set) {
            System.out.println(s);
        }
    }
}

HashSet集合&TreeSet集合

HashSet集合

HashSet集合的特点

1. 底层数据结构是哈希表
2. 对集合的迭代顺序不作任何保证，也就是说不保证存储和取出的元素顺序一致
3. 没有带索引的方法，所以不能使用普通for循环遍历
4. 由于是Set集合，所以是不包含重复元素的集合

HashSet集合的基本使用

public class HashSetDemo01 {
    public static void main(String[] args) {
        //创建集合对象
        HashSet<String> hs = new HashSet<String>();

        //添加元素
        hs.add("hello");
        hs.add("world");
        hs.add("java");

        hs.add("world");

        //遍历
        for(String s : hs) {
            System.out.println(s);
        }
    }
}

LinkedHashSet集合

LinkedHashSet集合特点

1. 哈希表和链表实现的Set接口，具有可预测的迭代次序
2. 由链表保证元素有序，也就是说元素的存储和取出顺序是一致的
3. 由哈希表保证元素唯一，也就是说没有重复的元素

基本使用

public class LinkedHashSetDemo {
    public static void main(String[] args) {
        //创建集合对象
        LinkedHashSet<String> linkedHashSet = new LinkedHashSet<String>();

        //添加元素
        linkedHashSet.add("hello");
        linkedHashSet.add("world");
        linkedHashSet.add("java");

        linkedHashSet.add("world");

        //遍历集合
        for(String s : linkedHashSet) {
            System.out.println(s);
        }
    }
}

TreeSet集合

TreeSet集合的概述和特点

1. 元素有序(不值存取有序)，可以按照一定的规则进行排序，具体排序方式取决于构造方法 TreeSet()：根据其元素的自然排序进行排序(无参) TreeSet(Comparator comparator) ：根据指定的比较器进行排序(带参)
2. 没有带索引的方法，所以不能使用普通for循环遍历
3. 3.由于是Set集合，所以不包含重复元素的集合

TreeSet集合基本使用

public class TreeSetDemo01 {
    public static void main(String[] args) {
        //创建集合对象
        TreeSet<Integer> ts = new TreeSet<Integer>();
        //添加元素
        ts.add(10);
        ts.add(40);
        ts.add(30);
        ts.add(50);
        ts.add(20);
        ts.add(30);
        //遍历集合
        for(Integer i : ts) {
            System.out.println(i);
        }
    }
}

自然排序

• 用TreeSet集合存储自定义对象，无参构造方法使用的是自然排序对元素进行排序的
• 自然排序，就是让元素所属的类实现Comparable接口，重写compareTo(T o)方法
• 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

 @override
    public int compareTo(Student s) {
        //按照年龄从小到大排序
       int num = this.age - s.age;
      int num = s.age - this.age;
        //年龄相同时，按照姓名的字母顺序排序
       int num2 = num==0?this.name.compareTo(s.name):num;
        return num2;
    }

比较器排序

• 用TreeSet集合存储自定义对象，带参构造方法使用的是比较器排序对元素进行排序的
• 比较器排序，就是让集合构造方法接收Comparator的实现类对象，重写compare(T o1,T o2)方法
• 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

 TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                //this.age - s.age
                //s1,s2
                int num = s1.getAge() - s2.getAge();
                int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
                return num2;
            }
        });

Map集合

Map集合概述

Map 是一种键-值对（key-value）集合，;map 集合中的每一个元素都包含一个键对象和一个值对象。

Map集合特点

1. 键值对映射关系
2. 一个键对应一个值
3. 键不能重复，值可以重复
4. 元素存取无序

Map集合的基本使用

public class MapDemo01 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String,String> map = new HashMap<String,String>();

        //V put(K key, V value) 将指定的值与该映射中的指定键相关联
        map.put("ITheima001","林青霞");
        map.put("itheima002","张曼玉");
        map.put("itheima003","王祖贤");
        map.put("itheima003","柳岩");

        //输出集合对象
        System.out.println(map);
    }
}

Map集合的常用方法

方法说明:

方法名	说明
V put(K key,V value)	添加元素
V remove(Object key)	根据键删除键值对元素
void clear()	移除所有的键值对元素
boolean containsKey(Object key)	判断集合是否包含指定的键
boolean containsValue(Object value)	判断集合是否包含指定的值
boolean isEmpty()	判断集合是否为空
int size()	集合的长度，也就是集合中键值对的个数

示例:

public class MapDemo02 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String,String> map = new HashMap<String,String>();

        //V put(K key,V value)：添加元素
        map.put("张无忌","赵敏");
        map.put("郭靖","黄蓉");
        map.put("杨过","小龙女");

        //V remove(Object key)：根据键删除键值对元素
//        System.out.println(map.remove("郭靖"));
//        System.out.println(map.remove("郭襄"));

        //void clear()：移除所有的键值对元素
//        map.clear();

        //boolean containsKey(Object key)：判断集合是否包含指定的键
//        System.out.println(map.containsKey("郭靖"));
//        System.out.println(map.containsKey("郭襄"));

        //boolean isEmpty()：判断集合是否为空
//        System.out.println(map.isEmpty());

        //int size()：集合的长度，也就是集合中键值对的个数
        System.out.println(map.size());


        //输出集合对象
        System.out.println(map);
    }
}

Map集合的获取方法

方法说明:

方法名	说明
V get(Object key)	根据键获取值
Set keySet()	获取所有键的集合
Collection values()	获取所有值的集合
Set<Map.Entry<K,V>> entrySet()	获取所有键值对对象的集合

示例:

public class MapDemo03 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String, String> map = new HashMap<String, String>();

        //添加元素
        map.put("张无忌", "赵敏");
        map.put("郭靖", "黄蓉");
        map.put("杨过", "小龙女");

        //V get(Object key):根据键获取值
//        System.out.println(map.get("张无忌"));
//        System.out.println(map.get("张三丰"));

        //Set<K> keySet():获取所有键的集合
//        Set<String> keySet = map.keySet();
//        for(String key : keySet) {
//            System.out.println(key);
//        }

        //Collection<V> values():获取所有值的集合
        Collection<String> values = map.values();
        for(String value : values) {
            System.out.println(value);
        }
    }
}

Map集合的遍历方式

方式一

• 遍历思路
  • 我们刚才存储的元素都是成对出现的，所以我们把Map看成是一个夫妻对的集合
    • 把所有的丈夫给集中起来
    • 遍历丈夫的集合，获取到每一个丈夫
    • 根据丈夫去找对应的妻子
• 步骤分析
  • 获取所有键的集合。用keySet()方法实现
  • 遍历键的集合，获取到每一个键。用增强for实现
  • 根据键去找值。用get(Object key)方法实现
• 代码实现

public class MapDemo01 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String, String> map = new HashMap<String, String>();

        //添加元素
        map.put("张无忌", "赵敏");
        map.put("郭靖", "黄蓉");
        map.put("杨过", "小龙女");

        //获取所有键的集合。用keySet()方法实现
        Set<String> keySet = map.keySet();
        //遍历键的集合，获取到每一个键。用增强for实现
        for (String key : keySet) {
            //根据键去找值。用get(Object key)方法实现
            String value = map.get(key);
            System.out.println(key + "," + value);
        }
    }
}

方式二

• 遍历思路

  • 我们刚才存储的元素都是成对出现的，所以我们把Map看成是一个夫妻对的集合
    • 获取所有结婚证的集合
    • 遍历结婚证的集合，得到每一个结婚证
    • 根据结婚证获取丈夫和妻子

• 步骤分析

  • 获取所有键值对对象的集合
    • Set<Map.Entry<K,V>> entrySet()：获取所有键值对对象的集合
  • 遍历键值对对象的集合，得到每一个键值对对象
    • 用增强for实现，得到每一个Map.Entry
  • 根据键值对对象获取键和值
    • 用getKey()得到键
    • 用getValue()得到值

• 代码实现

public class MapDemo02 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String, String> map = new HashMap<String, String>();

        //添加元素
        map.put("张无忌", "赵敏");
        map.put("郭靖", "黄蓉");
        map.put("杨过", "小龙女");

        //获取所有键值对对象的集合
        Set<Map.Entry<String, String>> entrySet = map.entrySet();
        //遍历键值对对象的集合，得到每一个键值对对象
        for (Map.Entry<String, String> me : entrySet) {
            //根据键值对对象获取键和值
            String key = me.getKey();
            String value = me.getValue();
            System.out.println(key + "," + value);
        }
    }
}

Map接口和Collection接口的不同

它们两个不存在继承关系，都是属于java.util包下面的平级关系 Map集合存储的元素都是成对出现的，Map元素的键是唯一的，值是可以重复。把这样的元素理解为：夫妻对 Collection集合存储的元素都是单独出现的，Collection接口下面的Set是元素唯一的， List集合中元素是可以重复的。