java面试(十九)--（1）使用JDBC操作数据库时，如何提升读取数据的性能？如何提升更新数据的性能（2）Java里Queue（3）SpringMVC原理（4）旋转数组的最小数字

1.使用JDBC操作数据库时，如何提升读取数据的性能？如何提升更新数据的性能？

1.进行SQL查询,当预期的结果集较大的时候,使用PreparedStatement.setFetchSize(FETCH_SIZE)或者Statement.setFetchSize(FETCH_SIZE),可以成百倍地增加性能
2. 当ResultSet很大的时候,而我们需要读取保存ResultSet里面的数据的时候,起初将所有的数据保存在List或者HashMap里,在进行多线程运行的时候,导致了Java heap space out of memory. 最终将数据逐行写入到CSV文件中,避免了性能问题
3. 在进行大量数据插入数据库的操作时,应该使用批量加入,一次执行的策略
有多种方法可以提高更新的效率. 简单说来：
1.暂停索引，更新后恢复.避免在更新的过程中涉及到索引的重建.
2.批量更新，每更新一些记录后及时进行提交动作.避免大量占用回滚段和或临时表空间.
3.创建一临时的大的表空间用来应对这些更新动作．

详细参考链接: https://www.cnblogs.com/z-zzz/articles/6547617.html

2.Java里Queue

1、LinkedBlockingQueue：基于链接节点的可选限定的blocking queue 。 这个队列排列元素FIFO（先进先出）。 队列的头部是队列中最长的元素。 队列的尾部是队列中最短时间的元素。 新元素插入队列的尾部，队列检索操作获取队列头部的元素。 链接队列通常具有比基于阵列的队列更高的吞吐量，但在大多数并发应用程序中的可预测性能较低。
blocking queue说明：不接受null元素；可能是容量有限的；实现被设计为主要用于生产者 - 消费者队列；不支持任何类型的“关闭”或“关闭”操作，表示不再添加项目实现是线程安全的；
2、PriorityQueue：
2.1、基于优先级堆的无限优先级queue 。 优先级队列的元素根据它们的有序natural ordering ，或由一个Comparator在队列构造的时候提供，这取决于所使用的构造方法。 优先队列不允许null元素。 依靠自然排序的优先级队列也不允许插入不可比较的对象（这样做可能导致ClassCastException ）。
2.2、该队列的头部是相对于指定顺序的最小元素。 如果多个元素被绑定到最小值，那么头就是这些元素之一 - 关系被任意破坏。 队列检索操作poll ， remove ， peek和element访问在队列的头部的元件。
2.3、优先级队列是无限制的，但是具有管理用于在队列上存储元素的数组的大小的内部容量 。 它始终至少与队列大小一样大。 当元素被添加到优先级队列中时，其容量会自动增长。 没有规定增长政策的细节。
2.4、该类及其迭代器实现Collection和Iterator接口的所有可选方法。 方法iterator()中提供的迭代器不能保证以任何特定顺序遍历优先级队列的元素。 如果需要有序遍历，请考虑使用Arrays.sort(pq.toArray()) 。
2.5、请注意，此实现不同步。 如果任何线程修改队列，多线程不应同时访问PriorityQueue实例。 而是使用线程安全的PriorityBlockingQueue类。
实现注意事项：此实现提供了O（log(n)）的时间入队和出队方法（ offer ， poll ， remove()和add ）; remove(Object)和contains(Object)方法的线性时间; 和恒定时间检索方法（ peek ， element和size ）。

3、ConcurrentLinkedQueue：基于链接节点的无界并发deque(deque是双端队列) 。 并发插入，删除和访问操作可以跨多个线程安全执行。 ConcurrentLinkedDeque是许多线程将共享对公共集合的访问的适当选择。像大多数其他并发集合实现一样，此类不允许使用null元素。

补充一个小的知识点:
表达式的数据类型自动提升, 关于类型的自动提升，注意下面的规则。
①所有的byte,short,char型的值将被提升为int型；
②如果有一个操作数是long型，计算结果是long型；
③如果有一个操作数是float型，计算结果是float型；
④如果有一个操作数是double型，计算结果是double型；

3.SpringMVC原理

SpringMVC是Spring中的模块，它实现了mvc设计模式的web框架，首先用户发出请求，请求到达SpringMVC的前端控制器（DispatcherServlet）,前端控制器根据用户的url请求处理器映射器查找匹配该url的handler，并返回一个执行链，前端控制器再请求处理器适配器调用相应的handler进行处理并返回给前端控制器一个modelAndView，前端控制器再请求视图解析器对返回的逻辑视图进行解析，最后前端控制器将返回的视图进行渲染并把数据装入到request域，返回给用户。
DispatcherServlet作为springMVC的前端控制器，负责接收用户的请求并根据用户的请求返回相应的视图给用户

4.旋转数组的最小数字

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非减排序的数组的一个旋转，输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。
示例代码:

import java.util.ArrayList;
public class TestRotateArray
{
    public int minNumberInRotateArray(int [] array) {
    
    }
}

实现代码:
(1)直接找出最小值

public class TestRotateArray {
    //1.直接查找最小的值
    public int minNumberInRotateArray(int [] array) {
        if(array.length==0) return 0;
        int min=array[0];
        for(int i=1;i<array.length;i++){
            if(array[i]<min){
                min=array[i];
            }
        }
        return min;
    }
    public static void main(String[] args) {
        int[] array={4,5,6,1,2,3};
        TestRotateArray test=new TestRotateArray();
        System.out.println(test.minNumberInRotateArray(array));
    }
}

(2) 由于旋转后，前面是一个递增子序列，后面是一个递增子序列，找出不是递增的那个元素

public class TestRotateArray {
    //1.旋转数组是按照递增顺序，当没有递增时,第一个没有递增的数就是最小值
    public int minNumberInRotateArray(int [] array) {
        if(array.length==0) return 0;
        for(int i=0;i<array.length-1;i++){
            if(array[i]<array[i+1]){
                continue;
            }else{
                return array[i+1];
            }
        }
        return array[0];
    }
    public static void main(String[] args) {
        int[] array={4,5,6,1,2,3};
        TestRotateArray test=new TestRotateArray();
        System.out.println(test.minNumberInRotateArray(array));
    }
}

(3) 利用二分查找。如果中间元素值>最后一个元素值，说明最小值右半区间，如果中间元素<最后一个元素区间，说明最小值在左半区间，如果相等说明有相同元素，需要将判断区间往前缩一下，继续判断，不断循环，当二分查找的的左右区间相等了，就说明找到最小值了.

public class TestRotateArray {
    public int minNumberInRotateArray(int [] array) {
        int length = array.length;
        if (length == 0)
            return 0;
        int pre = 0;//第一个元素下标
        int last = length - 1;//最后一个元素下标
        while (pre < last)
        {
            int mid = (pre + last) / 2;
            //当中间元素 大于 最后一个元素，说明最小值在右半区间
            //更新pre下标
            if (array[mid] > array[last])
            {
                pre = mid + 1;
            }
            //当中间元素 小于 最后一个元素，说明最小值在左半区间
            //但是中间这个元素，可能就是最小值，因此是 last=mid,而不是
            //last=mid-1
            else if (array[mid] < array[last]) {
                last = mid;
            }
            //当中间元素 等于 最后一个元素，说明有重复元素，将区间缩小一个
            else {
                last = last - 1;
            }
        }
        return array[pre];
    }
    public static void main(String[] args) {
        int[] array={4,5,6,1,2,3};
        TestRotateArray test=new TestRotateArray();
        System.out.println(test.minNumberInRotateArray(array));
    }
}