集合的简单使用

一、列表List

List最常用的是ArrayList，ArrayList是实现了基于动态数组的结构，而LinkedList则是基于实现链表的数据结构

1. 列表申明：
   ArrayList<Object> list = new ArrayList<>();
   注1：<>中是可以定义列表所属数据类型，可以是Integer等Java类，也可以是是自己定义的类，如果<>中指定了某个类，则后面添加、获取元素的时候，只能是指定的类，否则会报错，如果没有指定某个类（<>为Object），则可以添加任何类的数据；
   注2：不指定类的申明有2种方式：
   ArrayList<Object> list = new ArrayList<>();
ArrayList list = new ArrayList();
   注3：如果不指定类的申明，在获取值的时候，最好使用instanceof来判断数据的类型
2. 添加元素
   list.add(E e);
3. 根据下标删除元素
   list.remove(int index);
4. 根据值删除元素
   list.remove(E e); // 只能删除匹配的第一个元素
list.removeAll(Collectionn<?> c); // list中只要与集合C中的元素匹配的都删除
5. 获取列表长度
   list.size()
6. 根据下标获取值
   list.get(int index)
7. 遍历（迭代器）

Iterator<String> iterator = list.iterator();
while(iterator.hasNext()){
   System.out.print(iterator.next());
   System.out.print(" ");
}

示例：

public class ListTest {
    public static void main(String[] args){
        // 申明列表
        ArrayList<String> list = new ArrayList<>();

        // 添加元素
        list.add("wen");
        list.add("xiao");
        list.add("ba");
        list.add("is");
        list.add("girl");
        System.out.print("列表表达的意思：");
        // for循环打印列表的内容
        for (int i = 0; i < list.size(); i++){
            if(i != 0)
                System.out.print(" ");
            System.out.print(list.get(i));
        }
        System.out.println("\n");

        // 迭代器查询列表内容
        // 迭代器next()的作用：将迭代器位置移动到下一个位置，同时返回越过的元素
        Iterator<String> iterator = list.iterator();
        while(iterator.hasNext()){
            System.out.print(iterator.next());
            System.out.print(" ");
        }

        System.out.println("\n");
        // 根据下标删除列表元素
        list.remove(2);
        for (int i = 0; i < list.size(); i++){
            if(i != 0)
                System.out.print(" ");
            System.out.print(list.get(i));
        }
        System.out.println("\n");
        // 根据值删除列表元素
        list.remove("is");
        for (int i = 0; i < list.size(); i++){
            if(i != 0)
                System.out.print(" ");
            System.out.print(list.get(i));
        }


        System.out.println("\n");
        LinkedList<String> llist = new LinkedList<>();
        llist.add("wen");
        llist.add("xiao");
        llist.add("ba");
        llist.add("is");
        llist.add("girl");
        for (int i = 0; i < llist.size(); i++){
            if(i != 0)
                System.out.print(" ");
            System.out.print(llist.get(i));
        }
    }
}

执行结果：

列表表达的意思：wen xiao ba is girl

wen xiao ba is girl 

wen xiao is girl

wen xiao girl

wen xiao ba is girl

二、集Set

集Set也是集合的一种，其元素都是唯一的，不能重复，且是无序的，集有HashSet、TreeSet、LinkedHashSet等

1. 列表申明：
   Set<Object> set = new Set<>();
   注1：<>中是可以定义列表所属数据类型，可以是Integer等Java类，也可以是是自己定义的类，如果<>中指定了某个类，则后面添加、获取元素的时候，只能是指定的类，否则会报错，如果没有指定某个类（<>为Object），则可以添加任何类的数据；
   注2：不指定类的申明有2种方式：
   Set<Object> set = new Set<>();
Set set = new Set();
   注3：如果不指定类的申明，在获取值的时候，最好使用instanceof来判断数据的类型
2. 添加元素
   set.add(E e);
3. 根据值删除元素
   set.remove(E e); // 只能删除匹配的第一个元素
set.removeAll(Collectionn<?> c); // set中只要与集合C中的元素匹配的元素都删除
4. 获取集的长度
   set.size()
5. 遍历（迭代器）

Iterator<Integer> setIt= set.iterator();
while(setIt.hasNext()){
   System.out.print(setIt.next() + "    ");
}

8.哈希集HashSet

