111

数组内存分配：int [] arr=new int [3],左边指向栈内存，栈内存存储局部变量，右边指向堆内存，
堆内存存储new出来的实体或对象，初始化会给默认值。索引越界异常，空指针异常
类是属性和行为的抽象，对象是实体

成员变量：类中方法为，堆内存，随对象存在，有初始值
局部变量：方法内，栈内存，随方法调用存在，无初始值

StringBuild append 添加 reverse 反转
String定义为最终类，对象是不可变的

继承 好处：复用性、维护性 弊端：耦合性增强，父类变化子类也变化
子类所有构造方法默认都会访问父类中中的无参构造方法，每个子类构造方法
都会默认先执行super（）
如果父类中无无参构造方法，只有带参构造方法，子类可以用super调用父类带参构造方法，
或者在父类提供一个无参构造方法
私有方法不能被重写，子类方法访问权限不能更低（public>默认>私有）
权限修饰符，private、默认、protected、public，子类访问父类时，
根据同一个类，同包不同类，不同包子类，不同包不同类访问权限依次减少一个
final修饰方法，最终方法不能被重写；修饰变量，是常亮不能被再次赋值；修饰类，是最终类，不能被继承
修饰基本类型，数据值不能发生改变，修饰引用类型，地址值不能改变，内容可以改变
final成员变量表示常量，只能被赋值一次，赋值后值不再改变。

final类不能被继承，没有子类，final类中的方法默认是final的。

final方法不能被子类的方法覆盖，但可以被继承。

final不能用于修饰构造方法
final 常与 static一起用,作为常量来使用

static 修饰特点：被类的所有对象共享

多态：访问成员变量，编译看左边，执行看右边；成员方法，编译看左边，执行看右边 ；
因为成员方法有重写，成员变量没有
好处：提高了程序的扩展性，定义方法的时候，使用父类作为参数，子类参与操作
弊端：不能使用子类的特有功能

抽象类：不一定有抽象方法，有抽象方法一定是抽象类
不能被实例化，可以通过子类对象实例化，叫做抽象类多态
子类要么重写抽象类的所有抽象方法，要么是抽象类
有构造方法，作用是用于子类访问父类数据的初始化
成员变量可以是变量，也可以是常量
接口：成员变量只能是常量，默认修饰符是public static final
没有构造方法，因为是对行为进行抽象，一个类如果没有父类，默认继承自Object类
成员方法只能是抽象方法，默认修饰符public abstract
接口和接口之间是多继承，类可以单继承并多实现

接口和抽象类区别：
成员区别：抽象类：有变量，常量，抽象方法，非抽象方法
接口：常量，抽象方法（java8之后有默认方法（default修饰）和静态方法（只能被接口调用），java9之后又私有方法）
关系区别：类与类，继承，单继承
类与接口，实现，可以多实现
接口与接口：继承，可以多继承
设计理念区别：抽象类,对类抽象，包括属性、行为
接口，对行为抽象，主要是行为

Object类方法：equals，toString，hashCode
Arrays工具类Arrays.toString（arr） Arrays.sort（arr）数组排序
Integer.valueOf（100/“100”） Integer.parseInt（“100”）——>int

Throwable是所有错误和异常的超类：
Throwable： 1Error ：严重问题，不需要处理
2Exception：异常，程序本身可以处理的问题 非RuntimeException检查性异常，必须try catch或throws处理
RuntimeException不可检查异常， 可通过修改代码处理
对异常的处理是对可检查异常的处理
throws ： 用在方法声明后面，跟的是异常类名
表示抛出异常，由该方法的调用者来处理
表示出现异常的一种可能性，并不一定发生
throw： 用在方法体内，跟的是异常对象名
表示抛出异常，由方法体内的语句处理
执行throw一定抛出了某种异常

Collection: List: ArrayList：底层是数组，查询快增删慢
LinkedList:底层是链表，节点存储了地址和数据，增删快查询慢
itreator迭代器在遍历时，如果对集合进行增删操作，将会出现并发修改异常，LL
LinkedList特有LinkedIterator迭代器不会出现并发修改异常
Set： hashSet： 底层数据结构是哈希表，要保证元素的唯一性，需要重写hashCode和equals方法
哈希表底层是数组加链表
LinkedHashSet：不重复有序
TreeSet：默认自然排序，要让元素所属的类实现Comparable接口，重写compareTo方法
泛型好处：把运行时期的问题提前到编译期，避免了强制类型转化
泛型类定义：public class 类名<类型T/E/K/V>{
private T t;
public void show(T t){}
}
泛型方法改进：public class Demo（）{
public void show (T t ){

		}
	       }

