Java 正在尝试从Arraylist中删除对象-仍然可以访问对象

我正在尝试添加从数组列表中删除对象的函数（首先，我想为这些对象生成唯一的随机ID：

import java.util.ArrayList;
import java.util.ListIterator;
import java.util.Random;

public class Medium {
    public Medium(){
        this.id = generateID();
        System.out.println("ID: " + id);
        mlist.add(this);
    }

    protected int generateID() {
        Random random = new Random();
        int id;
        do {
            id = 100 + (random.nextInt(999-100));
        } while(idlist.contains(id));
         idlist.add(id);
        return id;
          }

    protected boolean delete(Medium delElem) {
        boolean isDeleted = false;
        ListIterator<Medium> it = mlist.listIterator(); 
                while(it.hasNext()) {
                it = mlist.listIterator();
                Medium next = it.next();
                if(delElem.getID() == next.getID()) {
                    delElem = next;
                    mlist.remove(delElem);
                    delElem = null;
                    if(delElem == null) {
                        System.out.println("Succesfull deleted");
                    }
                    isDeleted = true;
                    break;
                } 
            }
        return isDeleted;
        }
        protected int getID() {
            return id;
        }

        public String getTitle() {
            return title;
        }


    protected ArrayList<Medium> mlist = new ArrayList<Medium>();
    private ArrayList<Integer> idlist = new ArrayList<Integer>();
    protected String title;
    protected final int id;
}

import java.util.ArrayList；
导入java.util.ListIterator；
导入java.util.Random；
公共类媒体{
公共媒体（）{
this.id=generateID（）；
System.out.println（“ID:+ID”）；
添加（本）；
}
受保护的int-generateID（）{
随机=新随机（）；
int-id；
做{
id=100+（random.nextInt（999-100））；
}while（idlist.contains（id））；
idlist.add（id）；
返回id；
}
受保护的布尔删除（中等删除）{
布尔值isDeleted=false；
ListIterator it=mlist.ListIterator（）；
while（it.hasNext（））{
it=mlist.listIterator（）；
Medium next=it.next（）；
if（delElem.getID（）==next.getID（））{
delElem=next；
mlist.remove（delElem）；
delElem=null；
if（delElem==null）{
System.out.println（“成功删除”）；
}
isDeleted=真；
打破
} 
}
返回被删除；
}
受保护的int getID（）{
返回id；
}
公共字符串getTitle（）{
返回标题；
}
受保护的ArrayList mlist=新的ArrayList（）；
private ArrayList idlist=new ArrayList（）；
受保护的字符串标题；
受保护的最终int id；
}

我不确定我是否正确理解了这一点，但是如果我将delElem设置为满足相等id的对象，删除我的对象并将其设置为null，那么该对象就不应该再引用了。但是如果我在我的主函数中测试它，例如book.getTitle（），标题将被打印。我想这是因为它只是我函数中的一个局部对象。如果成功删除了对象，我如何全局删除函数中的对象并返回布尔值

---

谢谢！

评论中已经说明，您通常不会手动删除对象（通过将对象设置为null）。当不再需要对象时，垃圾收集将完成它的工作

代码中奇怪的一点是，媒体将自己添加到列表中。为什么不创建另一个表示书架的类。通过这种方式，可以在书架上实现添加或删除书籍的方法：

package com.example;

import java.util.ArrayList;
import java.util.Random;

public class BookShelf {

    protected ArrayList<Medium> mlist = new ArrayList<Medium>();
    private ArrayList<Integer> idlist = new ArrayList<Integer>();

    private class Medium {
        protected int id;
        protected String title;

        public int getId() {
            return id;
        }

        public void setId(int id) {
            this.id = id;
        }

        public String getTitle() {
            return title;
        }

        public void setTitle(String title) {
            this.title = title;
        }
    }

    public Medium addMedium(String title) {
        Medium medium = new Medium();
        medium.setId(this.generateID());
        medium.setTitle(title);
        this.mlist.add(medium);
        return medium;
    }