public static void main(String[] args){
        // 申明
        HashSet<Integer> hashSet = new HashSet<>();
        // 在集里添加元素
        hashSet.add(12);
        hashSet.add(9);
        hashSet.add(16);
        hashSet.add(193);
        hashSet.add(59);
        // 获取集的元素个数
        System.out.println("hashSet的元素个数：" + hashSet.size());

        // 因为集是无序的，没有get()方法，所以不能用for循环遍历，只能使用迭代器
        Iterator<Integer> iterator = hashSet.iterator();
        while(iterator.hasNext()){
            System.out.print(iterator.next() + "    ");
        }
}

执行结果：

hashSet的元素个数：5
16    193    9    59    12  

6. 树集TreeSet

public static void main(String[] args){
       TreeSet<Integer> treeSet = new TreeSet<>();
       treeSet.add(36);
       treeSet.add(25);
       treeSet.add(70);
       treeSet.add(25);
       treeSet.add(33);
       treeSet.add(5);
       treeSet.add(44);
       System.out.println("treeSet 的元素个数：" + treeSet.size());

       // TreeSet虽说是有序的，但是它的有序是指元素按照一定的规则进行排序，TA实现了 Comparator 接口
       // 不像List是按照插入顺序进行排序，所以也没有get()方法，不能使用for循环进行遍历
       Iterator<Integer> treeIt = treeSet.iterator();
       while(treeIt.hasNext()){
           System.out.print(treeIt.next() + "    ");
       }
}

执行结果：

treeSet 的元素个数：6
5    25    33    36    44    70  

7. 链表集LinkedHashSet：如果需要使用 HashSet 的查找元素的高性能，同时又需要按元素插入顺序来排序，可以使用LinkedHashSet

public static void main(String[] args){
    LinkedHashSet<Integer> lhset = new LinkedHashSet<>();
    lhset.add(34);
    lhset.add(12);
    lhset.add(58);
    lhset.add(3);
    lhset.add(20);
    System.out.println("linkedHashSet 的元素个数：" + lhset.size());

    Iterator ls = lhset.iterator();
    while(ls.hasNext()){
        System.out.print(ls.next() + "    ");
    }
    System.out.println();
    // 集只有根据对象进行删除，即值，没有根据下标进行删除的操作
    System.out.println(lhset.remove(12));
    System.out.println(lhset.remove(59));
    System.out.println("删除后：" + lhset);
}

执行结果：

linkedHashSet 的元素个数：5
34    12    58    3    20    
true
false
删除后：[34, 58, 3, 20]

三、映射表Map

1、map⽤来存放键/值对，根据键就能查找到值。Java 类有映射表的两个通⽤实现：HashMap 和
TreeMap，他们都实现了 Map 接⼝。
2、散列映射表（HashMap）对键进⾏散列，散列⽐较函数只能作⽤于键，与键关联的值不能进⾏散列⽐较。树映
射表（TreeMap）⽤键的整体顺序对元素进⾏排序，并将其组织成搜索树。
3、键必须是唯⼀的，不能对同⼀个键存放两个值，但可以更新键对应的值

1. 申明
   Map<Object, Object> map = new HashMap<>();
   注：<>内最好说明键和值的数据类型，避免因为强制转换报错
2. 添加或更新键值
   map.put(Object key, Object value)
   注：put 方法，如果键已经存在，则更新对应的值，并返回更新前的值（即旧值）
3. 根据键获取值
   map.get(Object key)
4. 根据键(key)删除元素
   map.remove(Object key)
5. for 循环遍历映射表

for(Map.Entry<Integer, String> entry : map.entrySet()){
           System.out.println(entry.getKey() + "=" + entry.getValue());
       }

示例：

public static void main(String[] args){
    // map 键值对，包括键、值，可以通过键快速找到对应的值
    // 特性：
    //      1.键不能重复
    //      2.put 方法，如果键已经存在，则更新对应的值，并返回更新前的值（即旧值）
    //      3.键和值可以为 null
    Map<Integer, String> hashMap = new HashMap<>();
    hashMap.put(1, "文一,23");
    hashMap.put(2, "露儿,19");
    hashMap.put(3, "张三,17");
    System.out.println(hashMap.put(2, "李四,24"));
    System.out.println(hashMap.get(2));
    // 遍历Map
    for(Map.Entry<Integer, String> entry : hashMap.entrySet()){
        System.out.println(entry.getKey() + "=" + entry.getValue());
    }
    // 根据key删除元素
    hashMap.remove(1);
    System.out.println(hashMap);
}

执行结果：

露儿,19
李四,24
1=文一,23
2=李四,24
3=张三,17
{2=李四,24, 3=张三,17}