关于链表的清空（防止内存泄漏）

构建链表之后为什么要将链表清空？链表是用指针把一个个存储的空间连接起来了，用完之后不清空，很容易发生内存泄漏（内存泄漏：向系统申请分配内存进行使用(new)，可是使用完了以后却不delete，而自己出于某些原因不能再访问到那块内存（也许把它的地址给弄丢了），这时候系统也不能再次将它分配给需要的程序。）JVM内存回收 jvm内存结构分为五大区域：程序计数器、虚拟机栈、本地方法...

x.yao

4159人浏览 · 2019-11-11 20:30:30

x.yao · 2019-11-11 20:30:30 发布

构建链表之后为什么要将链表清空？

链表是用指针把一个个存储的空间连接起来了，用完之后不清空，很容易发生内存泄漏（内存泄漏：向系统申请分配内存进行使用(new)，可是使用完了以后却不delete，而自己出于某些原因不能再访问到那块内存（也许把它的地址给弄丢了），这时候系统也不能再次将它分配给需要的程序。）

JVM内存回收

jvm内存结构分为五大区域：程序计数器、虚拟机栈、本地方法栈、堆区、方法区。其中虚拟机栈、本地方法栈与程序计数器这3个区域随线程而生、随线程而灭，因此就不需要考虑过多内存垃圾回收问题，一个方法调用结束或者线程结束时，内存自然就跟随着回收了。而方法区与堆区，这部分内存的分配和回收是动态的。

垃圾回收器

那么哪些可以回收，哪些不能回收呢？
垃圾收集器在对堆区和方法区进行回收工作前，首先肯定确定这些区域内对象哪些可以被回收，哪些暂时还不能回收，这时就要用到判断对象是否存活的算法，如何失去任何引用，垃圾收集器就把它收走。

1.单链表的清空：

class ListNode{
    public int data;
    public ListNode next;

    public ListNode(int data){
        this.data=data;
        this.next=null;
    }
}//节点类


class MyLinkList{
    public ListNode head;

    public MyLinkList(){
        this.head=null;
    }


    //尾插法建立
    public void addLast(int data){
        ListNode node=new ListNode(data);
        if(this.head==null){
           this.head=node;
        }else{
            ListNode cur=this.head;
            while(cur.next!=null){
                cur=cur.next;
            }
            cur.next=node;
        }
    }

    public void display(){
        ListNode cur=this.head;
        while(cur!=null){
            System.out.print(cur.data+" ");
            cur=cur.next;
        }
        System.out.println();
    }

    //清空单链表
    public void clear(){
        //1.将每一个next域都置为空，JVM自动回收掉没有引用的节点
        while(this.head!=null){
            ListNode cur=this.head.next;
            this.head.next=null;
            this.head=cur;
        }
    }
}


public class Test {
    public static void main(String[] args) {
        MyLinkList my = new MyLinkList();
        my.addLast(3);
        my.addLast(4);
        my.addLast(5);
        my.addLast(6);
        my.display();
        System.out.println("------------");
        my.clear();
        my.display();
        System.out.println("------------");
    }
}


//打印结果
3 4 5 6 
------------

------------

2.双向链表的清空：

class ListNode{
    public int data;
    public ListNode prev;
    public ListNode next;


    public ListNode(int data){
        this.data=data;
    }
}//节点类

class DoubleList {
    public ListNode head;
    public ListNode last;

    //头插法
    public void addFirst(int data) {
        ListNode node = new ListNode(data);
        if (this.head == null) {
            this.head = node;
            this.last = node;
        } else {
            node.next = this.head;
            this.head.prev = node;
            this.head = node;
        }
    }

    public void display() {
        if (this.head == null) {
            return;
        }
        ListNode cur = this.head;
        while (cur != null) {
            System.out.print(cur.data + " ");
            cur = cur.next;
        }
        System.out.println();
    }

    //清空
    public void clear() {
        while (this.head != null) {
            ListNode cur = this.head.next;
            this.head.prev = null;
            this.head.next = null;
            this.head = cur;
        }
        this.last = null;
    }
}




public class Test {
    public static void main(String[] args) {
        DoubleList doubleList = new DoubleList();
        doubleList.addFirst(1);
        doubleList.addFirst(2);
        doubleList.addFirst(3);
        doubleList.addFirst(4);
        doubleList.addFirst(5);
        doubleList.display();
        System.out.println("-------------");
        doubleList.clear();
        doubleList.display();
    }
}


//打印结果
5 4 3 2 1 
-------------