Java数据类型：数组，集合，迭代器，set接口，Map接口

Array数组 固定长度 特定类型   ArrayList，LinkedList集合，迭代器

class NewArray {
    public static void Array1(String[] args) {
        // 定义一个整型数组，限制元素个数3个
        int[] numArray = new int[3];
        numArray[0] = 123;
        numArray[1] = 456;
        numArray[2] = 789;
        System.out.println(Arrays.toString(numArray));  //[123, 456, 789]

        //定义字符串数组
        // 方法1,
        String[] names = new String[]{"李白", "孙尚香", "诸葛亮"};
        System.out.println(Arrays.toString(names));
        // 方法2,
        String[] nameArray = {"李白", "孙尚香", "诸葛亮"};
        System.out.println(Arrays.toString(nameArray));

        // 数组中使用length方法
        for (int idx = 0; idx < nameArray.length; idx++) {
            String item = nameArray[idx];
            System.out.println(item);
        }

        //Object类型（父类） 泛指子类 得到数组多样化 但是不安全
        Object[] array1 = {"哪吒", "孙悟空", 33, 99};
        int num = (int) array1[2];
        System.out.println(num);
    }

    public static void newArrayList(String[] args) {
        // ArrayList 基于动态数组实现
        ArrayList<Object> s1 = new ArrayList<>();
        s1.add("奥特曼");
        // addAll()方法
        ArrayList<Object> s2 = new ArrayList<>(Arrays.asList("小怪兽", 123, 888, "杜甫", 999, 999));
        s1.addAll(s2);
        System.out.println(s1);

        int size = s1.size();  //获取集合中元素个数

        boolean exists = s1.contains("小怪兽");  // contains方法 是否包含某个元素 不支持模糊匹配元素

        // 增强型 for 循环的性能略低于传统的 for 循环
        // 增强型 for 循环每次迭代都会调用迭代器的 next() 方法来获取下一个元素
        for (Object item : s1) {
            System.out.println(item);
        }

        // 集合中使用size()方法
        // 传统的 for 循环直接通过索引访问元素，性能稍微更好一些
        for (int i = 0; i < s1.size(); i++) {
            Object item = s1.get(i);
            System.out.println(item);
        }

        s1.set(0, "第一位元素");   // 设置指定下标元素内容 相当于修改下标0位置元素内容

        s1.remove(3); //根据下标删除
        s1.remove(Integer.valueOf(123)); // 根据整型值删除
        s1.remove("小怪兽");    //根据字符串删除

        //removeAll() 传入一个集合包，删除所有匹配值
        ArrayList<Object> elementsList = new ArrayList<>();
        elementsList.add("杜甫");
        elementsList.add(999);
        s1.removeAll(elementsList);
        System.out.println(s1);

        String name = (String) s1.get(0);  // Object强转(String) 使用get方法获取数组中指定元素
        System.out.println(name);
    }

    public static void newLinkedList(String[] args) {
        // LinkedList 基于链表形式
        // LinkedList 在插入和删除元素时比 ArrayList 更高效，但在访问和搜索元素时可能会稍慢，因为需要从头开始遍历链表。
        LinkedList<Object> s1 = new LinkedList<>();
        s1.add("苹果");
        s1.add("桃子");
        s1.add("橘子");
        s1.add(0, "香蕉");
        s1.set(2, "哈密瓜");
        s1.push("水蜜桃");  //将元素添加到列表的开头
        System.out.println(s1);
    }

    public static void main(String[] args) {
        //关于迭代器
        ArrayList<String> s1 = new ArrayList<>(Arrays.asList("草船借箭", "调虎离山", "围魏救赵", "虎落平阳", "背水一战"));
        Iterator<String> it = s1.iterator(); //迭代器
        while (it.hasNext()) {   //it.hasNext() 是否有下一个
            String item = it.next();    //下一个
            System.out.println(item);
        }
    }
}

set接口 去重

class NewSet {
    public static void v1(String[] args) {
        // HashSet 去重,无序
        HashSet<String> s1 = new HashSet<>();
        s1.add("北京");
        s1.add("上海");
        s1.add("广州");
        System.out.println(s1);

        // TreeSet 去重,内部默认排序（ascii,unicode）
        TreeSet<String> s2 = new TreeSet<>();
        s2.add("A中国");
        s2.add("Y洪荒");
        s2.add("B美国");
        s2.add("D荷兰");
        System.out.println(s2);
    }

    public static void main(String[] args) {
        HashSet<String> s1 = new HashSet<>() {
            {
                add("北京");
                add("上海");
                add("广州");
            }
        };
        HashSet<String> s2 = new HashSet<>() {
            {
                add("北京");
                add("河南");
                add("广州");
            }
        };

        //s1.retainAll(s2);   // 交集 &     [广州, 北京]

        //s1.addAll(s2);  // 并集 |      [上海, 广州, 河南, 北京]

        //s1.removeAll(s2);   // 差集   [上海]
        s2.removeAll(s1);   // 差集   [河南]
        System.out.println(s2);
    }
}

Map接口   类似于Python中的字典

class NewMap {
    public static void main(String[] args) {
        // HashMap 无序
        HashMap<String, Integer> s1 = new HashMap<>();
        s1.put("李白", 206);
        s1.put("李清照", 19);
        s1.put("朱元璋", 81);
        s1.put("李世民", 2);
        System.out.println(s1); //{李清照=19, 李白=206, 朱元璋=81, 李世民=2}

        // TreeMap 默认根据key排序 (常用) unicode
        // （注意：）TreeMap 在逆向过程中，可能存在和Python中字典先后循环顺序不一致问题，
        // 导致循环后拼接的结果再通过加密（例如MD5加密）后得到的结果不同
        // Python处理TreeMap键值对 >> python中 sorted()方法也是根据Unicode码点排序
        // my_dict = {3: 'three', 1: 'one', 2: 'two'}
        // sorted_dict = '&'.join(['{}={}'.format(k, my_dict[k]) for k in sorted(my_dict)])   # sorted(my_dict)默认以键进行排序
        // 输出 1=one&2=two&3=three
        TreeMap<Integer, String> s2 = new TreeMap<>();
        s2.put(206, "李白");
        s2.put(19, "李清照");
        s2.put(81, "朱元璋");
        s2.put(2, "李世民");
        System.out.println(s2); //{2=李世民, 19=李清照, 81=朱元璋, 206=李白}

        s2.remove(19);
        int size = s2.size();
        String value = s2.get(81); //不存在返回null

        boolean existsKey = s2.containsKey(206);
        boolean existsValue = s2.containsValue("一节刁民");

        s2.replace(81, "赵日天");
        System.out.println(s2);


        // Map 接口提供了一个 entrySet() 方法，
        // 该方法返回一个 Set 视图，其中包含了 Map 中的键值对（Entry 对象）。
        // 每个 Entry 对象包含一个键和对应的值。
        Set<Map.Entry<Integer, String>> s3 = s2.entrySet();   //{2=李世民, 81=赵日天, 206=李白}  >> [2=李世民, 81=赵日天, 206=李白]
        Iterator<Map.Entry<Integer, String>> it = s3.iterator();    //转换为迭代器
        while (it.hasNext()) {
            Map.Entry<Integer, String> entry = it.next();
            int k = entry.getKey();
            String v = entry.getValue();
            System.out.println(k + "------" + v);
        }

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