自定义链表中移除所有指定元素实例的教程

public class employee {
    private String number;
    private String name;
    private int years;
    private String courseName;

    // 构造函数
    public employee(String number, String name, int years, String courseName) {
        this.number = number;
        this.name = name;
        this.years = years;
        this.courseName = courseName;
    }

    // Getter方法
    public String getCourseName() {
        return courseName;
    }

    // 其他getter/setter方法...

    @Override
    public boolean equals(Object obj) {
        // 1. 检查是否为同一个对象引用
        if (this == obj) {
            return true;
        }
        // 2. 检查obj是否为null或类型不匹配
        if (obj == null || getClass() != obj.getClass()) {
            return false;
        }
        // 3. 将obj转换为employee类型
        employee other = (employee) obj;
        // 4. 比较关键属性（例如，如果只根据courseName判断相等）
        // 注意：这里假设只根据courseName来判断两个employee对象是否“相等”
        // 如果需要根据所有属性或特定组合属性判断，则需要修改比较逻辑
        if (this.courseName == null) {
            return other.courseName == null;
        }
        return this.courseName.equals(other.courseName);

        // 如果需要比较所有属性，例如：
        /*
        return Objects.equals(number, other.number) &&
               Objects.equals(name, other.name) &&
               years == other.years &&
               Objects.equals(courseName, other.courseName);
        */
    }

    @Override
    public int hashCode() {
        // 重写equals方法时通常也需要重写hashCode方法
        // 这里简化为只使用courseName
        return Objects.hash(courseName);
    }

    @Override
    public String toString() {
        return "Employee [number=" + number + ", name=" + name + ", years=" + years + ", courseName=" + courseName + "]";
    }
}

import java.util.Objects; // 用于employee类的equals和hashCode方法

// ... LinkedList类的其他代码 ...

public class LinkedList<T> implements LinkedListADT<T> {

     private int count;  // the current number of elements in the list
     private LinearNode<T> list; //pointer to the first element 
     private LinearNode<T> last; //pointer to the last element 

     // ... 构造函数、add、remove等方法 ...

    /**
     * 从链表中移除所有与给定元素相等的实例。
     *
     * @param element 要移除的元素。
     * @return 成功移除的元素数量。
     */
    public long clear(T element) {
        long removedCount = 0L; // 记录移除元素的数量

        LinearNode<T> current = this.list;
        LinearNode<T> previous = null; // 指向当前节点的前一个节点

        // 遍历链表
        while (current != null) {
            // 使用Objects.equals()处理可能为null的元素，并进行内容比较
            if (Objects.equals(current.getElement(), element)) {
                // 如果当前节点元素与目标元素相等，则移除当前节点
                if (previous != null) {
                    // 如果不是头节点，将前一个节点的next指向当前节点的next
                    previous.setNext(current.getNext());
                    // 如果当前节点是尾节点，更新last指针
                    if (current.getNext() == null) {
                        this.last = previous;
                    }
                } else {
                    // 如果是头节点，将list指针指向下一个节点
                    this.list = current.getNext();
                    // 如果链表现在为空，更新last指针
                    if (this.list == null) {
                        this.last = null;
                    }
                }
                // 减少链表元素计数
                this.count--;
                // 增加移除计数
                removedCount++;
                // 移除节点后，current不需要前进，因为previous已经跳过了它
                // 下一个要检查的节点已经是current.getNext()
                // 但是在循环的最后current会更新到下一个节点，所以这里不需要额外操作
            } else {
                // 如果当前节点元素不相等，则将previous指向current，然后current前进
                previous = current;
            }
            // 移动到下一个节点
            current = current.getNext();
        }

        return removedCount;
    }
}

public class TrainingCourses {
    // ... 其他代码 ...

    public void deleteCourses(){
        // ... 获取用户输入的employee b ...

        // 调用新的clear方法，它将移除所有匹配的员工
        long removed = list.clear(b); 
        System.out.println("成功移除了 " + removed + " 名员工。");
    }
    // ... 其他代码 ...
}