15个易遗忘的Java问题

1.Java中的基本数据类型以及所占内存大小

(1)整形

byte    1字节

short    2字节

int    4字节

long    8字节

(2)浮点型

float    4字节

double    8字节

(3)字符类型

char    2字节(Unicode-16)

(4)布尔类型

    布尔类型boolean比较特殊，尽管Java虚拟机定义了boolean类型，但虚拟机对boolean类型的支持是有限的，没有为boolean值单独设计JVM指令。操作布尔值的表达式在编译之后，它使用的是JVM的int数据类型，也就是占用4个字节。

JVM也不会直接支持boolean数组，boolean数组在编译之后，它的元素采用byte数据类型，用0表示false，1表示true，也就是boolean数组的元素只占用一个字节。

2.UTF-8与Unicode的关系

    Unicode是一个统一的编码标准，将现有的所有字符进行唯一编码。在第一个Unicode版本中，使用两个字节（16位）来表示一个字符，注意这里的字节并非指的是计算机内存中的存储单元，而是一个数学长度单位而已。然而，一个Unicode字符在内存中存储所占用的长度，就需要一个具体的编码规则来实现，比如UTF-8。因此，Unicode只是一个编码标准，而UTF-8是对这个标准的一个实现，UTF-8规定了一个Unicode字符在内存中占用的空间（英文和中文所占空间是不同的，有兴趣的读者可以查阅相关资料）。

代码点指的是可以用于对字符集进行编码的那些数字，比如在16位的Unicode编码字符集中，字符“A”的编码是U+0041，那么0041就是一个代码点。

代码单元指的是字符所占空间的单元。例如在UTF-32中，一个代码单元为32位，一个字符占用32位，恰好使用一个代码单元，这种方式会耗费大量内存。在UTF-16中，一个代码单元为16位，值 U+0000 至 U+FFFF 编码对应一个字符，每个字符占用一个代码单元，但是，对于超过这个范围的那些增补字符的编码，需要两个这样的单元（即32位）。而在UTF-8中，一个代码单元为8位，UTF-8 使用一至四个字节的序列对编码 Unicode 代码点进行编码，原理同UTF-32和UTF-16。

3.String字符串常量

    在Java语言中，一个String字符串常量对应着一个String对象，并且是不可更改和继承的（因为String类被final关键字修饰）。Java语言这样设计，主要是为了使得字符串常量（注意是字符串常量，字符串变量不符合这里所讲的规则）可以共享，因为JVM将字符串常量放入公共的存储池中，不同的变量可以引用相同的字符串常量。

 

public static void main(String[] args) {
    String a = “hello”;
    String b = “hello”;
    System.out.println(a == b);
}

    以上代码运行结果为：true。这就说明a和b引用的是同一String对象。

4.基本数据类型转换规则

    在双操作数运算中，会根据操作数类型将低级的一个类型转换为高级的一个类型。

1）只要两个操作数中有一个是double类型的，另一个将会被转换成double类型，并且结果也是double类型； 

2）只要两个操作数中有一个是float类型的，另一个将会被转换成float类型，并且结果也是float类型； 

3）只要两个操作数中有一个是long类型的，另一个将会被转换成long类型，并且结果也是long类型； 

4）两个操作数（包括byte、short、int、char）都将会被转换成int类型，并且结果也是int类型。

5.按值调用与按引用调用

    按值调用表示方法接收的是调用者提供的参数值。按引用调用表示方法接收的是调用者提供的是调用者提供的参数地址。Java程序设计语言总是按值调用的。下面是反例代码：

 

public void swap(Person a, Person b) {
    Person temp = a;
    a = b;
    b = tem;
}

    以上代码启动交换a和b所引用的对象，但实际编译执行会发现没有成功交换。这也就证明Java不是按引用调用的，a和b仅代表两个Person对象的值，而不是代表两个对象的引用，在参数传递上与int等基本类型的值没有区别。

6.对象初始化

    在使用构造器初始化对象时，首先运行初始化块，然后运行构造器的主题部分。调用构造器的具体初始化步骤如下：

1）类的所有数据域被初始化为默认值（0、false或null）。

2）按照在类中声明的次序，依次执行所有初始化语句和初始化块。

3）如果构造器第一行调用了第二个构造器，则执行第二个构造器。

4）执行构造器的主体。

    类第一次加载的时候，将会进行静态域的初始化。所有的静态初始化语句以及静态初始化块都将依照定义的顺序进行。

    使用super调用构造器的语句必须是子类构造器的第一条语句。

7.数组

    在Java中，子类数组的引用可以转换成父类数组的引用，而不需要采用强制类型转换。

8.继承

    在覆盖一个方法的时候，子类方法不能低于父类方法的可见性。即父类方法是protected的，子类覆盖的方法只能是protected或public的。

