Java复习

利用抽象数据类型将数据和基于数据的操作封装到一起，使其构成一个不可分割的独立实体，数据被保护在抽象数据的内部，尽可能的隐藏内部的细节，只保留一些对外的接口与外部建立联系

减少耦合，可以独立的开发、测试、优化、使用、理解和修改

减轻维护的负担，可以更容易被理解，在调试过程中可以不影响其他模块

有效地调节性能: 可以通过剖析确定哪些模块影响了系统的性能

提高软件的可重用性

降低了构建大型系统的风险，即便整个系统不可用，这些单独的模块也是可用的

继承实现了IS-A关系，例如Cat和Animal就是一种IS-A关系，子类可以继承父类的非私有的方法和属性

继承应当遵循里氏替换原则，子类对象必须能够替换掉所有父类对象

编译时多态

运行时多态

继承

覆盖（重写）

向上转型

基本类型的缓冲池

特性

Integer x = 2

int y = x

String被声明为final，所以不可被继承

内部使用char数组存储数据，数组被声明为final

可以缓存hash值

String pool的需要

安全性

线程安全

StringBuffer

StringBuilder

常量保存在本地内存的元空间，但字符串常量池、静态变量仍在堆中

抽象类和抽象方法都使用abstract关键字进行生命

接口是抽象类的延伸，可以看做是一个完全抽象的类，不可以有任何方法体

接口的成员(字段 + 方法)默认都是 public 的，并且不允许定义为 private 或者 protected。
字段默认都是static和final 

从 Java 8 开始，接口也可以拥有默认的方法实现，这是因为不支持默认方法的接口的维护成本太高了

抽象类不能被实例化，需要继承抽象类才能实例化其子类

从设计层面上看，抽象类提供了一种 IS-A 关系，那么就必须满足里式替换原则，即子类对象必须能够替换掉所有父类对象。而接口更像是一种 LIKE-A 关系，它只是提供一种方法实现契约，并不要求接口和实现接口的类具有 IS-A 关系

从使用上来看，一个类可以实现多个接口，但是不能继承多个抽象类

接口的字段只能是 static 和 final 类型的，而抽象类的字段没有这种限制。

接口的成员只能是 public 的，而抽象类的成员可以有多种访问权限。

必须在第一行，不可和this同时出现

必须在第一行，不可和super同时出现

子类方法访问权限必须大于等于父类方法

子类方法的返回类型必须是父类方法返回类型或者其子类

使用 @Override 注解，可以让编译器帮忙检查是否满足上面的两个限制条件

又称为类变量，也就是说这个变量属于类的，类所有的实例都共享静态变量，可以直接通过类名来访问它；静态变量在内存中只存在一份

静态方法在类加载的时候就存在了，它不依赖于任何实例。所以静态方法必须有实现，也就是说它不能是抽象方法(abstract)

只能访问所属类的静态字段和静态方法，方法中不能有 this 和 super 关键字

静态语句块在类初始化时运行一次

非静态内部类依赖于外部类的实例，而静态内部类不需要

静态内部类不能访问外部类的非静态的变量和方法

在使用静态变量和方法时不用再指明 ClassName，从而简化代码，但可读性大大降低

Field：可以使用get/set方法读取和修改Field对象关联的字段

Method : 可以使用 invoke() 方法调用与 Method 对象关联的方法

Constructor : 可以用 Constructor 创建新的对象

高速缓存中的值改变并没有直接存入到内存中

原子性：即一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行

i++

由于CPU分时复用（线程切换）的存在，线程1执行了第一条指令后，就切换到线程2执行，假如线程2执行了这三条指令后，再切换会线程1执行后续两条指令，将造成最后写到内存中的i值是2而不是3

在执行程序时为了提高性能，编译器和处理器常常会对指令做重排序。重排序分三种类型：

原子性

可见性

有序性

volatile、synchronized 和 final 三个关键字

Happens-Before 规则

新建（new）

可运行（Runnable）

阻塞（Blocking）

无限期等待（waiting）

死亡（Terminate）

