Java 创建和销毁对象

1、给不可实例化的类提供私有构造器

比如：每个项目中都有很多工具类，提供了很多static类型的方法供大家使用，谁也不希望看到下面的代码：

[java] view
plaincopy





TextUtils textUtils = new TextUtils();  

        if(textUtils.isDigitsOnly("123"))  

        {  

            //doSometing  

        }else  

        {  

            //doSomething  

        }  

自己写个工具类，总有人喜欢先初始化个实例在调用方法，然后还附带一个警告：The static method isDigitsOnly(CharSequence) from the type TextUtils should be accessed in a static way 。 你建议他使用类名.方法，人家还不乐意，我又没出错，干嘛要改，错了你负责么。所以最好的方式，让他没办法new实例。

为工具类添加私有构造器：

[java] view
plaincopy





public class TextUtils {  

    private TextUtils() { /* cannot be instantiated */ }  

这是android的TextUtils的源码，这样就可以了，让他妹的初始化实例~，当然你也可以在私有方法里面扔个异常。

[java] view
plaincopy





public class TextUtils  

    {  

        private TextUtils()   

        {   

            /* cannot be instantiated */   

                throw new UnsupportedOperationException("cannot be instantiated");  

        }  

      }  

对于异常的使用，一尽量使用Java提供的异常类，这样可以使你的API比较易读和易懂。

2、正确使用String，避免创建不必要的对象

很多人面试的时候都遇到过这样的问题：String s = new String("abc")；请问创建了几个对象。也从侧面说明了这是个反面的代码写法：

a、String s = new String("abc")；“abc”本身就是一个String的实例，所以new String创建了不必要的String实例

b、如果改写成 String s = "abc"，不仅只创建了一个实例，而且在同一台VM中，对于“abc”（字符串的字面常量）还会重用。

3、优先使用基本类型，Java提供了8种基本类型，以及对应的装箱基本类型，且在Java1.5 提供了自动装箱和解箱操作，虽然方便了代码的编写，但是如果不注意，可能带来不好的效果。

看下面的代码：

[java] view
plaincopy





long start = System.nanoTime();  

        Long sum = 0L;  

        for (long i = 0; i < Integer.MAX_VALUE; i++)  

        {  

            sum += i;  

        }  

        System.out.println(sum);  

        System.out.println(System.nanoTime() - start);//20995956735  

如果你观察了内存，会发现，一直GC一直在内存回收，并且计算时间需要20多秒，如果我说这段代码有个bug，导致代码运行很慢，以及耗费内存，你能找到吗？

下面我修改下代码：

[java] view
plaincopy





long start = System.nanoTime();  

        long sum = 0l;  

        for (long i = 0; i < Integer.MAX_VALUE; i++)  

        {  

            sum += i;  

        }  

        System.out.println(sum);  

        System.out.println(System.nanoTime() - start);//5029758632  

这次运行不会出现GC一直回收内存，且速度也只需要5秒左右，可能眼神不好的，没有发现哪个地方修改了。

问题就出在自动装箱、解箱上。第一次的程序sum为Long类型，在计算sum+=i；时会把sum自动解箱成long sum 然后运算，运算完成后，再装箱成Long sum，导致程序构造了大约2的32次方个多余Long实例。所以各位且用且严谨。

4、对于自己管理内存的类，一定要清除不必要的对象引用，防止内存泄漏

看下面的代码：

[java] view
plaincopy





package com.zhy._01;  

  

import java.util.Arrays;  

  

/* 

 * 使用数组模拟栈 

 */  

public class MyStack  

{  

    private static final int DEFAULT_INIT_SIZE = 10;  

  

    private Object[] eles = new Object[DEFAULT_INIT_SIZE];  

    /** 

     * 当前栈顶索引 

     */  

    private int currentIndex;  

  

    /** 

     * 弹栈 

     *  

     * @return 

     */  

    public Object pop()  

    {  

        if (currentIndex == 0)  

            throw new ArrayIndexOutOfBoundsException("stack is empty");  

        return eles[--currentIndex];  

    }  

  

    /** 

     * 压栈 

     *  

     * @param o 

     */  

    public void push(Object o)  

    {  

        ensureCapacity();  

        eles[currentIndex++] = o;  

    }  

  

    private void ensureCapacity()  

    {  

        if (eles.length == currentIndex)  

        {  

            eles = Arrays.copyOf(eles, currentIndex * 2 + 1);  

        }  

    }  

  

}  

代码中存在一个地方，导致了内存泄漏，你可以发现不？

[java] view
plaincopy





return eles[--currentIndex];  

这行代码导致，如果栈增长了特别大，然后调用多次pop弹栈，虽然currentIndex小了，但是栈始终保持中之前pop出的过期对象的引用，这就导致了内存泄漏。如果不注意甚至最终造成OOM。

应该改为：

[java] view
plaincopy





/** 

     * 弹栈 

     *  

     * @return 

     */  

    public Object pop()  

    {  

        if (currentIndex == 0)  

            throw new ArrayIndexOutOfBoundsException("stack is empty");  

        Object tmp = eles[--currentIndex];  

        eles[currentIndex] = null ;   

        return tmp ;   

    }  

当然了，不要因为担心内存泄漏，在每个变量使用完成后都添加xxx=null，对于消除过期引用的最好方法，就是让包含该引用的变量结束生命周期，而不是显示的清空。一般情况下，对于类自己管理的内存，应当警惕。