9.final修饰的类

    如果将一个类声明为final的，只有其中的方法自动成为final，而不包括域。

10.equals方法

    Object类的equals方法用于检测一个对象与另一个对象是否相等，即判断两个变量的引用是否相同。如果重新定义了equals方法，就必须重新定义hashCode方法，因为向散列表中添加数据时会根据hashCode和equals方法来确定插入位置。如果x.equals(y)返回true，那么x.hashCode()与y.hashCode()的返回值必须相同。

由于枚举值具有固定的实例，因此直接使用“==”就可以判定两个枚举值是否相同，而不需使用equals方法。

11.Class类

    JVM会为每个加载的类生成一个Class类型的实例，用于跟踪对象所属的类，获取Class类型实例的方法如下：

1）Object类中的getClass()方法将会返回一个Class类型的实例。

2）Class.forName(className)可以返回className指定类的Class实例。

3）MyClass.class可以返回MyClass类的Class实例。

12.局部类

    在方法中声明的类称为局部类（也属于内部类），局部类不仅能够访问包含它们的外部类，还可以访问局部变量。不过，可以被访问的局部变量必须被声明为final。

13.代理

    利用代理可以在运行时创建一个实现了一组给定接口的新类，这种功能只有在编译时无法确定需要实现哪个接口时才有必要使用。我们需要提供一个实现InvocationHandler接口的类来处理调用过程。

 

public class SaneseeProxyDemo{
    public static void main(String[] args) {
            //配置第一个代理aProxyInstance，用于代理Integer类型的a。
            Integer a = 1;
            InvocationHandler aHandler = new SaneseeHandler (a);
            Object aProxyInstance = Proxy.newProxyInstance(null, new Class[]{Comparable.class}, aHandler); //其中第一个参数null表示使用默认的类加载器，             //第二个参数表明需要代理类实现的接口，第三个参数为调用处理器类
            //配置第一个代理bProxyInstance，用于代理Integer类型的b。
            Integer b = 2;
            InvocationHandler bHandler = new SaneseeHandler (b);
            Object bProxyInstance = Proxy.newProxyInstance(null, new Class[]{Comparable.class}, bHandler);
            //输出两个代理类的比较结果
            Comparable aComparable = (Comparable)aProxyInstance;
            Comparable bComparable = (Comparable)bProxyInstance;
            System.out.println(aComparable.compareTo(b));
        }
    }
    class SaneseeHandler implements InvocationHandler
    {
        //需要代理的对象
        private Object target; 
        public SaneseeHandler (Object t)
        {
            target = t;
        }
        public Object invoke(Object proxy, Method m, Object[] args) throws Throwable
        {
            //打印被代理的对象
            System.out.print(target);
            // 打印方法名
            System.out.print("." + m.getName() + "(");
            // 打印参数
            if (args != null)
            {
                for (int i = 0; i < args.length; i++)
                {
                    System.out.print(args[i]);
                    if (i < args.length - 1) System.out.print(", ");
                }
            }
            System.out.println(")");
            // 调用方法
            return m.invoke(target, args);
        }
}

14.限定泛型变量

    关于类型变量限定的问题，一直以来是不少程序员感觉困惑的地方，本条就这个问题简要讨论一下。Java泛型一面有以下两种类型限定的泛型：

<T extends Comparable>

<T super Comparable>

    限定类型可以有多个，使用“&”分隔。比如：

<T super Comparable & Serializable>

    无论何时定义一个泛型类型，都自动提供了一个相应的原始类型。程序运行时，擦除类型变量，并替换为第一个限定类型（比如<T extends Comparable>被替换为Comparable），无限定的变量使用Object。

SaneseeDemo <T>

    不能用类型参数代替基本类型。因此没有SaneseeDemo<int>，只有SaneseeDemo<Integer>。

    不能实例化参数化类型的数组，例如：

SaneseeDemo<Integer>[] array = new SaneseeDemo<Integer>[10]; //这种写法是错误的，不能通过编译。

    这是因为array被擦除类型之后，它的类型为SaneseeDemo []，元素类型为SaneseeDemo，则相应的原始类型为Object[]，那么就可以往里面添加任何类型的元素，也就会出现类型错误。

    如果需要使用参数化类型对象，只有一种安全而有效的方法：使用ArrayList。

    同时，也不能在静态域或方法中引用类型变量，无法通过编译，比如：

 

