java高级特性-集合框架

0 前言

集合框架是java提供的一套用于存储和操作数据的工具类，它位于java.util包中，包含了各种集合接口和实现类，以及一些排序和搜索的算法。集合框架的优点是可以方便地对数据进行增删改查，以及实现数据的排序、去重、筛选等功能。在本文中，我们将介绍集合框架的体系结构，以及常用的集合接口和类，如Collection、List、Set、Map、ArrayList、LinkedList、HashSet、HashMap等。我们还将学习如何使用集合框架提供的方法和工具类来操作集合中的数据。

1 集合框架简介

1.1 为什么使用集合框架

由于数组在初始化时必须定义一个长度且不可变，导致数组的赋值及创建会有内存浪费的现象，于是集合作为可以更改长度的数组，可以解决内存浪费的现象。

1.2 java集合框架架构图

1）集合有两个父接口 Collection Map
2）Collection有两个子接口 List Set
3）List有两个常见的实现类 ArrayList LinkedList
4）Set有两个常见的实现类 HashSet TreeSet
5）Map有两个常见实现类 HashMap HashTable

1.3 java集合框架特点

Collection接口特点	不唯一	无序
List接口特点	不唯一	有序
Set接口特点	唯一	无序
Map接口特点	存放一对值	kay-value键值对

2 List接口

2.1 ArrayList

特点：查询效率高，增删改效率低。（数组形式）

public static void main(String[] args){
	//1 实例化ArrayList对象
	ArrayList arrayList = new ArrayList();
	//2 给集合添加数据
	//2.1 直接添加
	arrayList.add(1);
	arrayList.add(true);
	arrayList.add("zxc");
	//2.2 通过角标添加
	arrayList.add(3,2);
	arrayList.add(4,false);
	arrayList.add(5,"asd");
	//3 删除集合数据
	//3.1 通过角标删除
	arrayList.remove(1);
	//3.2 通过数据删除
	arrayList.remove("asd")
	//4 查询集合中的数据信息
	//4.1 传统for循环
	for(int i = 0;i<arrayList.size();i++){
        System.out.println(arrayList.get(i));
    }
	//4.2 增强for循环
	for(Object o : arrayList){
        System.out.println(o);
    }
}

2.2 LinkedList

特点：查询效率低，增删改效率高。（链表形式）

public static void main(String[] args){
	//1 实例化ArrayList对象
	LinkedList linkedList = new LinkedList();
	//2 给集合添加数据
	//2.1 直接添加
	linkedList.add(1);
	linkedList.add(true);
	linkedList.add("zxc");
	//2.2 通过角标添加
	linkedList.add(3,2);
	linkedList.add(4,false);
	linkedList.add(5,"asd");
	//2.3 链表特殊方式添加
	linkedList.addFirst(123);
	linkedList.addLast(789);
	//3 删除集合数据
	//3.1 通过角标删除
	linkedList.remove(1);
	//3.2 通过数据删除
	linkedList.remove("asd")
	//3.3 链表特殊方式删除
	linkedList.removeFirst();
	linkedList.removeLast();
	//4 查询集合中的数据信息
	//4.1 传统for循环
	for(int i = 0;i<arrayList.size();i++){
        System.out.println(linkedList.get(i));
    }
	//4.2 增强for循环
	for(Object o : linkedList){
        System.out.println(o);
    }
}

2.3 泛型

//先创建一个User类，添加属性id、name、pwd。
public static void main(String[] args){
	//创建集合或链表时定义它的数据类型（泛型）
	List<User> users = new LinkedList<>();
    User user1 = new User(1,"123","123");
    User user2 = new User(2,"123","123");
    users.add(user1);
    users.add(user2);
    for (User user : users){
        System.out.println(user.getId());
        System.out.println(user.getName());
        System.out.println(user.getPwd());
    }
}

3 Set接口

3.1 HashSet

public static void main(String[] args){
	HashSet<String> sets = new HashSet<>();
	//添加的数据不能重复
	sets.add("3");
	sets.add("4");
	sets.add("5");
	//利用迭代器遍历
	Iterator its = sets.iterator;
	while(its.hasNext()){
		String key = its.next();
		System.out.println(key); //输出结果时无序的
	}
}

4 Map接口

4.1 HashMap

public static void main(String[] args){
	Map<String,Object> map = new HashMap<String,Object>
	map.put("1","d");
	map.put("2","ff");
	map.put("3","ggg");
	Set<String> sets = map.keySet();
	Iterator<String> its = sets.iterator();
	while(its.hasNext()){
		String key = its.next();
		String value = map.get(key);
		System.out.println("key = "+key+"\t value = "+value);
	}
}

5 嵌套遍历

5.1 嵌套List+List

	/**
     * 遍历List<List<String>>
     */
	public static void main(String[] args) {
        List<String> list1 = new ArrayList<>();
        list1.add("111");
        list1.add("222");
        list1.add("333");
        List<String> list2 = new ArrayList<>();
        list2.add("444");
        list2.add("555");
        list2.add("666");
        List<List<String>> list = new ArrayList<>();
        list.add(list1);
        list.add(list2);
        for (List<String> l :
                list) {
            System.out.println("******外层******");
            for (String i :
                    l) {
                System.out.println(i);
            }
        }
    }

5.2 嵌套List+Map

	/**
     * 遍历List<Map<String,Object>>
     */
    public static void main(String[] args) {
        Map<String,Object> map1 = new HashMap<>();
        map1.put("1", 111);
        map1.put("2", 222);
        Map<String,Object> map2 = new HashMap<>();
        map2.put("3", 333);
        map2.put("4", 444);
        List<Map<String,Object>> list = new ArrayList<>();
        list.add(map1);
        list.add(map2);
        for(Map<String,Object> map : list) {
            Set<String> set = map.keySet();
            Iterator<String> its = set.iterator();
            while (its.hasNext()){
                String key = its.next();
                Object value = map.get(key);
                System.out.println("key = " + key + "\tvalue = " + value);
            }
        }
    }

5.3 遍历Map+Map

	/**
     * 遍历Map<String,Map<String,Object>>
     */
    public static void main(String[] args) {
        Map<String,Object> LMap1 = new HashMap<>();
        LMap1.put("1", 123);
        LMap1.put("2", 324);
        LMap1.put("3", 543);
        LMap1.put("22", 34534);
        LMap1.put("33", 54643);
        Map<String,Object> LMap2 = new HashMap<>();
        LMap2.put("11", 1523);
        LMap2.put("22", 34534);
        LMap2.put("33", 54643);
        Map<String,Object> LMap3 = new HashMap<>();
        LMap3.put("111", 1233);
        LMap3.put("222", 32324);
        LMap3.put("333", 42543);
        Map<String, Map<String,Object>> BMap = new HashMap<>();
        BMap.put("1111",LMap1);
        BMap.put("2222",LMap2);
        BMap.put("3333",LMap3);
        Set<String> Bset = BMap.keySet();
        Iterator<String> Bits = Bset.iterator();
        while (Bits.hasNext()){
            String Bkey = Bits.next();
            System.out.println("*******外层value*******");
            Map<String, Object> map = BMap.get(Bkey);
            Set<String> Lset = map.keySet();
            Iterator<String> Lits = Lset.iterator();
            while (Lits.hasNext()){
                String Lkey = Lits.next();
                Object o = map.get(Lkey);
                System.out.println("内层key = " + Lkey + "\t内层value = " + o);
            }
        }
    }