Map: 遍历方式：.entrySet（）、.keySet()、.values()
Collections工具类：.sort（List）、sort(List,Comparetor<>).reverse（List）

HashMap底层原理：主干是Entry数组，每个Entry包含一个key-value键值对。

hashMap由数组+链表组成，数组是主体，链表解决hash冲突。对于添加或查找，如果
有链表，需要遍历并通过equals方法比对。
扩容时是通过判断阈值大小（容量*负载因子）决定，也就是填充的哈希桶个数
常规构造器，初始化时没有分配内存空间，put时构建table数组

多线程： 继承Thread，可以通过父类带参构造方法给线程命名，或者在线程对象中setName，
创建多线程方式：1、创建类继承Thread，重写run方法，类对象执行start方法
2、类实现Runnable，重写run方法，将类对象放进new Thread（类对象），执行run方法
3、实现CallAble
4、线程池
java使用的是搶占式調度模型，线程默认优先级为5，最高10，最低1
join（），等待这个线程死亡
setDaemon（），将此线程设置为守护线程，当运行的线程都是守护线程，虚拟机将退出
线程生命周期： 阻塞
sleep结束 sleep/其他阻塞

            新建——>就绪(有执行资格，没有执行权)———>运行(有执行资格和执行权)——>（run结束/stop）死亡(线程死亡)

线程安全问题：是否是多线程环境，是否有共享数据，是否是多条语句操作共享 数据
同步代码块：sychronized（任意对象）{多条语句操作共享数据的代码}
同步方法：把sychronized放到方法修饰符后面，同步方法的锁对象是this，同步静态方法的锁对象是 类名.class
多线程环境，不用Vector和HashTable，可以用Collections.sychronizedCollection（Collection c ）
Lock锁：实现类 new ReentrantLock（true公平锁，false非公平锁），lock加锁，unLock（释放锁释放锁放在finally中）
lock.newCondition（）得到condition对象，condition.await（）等待，condition.signal()唤醒线程
wait（）和sychronized配合使用，notify唤醒；await（）和lock配合使用，signal唤醒

wait和sleep的区别：
wait必须在同步上下文中使用，sleep不需要
wait定义在object类中，作用于对象本身；sleep定义在Thread中，作用于当前线程
wait会释放锁资源，sleep不会释放
wait唤醒条件为notify，sleep不会唤醒，只能超时或interrupt中断
wait是实例方法，sleep是静态方法

Callable：创建类实现Callable接口，可以指定返回类型，重写call方法
执行线程，需要new FutureTask<返回类型>（类对象），将此对象放入Thread线程执行

Runnable和Callable比较：
相同：都是接口；都需要调用Thread.start()启动线程
不同：实现Callable能返回执行结果，Callable接口的call（方法允许抛出异常；）
实现Callable接口的线程可以调用Future.cancel取消执行
注意：Callable执行结果需调用FutureTask.get()方法实现，但会阻塞主线程直到获取结果

sychronizde和lock区别；
sychronizde是java内置关键字，在jvm层面，lock是个java类;
sychronized无法判断是否获取锁的状态，lock可以判断是否获取到锁
sychronizde会自动释放锁，lock需在finally中手工释放锁，否则容易思死锁
sychronized锁使用时，线程1获取到锁或者阻塞，线程2会等待；而lock获取不到不会一直等待，获取不到就结束
sychronized锁可重入、不可中断、非公平，lock可重入、可判断，公平都可
sychronizde适合少量代码
notify方法必须放在sychronized块中使用

死锁的必要条件：
互斥（资源仅一个进程占有）；不可被破坏
不可剥夺（资源未释放，不能被其他进程强行夺走）
请求与保持（保持的资源不释放，又提出被其他线程占有的资源）
循环等待（进程资源形成循环等待链）

线程池：
AbstractExecutorService ThreadPoolExcutor
Executor ExecutorService ScheduledThreadPoolExcutor
ScheduledExecutorService
Excutors用来创建四种线程池，线程池一般执行runnable接口
1、newCachedThreadPool:可缓存线程池
2、newFixedThreadPool：指定工作线程数量的线程池
3、newSingleThreadExecutor：单线程化的Excutor，发生异常会有新的取代
4、newScheduleThreadPool：定长线程池，支持定时、周期任务执行

在java中，每次程序运行至少启动两个线程，一个是main线程，一个是垃圾收集线程

java内存模型：堆:方法区（常量池）、堆（heap，垃圾回收）—共享区；栈：虚拟机栈、本地方法栈、程序计数器—独占区
程序计数器：每个线程对应一个，线程私有，记录线程正在执行的内存地址，以便线程中断恢复继续执行
虚拟机栈：每个线程对应一个java栈；每个栈由若干栈帧组成；每个方法对应一个栈帧；
栈帧在方法运行时创建入栈，结束弹栈并返回值；栈顶的为活动栈，表示当前执行的方法，被CPU执行
方法区：java堆的永久区；存放了要加载的类的信息（名称，修饰符等）、静态变量，final定义的常量、field信息、方法信息
方法区是被java线程共享的，

