手写泛型类、ArrayList、HashMap、Lambda熟悉一下 - 编程导航 | 一线开发者编程经验和技术实战分享

▼
text
复制代码
package cn.com.d99714.smart.practice;

/**
 * 练习 1：手写泛型类
 * 要求：Box可以装任意类型的值，通过泛型<T>实现
 */
public class GenericBox<T> {

    // TODO 1: 定义一个 private 的 T 类型字段 value
    private T value;

    // TODO 2: 写构造器，接收 T 类型参数，赋值给 value
    public GenericBox(T value) {
        this.setValue(value);
    }

    // TODO 3: 写 getValue() 方法，返回 T 类型
    public T getValue() {
        return this.value ;
    }

    // TODO 4: 写 setValue(T value) 方法
    public void setValue(T value) {
        this.value = value;
    }

    public static void main(String[] args) {
        // 测试：创建装 String 的 Box
        GenericBox<String> strBox = new GenericBox<>("Hello");
        System.out.println(strBox.getValue());

        // 测试：创建装 Integer 的 Box
        GenericBox<Integer> intBox = new GenericBox<>(100);
        System.out.println(intBox.getValue() + 50);

        // 测试：创建装 Double 的 Box，然后修改值
        GenericBox<Double> doubleBox = new GenericBox<>(3.14);
        doubleBox.setValue(2.71);
        System.out.println(doubleBox.getValue());
    }
}

▼
text
复制代码
package cn.com.d99714.smart.practice;

import cn.com.d99714.smart.entity.Worker;

import java.util.ArrayList;

/**
 * 练习2：ArrayList 增删改查
 * 要求：用 ArrayList 替代数组，完成师傅信息的完整管理
 */
public class WorkerListCrud {

    private static ArrayList<Worker> workers = new ArrayList<>();

    public static void main(String[] args) {
        // 初始化数据
        addWorker(new Worker("赵孙钱", "", "布线工", 8, 4.5));
        addWorker(new Worker("钱多多", "", "安装工", 5, 3.8));
        addWorker(new Worker("孙行者", "", "布线工", 12, 4.9));

        System.out.println("=== 初始列表 ===");
        printAll();

        System.out.println("\n=== 按姓名查找 '孙行者' ===");
        Worker found = findByName("孙行者");
        System.out.println(found != null ? found : "未找到");

        System.out.println("\n=== 删除 '钱多多' ===");
        boolean removed = removeByName("钱多多");
        System.out.println("删除结果：" + removed);
        printAll();

        System.out.println("\n=== 修改 '赵孙钱' 的评分为 5.0 ===");
        boolean updated = updateScore("赵孙钱", 5.0);
        System.out.println("修改结果：" + updated);
        printAll();

        System.out.println("\n=== 当前总人数 ===");
        System.out.println(getCount());
    }

    // TODO 1: 添加师傅到列表
    static void addWorker(Worker w) {
        workers.add(w);
    }

    // TODO 2: 遍历打印所有师傅（for-each）
    static void printAll() {
        for (Worker w : workers) {
            System.out.println(w);
        }
    }

    // TODO 3: 按姓名查找，找不到返回 null
    static Worker findByName(String name) {
        for (Worker w : workers) {
            if (w.getName().equals(name) ) {
                return w;
            }
        }
        return null;
    }

    // TODO 4: 按姓名删除，成功返回 true
    static boolean removeByName(String name) {
        Worker w = findByName(name);
        if (w != null) {
            workers.remove(w);
            return true;
        }
        return false;
    }

    // TODO 5: 按姓名修改评分，成功返回 true
    static boolean updateScore(String name, double newScore) {
        Worker w = findByName(name);
        if (w != null) {
            w.setScore(newScore);
            return true;
        }
        return false;
    }

    // TODO 6: 返回当前人数
    static int getCount() {
        if (workers.size() == 0) {
            return 0;
        }
        return workers.size();
    }
}

▼
text
复制代码
package cn.com.d99714.smart.practice;

import cn.com.d99714.smart.entity.Worker;

import java.util.HashMap;
import java.util.Map;

/**
 * 练习3：HashMap 键值对操作
 * 要求：用工号做 key，Worker 做 value，实现快速查找
 */
public class WorkerMapLookup {

    private static HashMap<String, Worker> workerMap = new HashMap<>();

