Java removeNull（）导致我的数组出现问题

我正在制作一个花名册类，其中包含学生（对象）。我应该把它们都放在一个没有任何空元素的数组中，但是当我使用removeNull（）方法时，它会将数组中的最后一个学生添加两次。有人知道我如何解决这个问题吗？我认为它与remove null方法有关，因为当我不使用它时，我没有这个问题，除非我的数组中充满了null。（不管有多少个空值，就是最后一个学生被添加到数组中的次数）如果有人知道如何解决这个问题，那就太好了，我已经尝试过了

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.LinkedList;

public class Roster {
    
    private Object [] array = new Student [10];
    private LinkedList <Student> roster = new LinkedList<Student>();
    private int counter = 0;
    
    public Roster (Student student) {// O(1) this runs in constant time
        addStudent(student);
    }

    public Student[] getArray() {// O(1) this runs in constant time
        return (Student[]) array;
    }

    public void setArray(Student[] array) {// O(1) this runs in constant time
        this.array = array;
    }

    public LinkedList<Student> getRoster() { // O(1) this runs in constant time
        return roster;
    }

    public void setRoster(LinkedList<Student> roster) {// O(1) this runs in constant time
        this.roster = roster;
    }
    
    public Object[] sort() { //O(n^2) runs n^2 times for the nested for loop
        array = roster.toArray();
        removeNull();
            for(int i =0; i < counter; i++) { // O(n)
                for(int j =1; j < counter - i; j++) // O(n)
                if((((Student) array[j - 1]).compareTo((Student) array[j])) >= 1) {
                    Student temp = (Student) array[j-1];
                    array[j-1] = array[j];
                    array[j] = temp;
            }
        }
        return array;
    } 

    public void loadRoster() { // O(n) executes the length of the array
        removeNull();
        for(int i =0; i< array.length; i++)
            System.out.println(array[i]);
    }
    
    public void addStudent(Student student) { // O(n) toArray()
        if(counter > 10) {
            System.out.println("Sorry the class is full");
        }
        else {
            roster.add(student);
            array = roster.toArray();
            counter++;
            loadRoster();
            System.out.println("Student added");
        }
    }
    
    public void removeStudent(String ID) { // O(n) toArray()
        if(counter <= 0)
            System.out.println("The class is empty");
        else {
            roster.remove(IDSearch(ID));            
            array = roster.toArray();
            counter--;
            loadRoster();
        }
    }
    public void removeNull() {
        int k = 0;
        for(int i =0; i < counter; i++) {
            if (array[i] != null)
                array[k++] = (Student) array[i];
        }   
    }

    public Student IDSearch( String IDNumber) {  // O(n) runs the for loop
        for(int i = 0; i < array.length;i++)
            if(((Student) array[i]).getIDNumber().equalsIgnoreCase(IDNumber)) {
                System.out.print(array[i]);
                System.out.println();
                System.out.println();
                return (Student) array[i];
            }
        
        System.out.println("Student not found");
        return null;
    }
    
    public Student nameSearch(String lastName , String firstName) { // O(n) for loop for array length
        for(int i = 0; i < array.length;i++)
            if((((Student) array[i]).getLastName().equalsIgnoreCase(lastName)) && (((Student) array[i]).getFirstName().equalsIgnoreCase(firstName))) {
                System.out.println(array[i]);
                return (Student) array[i];
            }
        System.out.print("Student not found");
        return null;    
    }
    
    public void save() { // constant time
        removeNull();
        sort();
        loadRoster();
    }

    public void saveChanges() throws FileNotFoundException{ // O(n) for loop to print to the new file
        save();
        File file = new File ("studentList.txt");
        
        if (file.exists())
            try {
                file.createNewFile();
            } catch (IOException e) {
                System.out.println("Error");
                e.printStackTrace();
            }
    
        PrintWriter out = new PrintWriter(file);
        for(int i =0; i <array.length; i++)
            out.println(array[i]);
        
        out.close();
    }
}

导入java.io.File；
导入java.io.FileNotFoundException；
导入java.io.IOException；
导入java.io.PrintWriter；
导入java.util.LinkedList；
公共班级名册{
私有对象[]数组=新学生[10]；
私有LinkedList花名册=新建LinkedList（）；
专用整数计数器=0；
公共花名册（学生）{//O（1）该花名册以固定时间运行
addStudent（学生）；
}
public Student[]getArray（）{//O（1）它以固定时间运行
返回（Student[]）数组；
}
public void setArray（Student[]数组）{//O（1）它以固定时间运行
this.array=数组；
}
public LinkedList getRoster（）{//O（1）它以固定时间运行
返回名册；
}
public void设置花名册（LinkedList花名册）{//O（1）它以固定时间运行
这个。花名册=花名册；
}
公共对象[]sort（）{//O（n^2）对嵌套的for循环运行n^2次
数组=花名册.toArray（）；
removeNull（）；
对于（int i=0；i=1）{
学生温度=（学生）数组[j-1]；
数组[j-1]=数组[j]；
数组[j]=温度；
}
}
返回数组；
} 
public void loadlotster（）{//O（n）执行数组的长度
removeNull（）；
for（int i=0；i10）{
System.out.println（“抱歉，课程已满”）；
}
否则{
增加（学生）；
数组=花名册.toArray（）；
计数器++；
加载花名册（）；
System.out.println（“学生添加”）；
}
}
public void removeStudent（字符串ID）{//O（n）toArray（）
如果（counter它没有两次添加最后一个学生；相反，最后一个学生从未移动过。您应该得到如下行为：

old list:  [s1,  s2,  null, s3,  s4 ]
new list:  [s1,  s2,  s3,  s4,  (s4) ]

roster.removeIf(Objects::isNull);
array = roster.toArray();

当您删除null并进行适当的移位时，列表的总大小不会改变。之后您需要适当地减小列表的大小。
顺便说一句，在这个循环中不需要强制转换到
（Student）
；类型强制转换通常是您应该避免的事情，在这里它根本不会给您带来任何好处。
既然您是从列表中创建数组的，为什么不从列表中删除空值并重新创建数组呢？类似这样：

old list:  [s1,  s2,  null, s3,  s4 ]
new list:  [s1,  s2,  s3,  s4,  (s4) ]

roster.removeIf(Objects::isNull);
array = roster.toArray();