集合相关使用方法

多态

       // 多态：父类引用指向子类对象
        Collection<String> c = new ArrayList<>();

迭代器遍历

    //使用迭代器遍历所有元素，并打印
    private static void print(Collection<String> c) {
        Iterator<String> it = c.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
    }

List遍历

    public static void main(String[] args) {
        // Integer 是 int 的 包装类
        List<Integer> list = new ArrayList<>();
        list.add(1); // 自动装箱
        list.add(2);
        list.add(100);
​
        //（1）for循环
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
​
        //（2）迭代器。
        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()) {
            Integer integer = iterator.next();
            System.out.println(integer);
        }
​
        //（3）增强for循环
        for (Integer i : list) {
            System.out.println(i);
        }
​
        //（4）foreach遍历
        // ctrl + Q：看方法详细信息
        list.forEach(System.out::println);
    }

队列

    public static void main(String[] args) {
        // 1、队列
        LinkedList<String> queue = new LinkedList<>();
        // 入队
        queue.addLast("一号选手");
        queue.addLast("二号选手");
        queue.addLast("三号选手");
        queue.addLast("四号选手");
        System.out.println(queue);
​
        // 出队
        System.out.println(queue.removeFirst());
        System.out.println(queue.removeFirst());
        System.out.println(queue.removeFirst());
        System.out.println(queue);
​
    }

栈

// 2、栈：先进后出
LinkedList<String> stack = new LinkedList<>();
// 压栈
stack.push("第1颗子弹");
stack.push("第2颗子弹");
stack.push("第3颗子弹");
stack.push("第4颗子弹");
System.out.println(stack);
​
// 弹栈
System.out.println(stack.pop());
System.out.println(stack.pop());
System.out.println(stack.pop());
System.out.println(stack);

Set特点

    public static void main(String[] args) {
        // Set<String> set = new HashSet<>(); // 无序、不重复、无索引
        Set<String> set = new LinkedHashSet<>(); // 有序、不重复、无索引
        set.add("张三");
        set.add("李四");
        set.add("王五");
        set.add("王五");
        set.add("赵六");
        set.add("杨宁");
​
        System.out.println(set);
        // set.get() 没有，无索引
​
        TreeSet<Integer> treeSet = new TreeSet<>(); // 排序、不重复、无索引
        treeSet.add(12);
        treeSet.add(11);
        treeSet.add(100);
        treeSet.add(100);
        treeSet.add(50);
        treeSet.add(99);
​
        System.out.println(treeSet);
    }

hashCode

    public static void main(String[] args) {
        // hashCode：对象的身份证
        
        Student s1 = new Student("张三", 18);
        Student s2 = new Student("张三", 18);
        // 同一个对象，多次调用hashCode()方法，获取的哈希值一样
        System.out.println(s1.hashCode());
        System.out.println(s1.hashCode());
        // 不同对象，哈希值极大概率不一样
        System.out.println(s2.hashCode());
​
        System.out.println("------------------------------");
​
        // 不同对象，极小概率生成的hashCode一样
        String str1 = new String("abc");
        String str2 = new String("acD");
        System.out.println(str1.hashCode());
        System.out.println(str2.hashCode());
    }

TreeSet

    public static void main(String[] args) {
        // TreeSet：排序、不重复、无索引
        Set<Student> treeSet = new TreeSet<>();
        Student s1 = new Student("张三", 19);
        Student s2 = new Student("张三", 100);
        Student s3 = new Student("张三", 7);
​
        // TreeSet：添加对象元素时，对象需要实现Comparable接口
        treeSet.add(s1);
        treeSet.add(s2);
        treeSet.add(s3);
​
        System.out.println(treeSet);
​
        System.out.println("---------------------");
​
        Set<String> treeSet2 = new TreeSet<>();
        treeSet2.add("java1");
        treeSet2.add("java3");
        treeSet2.add("java6");
        treeSet2.add("java4");
​
        System.out.println(treeSet2);
​
​
        Set<Integer> treeSet3= new TreeSet<>();
        treeSet3.add(1);
        treeSet3.add(2);
        treeSet3.add(6);
        treeSet3.add(3);
​
        System.out.println(treeSet3);
    }

遍历集合删除元素

    // 迭代器遍历删除：正确方式
    Iterator<String> it = list.iterator();
    while (it.hasNext()) {
        String name = it.next();
        if (name.contains("李")) {
            // 使用迭代器的remove()方法
            it.remove();
        }
    }
    System.out.println(list);      
   // 普通遍历删除，解决方式：remove方法后面 i--
    for (int i = 0; i < list.size(); i++) {
        String name = list.get(i);
        if (name.contains("李")) {
            list.remove(name);
            i--;
        }
    }
    System.out.println(list);
