面试遇到的题目

	//二分查找  非递归
    int bsearchWithoutRecursion(int a[], int key) {
        int low = 0;
        int high = a.length - 1;
        while (low <= high) {
            int mid = low + (high - low) / 2;
            if (a[mid] > key)
                high = mid - 1;
            else if (a[mid] < key)
                low = mid + 1;
            else
                return mid;
        }
        return -1;
    }
	// 二分查找 递归
    int binarysearch(int array[], int low, int high, int target) {
        if (low > high) return -1;
        int mid = low + (high - low) / 2;
        if (array[mid] > target)
            return binarysearch(array, low, mid - 1, target);
        if (array[mid] < target)
            return binarysearch(array, mid + 1, high, target);
        return mid;
    }

执行优先级
静态代码块>静态变量>普通代码块>构造函数
先执行父类（静态代码块，静态变量）在执行子类的（静态代码块，静态变量）
然后才是父类的（普通代码块，构造函数），其次是子类的（普通代码块，构造函数）

第二次的时候，
只执行父类普通代码块和构造函数和子类普通代码块和构造函数
因为静态代码块和静态变量只初始化一次

当加入了有参构造器的时候，结果有点细小的区别，就不会执行无参构造了，在代码块之后，执行有参构造（只执行子类的有参构造器）

public class Father {
	 public Father() {
	        System.out.println("加载父类构造函数---------C");
	 
	    }
	 
	    public static String fatherStaicVar = "父类静态变量";
	 
	    static {
	        System.out.println("加载父类静态代码块---------A");
	        System.out.println("加载------------B" + fatherStaicVar);
	    }
	 
	    {
	        System.out.println("加载父类普通代码块-------D");
	    }

}

public class Son extends Father{
	public Son() {
        System.out.println("加载子类构造函数----------c");
    }
 
    public static String sonStaicVar = "子类静态变量";
 
    static {
        System.out.println("加载子类静态代码块---------a");
        System.out.println("加载----------b" + sonStaicVar);
    }
 
    {
        System.out.println("加载子类普通代码块--------d");
    }


}

public class TestStaticVar {
	public static void main(String[] args) {
        Father father = new Son();
        System.out.println("========================");
        Father father2 = new Son();
	}
}

加载父类静态代码块---------A
加载------------B父类静态变量
加载子类静态代码块---------a
加载----------b子类静态变量
加载父类普通代码块-------D
加载父类构造函数---------C
加载子类普通代码块--------d
加载子类构造函数----------c
========================
加载父类普通代码块-------D
加载父类构造函数---------C
加载子类普通代码块--------d
加载子类构造函数----------c

public class TestI {
    public static void main(String[] args) {
        int i=1;
        i = i++;
        int j = i++;
        int k = i + ++i * i++;
        System.out.println("i = "+i);
        System.out.println("j = "+j);
        System.out.println("k = "+k);
    }
}
// 最后答案  4  1  11 多想一想就得出结果了

ArrayList的初始容量是多大？    		
	10
	
ArrayList的扩容机制？				
	当前元素放不下的时候，扩大到当前容量的1.5倍，然后把原数组的数据，原封不动的复制到新数组中，然后把ArrauList的地址指向新数组
	
ArrayList允许的最大容量是多少？
	就是Integer的最大值（-2的31次方~2的31次方减1）  即 2147483647
	
map的键不可重复，可以为空，有且只能有一个为空，值可以重复，也可以为空字符串

缓存穿透是指缓存和数据库中都没有的数据，而用户不断发起请求。
缓存穿透将导致不存在的数据每次请求都要到数据库去查询，失去了缓存保护后端数据库的意义。

解决方案：
接口层增加校验，如用户鉴权校验，id做基础校验，id<=0的直接拦截；
从缓存取不到的数据，在数据库中也没有取到，这时也可以将key-value对写为key-null，缓存有效时间可以设置短点，如30秒（设置太长会导致正常情况也没法使用）。这样可以防止攻击用户反复用同一个id暴力攻击

缓存击穿是指缓存中没有但数据库中有的数据（一般是缓存时间到期）。
这时由于并发用户特别多，同时读缓存没读到数据，又同时去数据库去取数据，引起数据库压力瞬间增大，造成过大压力。

解决方案：
1、设置热点数据永远不过期。
2、接口限流与熔断，降级。
3、布隆过滤器
4、加互斥锁

缓存雪崩是指缓存中数据大批量到过期时间，而查询数据量巨大，引起数据库压力过大甚至down机。
区别：和缓存击穿不同的是，缓存击穿指并发查同一条数据，缓存雪崩是不同数据都过期了，很多数据都查不到从而查数据库。

解决方案：
1、缓存数据的过期时间设置随机，防止同一时间大量数据过期现象发生。
2、如果缓存数据库是分布式部署，将热点数据均匀分布在不同的缓存数据库中。
3、设置热点数据永远不过期。

索引是什么？	索引是数据结构。索引可以提高数据的检索速度。
	
mysql的索引底层是如何实现的？
	mysql的两大常用存储引擎：
		InnoDB：聚集性索引
		MyISAM：非聚集性索引
			都B+Tree作为索引结构
	
		InnoDB 是以 ID 为索引的数据存储。
			采用 InnoDB 引擎的数据存储文件有两个，一个定义文件，一个是数据文件。
			InnoDB 通过 B+Tree 结构对 ID 建索引，然后在叶子节点中存储记录:
			
		Myisam 中的索引和数据分别存放在不同的文件，所以在索引树中的叶子节点中存的数据是该索引对应的数据记录的地址，由于数据与索引不在一起，所以 Myisam 是非聚簇索引:

如何进行SQL优化？
1、在表中建立索引，优先考虑where、group by使用到的字段。
2、尽量避免使用select *，返回无用的字段会降低查询效率
3、尽量避免使用in 和not in和or，会导致数据库引擎放弃索引进行全表扫描
4、尽量避免在字段开头模糊查询，会导致数据库引擎放弃索引进行全表扫描
5、尽量避免进行null值的判断，会导致数据库引擎放弃索引进行全表扫描
6、尽量避免在where条件中等号的左侧进行表达式、函数操作，会导致数据库引擎放弃索引进行全表扫描
7、当数据量大时，避免使用where 1=1的条件。通常为了方便拼装查询条件，我们会默认使用该条件，数据库引擎会放弃索引进行全表扫描

在查询的时候，要尽量让数据库引擎使用索引。而如何让数据库按我们的意思去使用索引就涉及到扫描参数（SARG）的概念。在数据库引擎在查询分析阶段，会使用查询优化器对查询的每个阶段（如一个带子查询的sql语句就存在不同的查询阶段）进行分析，来决定需要扫描的数据量。如果一个阶段可以被用作扫描参数，那么就可以限制搜索的数据量，从而一定程度上提高搜索效率。