    protected int generateID() {
        Random random = new Random();
        int id;
        do {
            id = 100 + (random.nextInt(999 - 100));
        } while (idlist.contains(id));
        idlist.add(id);
        return id;
    }

    protected boolean delete(Medium delElem) {
        boolean isDeleted = false;
        for (Medium medium : mlist) {
            if (medium.getId() == delElem.getId()) {
                mlist.remove(medium);
                isDeleted = true;
                break;
            }
        }
        return isDeleted;
    }

    public ArrayList<Medium> getAllBooks() {
        return this.mlist;
    }

    @Override
    public String toString() {
        StringBuilder strBuilder = new StringBuilder();
        strBuilder.append("Books in the shelf: " + this.getAllBooks().size() + "\n");
        for(Medium medium : this.getAllBooks()) {
            strBuilder.append("Title: " + medium.getTitle() + "\n");
        }
        return strBuilder.toString();
    }

    public static void main(String[] args) {
        BookShelf bookShelf = new BookShelf();
        //Add two books to the shelf
        Medium medium1 = bookShelf.addMedium("Book 1");
        Medium medium2 = bookShelf.addMedium("Book 2");

        System.out.println(bookShelf.toString());

        //Delete one
        bookShelf.delete(medium1);

        System.out.println(bookShelf.toString());
    }

}

package.com.example；
导入java.util.ArrayList；
导入java.util.Random；
公共类书架{
受保护的ArrayList mlist=新的ArrayList（）；
private ArrayList idlist=new ArrayList（）；
私人类媒体{
受保护的int-id；
受保护的字符串标题；
公共int getId（）{
返回id；
}
公共无效集合id（内部id）{
this.id=id；
}
公共字符串getTitle（）{
返回标题；
}
公共无效集合标题（字符串标题）{
this.title=标题；
}
}
公共媒体addMedium（字符串标题）{
介质=新介质（）；
medium.setId（this.generateID（））；
中等。片名（片名）；
此.mlist.add（中）；
返回介质；
}
受保护的int-generateID（）{
随机=新随机（）；
int-id；
做{
id=100+（random.nextInt（999-100））；
}while（idlist.contains（id））；
idlist.add（id）；
返回id；
}
受保护的布尔删除（中等删除）{
布尔值isDeleted=false；
用于（中等：mlist）{
if（medium.getId（）==delElem.getId（））{
mlist.remove（中等）；
isDeleted=真；
打破
}
}
返回被删除；
}
公共阵列列表getAllBooks（）{
返回此.mlist；
}
@凌驾
公共字符串toString（）{
StringBuilder strBuilder=新StringBuilder（）；
strBuilder.append（“书架上的书：“+this.getAllBooks（）.size（）+”\n”）；
for（中等：this.getAllBooks（））{
strBuilder.append（“标题：+medium.getTitle（）+”\n”）；
}
返回strBuilder.toString（）；
}
公共静态void main（字符串[]args）{
BookShelf BookShelf=新书架（）；
//在书架上加两本书
Medium medium1=书架添加Medium（“第1册”）；
Medium medium2=书架添加Medium（“第二册”）；
System.out.println（bookShelf.toString（））；
//删除一个
书架.删除（中1）；
System.out.println（bookShelf.toString（））；
}
}

我认为我们需要更多的上下文，你从哪里获得了

mlist

？比把所有的代码放在这里更好的是用额外的信息编辑你的文章。这有什么关系？一旦没有引用，它就有资格成为GC。如果目标是将它从发送的列表中删除，就像你已经完成了一样。我同意Dave。明确地说，d删除对象是Java中通常不做的事情。删除不再属于它们的引用，一旦对象不再被引用，它就有资格进行垃圾收集，并且可能会从内存中消失，谁在乎呢。但是，既然你显然在主方法中保留了引用，那就不会发生了。嗯，好吧如果我从列表中删除该对象并将其声明为null，则属性不应仍然可访问。但我明白，以这种方式，这不可能在全局范围内实现。非常感谢！