多线程特性：原子性、可见性、有序性
ThreadLocal：为线程提供局部变量
volatile关键字：共享变量被volatile修饰后，具备两层含义
1、保证不同线程对变量操作的可见性
2、禁止指令重排序
举例：单例模式（双重校验）
class Singleton{
private volatile static Singleton singleton=null；
private singleton（）{
}
public static Singleton getInstance（）{
if（singletonnull）{
sychronized（Singleton.class）{
if（singletonnull）{
singleton=new Singleton（）；
}
}
}
return singleton；
}
}

hashmap多线程问题：1.8之前put时调用addEntry方法，线程一在链表后面添加，线程2进来
也在同样的位置添加，就会覆盖；remove时删除链表上数据，线程2也会覆盖线程1的删除；
resize扩容时线程2和线程1都需要扩容，2扩容后添加的元素覆盖了1的元素

网络编程三要素：ip地址，端口，协议
UDP协议：无连接通信协议
TCP协议：面向连接，三次握手：1、客户端向服务器端发送连接请求，等待服务器确认
2、服务器端向客户端回送相应，通知收到了连接请求
3、客户端再次发送确认消息请求，确认连接

Lambda表达式三要素：形式参数、箭头、代码块
使用前提：有一个接口；接口中有且仅有一个抽象方法
参数类型可以省略，如果只有一个参数，小括号也可以省略
匿名内部类和Lambda表达式区别：
Lambda只能是接口；匿名内部类可以是接口，抽象类，具体类
Lambda接口中只能有一个抽象方法，不止一个用匿名内部类
Lambda编译后没有单独的.class文件，对应的字节码动态生成；匿名内部类是会单独生成.class文件的

Lambda表达式被对象的实例方法替代的时候，它的形式参数全部传递给该方法作为参数
Lambda表达式被类的实例方法替代时，第一个参数作为调用者，后面的参数全部作为参数

函数式接口（有FunctionalInterface注解）：有且仅有一个抽象方法的接口
如果方法的参数是一个函数式接口，可以用Lambda表达式作为参数传递
如果方法的返回值是一个函数式接口，可以使用Lambda表达式作为结果返回
Function接口：
常用方法：apply（）：将此函数应用于给定的参数
default Function andThen(Function after):返回一个组合函数，首先将该函数应用于输入，然后将after函数应用于结果
例：public class FunctionTest{
public static void main(String args []){
String s=“wuxiaolei,18”;
convert(s,ss->ss.split(",")[1],ss,->Integer.parseInt(ss),i->i+70);
//convert(s,ss->ss.split(",")[1],Integer::parset,i->i+70);
}
private static void convert(String s,Function<String,String> fun1,Function<String,Integer> fun2,Function<Integer,Integer> fun3){
int i=fun1.andThen(fun2).andThen(fun3).apply(s);
System.Ou.Println(i);
}
}

Stream流的使用：
生成流：通过数据源（集合，数组等）生成流，list.stream（）
中间操作：一个流后面可以跟多个中间操作，返回一个新的流，filter（）、limit（）、skip（）、distinct（）返回该流的不同元素、
sorted（）、sorted(Comparetor comparetor)、map(Function mapper)
终结操作：一个流只能有一个终结操作，执行后无法再被操作，forEach（）
Stream流的生成方式：
Collection体系的可以使用默认方法stream（）生成流
Map体系的集合间接生成流：map.keySet().stream();map.values().stream();map.entrySet().stream()
数组可以通过Stream接口的静态方法of（T…value）生成流： Stream.of(数组)

Stream流的收集操作: R collect(Collector collector) Collectors.toList()/toMap()/toSet()——>Collector
List<> list=listStream.collect(Collectors.toList);

类加载：类的加载（将class文件读入内存并创建class对象）
类的连接（检验类的结构，为类变量分配内存、并默认初始化）
类的初始化（对类变量进行初始化）
类的初始化步骤：假如类未被加载和连接，则程序先加载和连接；
假如该类父类未被初始化，先初始化父类
假如类中有初始化语句，执行初始化语句
类的初始化时机：创建类实例、调用静态方法、访问或设置类变量、反射、初始化子类