class SaneseeSingleton<T> {
    public static T t;
    public static T getInstance() {
        //Get instance statements;
    }
}

    因为类型擦除之后，就变为原始类型Object了。如果它可以正常执行，那么任何类型的T最终都会变为Object，那么不管传入什么类型的T，最终只能获取相同的单例，这与我们想要的功能是不一致的。

    不能抛出或捕获泛型类型的异常。

    Sanesee<String>不是Sanesee<Object>的子类，因此不能将Sanesee<String>类型的值赋给Sanesee<Object>类型的值。

    不能向<? extends Employee >类型的变量调用set方法的。假设它可以执行，因为程序无法知道这个变量的具体类型，它的类型可能是Manager，也可能是Executive，那么就会出现类型转换错误。只能向这个变量调用get方法，因为程序把获得的值自动转换为Employee类型，子类型可以自动转换为父类型。

    不能向<? super Employee>类型的变量调用get方法，因为程序无法知道返回的具体类型，它的类型可能是Person，也有可能是Object。只能调用set方法，因为不管是传入Employee还是其子类，都可以成功执行。

    总之，带有super限定的通配符可以向泛型对象写入，带有extends限定的通配符可以从泛型对象读取。而Sanesee<?>和Sanesee类型的不同点在于，Sanesee<?>类型擦除以后就是Object了，所以根本无法使用Object类型的对象去调用它，只有将它放在静态方法中执行一些简单的操作。

15.多线程

    当对一个线程调用interupt方法时，线程的中断状态将被置位。每个线程都具有一个boolean类型的中断标志，通过它来判断线程是否被中断：

Thread.currentThread().isInterupted()

    线程的run方法不能抛出任何受检异常，而受检异常会导致程序终止。然而，不需要使用catch语句来处理可以被传播的异常。相反，就在线程死亡之前，异常被传递到一个用于未捕获异常的处理器。可以使用setUncaughtExceptionHandler为任何线程安装一个处理器。

    可以调用ReentrantLock的lock和unlock方法获取锁或解除锁，也可以调用条件对象Condition（由ReentrantLock的newCondition方法获取）的await和singal实现等待或通知功能。两种方式的不同点在于，lock获取到的锁，会等到程序执行结束调用unlock时才会释放，哪怕正在执行耗时比较长的任务，或者处于等待状态。而Condition在需要等待的地方调用await方法，进入等待集，当锁可用时，该线程继续保持阻塞状态，直到另一个线程调用同一条件上的singalAll方法为止（singal方法可以随机解除一个线程的阻塞状态）。然而，最好不使用Lock/Condition或synchronized关键字，可以使用java.util.concurrent包中的任何一种机制，它会为你处理所有的加锁。如果一定得使用关键字，优先使用synchronized，这样可以减少代码的数量，其次才是Lock/Condition。

    ThreadLocal类型可以使得每个线程拥有自己的独立的变量。volatile类型为实例域的访问提供了一种免锁机制，可以使得线程每次都可以访问到最新的值（volatile变量不能保证原子性）。

    ReentrantReadWriteLock类适合读数据多而写数据少的情形：

ReentrantReadWriteLock.readLock();//多个线程共享，排斥写

ReentrantReadWriteLock.writeLock();//单个线程使用，排斥读写

    官方建议放弃使用stop和suspend方法，是因为stop强制终止一个线程是极不安全的操作，而suspend本身容易导致死锁。

    在阻塞队列中，生产者向队列中插入元素，消费者向队列获取元素。当队列为空时，消费者线程会被阻塞；当队列慢时，生产者线程将被阻塞。LinkedBlockingQueue可以不限容量，而ArrayBlockingQueue需要指定容量。PriorityBlockingQueue是一个带有优先级的队列，DelayQueue需要在指定延迟慢之后才能移除元素。LinkedTransferQueue的transfer(item)方法允许生产者线程等待，直到消费者准备就绪并移除这个item元素。

    java.util.concurrent包提供了Map、集合等的并发实现，ConcurrentHashMap、ConcurrentSkipListMap、ConcurrentSkipListSet和ConcurrentLinkedQueue，允许并发访问数据结构。

    任何集合类型可以通过使用同步包装器变成线程安全的（当然最好使用java.util.concurrent包中定义的集合，因为它们经过了精心的设计）：

List<E> list = Collections.synchronizedList(new ArrayList<E>);

Map<K, V> map = Collections.synchronizedMap(new HashMap<K, V>());

Runnable封装了一个异步运行的任务，可以看做没有参数和返回值的异步方法。Callable与Runnable类似，但它有返回值。

Executors是一个线程执行器，用于管理线程的创建和执行，使用它可以创建多种线程池，常见线程池如下：

Executors.newCachedThreadPool：必要时创建新线程，空闲线程会保留60秒。

Executors.newFixedThreadPool：创建固定容量的线程池。

Executors.newSingleThreadPool：创建只有一个线程的线程池。

 

Executors.newScheduledThreadPool：用于预定指定的线程池。