map，list简单方法

import java.lang.reflect.Array;
import java.util.*;
import java.util.function.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * TestDemo1：Stream 流的合并（获取流的第二种方式）
 * 练习内容：list.stream() 拿流、Stream.concat 合并两个流
 */
public class TestDemo1 {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1,2,3,4,6);
        // 获取流的方式一：集合对象.stream()
        Stream<Integer> stream = list.stream();

        List<Integer> list1 = Arrays.asList(1,2,3,4,6);
        List<Integer> list2 = Arrays.asList(6,7,8,9,10);
        List<Integer> list3 = Arrays.asList(1,2,3,4,6);

        // 合并流  获取流的方式二：Stream.concat(流1, 流2) 把两个流拼成一个
        Stream<Integer> concat = Stream.concat(list1.stream(), list2.stream());
        // 合并后的流还能再和第三个流合并（流合并可以连续拼接）
        Stream<Integer> concat1 = Stream.concat(concat, list3.stream());
        // toArray() 把流转成数组，再 Arrays.stream() 转回流，最后 toList() 收集成列表打印
        System.out.println(Arrays.stream(concat1.toArray()).toList());
    }
}

/**
 * A 类：Stream 基础练习（匿名内部类版 vs lambda 版对比）
 * 练习内容：filter 过滤、map 转换、distinct 去重、sorted 排序、
 *           collect 收集、limit 截取、count 计数、max 最大值、allMatch 判断、mapToInt 求和
 */
class A{
    public static void main(String[] args) {
        // ===== filter：过滤偶数（匿名内部类写法）=====
        List<Integer> nums = Arrays.asList(1,2,3,4,5);
        Stream<Integer> stream=nums.stream();
        stream.filter(new Predicate<Integer>() {          // filter 要传 Predicate：test 返回 true 的元素留下
            @Override
            public boolean test(Integer integer) {
                return integer%2==0;                      // 留下偶数
            }
        }).forEach(new Consumer<Integer>() {              // forEach 要传 Consumer：对每个留下的元素执行 accept
            @Override
            public void accept(Integer integer) {
                System.out.println(integer);
            }
        });
//        stream.filter(n->n%2==0).forEach(n-> System.out.println(n));   // 上面匿名内部类的 lambda 简写版

        // ===== map：转大写（方法引用版）=====
        List<String> words= Arrays.asList("java","Stream","socket");
        Stream<String> stream1 = words.stream();
        stream1.map(String::toUpperCase).forEach(System.out::println);   // map 转换，方法引用 = s -> s.toUpperCase()
//        stream1.map(new Function<String, String >() {                   // 等价匿名内部类版
//            @Override
//            public String apply(String s) {
//                return s.toUpperCase();
//            }
//        }).forEach(new Consumer<String>() {
//            @Override
//            public void accept(String s) {
//                System.out.println(s);
//            }
//        });

        // ===== distinct：去重 =====
        List<Integer> num = Arrays.asList(1, 2, 2, 3, 3, 3, 4);
        Stream<Integer> stream2 = num.stream();
        System.out.println(stream2.distinct().toList());   // 去重后收集成列表：输出 [1, 2, 3, 4]

        // ===== sorted：按长度排序 =====
        List<String> word =Arrays.asList("a","acs","oooowq","dd","qwe");
        Stream<String> stream3 = word.stream();
//        stream3.sorted(new Comparator<String>() {        // 等价匿名内部类版
//            @Override
//            public int compare(String o1, String o2) {
//                return o1.length()-o2.length();
//            }
//        }).forEach(new Consumer<String>() {
//            @Override
//            public void accept(String s) {
//                System.out.println(s);
//            }
//        });
        stream3.sorted((o1,o2)-> o1.length()-o2.length()).forEach(System.out::print);   // 按长度升序

        // ===== filter + collect：过滤后收集成新列表 =====
        List<Integer> number = Arrays.asList(10, 5, 3, 8, 1);
        Stream<Integer> stream4 = number.stream();
        List<Integer> list = stream4.filter(s -> s > 3).toList();   // 留下大于3的，收集成列表
        System.out.println(list);                                    // 输出 [10, 5, 8]

        // ===== limit：截取前 N 个 =====
        List<Integer> num1 = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);
        Stream<Integer> stream5 = num1.stream();
        System.out.println(stream5.limit(3).toList());   // 取前 3 个：输出 [1, 2, 3]

