Java集合总结

集合类的特点：提供一种存储空间可变的存储类型，存储的数据容量可以随时发生改变！
Java集合类的体系结构如下图所示：

1.Collection集合

Collection集合是单例集合的顶层接口，它表示一组对象，这些对象也称为Collection的元素；
JDK不提供此接口的直接实现，它提供更具体的子接口(如Set和List)实现；
创建Collection集合的对象，需要采用多态的方式，具体的实现类为ArrayList；

程序演示:

package com.demo01;

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

public class Test {
    public static void main(String[] args) {
        //创建Collection集合的对象
        Collection<String> arr=new ArrayList<>();
        
        //添加元素：boolean add(E e)
        arr.add("Java");
        arr.add("Python");
        arr.add("C++");
        arr.add("SpringBoot");

        //输出集合对象
        //直接输出集合元素，集合重写了toString方法，将添加到集合中的元素按照指定的格式在控制台输出
        System.out.println(arr);
    }
}

Collection集合的常用方法:

Collection集合常用方法代码演示：

package com.demo02;

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

public class Test {
    public static void main(String[] args) {
        //创建集合对象
        Collection<String> arr=new ArrayList<>();

        //添加集合元素
        //boolean add(E e) 调用add方法永远返回的都是true 具体如下所示
//        public boolean add(E e) {
//            ensureCapacityInternal(size + 1);  // Increments modCount!!
//            elementData[size++] = e;
//            return true;
//        }
        //向集合中添加三个元素
        arr.add("Java");
        arr.add("Python");
        arr.add("C++");
        //int size();集合的长度，也就是集合中元素的个数
        System.out.println(arr.size());//3

        //public boolean remove(Object o):从集合中删除指定元素
        System.out.println(arr.remove("C++")); //true
        System.out.println(arr.remove("Spring")); //false

        //public boolean contains(Object o):判断结合中是否存在指定的元素
        System.out.println(arr.contains("Java"));//true
        System.out.println(arr.contains("QT"));//false

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

        //public void clear():清空集合中的元素
        arr.clear();
        System.out.println(arr.isEmpty());//true
        System.out.println(arr);
    }
}

2.List集合

List集合概述：有序集合，用户可以精确控制列表中的每个元素的插入位置。用户可以通过整数索引访问元素，并搜索列表中的元素。
与Set集合，List通常允许重复的元素
List集合特点：
有序：存储和取出的元素顺序一致
可重复：存储的元素可以重复
程序演示：

package com.demo03;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        //创建集合对象List
        List<String> list=new ArrayList<>();
        //添加元素
        list.add("Java");
        list.add("Python");
        list.add("Mybatis");
        //元素可重复
        list.add("Java");
        //输出集合对象
        System.out.println(list);
        //迭代器的方式遍历
        Iterator<String> it=list.iterator();
        while(it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
        
    }
}

List集合的常用方法:
List集合的特有方法Collection集合是没有的，但是ArrayList是有的。

package com.demo04;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Test {
    public static void main(String[] args) {
        //创建集合对象List
        List<String> list=new ArrayList<>();
        //添加元素
        list.add("Java");
        list.add("Python");
        list.add("Mybatis");
        //void add(int index,E element);在此集合中的指定位置插入指定的元素
        list.add(1,"spring");
        //list.add(9,"spring");IndexOutOfBoundsException
        //E remove(int index);删除指定索引处的元素，返回被删除的元素
        System.out.println(list.remove(1)); //spring
        //System.out.println(list.remove(11));IndexOutOfBoundsException
        //E set(int index,E element);修改指定索引处的元素，返回被修改的元素
        System.out.println(list.set(1,"springboot"));
        //System.out.println(list.set(11,"springboot"));IndexOutOfBoundsException
        //E get(int index);返回指定索引处的元素
        System.out.println(list.get(1));
        //System.out.println(list.get(11));IndexOutOfBoundsException
        //输出集合对象
        System.out.println(list);
        //遍历集合
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

3.Set集合

Set集合的特点：
不包含重复元素的集合；
没有带索引的方法，不能使用普通for循环遍历，但是可以使用增强for循环遍历

代码演示：

package com.demo05;
import java.util.HashSet;
import java.util.Set;
public class Test {
    public static void main(String[] args) {
        //创建集合对象
        Set<String> set=new HashSet<>();
        //添加元素
        set.add("Java");
        set.add("Python");
        set.add("Mybatis");
        //不包含重复的元素
        set.add("Mybatis");
        //增强for遍历
        //HashSet对集合的迭代顺序不做任何保证
        for (String s : set) {
            System.out.println(s);
        }
    }
}

4.Map集合

Map集合概述：
interface Map<K,V> K：键的类型；V：值的类型
将键映射到值的对象；不能包含重复的键；每个键可以映射到最多一个值
创建Map集合对象，采用多态的方式，具体的实现类为HashMap
程序演示如下所示：

package com;
import java.util.HashMap;
import java.util.Map;
public class Test {
    public static void main(String[] args) {
        //创建集合对象
        Map<String,String> map=new HashMap<>();
        //往map集合添加元素
        //V put(K key,V value)将指定的值与该映射中的指定键相关联
        map.put("001","Java");
        map.put("002","Python");
        map.put("003","C++");
        //键是唯一的，不能重复,当键重复的时候，值就会被最新的值替代
        map.put("003","Mybatis");
        //输出集合对象中的值
        System.out.println(map);
    }
}

Map集合的基本功能：

代码演示：

package com;
import java.util.HashMap;
import java.util.Map;

public class Test {
    public static void main(String[] args) {
        //创建集合对象
        Map<String,String> map=new HashMap<>();
        //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("郭芙"));//null
        //boolean containsKey(Object key);判断集合是否包含指定的键
        System.out.println(map.containsKey("乔峰"));//true
        System.out.println(map.containsKey("郭芙"));//false

        //boolean isEmpty();判断集合是否为空
        System.out.println(map.isEmpty());
        //int size();集合的长度，也就是集合中键值对的个数
        System.out.println(map.size());
        //void clear();移出所有的键值对元素
        map.clear();
        System.out.println(map.isEmpty());
        //输出集合对象
        System.out.println(map);
    }
}