Java基础19-集合示例

List

package 集合;

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

public class List集合 {
    public static void main(String[] args) {
        /* java.util.List接口 extends Collection接口
        * 特点：
        * 1. 有序
        * 2. 具有索引
        *   add()
        *   get()
        *   remove()
        *   set()
        * 3. 允许元素重复
        * */

        List<String> list = new ArrayList<>();
        list.add("Jack");
        list.add("Rose");
        list.add("Blue");
        list.add("Jack");
        System.out.println(list);
        // [Jack, Rose, Blue, Jack]  有序不重复，重写了toString方法

        list.add(2,"Black");
        System.out.println(list);
        // [Jack, Rose, Black, Blue, Jack]  2 表示索引值

        // public E remove(int index) 移除列表中指定位置的元素，返回被删除元素
        String s = list.remove(2);
        System.out.println(s); // Black

        // public E set(int index, E element) 指定元素替换,返回被替换元素
        String s2 = list.set(2,"Hong");
        System.out.println(s2);

        // 获取元素的三种方法
        // 1. 普通for循环
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        // 2. 使用迭代器
        Iterator<String> it= list.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }

        // 3.增强for循环
        for (String s1 : list) {
            System.out.println(s1);
        }
    }
}

ArrayList

package 集合;

public class ArrayList集合 {
    /* ArrayList特点：
    * 1. 底层是数组结构，查询快，增删慢
    * 2. 添加元素时，底层会创建一个新数组，将原数组就行复制并长度加一，
    *    所以ArrayList的增加效率低，查询效率高，因为查询时元素在一起。
    * 3. 不是同步的（多线程、效率高）
    * */
}

LinkedList

package 集合;

import java.util.LinkedList;
import java.util.List;

public class LinkedList集合 {
    public static void main(String[] args) {

        /* 特点：
        * 1. 底层是链表结构，查询慢，增删快
        * 2. 包含许多操作首尾元素的方法，
        * 注意：使用LinkedList集合的特有方法，不能使用多态
        * */
        // 多态形式：不能使用特有方法
        List<String> list = new LinkedList<>();
        list.add("Jack");

        LinkedList<String> list1 = new LinkedList<>();
        list1.addLast("Jack");
        list1.addFirst("Rose");
        System.out.println(list1); // [Rose, Jack]

        list1.push("Hong"); // 等效于 addFirst
        System.out.println(list1); //[Hong, Rose, Jack]

        System.out.println(list1.getFirst());
        System.out.println(list1.getLast());

        if(! list1.isEmpty()){
            System.out.println("List1 is not empty");
        }
        list1.add("Chen");
        System.out.println(list1.removeLast());
        list1.clear(); // 清空集合

    }
}

Set

package 集合;

public class Set集合 {
    public static void main(String[] args) {
        /* Set特点：
        * 1. 不包含重复元素的Collection
        * 2. 不含索引方法，也不能使用普通的for循环遍历
        * */
    }
}

HashSet

package 集合;

import java.security.SecureRandom;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class HashSet接口 {

    public static void main(String[] args) {
        /* Set实现类HashSet特点：
         * 1. 不包含重复元素的Collection
         * 2. 不含索引方法，也不能使用普通的for循环遍历
         * 3. 是一个无序的劫，存储元素和取出元素的顺序有可能不一致
         * 4. 底层是一个哈希表结构，查询的速度非常快
        * */

        Set<Integer> set = new HashSet<>();
        set.add(1);
        set.add(3);
        set.add(2);
        set.add(4);
        set.add(1);
        // 迭代器遍历
        Iterator<Integer> it = set.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        } // 1 2 3 4 与存入的顺序不一致，且去重

        // 增强for遍历
        for (Integer integer : set) {
            System.out.println(integer);
        }

        /* 哈希值：
        *  是一个十进制的整数，由系统随机给出（就是对象的地址值，是一个逻辑地址，模拟得到的地址）
        * 在Object类中有一个方法，可以获取对象的哈希值
        * int hashCode(); 返回该对象的哈希值
        * */
        String s1 = new String("abc");
        String s2 = new String("abc");
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());

        System.out.println("重地".hashCode());  // 1179395
        System.out.println("通话".hashCode());  // 1179395  特殊巧合

    }

}

Map

package 集合;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class Map集合 {
    public static void main(String[] args) {

        // 添加 put
        Map<String,String> map = new HashMap<>();
        map.put("name","Jack");
        map.put("age","20");
        map.put("school","20");
        map.put("class","20");
        map.put("money","20");
        System.out.println(map);

        // 删除 remove
        String age = map.remove("age"); // 返回被删除键的值
        String gender = map.remove("gender"); // 无该键 返回null
        System.out.println(age);
        System.out.println(gender); // null

        // 获取 get
        String name = map.get("name");
        System.out.println(name);

        // 是否存在key ContainsKey
        System.out.println(map.containsKey("name"));  // true
        System.out.println(map.containsKey("nickName"));  // false

        // 遍历集合
        Set<String> set = map.keySet();
        Iterator<String> it = set.iterator();
        while (it.hasNext()){
            String key = it.next();
            String value = map.get(key);
            System.out.println(key+"="+value);
        }

        // 增强for遍历
        for (String key : set) {
            String value = map.get(key);
            System.out.println(key+"="+value);
        }

        // 增强for循环2
        for (String key : map.keySet()) {
            String value = map.get(key);
            System.out.println(key+"="+value);
        }

        /* Entry接口
        * 当Map集合一旦创建，就会在Map集合中创建一个Entry对象，用来记录键和值（键与值得映射关系）
        * */
        Set<Map.Entry<String,String>> set1 = map.entrySet();
        Iterator<Map.Entry<String,String>> it1 = set1.iterator();
        while (it1.hasNext()){
            Map.Entry<String, String> entry = it1.next();
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key+"="+value);
        }

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

    }

}

HashMap

package 集合;

import java.util.HashMap;
import java.util.Scanner;

public class HashMap集合 {

    public static void main(String[] args) {
        func();
    }

    public static void func() {
        Scanner sc = new Scanner(System.in);
        String str = sc.next();
        HashMap<Character, Integer> map = new HashMap<>();
        char[] array = str.toCharArray();

        for (char c : array) {
            if (map.containsKey(c)) {
                Integer value = map.get(c);
                value++;
                map.put(c,value);
            } else {
                map.put(c,1);
            }
        }

        for (Character character : map.keySet()) {
            System.out.println(character+"="+map.get(character));
        }
    }
}

Collections集合工具类

package 集合;

import java.util.ArrayList;
import java.util.Collections;

public class Collections集合工具类 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        // 整体添加
        Collections.addAll(list,"a", "b", "c", "d");
        System.out.println(list);

        // 打乱集合
        Collections.shuffle(list);
        System.out.println(list);

        // 排序
        // sort 方法的适用前提：
        //      被排序的集合里存储的元素，必须实现Comparable,重写接口中的方法compareTo定义排序的规则
        ArrayList<Integer> list1 = new ArrayList<>();
        list1.add(1);
        list1.add(3);
        list1.add(2);
        list1.add(4);
        System.out.println(list1);
        Collections.sort(list1); // 默认升序
        System.out.println(list1);

        ArrayList<String> list2 = new ArrayList<>();
        Collections.addAll(list2,"a","c","b");
        Collections.sort(list2);
        System.out.println(list2);
    }
}