1.交换两个常量的方式
int c = a;
a = b
b = c;
引入临时变量存储临时值
a = a+b
b = a-b
a = a-b
相加的方式可能会导致溢出
a = 10 1010
b = 8 1000
a = a ^ b 0010
b = a ^ b 1010
a = a ^ b 1000
利用异或运算 很容易还原值
2.String 常量池 Integer.valueOf()数字池的使用
在字符串进行相加的时候，在虚拟机中会有常量池，编译处理也会把连接的字符合成一个字符，并且去常量池中寻找，如果找到则返回该引用
String a = "a"+"b"+1;
String b = "ab1";
对于间接引用的字符串，编译器会用 StringBuilder.applend方法来处理生成新的引用，但是如果间接连接的字符串是 final型的话，那么编译器会
自动做优化将其合成一个字符串
final String x = "a";
String y = "a";
String c = x+"b1";
String d = y+"b1";
String的intern方法会将常量复制到常量池中去，但是如果常量池中存在该字符串的话，那么会直接返回该字符创的引用。
String e = new String("ab1");
e.intern();
3.并发知识点总结
a.并发和并行：并发通常是指在单CPU中，将CPU资源通过时间分片轮转调度的的方式，CPU资源分给每个进程使用，每一个时间点，也
只会有一个进程拥有CPU的资源，由于CPU切换的时间很短，人很难分辨出来，所以给人的感觉是在同一时间，可以同时去做多件事情。
而并行通常是指在多核心CPU中，在同一时间点上，可以同时存在多个线程在CPU上跑。
b.进程和线程的区别：进程是操作系统分配资源的最小基本单位，在该容器下，拥有很多线程，线程就想轻量级的进程。
c.并发编程的优点，1.能够提高用户体验度，减少阻塞。2.充分利用CPU资源，不让CPU偷懒 3.能够横向拓展计算能力
缺点：增加了计算编程复杂度，由于硬件不能在单个CPU上，将频率提高，增加计算能力，然后采用将CPU核心堆积起来增加计算能力，
这样导致在软件算法上，编程复杂度增加。
e.死锁：造成死锁的原因是，几个拥有资源的线程都持有对方所拥有的资源，但是每个线程都不释放资源，导致每个线程都在等待其他线程的资源，处在一直等待阶段。
活锁：每个线程都无法完整的获取所有资源，饥饿：主要是线程之间的优先级，在即将执行的任务队列中，由于某些线程的优先级高于队列前的一些线程
d.在JAVA语言中，提供了对并发编程的支持，java.util.concurrent 包，专门提供对并发编程的支持，减少编程的复杂度。
1.继承Thread类
2.实现 Runnable接口
3.实现 Callable接口
当我们启动线程的时候，不能直接调用线程的run方法，这样只是一个简单的方法调用，应该是将其放入线程队列中去，调用start（）方法，会使该线程获得使用CPU
资源的机会
f.线程的状态，新建，就绪态，执行，堵塞，死亡 操作：唤醒，睡眠，谦让，停止，中断
g.锁，通常我们会在可能出现并发的类方法变量前面添加锁，来保证一致性，synchronized 关键字，这个关键字会保证单个线程进来访问的时候会去查看有没有人在使用
该快区域的代码，如果有的话，那么该线程就会处于等待的状态。另外，JAVA提供了专门的LOCK类来处理锁的问题。
h.线程池，因为开辟线程也是需要消耗资源的，而且线程可以达到重用，所以为了避免资源浪费的情况，Java提供了线程池的设计方式，Excutors工厂方法来处理各种不同
作用的线程池。这样提供了一个中间处理角色。
4.虚拟机知识小结
虚拟机：我们为了达到和机器更好的交流，我们通过会在机器-》机器码-》汇编-》高级语言，系统一层一层往上去封装。虚拟机规范里面制定了一个标准，只要符合该规范的都能被
系统所识别。所以，我们的JAVA文件，经过JAVA编译器的编译，会形成CLASS文件，也就是ByteCode文件，这样的文件能够被JVM所识别，同样的道理，我们用其他的语言 scala，ruby等
语言，经过各自的编译器编译，形成ByteCode文件，都能统一被虚拟机所识别。
虚拟机运行 我们可以配置它运行时候的参数来决定它的运行状况
内存区域：通常我们的内存区域会划分为： 堆栈区，堆区，方法区，元数据区，我们的基本类型数据都是存在于栈区，而非基本类型只是将对象的引用存放于栈区
类加载：在虚拟机启动的时候，虚拟机中会默认加载系统的默认的一些类，这个时候只是将类的相关信息加载进来，对类的结构验证。
内存回收：虚拟机在内存回收这块，不需要用户手动去进行释放内存，虚拟机会检测某个对象的引用有没有直接或者间接的引用，如果存在这种引用，那么在虚拟机对新生代中EDEN区进行
内存回收的时候，是不能对这块内存进行回收的，经过一次内存回收之后的引用会被复制到存活区1或者2，进行第二次内存回收操作的时候，一般情况下，会将EDEN区中存在引用的以及存活 区中存在引用的统一复制到另外的一个存活区中区，一旦被引用的对象在经过16次的minorGC操作之后，还存活的话，那么此次会将这部分对象统一放到老年代中，然后老年代被占用的空间 也在不断增大，当增加到一定值的时候，老年代会进行一次MAJORGC，这次内存回收操作会占用很长的时间，所以我们一般需要避免出现这种情况。另外，在不一般的情况下面，假如我们在 EDEN区中某个对象很大，占用了很大的空间，那么在进行第一次eden内存回收的时候，由于存活区空间不足以支撑这个大对象，所以，这个对象会直接进入老年代，长期以往会造成系统由于 进行老年代的GC操作，所以，出现卡屏的情况。STOP the WORLD
回收算法：标志-清除：标志被引用的对象，然后清除没被引用的对象，但是这样会造成内存碎块的情况 复制：由于大部分对象都是朝生夕死，所以我们会准备两个同样大小的内存块，一块用完，我们标记上已经被引用的对象，然后将被因用的对象复制到另外一个内存区域上去，这样就不会存在内存碎块的情况，但是这种方式需要额外浪费一半的内存空间 标识-复制：新生代和老年代，新生代分为两部分，一部分EDEN伊甸区，一部分存活区，存活区均分为两块，通常的比例8:1:1，我们可以通过虚拟机参数来进行配置。
新生代，老年代，永久代 ：永久代主要存放常量池
回收器：CMS，paranl ，G2回收器
指令重排序
工具 vmconcel
5.数据库知识小结
6.框架知识小结
7.设计模式知识小结
1.设计原则
单一职责原则
依赖倒转原则
对拓展开放，修改关闭
狄米特原则
创建型
简单工厂
class FruitFactory {
public Fruit createFruit(T x ){
Fruit furit = null;
if(x == apple){
x = new Apple();
}else if(x == bear){
x = new Bear();
}else{
}
return x;
}
}
interface Fruit{
void water();
void plant();
void ripe();
}
Apple implements Fruit{
}
Bear implements Fruit{
}
工厂模式
interface FruitFacotry{
Fruit factory();
}
AppleFactroy implements FruitFactory{
Fruit factory(){
return new Apple();
}
}
BearFactroy implements FruitFactory{
Fruit factory(){
return new Bear();
}
}
抽象工厂
interface IFruitFactory{
Fruit createFruit();
Animal createAnimal();
}
class ConcreteFactoryA implements IFruitFacory{
Fruit createFruit();
Animal createAnimal();
}
class ConcreteFactoryB implements IFruitFacory{
Fruit createFruit();
Animal createAnimal();
}
单例模式
懒汉单例模式
class LazySingleton{
private LazySingleton(){}
private static LazySingleton = new LazySingleton();
public LazySingleton getLazySingleton(){
return LazySingleton;
}
}
饿汉式单例模式
class HungrySingleton{
private HungrySingleton(){}
private static HungrySingleton= null;
public synchronized LazySingleton getLazySingleton(){
if(HungrySingleton == null){
HungrySingleton= new HungrySingleton()
}
return HungrySingleton;
}
}
两者取其优点
class InnerHolderSingleton{
private InnerHolderSingleton(){}
private static class SingletonHolder{
private static final InnerHolderSingleton single = new InnerHolderSingleton();
}
public static InnerHolderSingleton getInstance(){
return SingletonHolder.single ;
}
}
结构型
适配器模式
interface target{
oper1();
oper2();
}
class Adaptee{
public void oper1(){}
}
public class Adapter extends Adaptee implements target{
public void oper2(){
//
}
}
public class Adapter implements target{
Adaptee adaptee = null;
public Adapter(Adaptee adaptee){
this.adaptee = adaptee;
}
public void oper1(){
this.oper1();
}
public void oper2(){
//
}
}
代理模式
interface Subject{
void request();
}
class RealSubject implements Subject{
void request(){
}
}
class ProxySubject implements Subject{
Subject subject = null;
public ProxySubject(Subject subject){
this.subject = subject;
}
public void request(){
beforeRequest();
this.subject.request();
afterRequest();
}
}
建造模式
行为型
观察者模式
策略模式
interface DiscountStrategy(){
int calcPrice(double price , int number);
}
class VeryImportantMem implements DiscountStrategy(){
public int calcPrice(double price , int number){
return
}
}
class Context{
DiscountStrategy strategy = null;
public Context(DiscountStrategy str){
this.strategy = str;
}
public int getCalcDisa(){
return strategy.calcPrice(100,20);
}
}
享元模式
责任链模式
命令模式
8.关于怎么去写API的想法
9.关于网络通信，消息机制的理解
10.算法总结（排序算法，分治法，贪心法，动态规划，回溯法，时间复杂度O(F(X))分析，图论，树）
10.预算部业务技术小结
int c = a;
a = b
b = c;
引入临时变量存储临时值
a = a+b
b = a-b
a = a-b
相加的方式可能会导致溢出
a = 10 1010
b = 8 1000
a = a ^ b 0010
b = a ^ b 1010
a = a ^ b 1000
利用异或运算 很容易还原值
2.String 常量池 Integer.valueOf()数字池的使用
在字符串进行相加的时候，在虚拟机中会有常量池，编译处理也会把连接的字符合成一个字符，并且去常量池中寻找，如果找到则返回该引用
String a = "a"+"b"+1;
String b = "ab1";
对于间接引用的字符串，编译器会用 StringBuilder.applend方法来处理生成新的引用，但是如果间接连接的字符串是 final型的话，那么编译器会
自动做优化将其合成一个字符串
final String x = "a";
String y = "a";
String c = x+"b1";
String d = y+"b1";
String的intern方法会将常量复制到常量池中去，但是如果常量池中存在该字符串的话，那么会直接返回该字符创的引用。
String e = new String("ab1");
e.intern();
3.并发知识点总结
a.并发和并行：并发通常是指在单CPU中，将CPU资源通过时间分片轮转调度的的方式，CPU资源分给每个进程使用，每一个时间点，也
只会有一个进程拥有CPU的资源，由于CPU切换的时间很短，人很难分辨出来，所以给人的感觉是在同一时间，可以同时去做多件事情。
而并行通常是指在多核心CPU中，在同一时间点上，可以同时存在多个线程在CPU上跑。
b.进程和线程的区别：进程是操作系统分配资源的最小基本单位，在该容器下，拥有很多线程，线程就想轻量级的进程。
c.并发编程的优点，1.能够提高用户体验度，减少阻塞。2.充分利用CPU资源，不让CPU偷懒 3.能够横向拓展计算能力
缺点：增加了计算编程复杂度，由于硬件不能在单个CPU上，将频率提高，增加计算能力，然后采用将CPU核心堆积起来增加计算能力，
这样导致在软件算法上，编程复杂度增加。
e.死锁：造成死锁的原因是，几个拥有资源的线程都持有对方所拥有的资源，但是每个线程都不释放资源，导致每个线程都在等待其他线程的资源，处在一直等待阶段。
活锁：每个线程都无法完整的获取所有资源，饥饿：主要是线程之间的优先级，在即将执行的任务队列中，由于某些线程的优先级高于队列前的一些线程
d.在JAVA语言中，提供了对并发编程的支持，java.util.concurrent 包，专门提供对并发编程的支持，减少编程的复杂度。
1.继承Thread类
2.实现 Runnable接口
3.实现 Callable接口
当我们启动线程的时候，不能直接调用线程的run方法，这样只是一个简单的方法调用，应该是将其放入线程队列中去，调用start（）方法，会使该线程获得使用CPU
资源的机会
f.线程的状态，新建，就绪态，执行，堵塞，死亡 操作：唤醒，睡眠，谦让，停止，中断
g.锁，通常我们会在可能出现并发的类方法变量前面添加锁，来保证一致性，synchronized 关键字，这个关键字会保证单个线程进来访问的时候会去查看有没有人在使用
该快区域的代码，如果有的话，那么该线程就会处于等待的状态。另外，JAVA提供了专门的LOCK类来处理锁的问题。
h.线程池，因为开辟线程也是需要消耗资源的，而且线程可以达到重用，所以为了避免资源浪费的情况，Java提供了线程池的设计方式，Excutors工厂方法来处理各种不同
作用的线程池。这样提供了一个中间处理角色。
4.虚拟机知识小结
虚拟机：我们为了达到和机器更好的交流，我们通过会在机器-》机器码-》汇编-》高级语言，系统一层一层往上去封装。虚拟机规范里面制定了一个标准，只要符合该规范的都能被
系统所识别。所以，我们的JAVA文件，经过JAVA编译器的编译，会形成CLASS文件，也就是ByteCode文件，这样的文件能够被JVM所识别，同样的道理，我们用其他的语言 scala，ruby等
语言，经过各自的编译器编译，形成ByteCode文件，都能统一被虚拟机所识别。
虚拟机运行 我们可以配置它运行时候的参数来决定它的运行状况
内存区域：通常我们的内存区域会划分为： 堆栈区，堆区，方法区，元数据区，我们的基本类型数据都是存在于栈区，而非基本类型只是将对象的引用存放于栈区
类加载：在虚拟机启动的时候，虚拟机中会默认加载系统的默认的一些类，这个时候只是将类的相关信息加载进来，对类的结构验证。
内存回收：虚拟机在内存回收这块，不需要用户手动去进行释放内存，虚拟机会检测某个对象的引用有没有直接或者间接的引用，如果存在这种引用，那么在虚拟机对新生代中EDEN区进行
内存回收的时候，是不能对这块内存进行回收的，经过一次内存回收之后的引用会被复制到存活区1或者2，进行第二次内存回收操作的时候，一般情况下，会将EDEN区中存在引用的以及存活 区中存在引用的统一复制到另外的一个存活区中区，一旦被引用的对象在经过16次的minorGC操作之后，还存活的话，那么此次会将这部分对象统一放到老年代中，然后老年代被占用的空间 也在不断增大，当增加到一定值的时候，老年代会进行一次MAJORGC，这次内存回收操作会占用很长的时间，所以我们一般需要避免出现这种情况。另外，在不一般的情况下面，假如我们在 EDEN区中某个对象很大，占用了很大的空间，那么在进行第一次eden内存回收的时候，由于存活区空间不足以支撑这个大对象，所以，这个对象会直接进入老年代，长期以往会造成系统由于 进行老年代的GC操作，所以，出现卡屏的情况。STOP the WORLD
回收算法：标志-清除：标志被引用的对象，然后清除没被引用的对象，但是这样会造成内存碎块的情况 复制：由于大部分对象都是朝生夕死，所以我们会准备两个同样大小的内存块，一块用完，我们标记上已经被引用的对象，然后将被因用的对象复制到另外一个内存区域上去，这样就不会存在内存碎块的情况，但是这种方式需要额外浪费一半的内存空间 标识-复制：新生代和老年代，新生代分为两部分，一部分EDEN伊甸区，一部分存活区，存活区均分为两块，通常的比例8:1:1，我们可以通过虚拟机参数来进行配置。
新生代，老年代，永久代 ：永久代主要存放常量池
回收器：CMS，paranl ，G2回收器
指令重排序
工具 vmconcel
5.数据库知识小结
6.框架知识小结
7.设计模式知识小结
1.设计原则
单一职责原则
依赖倒转原则
对拓展开放，修改关闭
狄米特原则
创建型
简单工厂
class FruitFactory {
public Fruit createFruit(T x ){
Fruit furit = null;
if(x == apple){
x = new Apple();
}else if(x == bear){
x = new Bear();
}else{
}
return x;
}
}
interface Fruit{
void water();
void plant();
void ripe();
}
Apple implements Fruit{
}
Bear implements Fruit{
}
工厂模式
interface FruitFacotry{
Fruit factory();
}
AppleFactroy implements FruitFactory{
Fruit factory(){
return new Apple();
}
}
BearFactroy implements FruitFactory{
Fruit factory(){
return new Bear();
}
}
抽象工厂
interface IFruitFactory{
Fruit createFruit();
Animal createAnimal();
}
class ConcreteFactoryA implements IFruitFacory{
Fruit createFruit();
Animal createAnimal();
}
class ConcreteFactoryB implements IFruitFacory{
Fruit createFruit();
Animal createAnimal();
}
单例模式
懒汉单例模式
class LazySingleton{
private LazySingleton(){}
private static LazySingleton = new LazySingleton();
public LazySingleton getLazySingleton(){
return LazySingleton;
}
}
饿汉式单例模式
class HungrySingleton{
private HungrySingleton(){}
private static HungrySingleton= null;
public synchronized LazySingleton getLazySingleton(){
if(HungrySingleton == null){
HungrySingleton= new HungrySingleton()
}
return HungrySingleton;
}
}
两者取其优点
class InnerHolderSingleton{
private InnerHolderSingleton(){}
private static class SingletonHolder{
private static final InnerHolderSingleton single = new InnerHolderSingleton();
}
public static InnerHolderSingleton getInstance(){
return SingletonHolder.single ;
}
}
结构型
适配器模式
interface target{
oper1();
oper2();
}
class Adaptee{
public void oper1(){}
}
public class Adapter extends Adaptee implements target{
public void oper2(){
//
}
}
public class Adapter implements target{
Adaptee adaptee = null;
public Adapter(Adaptee adaptee){
this.adaptee = adaptee;
}
public void oper1(){
this.oper1();
}
public void oper2(){
//
}
}
代理模式
interface Subject{
void request();
}
class RealSubject implements Subject{
void request(){
}
}
class ProxySubject implements Subject{
Subject subject = null;
public ProxySubject(Subject subject){
this.subject = subject;
}
public void request(){
beforeRequest();
this.subject.request();
afterRequest();
}
}
建造模式
行为型
观察者模式
策略模式
interface DiscountStrategy(){
int calcPrice(double price , int number);
}
class VeryImportantMem implements DiscountStrategy(){
public int calcPrice(double price , int number){
return
}
}
class Context{
DiscountStrategy strategy = null;
public Context(DiscountStrategy str){
this.strategy = str;
}
public int getCalcDisa(){
return strategy.calcPrice(100,20);
}
}
享元模式
责任链模式
命令模式
8.关于怎么去写API的想法
9.关于网络通信，消息机制的理解
10.算法总结（排序算法，分治法，贪心法，动态规划，回溯法，时间复杂度O(F(X))分析，图论，树）
10.预算部业务技术小结