java反射机制：在运行时获取类的变量和方法信息创建对象，调用方法
获取class对象的三种方式：类名.class； 类对象.getClass（） ；Class.forName(类的全路径)
Constructor con=class.getConstructor(带参的需要用类型.class)得到构造方法；
私有构造方法可以先暴力反射：con.setAccessible(true);
Object obj=con.newInstance();得到类对象
Field[] fields=con.getFields();得到成员变量，也可以通过con.getField(“属性名”)获取具体成员变量
获取成员方法并使用：Method m=con.getMethod(“方法名”，参数.clsaa)；
m.invoke(obj,方法参数)
用properties读取文件流程：Properties prop=new Properties();
FileReader fr=new FileReader(文件名);
prop.load(fr);
String value=prop.getProperty(key);
Servlet:运行在服务器端的小程序，Servlet就是一个接口，定义了java类被浏览器访问到的规则
执行原理：服务器接受请求，解析请求路径，获取Servlet资源路径，
查找web.xml文件，找到对应类
tomcat加载字节码文件进内存，反射创建其对象，调用其方法
生命周期：init方法，执行一次； 说明Servlet在内存中只存在一个对象，是单例的；存在线程安全问题
service方法，每次调用都执行；
destroy方法，执行一次
请求转发：特点：1、浏览器地址栏路径不发生变化
2、只能转发到当前服务器内部
3、转发是一次请求
request.setAttribute()存储数据；getAttribute()获取数据；request.getRequestDispatcher(路径，不加虚拟目录).forward(request,response)

重定向：response.sendRedirect(地址，要加虚拟目录 动态获取request.getContextPath) 特点：和转发的特点相反
response告诉浏览器使用编码：response.setContentType(“text/html;charset=utf-8”)

ServletContext对象：
获取：request.getServletContext(); HttpServlet.getServletContext()
作用：获取MIMIE类型；域对象 共享数据（作用范围是所有用户所有请求）； 获取文件的真实路径

cookie：tomcat8之后能存中文，但是不支持特殊字符，比如空格，，可以先进行编码，URLEncoder.encoder（数据，“utf-8”）

获去src路径下的文件的方式：
ClassLoader classLoader=当前类.class.getClassLoader();
URL res=classLoader.getResource(“文件名”);
String path=res.getPath();

spring bean:
当scope为singleton时，当核心文件被加载实例化bean；
生命周期： 对象创建：应用加载，创建容器时，对象创建；当应用卸载，容器销毁时，对象销毁
当scope为prototype时，当调用getBean（）方法时实例化bean
生命周期： 对象创建：当使用对象时，创建实例，当对象长时间不用时，被java垃圾回收器回收

@Repositry dao层 @Qualifile 结合@Autowired使用，根据名称注入
@Resoutce =@Autowired+@Qualifile
@Value("${配置文件中的键}") 为属性赋值
@Configuration 核心配置类
@ComponentScan（“包路径”） 扫描包
@PropertySource（文件名） 加载配置文件
@Import（） 在核心配置文件中导入其他配置类

AOP：面向切面编程，使用了动态代理，降低耦合，提高代码重用性
JDK代理：基于接口的动态代理
cglib代理：基于父类的动态代理技术

连接点：被拦截的点 切入点：对连接点进行拦截到的点 通知：增强方法
切面：切入点和通知的结合 织入：把增强应用到目标形成新代理对象过程
通知的类型：前置，后置，环绕，异常抛出，最终

AOP注解开发：配置文件开启aop自动代理，aop:aspectj-autoproxy
@Component类注册进容器@Aspect表明切面类，@Before（要增强方法位置）/@after等表面增强方法

隔离级别：read-uncommitted、read-committed、repeatable-read、serializable
脏读、不可重复读、幻读

myBatis连表查询：一对一 ： ——> …
一对多：——> …

SpringBoot:
@ConfigurationProperties(注入application.properties或application.ymal)
1、编写配置类上加此注解，再将此配置类用@EnableConfiguration（配置类.class）注入到类中
2、在方法上使用，声明要注入的属性前缀，springboot会自动用set方法注入对象
在多个配置文件时，需要在application.yml中激活：
spring:
profiles:
active: abc,def(abc表示application-abc.yml)
集成mybatis：通用mapper需要在启动类上添加@MapperScan（包类径）扫描

服务调用方式：RPC:基于socket，速度快，效率高
HTTP：基于TCP， restful、springcloud
springcloud：eureka服务注册中心 @EnableEurekaServer（eureka注册）
@EnableDiscoveryClient开启客户端发现功能
Ribbon负载均衡、熔断器Hystrix（线程隔离、服务降级）
feign注解开启：@EnableFeignClients
gateWay网关：全局过滤器 实现GlobalFilter，Order

dubbo： Consumer、provider、Registry、Monitor
dubbo支持的协议：dubbo（单一长连接NIO异步通信）、rmi、hessian、http
添加事务：需要修改代理方式为cglib，@Service要指定接口