    public static void main(String[] args) {
        // 注册师傅（工号 -> 对象）
        register("W001", new Worker("赵孙钱", "", "布线工", 8, 4.5));
        register("W002", new Worker("钱多多", "", "安装工", 5, 3.8));
        register("W003", new Worker("孙行者", "", "布线工", 12, 4.9));

        System.out.println("=== 按工号查找 W002 ===");
        Worker w = findById("W002");
        System.out.println(w != null ? w.getName() : "不存在");

        System.out.println("\n=== 查找不存在的 W999 ===");
        Worker notFound = findById("W999");
        System.out.println(notFound != null ? notFound.getName() : "不存在");

        System.out.println("\n=== 重复注册 W001（应该覆盖）===");
        register("W001", new Worker("赵新名", "","调试工", 3, 4.0));
        Worker updated = findById("W001");
        System.out.println(updated.getName() + " - " + updated.getJobType());

        System.out.println("\n=== 统计各工种人数 ===");
        printJobTypeStats();
    }

    // TODO 1: 注册师傅（put），如果工号已存在则覆盖
    static void register(String id, Worker w) {
        workerMap.put(id, w);
    }

    // TODO 2: 按工号查找，不存在返回 null
    static Worker findById(String id) {
        return workerMap.get(id);
    }

    // TODO 3: 判断工号是否已注册
    static boolean isRegistered(String id) {
        return workerMap.containsKey(id);
    }

    // TODO 4: 遍历 HashMap，统计各工种人数（用另一个 HashMap<String, Integer>）
    // 输出格式：布线工: 2人, 安装工: 1人
    static void printJobTypeStats() {
        HashMap<String, Integer> jobTypeCount = new HashMap<>();

        for (Worker w : workerMap.values()){
            String jobType = w.getJobType();
            int count = jobTypeCount.getOrDefault(jobType, 0) + 1;
            jobTypeCount.put(jobType,count);
        }

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

package cn.com.d99714.smart.practice;

import cn.com.d99714.smart.entity.Worker;

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

/**

练习4：Lambda 替换匿名内部类

要求：用 Lambda 表达式实现 Comparator，完成多种排序 */ public class WorkerSortLambda {

public static void main(String[] args) { ArrayList workers = new ArrayList<>();

▼
text
复制代码
 workers.add(new Worker("赵孙钱", "", "布线工", 8, 4.5));
 workers.add(new Worker("钱多多", "", "安装工", 5, 3.8));
 workers.add(new Worker("孙行者", "", "布线工", 12, 4.9));
 workers.add(new Worker("李四海", "", "调试工", 3, 4.2));

 System.out.println("=== 原始顺序 ===");
 printWorkers(workers);

 System.out.println("\n=== 按工龄升序（Lambda）===");
 // TODO 1: 用 Collections.sort + Lambda 按工龄从小到大排
 //  1. Lambda完整的写法
 Collections.sort(workers, (Worker a, Worker b) -> {
     return a.getWorkYear() - b.getWorkYear();
 });
 printWorkers(workers);

 //  2. Lambda省略参数的写法
 Collections.sort(workers, (a, b) -> {
     return a.getWorkYear() - b.getWorkYear();
 });
 //  printWorkers(workers);

 //  3. Lambda最简化的写法
 Collections.sort(workers, (a, b) -> a.getWorkYear() - b.getWorkYear());
 //  printWorkers(workers);

 System.out.println("\n=== 按评分降序（Lambda）===");
 // TODO 2: 按评分从高到低排（注意：降序是后减前）
 Collections.sort(workers, (a, b) -> Double.compare(b.getScore(), a.getScore()));
 printWorkers(workers);

 System.out.println("\n=== 按姓名拼音升序（Lambda）===");
 // TODO 3: 按 name 的 compareTo 排序
 Collections.sort(workers, (a, b) -> a.getName().compareTo(b.getName()));
 //  printWorkers(workers);

 System.out.println("\n=== 先按工种排序，同工种再按工龄降序 ===");
 // TODO 4（进阶）：多字段排序，先 jobType 升序，再 workYears 降序
 //  1. 完整写法
 Collections.sort(workers,(a, b) -> {
     int jobTypeCompare = a.getJobType().compareTo(b.getJobType());
     if (jobTypeCompare != 0){
         return jobTypeCompare;
     }
     return b.getWorkYear() - a.getWorkYear();
 });
 printWorkers(workers);

 //  2. 链式写法
 Collections.sort(workers, Comparator
         .comparing(Worker::getJobType)
         .thenComparing((a, b) -> b.getWorkYear() - a.getWorkYear()));
 //  printWorkers(workers);

 //   3. reversed，晕
 workers.sort(Comparator
         .comparing(Worker::getJobType)
         .thenComparing(Worker::getWorkYear, Comparator.reverseOrder()));
 //  printWorkers(workers);

}

static void printWorkers(ArrayList list) { for (Worker w : list) { System.out.println(w.getName() + " | " + w.getJobType() + " | " + w.getWorkYear() + "年 | " + w.getScore() + "分"); } System.out.println(); } }