​
    // 普通遍历删除,从后往前遍历
    for (int i = list.size() - 1; i >= 0; i--) {
        String name = list.get(i);
        if (name.contains("李")) {
            list.remove(name);
        }
    }
    System.out.println(list);
​

可变参数

public class ParamTest {
    public static void main(String[] args) {
        // 计算两数的和
        System.out.println(sum(1, 2));
        // 3
        System.out.println(sum(1, 2, 3));
        System.out.println(sum(1, 2, 3, 4, 5, 6, 7, 111111));
    }
​
    // 可变参数
    public static int sum(int a, int... b) {
        // 方法体里面，可变参数int... b 变成了 int[] b
        for (int i : b) {
            a += i;
        }
        return a;
    }
​
}

Map使用

public class MapTest2 {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
​
        // 1.添加元素: 无序，不重复，无索引。 put
        map.put("啤酒", 20);
        map.put("饮料", 8);
        map.put("矿泉水", 5);
        map.put("花生", 18);
        map.put("瓜子", 30);
        map.put("八宝粥", 1);
​
        // 2.public int size():获取集合的大小
        System.out.println(map.size());
        // 3、public void clear():清空集合
        // map.clear();
        // System.out.println(map.size());
        // 4.public boolean isEmpty(): 判断集合是否为空，为空返回true ,反之！
        System.out.println(map.isEmpty());
​
        // 5.public V get(Object key)：根据键获取对应值
        System.out.println(map.get("啤酒")); // 20 (对应的value)
        System.out.println(map.get("abc")); // null
​
        // 6. public V remove(Object key)：根据键删除整个元素(删除键会返回键的值)
        map.remove("八宝粥");
        System.out.println(map);
​
        // 7.public  boolean containsKey(Object key): 判断是否包含某个键 ，包含返回true ,反之
        System.out.println(map.containsKey("瓜子"));
​
        // 8.public boolean containsValue(Object value): 判断是否包含某个值。
        System.out.println(map.containsValue(20));
​
        // 9.public Set<K> keySet(): 获取Map集合的全部键。
        Set<String> set = map.keySet();
        System.out.println(set);
​
​
        // 10.public Collection<V> values(); 获取Map集合的全部值。
        Collection<Integer> values = map.values();
        System.out.println(values);
​
        // 11.void putAll(Map m) 把其他Map集合的数据倒入到自己集合中来。(拓展)
        HashMap<String, Integer> map1 = new HashMap<>();
        map1.put("java",20);
​
        HashMap<String, Integer> map2 = new HashMap<>();
        map2.put("php",30);
        map2.put("c++",40);
​
        map1.putAll(map2);
        System.out.println(map1);
    }
}

Map遍历

public class MapTest3 {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>(); // 有序、不重复、无索引
        map.put("啤酒", 20);
        map.put("饮料", 8);
        map.put("矿泉水", 5);
        map.put("花生", 18);
        map.put("瓜子", 30);
        map.put("八宝粥", 1);
​
        // 方法参数是抽象类、接口时：用匿名内部类写
        map.forEach(new BiConsumer<String, Integer>() {
            @Override
            public void accept(String s, Integer integer) {
                System.out.println("key=" + s + " value=" + integer);
            }
        });
​
        // 通过idea把代码转为lambda形式
        // shift + f6：更改光标指示的代码的名字
        map.forEach((key, value) -> System.out.println("key=" + key + " value=" + value));
    }
}

集合嵌套

    public static void main(String[] args) {
        // 定义一个Map存省份和对应的市的集合
        //  * 江苏省 = "南京市","扬州市","苏州市“,"无锡市","常州市"
        //  * 湖北省 = "武汉市","孝感市","十堰市","宜昌市","鄂州市"
        //  * 河北省 = "石家庄市","唐山市", "邢台市", "保定市", "张家口市"
        List<String> list1 = new ArrayList<>();
        Collections.addAll(list1, "南京市", "扬州市", "苏州市", "无锡市", "常州市");
​
        List<String> list2 = new ArrayList<>();
        Collections.addAll(list2, "武汉市", "孝感市", "十堰市", "宜昌市", "鄂州市");
​
        List<String> list3 = new ArrayList<>();
        Collections.addAll(list3, "石家庄市", "唐山市", "邢台市", "保定市", "张家口市");
​
        // 集合嵌套：集合的一个元素是集合，最常见的集合嵌套：Map<String, List<String>> map = new HashMap<>();
        Map<String, List<String>> map = new HashMap<>();
        map.put("江苏省", list1);
        map.put("湖北省", list2);
        map.put("河北省", list3);
​
        List<String> list = map.get("河北省");
        System.out.println(list);
    }