Think in java备忘录

1..new在内部类中的使用

.new可以用使用外部类对象创建一个内部类，对象

DotNew.java

package com.gxf.innerclass;

public class DotNew {
    class InnerClass{                                //定义内部类
        public String toString(){
            return "this is InnerClass";
        }
    }
    public static void main(String[] args) {
        DotNew dtn = new DotNew();
        InnerClass inc = dtn.new InnerClass();        //使用外部类  + .new实例化内部类
        System.out.println(inc);
    }

}

 必须使用外部类实例来实例化内部类对象，不能直接new 外部类名.内部类名，如上面的dtn.new DotNew.InnerClass()

2.java System.arraycopy()函数只能改变数组内容，不能改变数组大小

package com.gxf.ArrayTest;

public class Test {
    public static void main(String []args){
        int dest[] = new int[]{1,2,3,4,5};
        int src[] = new int[]{6,7,8};
        System.arraycopy(src, 0, dest, 0, src.length);            //System.arraycopy()只能改变数组中的内容不能改变数组的大小
        showArray(dest);
    }
    private static void showArray(int []num){
        for(int i = 0; i < num.length; i++){
            System.out.println(num[i] + " ");
        }
    }
}

output:

6
7
8
4
5

3.java主线程退出，守护线程不会退出

这里创建通过主线程创建了一个子线程，子线程每一秒输出一个数字并且无线循环。

ThreadExit.java

/**
 * 测试主线程退出，子线程是否退出
 * @author Administrator
 *
 */
public class ThreadExit {
    
    //子线程每秒向控制台输出一个数字
    class MyThread extends Thread{
        int count = 0;
        public void run(){
            while(true){
                System.out.println("count = " + count ++);
                System.out.println("当前线程名称： " + Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                    
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }//catch
            }//while            
        }//run        
    }//class
    
    public static void main(String args[]){
        ThreadExit threadExit = new ThreadExit();
        MyThread myThread = threadExit.new MyThread();
        myThread.start();                //启动线程
        System.out.println("当前线程名称： " + Thread.currentThread().getName());
    }
}

这里并不能说明主线程已退出，注意这里说的是主线程，不是进程。

使用jps和jstack这两个工具可以看到进程中堆栈信息，这里我暂时成为堆栈信息

信息有点长就不贴出来了，从信息中可以看出，主线程是退出了，子线程并没有退出。

这个好像和c/c++有点不同

4.Iterator.remove()

API文档中是这样写的

从迭代器指向的 collection 中移除迭代器返回的最后一个元素（可选操作）。每次调用 next 只能调用一次此方法。如果进行迭代时用调用此方法之外的其他方式修改了该迭代器所指向的 collection，则迭代器的行为是不确定的。

 这里我的理解是返回最后一个next所指的元素

下面的代码中我用了一个list放了10，用Iterator来遍历list。如果5 = iterator.next(),调用iterator.remove()方法，通过最后输出list可以看出5被删除了

package com.gxf.collection;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class TestForIterator {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>();
        for(int i = 1; i <= 10;i++){
            list.add(i);
        }//for
        System.out.println(list);
        
        Iterator<Integer> iterator = list.iterator();
        while(iterator.hasNext()){
            int temp = iterator.next();
            if(temp == 5)
                iterator.remove();                //5从list中删除了
        }//while
        
        System.out.println(list);
    }
}

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[1, 2, 3, 4, 6, 7, 8, 9, 10]

5.随机种子相同，产生的随机数是一样的

package com.gxf.test;

import java.util.Random;

public class Test {    
    public static void main(String[] args) {
        Random random1 = new Random(1);
        Random random2 = new Random(1);
        
        System.out.println(random1.nextInt());
        System.out.println(random2.nextInt());
    }    
}

output:

-1155869325
-1155869325

6.类什么时候被加载/类加载时机：

第一：生成该类对象的时候，会加载该类及该类的所有父类；

第二：访问该类的静态成员的时候；

第三：class．forName("类名")；

7.java中的三种类加载器

其实在java中有三种类类加载器。

1）Bootstrap ClassLoader 此加载器采用c++编写，一般开发中很少见。

2）Extension ClassLoader 用来进行扩展类的加载，一般对应的是jre\lib\ext目录中的类

3）AppClassLoader 加载classpath指定的类，是最常用的加载器。同时也是java中默认的加载器。

这是从CSDN上面看到的，感觉是正确的，待验证