java编程思想日志（一）

1.赋值操作符：
Java数据类型分为原始数据类型和对象数据类型，原始数据类型（八个）如int、boolean、double，对象类型即为Java类的实例。如果将一个原始类型赋值给另一个变量，则会复制一份，各自修改值互不干涉；而如果将对象类型赋值给另一个变量，则只是赋给它对象的引用（也就是指针），修改该对象的值两者都会修改。以下是自己测试的代码

public class Test {

    /**
     * @param args
     */
    public static void main(String[] args) {
        //测试对象类
        Tank t1 = new Tank();
        Tank t2 = new Tank();
        t1.x = 20;
        t2.x = 10;
        System.out.println("t1="+t1.x +"t2="+t2.x);
        t1 = t2;
        System.out.println("t1="+t1.x +"t2="+t2.x);
        t1.x = 30;
        System.out.println("t1="+t1.x +"t2="+t2.x);

        //测试基础数据类型
        System.out.println("--------------------");
        int x;
        int y;
        x=20;
        y=30;
        System.out.println("x="+x+"y="+y);
        x = y;
        System.out.println("x="+x+"y="+y);
        x=0;
        System.out.println("x="+x+"y="+y);
    }

}

class Tank{
    float x;
}

证明改变的的确是指向对象的指针，而对象t1原来指向的那个值10则被回收。

2.random方法：

例如：Random ran1 = new Random(10);则表示以10为种子的随机数生成器，这里的种子是可以任意指定的，种子数只是随机算法的起源数字，和生成的随机数的区间没有任何关系。

如果为Random ran1 = new Random();就是默认以当前系统时间的毫秒数作为种子数。

具体代码为下

package IO;

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

public class TestRandom {

    public static void main(String[] args) {

        // 案例2
        // 对于种子相同的Random对象，生成的随机数序列是一样的。
        Random ran1 = new Random(10);
        System.out.println("使用种子为10的Random对象生成[0,10)内随机整数序列: ");
        for (int i = 0; i < 10; i++) {
            System.out.print(ran1.nextInt(10) + " ");
        }
        System.out.println();
        Random ran2 = new Random(10);
        System.out.println("使用另一个种子为10的Random对象生成[0,10)内随机整数序列: ");
        for (int i = 0; i < 10; i++) {
            System.out.print(ran2.nextInt(10) + " ");
        }
        /**
         * 输出结果为：
         * 
         * 使用种子为10的Random对象生成[0,10)内随机整数序列: 
         * 3 0 3 0 6 6 7 8 1 4 
         * 使用另一个种子为10的Random对象生成[0,10)内随机整数序列: 
         * 3 0 3 0 6 6 7 8 1 4 
         * 
         */

        // 案例3
        // 在没带参数构造函数生成的Random对象的种子缺省是当前系统时间的毫秒数。
        Random r3 = new Random();
        System.out.println();
        System.out.println("使用种子缺省是当前系统时间的毫秒数的Random对象生成[0,10)内随机整数序列");
        for (int i = 0; i < 10; i++) {
            System.out.print(r3.nextInt(10)+" ");
        }
        /**
         * 输出结果为：
         * 
         * 使用种子缺省是当前系统时间的毫秒数的Random对象生成[0,10)内随机整数序列
         * 1 1 0 4 4 2 3 8 8 4
         *  
         */


    }


}

总结起来就是如果种子数相同，区间相同，生成的随机数也是相同的，然后rand.nextInt(10)，代表生成区间为[0,10)的整数，并且下限永远是0。同时还有nextByte(),nextBoolean()方法等，在这里就不详述了。

下面是生成不重复的数字的随机数序列的方法

// 另外，直接使用Random无法避免生成重复的数字，如果需要生成不重复的随机数序列，需要借助数组和集合类
        ArrayList list=new TestRandom().getDiffNO(10);
        System.out.println();
        System.out.println("产生的n个不同的随机数："+list);
         /**
     * 生成n个不同的随机数，且随机数区间为[0,10)
     * @param n
     * @return
     */
    public ArrayList getDiffNO(int n){
        // 生成 [0-n) 个不重复的随机数
        // list 用来保存这些随机数
        ArrayList list = new ArrayList();
        Random rand = new Random();
        boolean[] bool = new boolean[n];
        int num = 0;
        for (int i = 0; i < n; i++) {
            do {
                // 如果产生的数相同继续循环
                num = rand.nextInt(n);
            } while (bool[num]);
            bool[num] = true;
            list.add(num);
        }
        return list;
    }

原理是：例如刚开始的随机数是3，那么因为bool[3]是不存在的，所以会返回一个false值，这样结束do…while()循环，然后把这个数字的bool[3]赋值为true，这样在循环里面，如果这个数字是存在的，那么会继续循环，直到为不重复的为止，并且使用do…while循环可以先执行后判断。

3.关于“==”和“equals()的区别”
equals()比较的是两个对象的值是否相同，而==表示的是引用对象是否相同，两者之间有着本质上的差别，但是需要注意的地方是，看以下代码:

public class EqualsTest {

    public static void main(String[] args) {
        Integer n1 = new Integer(47);//个人感觉就是等于int n1 = 47;
        Integer n2 = new Integer(47);
        System.out.println(n1.equals(n2));
        System.out.println("-------------------");
        Value v1 = new Value();
        Value v2 = new Value();
        v1.i = 100;
        v2.i = 100;
        System.out.println(v1.equals(v2));
    }
    /*
     * Output: 1.true
     *           2.false
     * */


}

class Value{
    int i;
};

这里却是false，为什么呢？因为在这个地方，equals()比较的仍然是看是否是一个引用，所以除非在Value类中override equals()方法，不然是不能够直接比较值的。