http://blog.csdn.net/qq_34120041/article/details/67636202
http://www.cnblogs.com/xrq730/p/5260294.html
刷题是为了检测自己学习成果
面试准备需要提前准备一个月
没有平庸的项目只有平庸的人
- 亮点总结
–Java部分
*private、默认、protected、public作用范围
1）private，同类
2）默认，同类、同包
3）protected，同类，同包，子类
4）public，所有
*String直接赋值和new String()的区别：https://www.cnblogs.com/qiaoyanlin/p/6877628.html
*Java基础之三大特性
1、封装：
概念：隐藏对象的成员变量和方法，只对外提供公共的访问方式
优点：将变化隔离、便于使用、提高复用性、提高安全性
2、继承：
优点：提高代码复用性，同时继承是多态的前提
注意：子类所有的构造函数都会默认访问父类中的空参数的构造函数，默认第一行有super()，若无空参数构造函数，需要在子类中指定
3、多态：顾名思义同种引用不同的实现
环境：父类或接口的引用变量可以指向子类或具体实现类的实例对象
有点：提高程序的扩展性
弊端：父类引用指向子类对象时，虽然提高了扩展性，但只能访问父类中具备的方法，不可以方法问子类中的方法。访问局限性。
继承和多态的区别
继承，子类继承父类中所以的属性和方法，但是对于private的属相和方法，由于这个是父类的隐私，所以子类虽然是继承了，但是没有可以访问这些属性和方法的引用，所以相当于没有继承到。很多时候，可以理解为，没有继承。
多态：就是父类引用可以持有子类对象。这时候只能调用父类中的方法，而子类中特有方法是无法访问的，因为这个时候（编译时）你把他看作父类对象的原因，但是到了运行的时候，编译器就会发现这个父类引用中原来是一个子类的对像，所以如果父类和子类中有相同的方法时，调用的会是子类中的方法，而不是父类的(即重载)。
可以这么说：编译时看父类，运行时看子类。
*抽象类与接口的异同
https://blog.csdn.net/wangxin1982314/article/details/70804793
同：具有抽象方法
异：
1）抽象类可以有构造器，非抽象方法，非公有属性，仅可以单继承抽象类
2）接口仅有公有抽象方法或者公有静态常量，可以同时实现多个接口
通俗说法：接口比抽象类更抽象（接口不能有属性，只能有方法，但抽象类可以，抽象类还可以有具体实现的方法，接口则只能有抽象方法），对于抽象类，如果需要添加新的方法，可以直接在抽象类中添加具体的实现，子类可以不进行变更；而对于接口则不行，如果接口进行了变更，则所有实现这个接口的类都必须进行相应的改动。
个人使用经验：一般在控制层使用抽象类，提取公共初始化方法、框架定制化工具方法等
一般会在业务层使用接口
1、方法继承：利用extends关键字一个方法继承另一个方法，而且只能直接继承一个类。
当Sub类和Base类在同一个包时Sub类继承Base类中的public/protected/默认级别的变量个方法
在不同包时继承public/protected级别的变量和方法。
2、方法重载：如果有两个方法的方法名相同，但参数不一致，哪么可以说一个方法是另一个方法的重载。
方法名相同
方法的参数类型，个数顺序至少有一项不同
方法的返回类型可以不相同
方法的修饰符可以不相同
main方法也可以被重载
3、方法覆盖：如果在子类中定义一个方法，其名称、返回类型及参数签名正好与父类中某个方法的名称、返回类型及参数签名相匹配，那么可以说，子类的方法覆盖了父类的方法。
子类的方法名称返回类型及参数签名 必须与父类的一致
子类方法不能缩小父类方法的访问权限
子类方法不能抛出比父类方法更多的异常
方法覆盖只存在于子类和父类之间，同一个类中只能重载
父类的静态方法不能被子类覆盖为非静态方法
子类可以定义于父类的静态方法同名的静态方法，以便在子类中隐藏父类的静态方法（满足覆盖约束），
而且Java虚拟机把静态方法和所属的类绑定，而把实例方法和所属的实例绑定。
父类的非静态方法不能被子类覆盖为静态方法
父类的私有方法不能被子类覆盖
父类的抽象方法可以被子类通过两种途径覆盖（即实现和覆盖）（P169）
父类的非抽象方法可以被覆盖为抽象方法
4、Super关键字：super和this关键字都可以用来覆盖Java语言的默认作用域，使被屏蔽的方法或变量变为可见。
父类的成员变量和方法为private使用super访问编译出错
在类的构造方法种，通过super语句调用这个类的父类的构造方法
在子类种访问父类的被屏蔽的方法和属性
只能在构造方法或实例方法内使用super关键字，而在静态方法和静态代码块内不能使用super
5、多态：
对于一个引用类型的变量，Java编译器按照它的声明的类型来处理
对于一个引用类型的变量，运行时Java虚拟机按照它的实际引用的对象来处理
运行时环境中，通过引用类型变量来访问所引用对象的方法和属性时，Java虚拟机采用以下绑定规则
1）实例方法与引用变量实际引用的对象的方法绑定，属于动态绑定
2）静态方法与引用变量所声明的类型的方法绑定，属于静态绑定
3）成员变量（包括静态和实例变量）与引用变量所声明的类型的成员变量绑定，属于静态绑定
6、继承的利弊和使用原则：
集成数的层次不可太多
集成数的上层为抽象层
1）定义了下层子类都用友的相同属性和方法，并且尽可能默认实现，从而提高重用性
2）代表系统的接口，描述系统所能提供的服务
继承关系最大的弱点：打破封装
精心设计专门用于被继承的类
1）对这些类必须提供良好的文档说明
2）尽可能的封装父类的实现细节，把代表时间细节的属性和方法定义为private类型
3）如果某些实现细节必须被子类访问，定义为protected类型
4）把不允许子类覆盖的方法定义为final类型
5）父类的构造方法不允许调用可被子类覆盖的方法
6）如果某些类不是专门为了继承而设计，那么随意继承它是不安全的
*ArrayList和LinkedList的大致区别：
1.ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。
2.对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。
3.对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。
*HashMap的实现原理
通过hash的方法，通过put和get存储和获取对象。存储对象时，我们将K/V传给put方法时，它调用hashCode计算hash从而得到bucket位置，进一步存储，HashMap会根据当前bucket的占用情况自动调整容量(超过Load Facotr则resize为原来的2倍)。获取对象时，我们将K传给get，它调用hashCode计算hash从而得到bucket位置，并进一步调用equals()方法确定键值对。如果发生碰撞的时候，Hashmap通过链表将产生碰撞冲突的元素组织起来，在Java 8中，如果一个bucket中碰撞冲突的元素超过某个限制(默认是8)，则使用红黑树来替换链表，从而提高速度。
【冲突产生的原因：你可以把hash想象成一个数组，现在你想把一个数据存到hash表中。那么问题来了：这个数据应该存到哪里？
于是，你需要一个hash函数，这个函数的作用就是把你要存的数据映射成hash表中的一个位置，这个位置就是你要存放该数据的地方。一般把hash表的每个位置都叫做“槽（slot）”，很形象，你要往槽里放数据。假如你要存的数据为k，存放在哪个槽里呢？很简单，存在hash（k）这个槽里。
这个hash函数是你自己选的。这里我以《算法导论》里面的一个题目举例：现在你选的hash函数是这样的：
hash(k) = k mod 9
假设hash表的大小为9（即有9个槽），现在要把一串数据存到表里：5,28,19,15,20,33,12,17,10
简单计算一下：hash(5)=5, 所以数据5应该放在hash表的第5个槽里；hash(28)=1，所以数据28应该放在hash表的第1个槽里；hash(19)=1，也就是说，数据19也应该放在hash表的第1个槽里——于是就造成了碰撞（也称为冲突，collision）。解决冲突的方法有拉链法，开放定址法等，就不多说了】
*Java中的transient关键字的作用：transient是Java语言的关键字，用来表示一个域不是该对象串行化的一部分。当一个对象被串行化的时候，transient型变量的值不包括在串行化的表示中，然而非transient型的变量是被包括进去的。
*List、Set、Collections区别
1）List，有序可重复
2）Set， 无序不可重复
3）Collections，集合工具类
*Collection和Collections的区别
java.util.Collection 是一个集合接口。它提供了对集合对象进行基本操作的通用接口方法。Collection接口在Java 类库中有很多具体的实现。Collection接口的意义是为各种具体的集合提供了最大化的统一操作方式。
Collection
├List
│├LinkedList
│├ArrayList
│└Vector
│ └Stack
└Set
java.util.Collections 是一个包装类。它包含有各种有关集合操作的静态多态方法。此类不能实例化，就像一个工具类，服务于Java的Collection框架。Collections中常用的方法有Collections.sort(),Collectios.max(),Collections.binarySearch(),Collections.replaceAll(),Collections.reverse(),Collections.fill()等等
*向上转型，向下转型
向下转型Father f = new Son();
向上转型Son s = new Father();
*Java 启动线程三种方式
继承Thread，实现Runnable接口，直接在函数体使用
实现Runnable接口优势：
1）适合多个相同的程序代码的线程去处理同一个资源
2）可以避免Java中的单继承的限制
3）增加程序的健壮性，代码可以被多个线程共享，代码和数据独立。
继承Thread类优势：
1）可以将线程类抽象出来，当需要使用抽象工厂模式设计时。
2）多线程同步（值得商榷，实现Runnable接口也可以实现多线程同步）
在函数体使用优势
1）无需继承thread或者实现Runnable，缩小作用域。
另外，实现Runnable接口的线程自身无法启动，只能通过系统线程启动，如：Thread t = new Thread(new Runnable()).start();
*Java实现多线程的3种方法：继承Thread类、实现runnable接口、使用ExecutorService，Callable、Future实现有返回值的多线程。前2种线程的实现方式没有返回值，第三种实现方式可以获取线程执行的返回值。
*线程池的submit和execute方法的区别：前者执行会返回一个future对象，可以通过这个future对象获取到线程内部的内容，后者只是会执行线程，但是没有返回
*三次握手和四次挥手
1. 三次握手
第一次握手：客户端发送syn包(syn=x)到服务器，并进入SYN_SEND状态，等待服务器确认；
第二次握手：服务器收到syn包，必须确认客户的SYN（ack=x+1），同时自己也发送一个SYN包（syn=y），即SYN+ACK包，此时服务器进入SYN_RECV状态；
第三次握手：客户端收到服务器的SYN＋ACK包，向服务器发送确认包ACK(ack=y+1)，此包发送完毕，客户端和服务器进入ESTABLISHED状态，完成三次握手。握手过程中传送的包里不包含数据，三次握手完毕后，客户端与服务器才正式开始传送数据。
理想状态下，TCP连接一旦建立，在通信双方中的任何一方主动关闭连接之前，TCP连接都将被一直保持下去。
确认号：其数值等于发送方的发送序号+1(即接收方期望接收的下一个序列号)。
2. 四次挥手
第一次挥手：主动关闭方发送一个FIN，用来关闭主动方到被动关闭方的数据传送，也就是主动关闭方告诉被动关闭方：我已经不会再给你发数据了(当然，在fin包之前发送出去的数据，如果没有收到对应的ack确认报文，主动关闭方依然会重发这些数据)，但是，此时主动关闭方还可以接受数据。
第二次挥手：被动关闭方收到FIN包后，发送一个ACK给对方，确认序号为收到序号+1（与SYN相同，一个FIN占用一个序号）。
第三次挥手：被动关闭方发送一个FIN，用来关闭被动关闭方到主动关闭方的数据传送，也就是告诉主动关闭方，我的数据也发送完了，不会再给你发数据了。
第四次挥手：主动关闭方收到FIN后，发送一个ACK给被动关闭方，确认序号为收到序号+1，至此，完成四次挥手。
*重写就是再写一遍，重载就是再多一个。
重写：父类里有，子类再照猫画虎写一个。
重载：自己类里面有，觉得不够再写一个。
java的重写,是指在子类中对父类的某方法进行重新定义,其子类的该方法名以及参数搜索位置和个数均与父类相同,从而在调用子类的该方法时,不会执行父类的方法.如果在父类中以final定义的方法,在子类中无法重写.
1、重载:
方法名相同，参数列表不同
2、重写：
也叫覆盖，指在子类中定义一个与父类中方法同名同参数列表的方法。因为子类会继承父类的方法，而重写就是将从父类继承过来的方法重新定义一次，重新填写方法中的代码。
重写方法上可以加@Override，重载不可以
重写是覆盖,重载是多态
*覆写equals方法必须覆写hashCode方法是为了保证数据的唯一性
解释：对象存入带hash的集合，如hashSet，hashMap，都要基于hashCode和equals方法，当hashCode方法返回的值一样时，还会调用equals方法判断，如果两个方法返回的都是一致，才判断两个对象是同一个对象，不存入集合（带hash的集合都保证数据是唯一的！)。
equals是object类的方法，所有没有重写这个方法的类中的这个方法比较的都是地址，也就是和’==’是一样的，重写过这个方法的类就按照重写的方法来比较，比如String类就重写了这个方法，比较的是内容。
当你对比两个对象时，在选择==和equals方法中很容易困惑，当你比较的两个引用指向的对象是Object的类型的时候，那么你看到的结果和==是一致的，因为默认的equals方法实现仅仅比较的内存地址。
*乐观锁和悲观锁的区别（最全面的分析）
悲观锁(Pessimistic Lock), 顾名思义，就是很悲观，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会block直到它拿到锁。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。它指的是对数据被外界（包括本系统当前的其他事务，以及来自外部系统的事务处理）修改持保守态度，因此，在整个数据处理过程中，将数据处于锁定状态。悲观锁的实现，往往依靠数据库提供的锁机制（也只有数据库层提供的锁机制才能真正保证数据访问的排他性，否则，即使在本系统中实现了加锁机制，也无法保证外部系统不会修改数据）。
乐观锁(Optimistic Lock), 顾名思义，就是很乐观，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号等机制。乐观锁适用于多读的应用类型，这样可以提高吞吐量，像数据库如果提供类似于write_condition机制的其实都是提供的乐观锁。
两种锁各有优缺点，不可认为一种好于另一种，像乐观锁适用于写比较少的情况下，即冲突真的很少发生的时候，这样可以省去了锁的开销，加大了系统的整个吞吐量。但如果经常产生冲突，上层应用会不断的进行retry，这样反倒是降低了性能，所以这种情况下用悲观锁就比较合适。
本质上，数据库的乐观锁做法和悲观锁做法主要就是解决下面假设的场景，避免丢失更新问题：
一个比较清楚的场景
下面这个假设的实际场景可以比较清楚的帮助我们理解这个问题：
假设当当网上用户下单买了本书，这时数据库中有条订单号为001的订单，其中有个status字段是’有效’,表示该订单是有效的；
后台管理人员查询到这条001的订单，并且看到状态是有效的
用户发现下单的时候下错了，于是撤销订单，假设运行这样一条SQL: update order_table set status = ‘取消’ where order_id = 001;
后台管理人员由于在b这步看到状态有效的，这时，虽然用户在c这步已经撤销了订单，可是管理人员并未刷新界面，看到的订单状态还是有效的，于是点击”发货”按钮，将该订单发到物流部门，同时运行类似如下SQL，将订单状态改成已发货:update order_table set status = ‘已发货’ where order_id = 001
观点1：只有冲突非常严重的系统才需要悲观锁；“所有悲观锁的做法都适合于状态被修改的概率比较高的情况，具体是否合适则需要根据实际情况判断。”，表达的也是这个意思，不过说法不够准确；的确，之所以用悲观锁就是因为两个用户更新同一条数据的概率高，也就是冲突比较严重的情况下，所以才用悲观锁。
观点2：最后提交前作一次select for update检查，然后再提交update也是一种乐观锁的做法，的确，这符合传统乐观锁的做法，就是到最后再去检查。但是wiki在解释悲观锁的做法的时候，’It is not appropriate for use in web application development.’， 现在已经很少有悲观锁的做法了，所以我自己将这种二次检查的做法也归为悲观锁的变种，因为这在所有乐观锁里面，做法和悲观锁是最接近的，都是先select for update，然后update
在实际应用中我们在更新数据的时候，更严谨的做法是带上更新前的“状态”，如
update order_table set status = ‘取消’ where order_id = 001 and status = ‘待支付’ and ……….;
update order_table set status = ‘已发货’ where order_id = 001 and status = ‘已支付’ and ……….;
然后在业务逻辑代码里判断更新的记录数，为0说明数据库已经被更新了，否则是正常的。
–JSP,JS部分
web容器的四种作用域
几乎所有web应用容器都提供了四种类似Map的结构：application session request page，Jsp或者Servlet通过向着这四个对象放入数据，从而实现Jsp和Servlet之间数据的共享。
application：整个应用，对应servlet中ServletContext
session：会话 对应servlet中HttpSession
request：一次请求 对应servlet中的HttpServletRequest
page：当前页面
–框架部分
–数据库部分
*inner join、left join、 right join区别
1）inner join，两表字段都有值才会显示一条记录
2）left join，两表字段值相同，以及左表字段有值，右表字段值为null，如果用where的话，右表字段为null，查询的时候会报错。
3）right join，与上相反
*防止SQL注入
参数化查询和词法分析(正则表达式)
*数据库优化
1 查询语句的优化，这个主要是根据语句和数据库索引的情况，结合查询计划的分析结果，对性能较低的查询语句进行重写，在执行查询前执行表分析语句也可以算这里；再比如用使用存储过程；
2 数据结构优化，这个包括根据实际的应用中业务逻辑，对数据库的结构进行重新设计，或者创建相关索引里提高查询效率；
3 数据库设置优化，这方面主要是调整数据库和数据结构的相关参数提高应用访问系统的效率；
4 存储结构优化，在数据量较大的情况下，可以考虑通过数据库的存储结构进行优化，比如对数据进行partition，将数据存储在磁盘阵列服务器上等。
对多个表进行连接查询时应遵循的优化原则：
(1) 用于连接的子句的列应被索引、在Where子句中应尽量利用索引，而不是避开索引。
(2) 连接操作应从返回较少行上驱动。
(3) 如果所连接的表A和B，A表长度远远大于B表，建议从较大的A表上驱动。
(4) 如果Where子句中含有选择性条件,Where No=20，将最具有选择性部分放在表达式最后。
(5) 如果只有一个表有索引，另一表无索引，无索引的表通常作为驱动表。如A表的No列以被索引，而B表的No 列没被索引，则应当B表作为驱动表，A表作为被驱动表。
(6) 若用于连接的列和Where子句中其他选择条件列均有索引，则按各个索引对查询的有效性和选择性分别定出级别，结合表中具体数据构成情况，从中选出优化路径，一般需要考虑：子句中哪些列可以使用索引、哪些索引具有唯一性及被查询表行数目等。
*oracle的行列转换
固定行列转换
方法一:
SELECT ID,NAME,
SUM(DECODE(course,’语文’,score,0)) 语文,–这里使用max,min都可以
SUM(DECODE(course,’数学’,score,0)) 数学,
SUM(DECODE(course,’英语’,score,0)) 英语,
SUM(DECODE(course,’历史’,score,0)) 历史,
SUM(DECODE(course,’化学’,score,0)) 化学
FROM kecheng
GROUP BY ID ,NAME
方法二:
Case方式
SELECT ID,NAME,
MAX(CASE WHEN course=’语文’ THEN score ELSE 0 END) 语文,
MAX(CASE WHEN course=’数学’ THEN score ELSE 0 END) 数学,
MAX(CASE WHEN course=’英语’ THEN score ELSE 0 END) 英语,
MAX(CASE WHEN course=’历史’ THEN score ELSE 0 END) 历史,
MAX(CASE WHEN course=’化学’ THEN score ELSE 0 END) 化学
FROM kecheng
GROUP BY ID ,NAME
方法三:
wmsys.wm_concat行列转换函数
SELECT ID,NAME,
wmsys.wm_concat(course || ‘:’||score) course
FROM kecheng
GROUP BY ID ,NAME;
方法四:
SELECT NAME,
wmsys.wm_concat(course ||score) OVER (PARTITION BY NAME)
FROM kecheng
动态转换
方法五:使用PL/SQL
DECLARE
–存放最终的SQL
LV_SQL VARCHAR2(3000);
–存放连接的SQL
SQL_COMMOND VARCHAR2(3000);
–定义游标
CURSOR CUR IS
SELECT COURSE FROM KECHENG GROUP BY COURSE;
BEGIN
–定义查询开头
SQL_COMMOND := ‘SELECT NAME ‘;
FOR I IN CUR LOOP
–将结果相连接
SQL_COMMOND := SQL_COMMOND || ’ ,SUM(DECODE(course,”’ || I.COURSE ||
”’,score,0)) ’ || I.COURSE;
DBMS_OUTPUT.PUT_LINE(SQL_COMMOND);
END LOOP;
SQL_COMMOND := SQL_COMMOND || ’ from KECHENG group by name’;
LV_SQL := ‘INSERT INTO temp_ss ’ || SQL_COMMOND;
DBMS_OUTPUT.PUT_LINE(LV_SQL);
EXECUTE IMMEDIATE LV_SQL;
END;
*过程主要是针对数据处理。业务性的。视图主要是取得数据。一般来说，视图只是select,没有update，delete功能。过程啥都能干。
*Oracle sql”NOT IN”语句优化，查询A表有、B表没有的数据
记录量大的情况下，采用NOT IN查询，那肯定会慢的无法接受。比如：
[sql] view plain copy
SELECT A.*
FROM TABLE_A
WHERE A.USER_ID NOT IN (SELECT B.USER_ID FROM TABLE_B)
目前找到的最优方法，可以秒查。示例如下，查询A表有、B表没有的DEPT_ID数据：
[sql] view plain copy
SELECT A.*
FROM TB_DEPT A, TB_DEPT_LEV B
WHERE A.DEPT_ID = B.DEPT_ID(+)
AND B.DEPT_ID IS NULL
（+）号可以这样来理解： + 表示补充，即哪个表有加号，这个表就是匹配表。这里加号写在右表，左表就是全部显示，故是左连接。
原文链接：http://blog.csdn.net/dengjh_business/article/details/35226227
–算法
http://blog.csdn.net/Tri_Color_Flag/article/details/52523723