实现Runnable接口

实现Callable接口

继承Thread类

实现接口比继承Thread类优势

管理多个异步任务的执行，而无需程序员显式的管理线程的生命周期

CachedThreadPool: 一个任务创建一个线程

FixedThreadPool: 所有任务只能使用固定大小的线程

SingleThreadExecutor: 相当于大小为 1 的 FixedThreadPool。

守护线程是程序运行时在后台提供服务的线程，不属于程序中不可或缺的部分

main() 属于非守护线程

使用 setDaemon() 方法将一个线程设置为守护线程

Thread.sleep(millisec) 方法会休眠当前正在执行的线程，millisec 单位为毫秒

sleep() 可能会抛出 InterruptedException，因为异常不能跨线程传播回 main() 中，因此必须在本地进行处理。线程中抛出的其它异常也同样需要在本地进行处理

不释放锁

对静态方法 Thread.yield() 的调用声明了当前线程已经完成了生命周期中最重要的部分，可以切换给其它线程来执行

交给优先级高（同级）的

不释放锁

通过调用一个线程的 interrupt() 来中断该线程，如果该线程处于阻塞、限期等待或者无限期等待状态，那么就会抛出 InterruptedException，从而提前结束该线程。但是不能中断 I/O 阻塞和 synchronized 锁阻塞

调用 Executor 的 shutdown() 方法会等待线程都执行完毕之后再关闭，但是如果调用的是 shutdownNow() 方法，则相当于调用每个线程的 interrupt() 方法

在线程中调用另一个线程的 join() 方法，会将当前线程挂起，而不是忙等待，直到目标线程结束

释放锁

wait()

notify()

await()

signal()

signalAll()

概述

乐观锁适合读操作多的场景，不加锁的特点能够使其读操作的性能大幅提升

synchronized和Lock的实现类

悲观锁适合写操作多的场景，先加锁可以保证写操作时数据正确。

会带来更大的开销、降低吞吐量

队列，先进先出

插队，失败入队列

同一时间只能有一个线程占有它

Synchronized

同一时间可以有多个线程同时占有

ReadWriteLock

Semaphore

一把锁只能同时被一个线程获取，没有获得锁的线程只能等待

每个实例都对应有自己的一把锁(this),不同实例之间互不影响；例外：锁对象是*.class以及synchronized修饰的是static方法的时候，所有对象公用同一把锁

synchronized修饰的方法，无论方法正常执行完毕还是抛出异常，都会释放锁

包括方法锁(默认锁对象为this,当前实例对象)和同步代码块锁(自己指定锁对象)

实例

分析

原理

Synchronized的重入性

锁粗化(Lock Coarsening)

锁消除(Lock Elimination)

轻量级锁(Lightweight Locking)

