泛型例题和垃圾回收机制

小提示：1.按Ctrl  +  Q  可以打印出来函数信息。

　　　　2.对共有的成员变量，方法和类 加注解，要用斜杠加两个星回车的方式。

一，写一个泛型类型的栈。

package L15;

import java.util.Arrays;
public class GenericStack<T> {
    private  T[] array;
    private  int top;

    public GenericStack(int size){ //Alt +insert
        this.array=(T[]) new Object[size];  //因为T是类型参数，所以不能直接new一个T类型的对象
        this.top=0;
    }

    /**
     *
     * @param data  入栈
     */
    public void push(T data){
        if(full()){  //扩容
            this.array=Arrays.copyOf(this.array,this.array.length*2);
        }
        this.array[this.top++]=data;
    }

    /**
     *
     * @return  出栈
     */
    public T pop(){
        if(empty()){   //先判断栈空
            return null;
        }
        T data =this.array[--this.top];   //注意this.top的作用域为整个类中，此处减过之后，下一行就不用减了
        this.array[this.top]=null;    //当引用变量为空时，gc将回收
        return data;
    }
    /**
     * 获取栈顶元素
     */
    public T  back(){
        if(this.top==0){   //先判断栈空
            return null;
        }
        return this.array[this.top-1];
    }
    /**
     * 判断栈空
     */
    public boolean empty(){
        return this.top==0;
    }
    /**
     * 栈满
     */
    public boolean full(){
       return this.top==this.array.length;
       }
    public int size(){
        return this.top;
    }



    public static void main(String[] args) throws InterruptedException{
       GenericStack<String>  G=new  GenericStack(20);
       for (int i = 0; i < 20;i++ ) {
            G.push(String.valueOf(i+1));
       }
      while(!G.empty()){
        System.out.print(G.pop()+" ");
       }
    }
}

运行结果：

二，定义一个学生类型的栈（通过泛型方式实现）

package L15;

import java.util.Arrays;
class Student implements Comparable<Student>{

   private  Integer id;
   private String name;
   private Integer age;
       public Student(Integer id,String name,Integer age){
        this.id=id;
        this.name=name;
        this.age=age;
    }

    @Override
    public String toString() {
        return "Student:" + "id=" + id + " name=" + name + "age=" + age ;
    }

   @Override
    public Integer compareTo( Student o) {
        //st=(Student)o;
        return this.id.compareTo(o.id);  //注意若要用compareTo()来比较，则必须保证传进来的是包装类型，如Integer ,所以简单类型 int 不行。
    }
}

/**
 * 泛型的顺序栈
 */
public class GenericStack<T> {
    private  T[] array;
    private  int top;

    public GenericStack(int size){ //Alt +insert
        this.array=(T[]) new Object[size];
        this.top=0;
    }

    /**
     *
     * @param data  入栈
     */
    public void push(T data){
        if(full()){  //扩容
            this.array=Arrays.copyOf(this.array,this.array.length*2);
        }
        this.array[this.top++]=data;
    }

    /**
     *
     * @return  出栈
     */
    public T pop(){
        if(empty()){   //先判断栈空
            return null;
        }
        T data =this.array[--this.top];   //注意this.top的作用域为整个类中，此处减过之后，下一行就不用减了
        this.array[this.top]=null;    //当引用变量为空时，gc将回收
        return data;
    }
    /**
     * 获取栈顶元素
     */
    public T  back(){
        if(this.top==0){   //先判断栈空
            return null;
        }
        return this.array[this.top-1];
    }
    /**
     * 判断栈空
     */
    public boolean empty(){
        return this.top==0;
    }
    /**
     * 栈满
     */
    public boolean full(){
       return this.top==this.array.length;
       }
    public int size(){
        return this.top;
    }



    public static void main(String[] args) throws InterruptedException{
           GenericStack<Student>  GG=new  GenericStack(5);   //定义了一个学生类型的栈
        GG.push(new Student(101,"zhangsan",20));   //往栈里放元素（元素类型为学生类）
        GG.push(new Student(103,"lisi",20));
        GG.push(new Student(102,"wangwu",20));
        GG.push(new Student(101,"张三",20));
        GG.push(new Student(101,"张三",20));
        GG.pop();       //出栈
        GG.pop();
        System.gc();
        Thread.sleep(100000);
       Student[] stu=new Student[GG.size()];     //定义一个学生类型的数组，数组名为stu
       for(int i=0;!GG.empty();i++){     //将栈里剩余的元素放到这个学生类型的数组中
           stu[i]=GG.pop();
       }
        Arrays.sort(stu);    //对数组进行排序（要对student对象进行排序，要在类名后实现Comparable接口，
                             //并在student类中对compareTo()方法进行重写
        System.out.println(Arrays.toString(stu)); //对数组元素进行打印，若元素为自定义类型，
                                                    // 则在该类型中要对toString()方法进行重写
        int[] arr=new int[]{1,1,1,2};
        System.out.println(Arrays.toString(arr)); //因为arr为Interage类型，该类型在底层已经对toString()方法进行重写过了

    }
}

       在编码的过程中因为将id定义成了简单类型int,所以在底下使用compareTo()方法时，一直报错。

在当我将所有简单类型换成包装类型Integer时，则错误消失。这是因为包装类型Integer对compareTo()方法

进行重写了，而简单类型没有，所以简单类型不能调用compareTo()方法。

 ***************************************************************************************************************

         

**********************************************************************************************************************

所以要用简单类型进行比较时，需要改成如下代码。

 

三，关于垃圾回收机制。

         如果没有被其他引用变量所引用，这个对象就可以被GC回收了，需要手动启动它。如：System.GC;

可以在命令提示符（cmd)中查看，对象有没有被回收。

方式：cmd  ->  jps  ->   jmap -histo:live  进程号  >  文件名     回车

           start.     回车

举例：

**************************************************************************************

      若出栈方式如上面所定义的，则启动垃圾回收机制，前面pop()出来的这些学生对象仍不会不会被回收，

因为pop()是通过将top指针移动来实现的，而被pop()了的对象仍被变量引用着。所以此时用cmd查看时，会

看到进程中有5个Student对象。

       所以必须要将不用的对象置为null,这样垃圾回收机制才能将不用的对象回收掉。

例如将出栈函数这样写：

 

此时运行时，在进程中就只能看到3个对象。