Java面试题

1、Java基本类型所占字节

boolean false/true(理论上占用1bit,1/8字节，实际处理按1byte处理)
byte 1字节
short 2字节
int 4字节
long 8字节
char 2字节（C语言中是1字节）可以存储一个汉字
float 4字节
double 8字节

2、String类能被继承吗，为什么

https://blog.youkuaiyun.com/zhaohong_bo/article/details/87912466

3、JAVA8的ConcurrentHashMap为什么放弃了分段锁，有什么问题吗，如果你来设计，你如何 设计

JDK 1.8之前
HashTable容器在竞争激烈的并发环境下表现出效率低下的原因，是因为所有访问HashTable的线程都必须竞争同一把锁，那假如容器里有多把锁，每一把锁用于锁容器其中一部分数据，那么当多线程访问容器里不同数据段的数据时，线程间就不会存在锁竞争，从而可以有效的提高并发访问效率，这就是ConcurrentHashMap所使用的锁分段技术，首先将数据分成一段一段的存储，然后给每一段数据配一把锁，当一个线程占用锁访问其中一个段数据的时候，其他段的数据也能被其他线程访问。

JDK 1.8及之后

//全程无分段锁  
public V get(Object key) {  
        Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;  
        int h = spread(key.hashCode());  
        if ((tab = table) != null && (n = tab.length) > 0 &&  
//tabAt() 里面调用了U.getObjectVolatile(tab, ((long)i << ASHIFT) + //ABASE); 亲们可能都知道数据在内存存储都是有位置的，这位置就是内存地址  
//volatile 做java的应该都知道，他可以保证数据的可见性，一般来说锁是保证了  
//可见性和顺序性。  
            (e = tabAt(tab, (n - 1) & h)) != null) {  
            if ((eh = e.hash) == h) {  
                if ((ek = e.key) == key || (ek != null && key.equals(ek)))  
                    return e.val;  
            }  
            else if (eh < 0)  
                return (p = e.find(h, key)) != null ? p.val : null;  
            while ((e = e.next) != null) {  
                if (e.hash == h &&  
                    ((ek = e.key) == key || (ek != null && key.equals(ek))))  
                    return e.val;  
            }  
        }  
        return null;  
    }  

看完了put和get果然没有分段锁了，那么它是怎么保证线程安全的呢——Unsafe.class 。运用了硬件的CAS机制保障。硬件技术推动了软件技术发展。

4、有没有有顺序的Map实现类，如果有，他们是怎么保证有序的

TreeMap（默认字典升序，可重写compare方法）和LinkedHashMap（按照插入顺序）

5、IO模型有哪些，讲讲你理解的nio ，他和bio，aio的区别是啥，谈谈reactor模型

Linux 5种IO模型，传送门
AIO、BIO、NIO，传送门
reactor模型，传送门

6、类的实例化顺序

讲讲类的实例化顺序，比如父类静态数据，构造函数，字段，子类静态数据，构造函数，字 段，当new的时候，他们的执行顺序。

class P {
	
	public static int i ;
	
	static {
		System.out.println("p.static init start. i="+i);
		i =1;
		System.out.println("p.static init finished. i="+i);
	}
	
	public P() {
		System.out.println("P() init start. i="+i);
		i =2;
		System.out.println("P() init finished. i="+i);
	}
	
}

class S extends P {
	
	public static int i;
	
	static {
		System.out.println("s.static init start. i="+i);
		i =3;
		System.out.println("s.static init finished. i="+i);
	}
	
	public S() {
		System.out.println("S() init start. i="+i);
		i =4;
		System.out.println("S() init finished. i="+i);
	}
}


public class Test {
	
	public static void main(String[] args) {
//		System.out.println(P.i);
		System.out.println(new S().i);
	}
}

输出如下：

p.static init start. i=0
p.static init finished. i=1
s.static init start. i=0
s.static init finished. i=3
P() init start. i=1
P() init finished. i=2
S() init start. i=3
S() init finished. i=4
4

根据输出可知，创建对象，引用属性时，执行顺序如下：

1. 基本变量先做初始化，比如int类型会先初始化为0
2. 执行static块（先父类，后子类）
3. 执行构造方法（先父类，后子类）