        // ===== filter + count：统计个数（count 返回 long）=====
        List<String> word1 = Arrays.asList("java", "is", "fun", "socket", "ok");
        System.out.println(word1.stream().filter(s -> s.length() > 2).count());   // 长度>2 的有 3 个

        // ===== max：最大值（返回 Optional，.get() 取出）=====
        List<Integer> num2 = Arrays.asList(5, 9, 2, 7, 1);
//        System.out.println(num2.stream().max(new Comparator<Integer>() {   // 等价匿名内部类版
//            @Override
//            public int compare(Integer o1, Integer o2) {
//                return o1 - o2;
//            }
//        }));
        System.out.println(num2.stream().max((a, b) -> a - b).get());   // 输出 9

        // ===== allMatch：判断是否全部满足条件 =====
        List<Integer> num3 = Arrays.asList(-1, 3, 5, 8);
//        System.out.println(num3.stream().allMatch(new Predicate<Integer>() {   // 等价匿名内部类版
//            @Override
//            public boolean test(Integer integer) {
//                return integer > 0;
//            }
//        }));
        System.out.println(num3.stream().allMatch(a -> a > 0));   // 有 -1 不满足：输出 false

        // ===== mapToInt + sum：求和 =====
        List<Integer> num4 = Arrays.asList(3, 5, 2);
//        System.out.println(num4.stream().mapToInt(new ToIntFunction<Integer>() {   // 等价匿名内部类版
//            @Override
//            public int applyAsInt(Integer value) {
//                return value;
//            }
//        }).sum());
        System.out.println(num4.stream().mapToInt(a -> {
            return a;
        }).sum());   // 3+5+2 = 10


    }
}

/**
 * B 类：Stream 进阶练习
 * 练习内容：reduce 归约求和、skip 跳过、findFirst 找第一个、groupingBy 分组
 */
class B{
    public static void main(String[] args) {
        // ===== reduce：把流里所有元素两两合并成一个 =====
        List<Integer> num1 = Arrays.asList(3, 5, 2);
        System.out.println(num1.stream().reduce(Integer::sum).get());   // 3+5+2 = 10
//        System.out.println(num1.stream().reduce(new BinaryOperator<Integer>() {   // 等价匿名内部类版
//            @Override
//            public Integer apply(Integer integer, Integer integer2) {
//                return integer + integer2;
//            }
//        }).get());

        // ===== skip：跳过前 N 个 =====
        List<Integer> num2 = Arrays.asList(1, 2, 3, 4, 5);
        num2.stream().skip(2).forEach(System.out::println);   // 跳过前2个，打印 3 4 5

        // ===== filter + findFirst：找第一个符合条件的（返回 Optional，orElse 兜底）=====
        List<String> word1 = Arrays.asList("java", "python", "go", "rust");
        System.out.println(word1.stream().filter(a -> a.length() > 4).findFirst().orElse("没有找到"));   // 输出 python

        // ===== groupingBy：分组（groupingBy 的参数是"分组键"函数）=====
        List<String> word2 = Arrays.asList("java", "go", "python", "rust", "c");
        Map<Integer, List<String>> map = word2.stream().collect(Collectors.groupingBy(new Function<String, Integer>() {   // 匿名内部类版
            @Override
            public Integer apply(String s) {
                return s.length();   // 按长度分组：长度相同的进同一个桶
            }
        }));
        System.out.println(map);   // 输出 {1=[c], 2=[go], 4=[java, rust], 6=[python]}


    }
}

/**
 * C 类：List 和 Map 常用方法练习
 * 练习内容：ArrayList 增删查改、LinkedList 头尾操作、HashMap 增删查、Map 三种遍历方式
 */