偏向锁(Biased Locking

适应性自旋(Adaptive Spinning)

synchronized的缺陷

Lock

锁对象不能为空，因为锁的信息都保存在对象头里

作用域不宜过大，影响程序执行的速度，控制范围过大，编写代码也容易出错

在能选择的情况下，既不要用Lock也不要用synchronized关键字，用java.util.concurrent包中的各种各样的类，如果不用该包下的类，在满足业务的情况下，可以使用synchronized关键，因为代码量少，避免出错

避免死锁

可见性问题主要指一个线程修改了共享变量值，而另一个线程却看不到

原因是每个线程拥有自己的一个高速缓存区——线程工作内存

Volatile可以将修改后的值马上刷新进内存

内存屏障，又称内存栅栏，是一个 CPU 指令

在程序运行时，为了提高执行性能，编译器和处理器会对指令进行重排序，JMM 为了保证在不同的编译器和 CPU 上有相同的结果，通过插入特定类型的内存屏障来禁止+ 特定类型的编译器重排序和处理器重排序，插入一条内存屏障会告诉编译器和 CPU：不管什么指令都不能和这条 Memory Barrier 指令重排序

特点

声明数据为常量，可以是编译时常量，也可以是在运行时被初始化后不能被改变的常量

方法不可以被子类重写
可以被重载

声明类不允许被继承

Compare-And-Swap

对比和交换，是一条原子指令

只可以保障一个共享变量的原子操作

是让CPU先进行比较两个值是否相等，然后原子地更新某个位置的值

ABA 问题

public final native boolean compareAndSwapObject(Object paramObject1, long paramLong, Object paramObject2, Object paramObject3

public final native boolean compareAndSwapInt(Object paramObject, long paramLong, int paramInt1, int paramInt2);

public final native boolean compareAndSwapLong(Object paramObject, long paramLong1, long paramLong2, long paramLong3);

原理

方法

HashTable使用了synchronized关键字对put方法，synchronized锁的是整个对象，锁住了整个hash表

1.7

1.8

可以重复进入

队列，先进先出

会带来更大的开销、降低吞吐量

插队，失败入队列

顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现

初始容量10，加载因子0.5

扩容

顺序容器/队列(Queue)

底层双向链表，决定了所有跟下标相关的操作都是线性时间，而在首尾位置只需要常数时间

如果需要同步，可以采用Collections.synchronizedList()对其进行包装

Vector

TreeSet

LinkedHashSet

默认内存10，加载因子0.75

ArrayDeque

事实上LinkedHashMap是HashMap的直接子类，二者唯一的区别是LinkedHashMap在HashMap的基础上，采用双向链表(doubly-linked list)的形式将所有entry连接起来，这样是为保证元素的迭代顺序跟插入顺序相同

冲突

当entry的数量超过capacity*load_factor时，容器将自动扩容并重新哈希。对于插入元素较多的场景，将初始容量设大可以减少重新哈希的次数

1.7

1.8

List <Person> people = list.getStream.parallel().collect(Collectors.toList());

List <Person> people = list.getStream.collect(Collectors.toList());

Stream stream = list.stream();

Stream stream = Stream.of("hollis","hollischuang");

filter方法用于通过设置的条件过滤元素

List<String> strings = Arrays.asList("a", "b", "", "d");
Stream<String> stream = strings.stream();
stream.filter(string->!string.isEmpty()).forEach(System.out::println);

用法

map方法用于映射每个元素对应的结果

List<Integer> strings = Arrays.asList(1,3,5,1,2,6,8);
Stream<Integer> stream = strings.stream();
stream.map(i->i+1).forEach(System.out::println);

limit返回Stream前面的n个元素；skip是去掉前n个元素

List<Integer> numbers= Arrays.asList(1,3,5,1,2,6,8); numbers.stream().limit(4).forEach(System.out::println);

sorted方法对于流进行排序

List<Integer> numbers= Arrays.asList(1,3,5,1,2,6,8);
numbers.stream().sorted().forEach(System.out::println);

distinct主要用来去重

List<Integer> numbers= Arrays.asList(1,3,5,1,2,6,8); numbers.stream().distinct().forEach(System.out::println);

List<LikeDO> likeDOs=new ArrayList<LikeDO>();
List<Long> likeTidList = likeDOs.stream().map(LikeDO::getTid)
                .distinct().collect(Collectors.toList());

Stream的中间操作得到的结果还是一个Stream，最终结果将不会再返回一个流

迭代流中的每个数据

Random random = new Random();
random.ints().limit(10).forEach(System.out::println);

统计流中的元素个数

List<String> strings = Arrays.asList("Hollis", "HollisChuang", "hollis","Ho llis666", "Hello", "HelloWorld", "Hollis");  System.out.println(strings.stream().count());

int countOfAdult=persons.stream()
                       .filter(p -> p.getAge() > 18)
                       .map(person -> new Adult(person))
                       .count();

可以接受各种做法作为参数，将流中的元素累积成一个汇总结果

List<String> strings = Arrays.asList("Hollis", "HollisChuang", "hollis","Ho llis666", "Hello", "HelloWorld", "Hollis");  strings = strings.stream().filter(string -> string.startsWith("Hollis")).collect(Collectors.toList());  System.out.println(strings);

// Supplier<Student> s = () -> new Student();
Supplier<Student> s = Student::new;

Map<Long, UmsPermission> permissionMap = permissionList.stream()     .collect(Collectors.toMap(permission -> permission.getId(), permission -> permission));

构造引用

对象::实例方法

类名:静态方法

类名:实例方法

//消费型
Consumer consumer =  new Consumer<>() {
    @Override
    public void accept(Object o) {
        System.out.println("消费型接口");
    }
};

///供给型
Supplier supplier= new Supplier<String>() {
    @Override
    public String get() {
        return "我是返回值";
    }
};
Supplier <Integer>  supplier =  () -> 12;
Supplier <Integer>  supplier = "aa"::hashCode;

//函数型
Function function = new Function() {
    @Override
    public Object apply(Object o) {
        return null;
    }
};
Function function = o -> null;

//断言型
Predicate predicate = new Predicate() {
    @Override
    public boolean test(Object o) {
        return false;
    }
};
Predicate predicate = o -> false;

private static java.lang.Object lambda$0(java.lang.String);

表名这是一个切面类

声明切那个包下哪个方法

前后都有

将配置类指定的类解析为BeanDefinition对象，并放入BeanFactory的beanDefinitionMap中

BeanDefinitionStoreException

populateBean()

选择的数据库

分页是否合理化

可以进行count语句的查询

以接口的方式传递信息是被允许的

JVM的主要目的是将字节码从各个位置（网络、磁盘）转换为二进制流加载到内存中，接着为这个类在JVM的方法区创建一个对应的class对象，这个class对象就是这个类各种数据的访问入口

类加载器是个通用组件，加载别人编译的.class文件，避免异常错误，需要对文件进行验证

文件格式验证

元数据验证

字节码验证

符号引用验证

以一组符号描述所引用的目标，可以使任何形式的字面量，只要可以无歧义的定位到目标就好

可以指向目标的指针、相对偏移量或者一个可以直接或者间接定位到目标的句柄

类、接口、字段、类方法、接口方法、方法类型、方法句柄、调用点限定符

1、假如这个类还没有被加载和连接，则程序先加载并连接该类

2、假如该类的直接父类还没有被初始化，则先初始化其直接父类

3、假如类中有初始化语句，则系统依次执行这些初始化语句

只有当对类的主动使用的时候才会导致类的初始化

当虚拟机启动,先初始化main方法所在的类

new一个类的对象

调用类的静态成员(除了final常量)和静态方法

使用java.lang.reflect包的方法对类进行反射调用

当初始化一个类,如果其父类没有被初始化,则会先初始化它的父类

父类如果没有初始化，会先初始化父类

类的构造器方法

特点

new对象，调用构造方法时才会执行

所以要引入synchronized关键字修饰方法

在多线程情况下效率极低

自动延迟加载

线程友好

实现InvocationHandler接口

重写invoke方法

获取代理对象（强制转换类型）

实现MethodInterceptor接口

重写invoke方法

获取代理对象

key不要太长尽量不要超过1024字节，不仅会消耗内存也会降低查找的速率

key也不要太短，key太短可读性会降低

在一个项目中key最好使用统一的命名格式，例如user:1000:password

字符串、整数、浮点数、二进制

可对整个字符串或者一部分进行操作，比如执行自增和自减

特点

数据结构

应用场景

常用命令

链表，每个链表的每个节点都包含一个字符串

从链表的两端推入或者弹出元素，根据偏移量来对链表进行修剪（trim），读取单个或者多个元素，根据值来查找或者移除元素

特点

数据结构

常见场景

常见命令

包含字符串的无序收集器，并且包含的字符串都是唯一的

添加、获取、移除单个元素，检查一个元素是否存在于集合中，可以计算交集、并集、差集，从集合里随机获取元素

特点

应用场景

常用命令

包含键值对的无序散列表

添加、获取、移除单个键值对；获取所有键值对

特点

与String的区别

应用场景

常用命令

字符串成员由浮点数分值之间的有序映射，元素的排列顺序由分值的大小决定

添加、获取、删除单个元素；根据分值范围(range)或者成员来获取元素

特点

应用场景

常用命令

<!--redis依赖配置-->
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

redis:
    host: localhost # Redis服务器地址
    database: 0 # Redis数据库索引（默认为0）
    port: 6379 # Redis服务器连接端口
    password: # Redis服务器连接密码（默认为空）
    jedis:
      pool:
        max-active: 8 # 连接池最大连接数（使用负值表示没有限制）
        max-wait: -1ms # 连接池最大阻塞等待时间（使用负值表示没有限制）
        max-idle: 8 # 连接池中的最大空闲连接
        min-idle: 0 # 连接池中的最小空闲连接
    timeout: 3000ms # 连接超时时间（毫秒）

# 自定义redis key
redis:
  key:
    prefix:
      authCode: "portal:authCode:"
    expire:
      authCode: 120 # 验证码超期时间

在使用@Resource注解注入RedisTemplate的时候需要注意

Resource和AutoWried注解的区别

代码

先获取valueOperation对象

获取ValueOperation对象

获取ValueOperation对象

获取ValueOperation对象

获取ValueOperation对象

批量操作在发送EXEC命令前被放入队列缓存

收到EXEC命令后放入事务执行，事务中的任意命令执行失败，其余的命令依然被执行

在事务执行过程中，其他客户端提交的命令不会插入到哦事务执行命令序列中去

开始事务

命令入队

执行事务

单个redis命令是原子性的，但是Redis没有在事务上增加任何维持原子性的机制，所以Redis事务并不是原子性的

取消事务、放弃执行事务块中所有命令

执行所有事务块的命令

标记一个事务块的开始

监视一个或多个key，如果事务执行前这个key被其他的命令所改动，事务将被打断

取消watch命令对所有key的监视

Redis单条命令具有原子性，但事务不具备原子性，不支持回滚

子主题

多个事务并发访问同一数据产生的问题，Redis是单进程单线程的操作

通过RDB、AOF可以实现

Watch可以监视key的值是否发生变化

单体架构可以使用，多台服务器，不同端口会有并发风险

引入依赖

注入

加锁

解锁

提升插入性能

只对于非聚集索引（非唯一）的插入和更新有效，对于每一次的插入不是写到索引页中，而是先判断插入的非聚集索引页是否在缓冲池中，如果在则直接插入；若不在，则先放到Insert Buffer 中，再按照一定的频率进行合并操作，再写回disk。这样通常能将多个插入合并到一个操作中，目的还是为了减少随机IO带来性能损耗

change Buffer

非聚集索引

非唯一索引

ICP的诞生主要是为了进一步提高B+Tree索引查询的可用性

模糊匹配后结果变成无序，所以后面条件无法再使用到索引，
因此需回表提取出name like 'XX'结果集后，再通过普通查询得到age = 18的最终结果

引入ICP后

连续的可以换成between

子查询可以换 exists

可以用union

可以设置默认值0

如FORCE INDEX

不需要的列会增加数据传输时间和网络开销

对于无用的大字段，如 varchar、blob、text，会增加 io 操作

失去MySQL优化器“覆盖索引”策略优化的可能性

MySQL采用从左往右，自上而下的顺序解析where子句。
根据这个原理，应将过滤数据多的条件往前放，最快速度缩小结果集。

关联类型，决定访问表的方式

SIMPLE

PRIMARY

....

system>const>eq_ref>ref>fulltext>ref_or_null>index_merge>unique_subquery>index_subquery>range>index>ALL

eq_ref

ref

range

ALL

可以使用哪些索引

实际决定使用哪个索引

索引字段的可能最大长度，不是表中实际数据使用的长度

表示key展示的索引实际使用的列或者常量

查询数据需要读取的行数，只是一个预估的数值，但是能很直观的看出SQL的优劣了

表示针对符合查询条件的记录数的百分比估算，用rows和filtered相乘可以计算出关联表的行数

解析查询的附加额外信息

Using index

Using index condition

Using where

....