class C{
    public static void main(String[] args) {
        // ===== ArrayList：增删查改 =====
        List<String> list=new ArrayList<>();
        list.add("java");        // add：追加元素
        list.add("go");
        list.add("rust");
        System.out.println(list.get(1));    // get(下标)：按下标取元素，输出 go
        list.set(1,"python");               // set(下标, 新值)：替换下标1的元素
        list.add("c");                      // 末尾再追加
        list.remove(2);                     // remove(下标)：删除下标2的 "rust"
        System.out.println(list);           // 输出 [java, python, c]
//        System.out.println(list.toArray().length);   // 转数组取长度（多余，用 size 就行）
        System.out.println(list.size());    // size()：元素个数，输出 3

        // ===== LinkedList：头尾操作（ArrayList 没有这些方法）=====
        LinkedList<Integer> list1=new LinkedList<>();
        list1.add(1);
        list1.add(2);
        list1.add(3);           // 现在 [1, 2, 3]
        list1.addFirst(0);      // 头部插入 → [0, 1, 2, 3]
        list1.addLast(4);       // 尾部插入 → [0, 1, 2, 3, 4]
        System.out.println(list1.getFirst());   // 取头部：0
        System.out.println(list1.getLast());    // 取尾部：4
        list1.removeFirst() ;   // 删除头部 → [1, 2, 3, 4]
        System.out.println(list1);

        // ===== HashMap：增删查改 =====
        HashMap<String,Integer> map=new HashMap<>();
        map.put("张三",85);      // put：新增键值对
        map.put("李四",92);
        map.put("王五",78);
        System.out.println(map.get("张三"));            // get：按键取值，输出 85
        System.out.println(map.containsKey("赵六") );   // containsKey：判断键是否存在，输出 false
        map.put("王五",88);                             // 键已存在时 put = 覆盖旧值（改成绩）
        map.remove("张三");                             // remove：按键删除
        System.out.println(map.size());                 // size：现在 2 个
        System.out.println(map.keySet());               // keySet：所有键的集合
        System.out.println(map);                        // 直接打印 Map：{李四=92, 王五=88}

        // ===== Map 三种遍历方式 =====
        // 方式3：forEach（最简单，lambda 版）
        map.forEach(new BiConsumer<String, Integer>() {
            @Override
            public void accept(String s, Integer integer) {
                System.out.println(s+"="+integer);
            }
        });
        // 方式2：entrySet() 拿"键值对条目"，每条 getKey()/getValue()
        for (Map.Entry<String, Integer> stringIntegerEntry : map.entrySet()) {
            System.out.println(stringIntegerEntry.getKey()+stringIntegerEntry.getValue());
        }
        // 方式1：keySet() 拿所有键，再 get(键) 取值
        for (String s : map.keySet()) {
            System.out.println(s+"="+map.get(s));
        }


    }
}

/**
 * D 类：三种 Map 的顺序对比（同一份数据：插入顺序 b → a → c）
 * HashMap 无序 / LinkedHashMap 保持插入顺序 / TreeMap 按键排序
 */
class D{
    public static void main(String[] args) {
        // 把下面 3 组（插入顺序都是 b → a → c）分别打印 keySet，观察顺序差异：

// ① HashMap（无序，输出顺序不保证）
        HashMap<String, Integer> map1 = new HashMap<>();
        map1.put("b", 2);
        map1.put("a", 1);
        map1.put("c", 3);
        System.out.println(map1.keySet());   // 观察：无序

// ② LinkedHashMap（保持插入顺序：b → a → c）
        LinkedHashMap<String, Integer> map2 = new LinkedHashMap<>();
        map2.put("b", 2);
        map2.put("a", 1);
        map2.put("c", 3);
        System.out.println(map2.keySet());   // 观察：插入顺序

// ③ TreeMap（按键自动排序：a → b → c，底层是红黑树）
        TreeMap<String, Integer> map3 = new TreeMap<>();
        map3.put("b", 2);
        map3.put("a", 1);
        map3.put("c", 3);
        System.out.println(map3.keySet());   // 观察：键排序
        System.out.println(map3.get("a"));   // TreeMap 也能正常 get，输出 1


    }
}

/**
 * E 类：统计字符串中每个字符出现的次数（计数数组法，只适用 ASCII）
 * 思路：字符的 ASCII 码直接当数组下标，count[97] 就记 'a' 出现的次数
 */
class E{
    public static void main(String[] args) {
//        HashMap<Character, Integer> map = new HashMap<>();   // 备选：HashMap 版（下方注释掉）
        String s = "java go java rust go java c";
//        for (int i = 0; i < s.length(); i++) {               // HashMap 版：charAt 遍历
//            char c = s.charAt(i);
//            if (map.containsKey(c)) map.put(c, map.get(c) + 1);
//            else map.put(c, 1);
//        }
        int[] count = new int[128];            // ASCII 码只有 0~127，128 个位置够用
        for (char c : s.toCharArray()) {
            count[c]++;// count[字符的码值]++    // 字符的码值当下标，出现一次 +1
            System.out.println(count[c]);       // 打印每次累加后的值（调试用）
        }
        for (int i = 0; i < 128; i++) {
            if (count[i] > 0) {                 // 出现过的字符（次数>0）
                System.out.println((char) i + "=" + count[i]);   // 下标转回字符打印
            }
        }



    }
}