java最全面经链接总结

目录

场景题 关于redis的

分布式锁,如何添加,放在什么位置

Spring源码

Java(总结完)

1一个变量从产生到结束所经历的过程,讲一下字符串常量的过程?

2 Integer和int有啥区别,integer中有哪些特殊的函数?

4 Java的多态与实现

5 深拷贝浅拷贝

6 接口和抽象类的区别

7 static 匿名内部类

8 java与C++区别

9 反射机制

10java1.7与java1.8对比

11 java中的NIO与BIO

12 Io处理

13 重载

JVM(总结完)

1 分代回收算法

2 对象如何进入老年代

3 如何减少GC次数

4 JVM

5 JVM的垃圾收集器,G1和CMS有啥区别?

6 GC

7类加载

8 Java双亲委派模型是什么、优势在哪、双亲委派模型的破坏

9 一个类的实例从new开始的过程

10 内存溢出、内存泄露

多线程(总结完)

1 lock ,sychronized,volatile的区别

2 synchronized原理以及锁优化

3乐观锁,悲观锁

4乐观锁使用场景,使用乐观锁的产品或中间件

5线程安全问题产生的原因?

6 Java你知道的实现线程安全的方式,每一种方式的特点

程池参数

8一个核心池为2,等待队列3,最大线程数10的线程池,已有两个线程运行任务,第三个任务进来时如何处理

9 多线程的4种方式

10 多线程的同步

11多线程之间通信

12多线程编程的建议

13 多线程中锁的种类

集合(总结完)

1 HashMap说一下?get流程?线程安全吗?如何选择线程安全的容器?

2 HashMap、Hashtable、ConcurrentHashMap的原理与区别

高并发(总结完)

1 消费者生产者模型

2  网站的高并发

3  juc

数据库(总结完)

1什么是数据库事务

3 数据库如何实现串行化

4数据库中的锁

5 MVCC(多版本并发控制机制)

 6 数据库引擎及比较

7说一聚簇索引和非聚簇索引的有什么不同

8 数据库索引

9 优化查询方法

10 大访问量到数据库上,如何优化

11 SQL注入以及解决

12 SQL语句(这个是重点,最好总结一下)

13存储过程

14 慢查询优化

计算机网络(总结完)

1 http、https的连接过程,数字证书。

2 TCP的三次握手,四次挥手

3对称加密和非对称加密的区别以及应用。了解哪些常用的加密算法?MD5算法详解

4 五层协议详解

5 CSRF攻击防御

6 输入url回车会生什么

7 TCP如何保证可靠传输的

8 TCP三次握手漏洞

9 TCP与UDP区别

10 流量控制和拥塞控制

11Cookie与Session

12 粘包原因解决办法

13 TCP头部有哪些字段

14 路由转发算法

数据结构(总结完)

1 TreeMap了解吗 红黑树

2堆排序

3 B+树

4 排序总结

5 快速排序

6 树的遍历

7 链表

8归并排序

操作系统(总结完)

1 进程间通信

2 进程调度方法

3 磁盘臂调度算法

4死锁是什么?发生的条件?如何尽可能避免。

5 进程和线程之间的区别

6 缓存数据处理【说的LRU】

7 线程同步和互斥有何异同,在什么情况下分别使用他们?举例说明

8线程同步的通信方式

设计模式(总结完)

1单例模式

2 享元模式

3桥接模式

4观察者模式

5简单工厂模式、工厂模式

TopN问题(总结完)

企业知识(还未总结完)

1 阿里

刷题

LeetCode(还未总结完)

动态规划

回溯法

dfs深度优先搜索

bfs 广度优先搜索

贪心

剑指Offer(还未总结完)

1-10

11-20

21-30

31-40

41-50

51-60


场景题 关于redis的

分布式锁,如何添加,放在什么位置

Spring源码

Java(总结完)

1一个变量从产生到结束所经历的过程,讲一下字符串常量的过程?

变量类型:局部变量(栈帧)、常量、静态变量

 

局部变量:局部变量随着方法的调用产生和结束,在调用方法的时候回创建栈帧,而栈帧里存在局部变量表,当方法调用结束的时候栈帧销毁,局部变量随着销毁。

 

常量/静态变量:一般存放在方法区,而方法区的周期与堆相似,声明并赋值后直接放入常量池,之后通过可达性分析判断常量是否存在引用链,如不存在移除常量池。

2 Integer和int有啥区别,integer中有哪些特殊的函数?

 博客https://blog.csdn.net/weixin_41563161/article/details/103896437 

4 Java的多态与实现

 

博客https://blog.csdn.net/weixin_41563161/article/details/104161750

5 深拷贝浅拷贝

内推军7   博客https://blog.csdn.net/weixin_41563161/article/details/101628243

6 接口和抽象类的区别

博客https://blog.csdn.net/weixin_41563161/article/details/103642165

 

7 static 匿名内部类

 

8 java与C++区别

 

9 反射机制

 

优缺点

1 运行时动态获取类的实例

2与java动态编译相结合。实现无比强大的功能

 

1性能降低 2 破坏类的封装性

解决

1安全检查较多,通过setAccessible(true)关闭

2 多次动态创建类,使用缓存机制吧

3 ReflectASM工具类,通过子界面生成的方式加快反射速度

10java1.7与java1.8对比

 

https://blog.csdn.net/weixin_41563161/article/details/104242518

11 java中的NIO与BIO

 

https://blog.csdn.net/weixin_41563161/article/details/104242190

12 Io处理

https://blog.csdn.net/weixin_40102671/article/details/80260982

https://blog.csdn.net/weixin_41563161/article/details/102944128

13 重载

 

JVM(总结完)

https://mp.weixin.qq.com/s/T0nYlJsbL2ueZBEghJO8Lw

1 分代回收算法

程序运行期间才知道会创建哪些对象,内存的分配和回收是动态的

引用计数法,可达性分析法(虚拟机栈 方法区静态对象 方法区常量 本地方法栈)

方法区

1该类的所有实例都已经被回收,java堆不存在该类的实例

2加载该类的ClassLoader已经回收

3 该类对应的Class对象没有在任何地方被引用,无法在任何地方通过反射访问该类的方法

 jvm72  博客https://blog.csdn.net/weixin_41563161/article/details/103865628

新生代用的什么算法,老年代用的什么算法

  jvm70

2 对象如何进入老年代

jvm92  博客https://blog.csdn.net/weixin_41563161/article/details/103865688

3 如何减少GC次数

 

1 对象不用时显式的设置为null

2 减少System.gc()

3 尽量减少静态变量

4 尽量使用StringBuffer

5 少用finalize函数

6 图片缓存这些用软引用

7 基本类型

8修改参数增大内存

4 JVM

  jvm38 

定义:java虚拟机是能够提供java程序的运行环境,屏蔽了与具体操作系统平台相关的信息,java程序只需要生成字节码便可以在不同的平台借助虚拟机运行。即借助虚拟机,字节码可跨平台。

 

系统架构:类加载子系统、运行时数据区、直接内存、垃圾回收系统、执行引擎。

博客https://blog.csdn.net/weixin_41563161/article/details/102670179

Java内存分布、常量池、运行时数据区域

 

Jvm61 博客https://blog.csdn.net/weixin_41563161/article/details/104093660

GC回收机制(垃圾回收器经典算法)(JVM中内存区域的划分)(GC收集器有哪些)

Serial

ParNew

Parallel Scavenge 吞吐量

CMS 缩短停顿

G1 并发 分代收集 空间整合 解决停顿

博客https://blog.csdn.net/weixin_41563161/article/details/104183988什么是Native方法

 

5 JVM的垃圾收集器,G1和CMS有啥区别?

Jvm76  博客https://blog.csdn.net/weixin_41563161/article/details/103882414

博客https://blog.csdn.net/weixin_41563161/article/details/104093660

GC回收机制(垃圾回收器经典算法)(JVM中内存区域的划分)(GC收集器有哪些)

6 GC

Jvm61 博客https://blog.csdn.net/weixin_41563161/article/details/104093660

(垃圾回收器经典算法)(JVM中内存区域的划分)(GC收集器有哪些)

7类加载

JVMp209 内推军15博客https://blog.csdn.net/weixin_41563161/article/details/103550512

类加载分为五个阶段,1加载,2连接(验证,准备,解析)3初始化,4使用,5卸载

五种情况必须进行初始化

1 遇到new getstatic putstatic invokestatic

2 反射

3 初始化一个类,父类还没有初始化

4 虚拟机启动需要指定一个主类

5

8 Java双亲委派模型是什么、优势在哪、双亲委派模型的破坏

Jvm229 博客https://blog.csdn.net/weixin_41563161/article/details/103885802

启动类加载器

扩展类加载器

应用程序类加载器

自定义 自定义

 

避免重复加载

安全问题

9 一个类的实例从new开始的过程

博客https://blog.csdn.net/weixin_41563161/article/details/104093890

1 类加载

2 分配内存  指针碰撞和空闲列表(多线程的请求)

3 设置对象头信息

4调用对象的init()方法,根据传入的属性值给对象属性赋值

5在线程栈中新建对象引用,并指向堆中刚刚新建的对象实例

10 内存溢出、内存泄露

内推军12 Jvm50博客https://blog.csdn.net/weixin_41563161/article/details/102516372

内存泄露 情况 内推军8

1堆中申请的空间没有释放,2堆中对象不再使用,但是仍在内存中保存着

内存泄露 原因  内推军9

1静态集合 vector HashMap

2各种连接 IO 数据库 网络连接

3***

4 变量不合理作用域

5 单例可能造成内存泄露

内存泄露 解决情况 内推军10

1避免在循环中创建对象

2尽早释放无用对象引用

3尽量少用静态变量

4 字符串StringBuffer

内存溢出 情况 内推军12

1 本地虚拟机 本地方法栈溢出

2 堆溢出

3 方法区溢出

4 运行时常量溢出

内存溢出 原因  内推军13

内存中加载数据量过大

集合类有对象引用,使用后没有清空

循环创建或者是死循环

启动参数设置的小

 

内存溢出 解决情况 内推军13

 

多线程(总结完)

1 lock sychronized,volatile的区别

博客https://blog.csdn.net/weixin_41563161/article/details/103869694 lock ,sychronized,volatile

1Volatile线程间可见   instance = new Singleton();

2禁止指令重排(编译器优化,比如先分配内存空间,初始化,然后指向刚分配的内存地址)

Volatile与Synchronized区别

1 Volatile修饰变量 synchronized代码块和方法

2 Volatile 不会对变量加锁,synchronized会对变量加锁,会对线程阻塞

3 Volatile仅能实现变量的修改可见性。但是synchronized 还可以保证原子性

4 Volatile禁止指令重排 synchronized可以被编译器优化

Lock和Synchronized区别(监视器锁(monitor),monitorenter 和 monitorexit 指令完成。)

1 lock是一个接口,synchronized是java关键字

2 synchronized发生异常会释放线程占有的锁,不会导致死锁发生, lock要手动

3 lock可以中断  synchronized不能响应中断

4 lock可以知道有没有获得锁 tryLock()

5 lock可以实现公平锁

6lock可以提供多个线程读写的效率

2 synchronized原理以及锁优化

博客https://blog.csdn.net/weixin_41563161/article/details/104117425 synchronized原理以及锁优化

 

博客https://blog.csdn.net/weixin_41563161/article/details/102458297重量级锁、自旋锁、轻量级锁、偏向锁、悲观、乐观锁等各种锁

Jvm 397

无锁状态  偏向锁状态  轻量级锁  重量级锁

1重量级锁 从用户态转换到核心态,这个转换过程成本较高

2轻量级锁 对于绝大部分锁,在整个同步周期内都是不存在竞争的。如果没有竞争,轻量级锁就可以使用 CAS 操作避免互斥量的开销,从而提升效率。

(栈帧建立Lock Record空间,存储Mark Word01的拷贝)CAS成功00,否则10

3 偏向锁

偏向锁是在无多线程竞争的情况下,将这个同步都消除掉

绝大部分锁,在整个同步周期内不仅不存在竞争,而且总由同一线程多次获得。偏向锁会偏向第一个获得它的线程

4适应性自旋

如果锁被占用的时间比较短,那么自旋等待的效果就会比较好,

5锁消除

如果判断一段代码中,堆上的数据不会逃逸出去从而被其他线程访问到,则可以把他们当做栈上的数据对待

6锁粗化

同步块作用范围限制尽量小

3乐观锁,悲观锁

博客https://blog.csdn.net/weixin_41563161/article/details/103875120悲观锁与乐观锁

 

博客https://blog.csdn.net/weixin_41563161/article/details/102490808数据库中的锁

CAS产生的问题

1注意ABA的问题

2 CPU开销大

3多个共享变量

4乐观锁使用场景,使用乐观锁的产品或中间件

高并发的例子https://blog.csdn.net/qq_33764491/article/details/81083644

SVN

5线程安全问题产生的原因?

博客https://blog.csdn.net/weixin_41563161/article/details/103888689线程安全的方式,每一种方式的特点

1、多线程环境下

2、多个线程共享同一个资源

3、对资源进行非原子性操作

 

6 Java你知道的实现线程安全的方式,每一种方式的特点

博客https://blog.csdn.net/weixin_41563161/article/details/104163177线程安全的方式,每一种方式的特点

Jvm  386  P81

1、synchronized锁(偏向锁,轻量级锁,重量级锁)

2、volatile英[ˈvɒlətaɪl]锁,只能保证线程之间的可见性,但不能保证数据的原子性

3、jdk1.5并发包中提供的Atomic原子类  CAS

4、Lock锁

5. 多实例、或者是多副本(ThreadLocal): 当使用ThreadLocal维护变量时,ThreadLocal为每个使用该变量的线程提供独立的变量副本,所以每一个线程都可以独立地改变自己的副本,而不会影响其它线程所对应的副本;

程池参数

线程池介绍 

线程池的好处 

缓存线程池的参数如何设置,特性是什么

博客https://blog.csdn.net/weixin_41563161/article/details/103666165

线程池好处

1重复利用已创建线程,减少创建销毁时间

2 提高响应速度

3对线程统一管理

4 有可能造成创建大量线程消耗完系统内存

CachedThreadPool:可缓存的线程池该线程池中没有核心线程,非核心线程的数量为无限大,没有需要时回收线程,适用于耗时少,任务量大的情况。

SecudleThreadPool:周期性执行任务的线程池,

SingleThreadPool:只有一条线程来执行任务,适用于有顺序的任务的应用场景。

核心线程数和最大线程数均为1,多余的先存储到工作队列,一个一个执行

FixedThreadPool:定长的线程池有核心线程,核心线程的即为最大的线程数量

线程池参数设置

corePoolSize:核心线程数       1每秒线程    2 8020原则

queueCapacity:任务队列容量(阻塞队列) (coreSizePool/taskcost)*responsetime

maxPoolSize:最大线程数(最大任务数-队列容量)/每个线程每秒处理能力 = 最大线程数

keepAliveTime:线程空闲时间

allowCoreThreadTimeout:允许核心线程超时

rejectedExecutionHandler:任务拒绝处理器

 

Executor                              Executors用了创建线程池

ExecutorService                       

AbstracExecutorService             ThreadPoolExecutor 继承了AbstracExecutorService

 

8一个核心池为2,等待队列3,最大线程数10的线程池,已有两个线程运行任务,第三个任务进来时如何处理

判断等待队列中是否有地方存放该任务,如果有就将任务保存在等待队列中等待执行,没有就去判断最大可容纳的线程数,如果没有超出这个数量就去开创非核心线程执行任务,否则调用handler实现拒绝策略。

内推军93

9 多线程的4种方式

https://blog.csdn.net/weixin_41563161/article/details/102671366

 

1 Thread

2 Runnable  很容易的实现资源共享

3 Callable Future FutureTask

https://www.cnblogs.com/xiaoxi/p/8303574.html

https://www.cnblogs.com/frankltf/p/10554932.html

https://blog.csdn.net/qq_30572275/article/details/80636759

4 线程池

1 可以看到使用Thread是继承关系,而使用Runnable是实现关系。我们知道java不支持多继承,如果要实现多继承就得要用implements,所以使用上Runnable更加的灵活

2 Runnable是可以共享数据的,多个Thread可以同时加载一个Runnable,当各自Thread获得CPU时间片的时候开始运行runnablerunnable里面的资源是被共享的

10 多线程的同步

 

1 Synchronized

2 Lock

3 wait()\notify()\nitifyAll()

4 CAS

11多线程之间通信

https://blog.csdn.net/weixin_41563161/article/details/102671366

1 Object类的wait()\notify()\notifyAll()

2 Condition

3管道

4 volatile

12多线程编程的建议

 

1 线程有意义的名字

2 避免锁定或者缩小同步范围

3 多用同步辅助类 少用wait 和notify

4 多用并发容器,少用同步容器

13 多线程中锁的种类

 

1可重入锁 ReetrantLock自旋锁  synchronized

2 可中断锁 synchronized不可中断  lock可中断

3 公平锁  synchronized  lock

4 读写锁  readLock()读锁  writeLock()写锁

集合(总结完)

https://blog.csdn.net/weixin_41563161/article/details/102506009 java基础--集合

 

1 HashMap说一下?get流程?线程安全吗?如何选择线程安全的容器?

内推军P19  博客https://blog.csdn.net/weixin_41563161/article/details/102659874

ps:hashmap线程不安全的表现,这个问题我回答的是在扩容的时候线程不安全会出现问题。但是我觉得put和get也会出现,但是我的回答都被反驳了。hashmap在put或者get的时候,哪些情况下与concurrenthashmap结果是不同的?

 

HashMap  默认16 超过12 扩容32                                               

put()

1先计算hashCode() 然后对哈希值进行再哈希

2与(数组-1)按位与 注意这里数组长度是2 的n次方 -1之后每个位上都是1,速度加快  碰撞几率小

3没有链表,直接插  有链表进行遍历相同插入  不同的话头插法

get()

1 通过key的两次hash后的值与数组的长度-1进行与操作定位到数组某个位置 遍历链表

2不能判断null

多线程下HashMap不安全

1多线程同时put 触发rehash 循环结点  get的时候会死循环

2 多线程put会导致元素丢失

2 HashMap、Hashtable、ConcurrentHashMap的原理与区别

 

博客https://blog.csdn.net/weixin_41563161/article/details/104190568

ConcurrentHashMap的原理 get put remove 高并发的原因

https://blog.csdn.net/weixin_41563161/article/details/104190694强一致性、顺序一致性、弱一致性和共识

ConcurrentHashMap(分离锁   HashEntry对象不变性   Volatile变量可见性)

数据一段一段存储(segment)

Static final class HashEntry<K,V>{

         Final K key;

         Final int hash;

         Volatile V value;

         Final HashEntry<K,V> next;

}

get  

整个get不会加锁,除非读到的是空才会加锁  happen before原则 对于Volatile写入先于读

Put

1先判断是否扩容 HashMap后判断

2 插入锁定的是Segment不是整个ConcurrenthashMap 头插法  读不会影响  非同步读可能读到null  再次读一遍

Remove

先找到待删除的列表,然后把删除之前的复制到一个表上   但是顺序相反了  所以读不会影响

3 HashMap与TreeMap区别

HashMap哈希表  TreeMap基于红黑树

TreeMap能够保存键排序

HashMap通常比TreeMap快一点(树和哈希表的数据结构使然),建议多使用HashMap,在需要排序的Map时候才用TreeMap.

Treemap按照自然顺序

高并发(总结完)

1 消费者生产者模型

不知道这里的代码会不会需要让背写出来

  博客https://blog.csdn.net/weixin_41563161/article/details/104092514

1 使用阻塞队列实现

2 使用Object的wait()和notify()实现

3 使用Condition实现

Condition是在java 1.5中才出现的,它用来替代传统的Object的wait()、notify()实现线程间的协作,相比使用Object的wait()、notify(),使用Condition的await()、signal()这种方式实现线程间协作更加安全和高效。因此通常来说比较推荐使用Condition,阻塞队列实际上是使用了Condition来模拟线程间协作。

https://blog.csdn.net/a1439775520/article/details/98471610

https://blog.csdn.net/andyzhaojianhui/article/details/79361454\

 Class Producer implements Runnable{
    private final BlockingDeque shareQueue;
    public Producer(BlockingDeque shareQueue){
        this.sharedQueue = shareQueue;
    }
    public void run(){
        for(int i =0;i<10;i++){
            try{
                System.out.println("produced:" +1);
                shareQueue.put(i);
            }catch (InterruptedException ex){
                System.out.println(ex);
            }
        }
    }
}

Class Consumer implements Runnable{

    private final BlockingDeque shareQueue;

    public Consumer(BlockingDeque shareQueue){

        this.shareQueue = shareQueue;

    }

    public void run(){

        while (true){

            try {

                int i = (Integer)shareQueue.take();

                System.out.println("Consumed:" +i);

            }catch (InterruptedException ex){

                System.out.println(ex);

            }

        }

    }
public static void main(String[] args) {

    BlockingDeque shareQueue = new LinkedBlockingDeque();

    Thread proThread = new Thread(new Producer(shareQueue));

    Thread conThread = new Thread(new Consumer(shareQueue));

    proThread.start();

    conThread.start();

}

网站的高并发

 

1 html静态化(访问频率高)

2图片服务器和应用服务器分离

3数据库优化

4 缓存

5 镜像

6 负载均衡

7 并发控制

8 消息队列

juc

博客 https://blog.csdn.net/weixin_41563161/article/details/104163390

这里的源码

ConcurrentHashMap P81  P23

CopyOnWriteArrayList P81

内推军P95

同步辅助类

CountDownLatch 允许1个线程等待其他线程执行完之后才能执行。

CyclicBarrier    允许n个线程相互等待到某个公共屏障点,然后这一组线程再同时执行。

Semaphore    可以控制某个资源可被同时访问的个数。

 

阻塞队列

ArrayBlockingQueue  数组支持的有界缓存的阻塞队列  线程安全的 单独的锁

LinkedBlockingQueue 独立的锁

ArrayBlockingQueue与LinkedBlockingQueue区别               

内推军P106

PriorityBlockingQueue PriorityQueue

DelayQueue 加入数据是不会阻塞的,但是取数据是有阻塞的,如果时间没有到,取不出来任何数据。

SynchronousQueue 缓存为1 的阻塞队列

数据库(总结完)

1什么是数据库事务

原子性   一致性   隔离性  持久性(只要成功永久保存下来)

丢失更新 脏读    不可重复读   幻读

读未提交 读提交  可重复读(mysql默认)   可串行化

一级封锁协议  二级封锁协议   三级封锁协议 最强封锁协议

共享锁(s) (只能读,不能写)                  排他锁(X)(不能读也不能写)

快照(mdf文件)  (比如在可重复读的情况下开启事务,这个时候拍个照片,然后期间看到的还是和之前一样)

  1. 通过保存历史数据,可以用来生成报表来和修改之前的数据进行对比

2,可以用数据库快照来恢复数据库,而且它的的恢复速度可比backup文件恢复的快很多。
3,在对数据库做较大操作之前可以达到保护数据库的目的,尤其是在项目测试阶段这个作用很有用。

MVCC(多版本并发控制机制)

数据表中的一行记录,其实可能有多个版本 (row), 每个版本有自己的 row trx_id。

对于可重复读,查询只承认在事务启动前就已经提交完成的数据;

对于读提交,查询只承认在语句启动前就已经提交完成的数据;

事务启动  

显式启动事务语句, begin 或 start transaction。配套的提交语句是commit,回滚语句是rollback。

set autocommit=0 长事务  建议你总是使用set autocommit=1, 通过显式语句的方式来启动事务

 

https://blog.csdn.net/weixin_41563161/article/details/102852150事务到底隔离还是不隔离

https://blog.csdn.net/weixin_41563161/article/details/101111928 最全事务

里面有以下四种的具体示例

https://blog.csdn.net/weixin_41563161/article/details/102373535 为什么你改了我看不见

1更新丢失

2脏读

3不可重复读

4幻读

 

长事务

3 数据库如何实现串行化

[ˈsɪˌriəˌlaɪzəbl]、

可重复读实现了读取前后数据内容一致,

但是产生了数据条目不一致(幻读),

可串行化解决了这个问题,

串行化是最严格的事物隔离级别:

事物a 执行读写操作时,会锁定检索的数据行范围(范围锁),这种锁会阻止其他事物在本范围内的一切操作,

只有事物a执行完毕,提交事物后,才会释放范围锁,这样就避免了幻读。

但是,实际项目中,这个级别的隔离很少用,因为并发性能低,容易死锁。

4数据库中的锁

全局锁 Flush tables with read lock (FTWRL)  全库逻辑备份 整库都只读  

全局锁通用     但是(InnoDB事务官方自带工具 mysqldump) single-transaction参数

表锁 直接锁定整张表,其它进程无法对表进行写操作  写 读也不允许(不会出现死锁  快 锁冲突高)  MyISAM

行锁 (加锁慢 锁冲突最低  不会死锁)InnoDB

表级锁更适合于以查询为主,只有少量按索引条件更新数据的应用

而行级锁则更适合于有大量按索引条件并发更新少量不同数据,同时又有并发查询的应用

避免死锁

行锁是在需要的时候才加上的,但并不是不需要了就立刻释放,而是要等到事务结束时才释放。这个就是两阶段锁协议

1影响并发度的锁尽量往后放  2 直接进入等待,直到超时。  3死锁检测innodb_deadlock_detect

 

https://blog.csdn.net/weixin_41563161/article/details/102490808数据库中的锁

 

从锁的角度来说,表级锁更适合于以查询为主,只有少量按索引条件更新数据的应用,如Web应用;而行级锁则更适合于有大量按索引条件并发更新少量不同数据,同时又有并发查询的应用,如一些在线事务处理(OLTP)系统。

5 MVCC(多版本并发控制机制)

数据库快照

博客https://blog.csdn.net/weixin_41563161/article/details/102852150        

事务到底是隔离的还是不隔离的?

 6 数据库引擎及比较

 

1事务 MyISAM快, InnoDB提供事务支持

2 MyISAM 不支持外键   InnoDB支持外键

3 MyISAM支持表级锁    InnoDB表级和行级

4 MyISAM全文索引,

5 MyISAM 允许没有主键的表存在

6表的具体行数   MyISAM保存了  InnoDB要重新计算

1. InnoDB

InnoDB 是 MySQL 默认的事务型存储引擎,只有在需要 InnoDB 不支持的特性时,才考虑使用其它存储引擎。

采用 MVCC 来支持高并发,并且实现了四个标准的隔离级别,默认级别是可重复读。

表是基于聚簇索引建立的,它对主键的查询性能有很高的提升。

内部做了很多优化,包括从磁盘读取数据时采用的可预测性读、能够自动在内存中创建哈希索引以加速读操作的自适应哈希索引、能够加速插入操作的插入缓冲区等。

通过一些机制和工具支持真正的热备份。

2. MyISAM

MyISAM 提供了大量的特性,包括全文索引、压缩、空间函数(GIS)等。但 MyISAM 不支持事务和行级锁,而且崩溃后无法安全恢复。

只能对整张表加锁,而不是针对行。

可以手工或者自动执行检查和修复操作,但是和事务恢复以及崩溃恢复不同,可能导致一些数据丢失,而且修复操作是非常慢的。

可以包含动态或者静态的行。

如果指定了 DELAY_KEY_WRITE 选项,在每次修改执行完成时,不会立即将修改的索引数据写入磁盘,而是会写到内存中的键缓冲区,只有在清理键缓冲区或者关闭表的时候才会将对应的索引块写入磁盘。这种方式可以极大的提升写入性能,但是在数据库或者主机崩溃时会造成索引损坏,需要执行修复操作。

如果表在创建并导入数据以后,不会再进行修改操作,那么这样的表适合采用 MyISAM 压缩表。

对于只读数据,或者表比较小、可以容忍修复操作,则依然可以继续使用 MyISAM。

MyISAM 设计简单,数据以紧密格式存储,所以在某些场景下性能很好。

3. InnoDB 与 MyISAM 的比较

事务

InnoDB 是事务型的。

备份

InnoDB 支持在线热备份。

崩溃恢复

MyISAM 崩溃后发生损坏的概率比 InnoDB 高很多,而且恢复的速度也更慢。

并发

MyISAM 只支持表级锁,而 InnoDB 还支持行级锁。

其它特性

MyISAM 支持全文索引,地理空间索引。

 

7说一聚簇索引和非聚簇索引的有什么不同

内推军237

主键索引与辅助索引区别

https://blog.csdn.net/wrs120/article/details/91126531

8 数据库索引

索引(索引中除了存储列的值,还存储着一个指向在行数据的索引。

1连接器    2查询缓存(默认不要 弊大于利)  3分析器       4优化器    5执行器

1用户账号密码 2是否有key为当前sql  3sql语法错误4最终的方案  索引以及表的链接顺序  5权限控制                                           ----一条语句查询过程

 WAL的全称是Write-Ahead Logging(先写日志,再写磁盘)

binlog(归档日志) 1是Mysql Server层的,所有引擎都能用  2逻辑日志     3追加写

redolog(重做日志)1InnoDB (crash-safe 数据库异常记录不会丢失) 2物理日志 3循环写的,会用完

两阶段提交  redlogPrepare  binlog  commit

先redolog后binlog导致binlog丢失     先binlog后redolog多一次事务出来

唯一索引、 主键索引(自增 页分裂)、普通索引、组合索引、        聚集索引/聚簇索引

应该不应该 建立索引的

1经常需要搜索的列 2 作为主键的列  3范围查询的列  4 经常排序的列 5经常where 6经常连接的

1很少使用         2很少值         3text  image 类型    4修改性能大于检索性能

建立索引原则

1最左前缀  2区分度高的  3不做运算或使用函数  4where  5模糊右  6尽量扩展,不要新建索引

1组合不是第一失效 2or前后没有同时使用 3字符串没有“”起来 4 做了运算  5使用了其它模糊

整体介绍索引

0数据库查询的过程1索引是什么2索引原理3索引数据结构(为什么用B+)4索引种类 5索引原则

(为什么用B+) 1高度 大量的关键字  2路径一样稳定  3 磁盘预读性和局部性 一读读一个页

优化器的逻辑

扫描的行数    索引的“区分度”(可能优先主键)

 

 

内推军236 

https://blog.csdn.net/weixin_41563161/article/details/103553313 数据库索引怎么实现

https://blog.csdn.net/weixin_41563161/article/details/102859171普通索引和唯一索引选择

https://blog.csdn.net/weixin_41563161/article/details/102966786字符串字段加索引

https://blog.csdn.net/weixin_41563161/article/details/102457643深入浅出索引https://blog.csdn.net/weixin_41563161/article/details/102957941 MySQL为什么有时候会选错索引?

什么是索引

在数据之外,数据库系统还维护着满足特定查找算法的数据结构,这些数据结构以某种方式引用(指向)数据,这样就可以在这些数据结构上实现高级查找算法。这种数据结构,就是索引。

哪些数据结构

哈希表

因为不是有序的,所以哈希索引做区间查询的速度是很慢的。适用于只有等值查询的场景,比如Memcached及其他一些NoSQL引擎。

有序数组

有序数组在等值查询和范围查询场景中的性能就都非常优秀

在需要更新数据的时候就麻烦了,你往中间插入一个记录就必须得挪动后面所有的记录,成本太高。

所以,有序数组索引只适用于静态存储引擎,比如你要保存的是2017年某个城市的所有人口信息,这类不会再修改的数据。

二叉搜索树

它们是时间复杂度低, 查找、删除、插入操作都可以可以在对数时间内完成。

另外一个重要原因存储在B-Tree中的数据是有序的

索引种类

  唯一索引、 主键索引、普通索引、组合索引、聚集索引/聚簇索引

 

索引的优点

1速度

2 唯一性索引,使得数据唯一

3 加速表与表之间连接

4 使用分组和排序字句进行检索可以显著减少时间

5通过使用索引,可以在查询的过程中,使用优化隐藏器,提高系统的性能。

 

索引的缺点

  1 占物理空间

  2 维护当对表中的数据进行增加、删除和修改的时候,索引也要动态的维护,这样就降低了数据的维护速度

3 创建索引和维护索引要耗费时间,这种时间随着数据量的增加而增加。

索引的原理

DB在执行一条Sql语句的时候,默认的方式是根据搜索条件进行全表扫描,遇到匹配条件的就加入搜索结果集合。如果我们对某一字段增加索引,查询时就会先去索引列表中一次定位到特定值的行数,大大减少遍历匹配的行数,所以能明显增加查询的速度。

 

MyISAM 与 InnoDB索引的区别

 

 

建立索引用B+树的原因,

 

 

建立索引的原则

1 最左前缀匹配原则

2 区分度高的

3 不在索引列做运算或者使用函数

4 尽量扩展,不要新建索引

5 where中经常使用的字段应该有索引

6 模糊查询中右模糊查询会使用索引 321%   其它的%321  %321%会全局扫描

 

数据库索引失效的原因

1对于组合索引不是第一部分会失效

2 or语句前后没有同时使用索引

3 字符串用引号引起来

4 不在索引列做运算或者使用函数

5 模糊查询中右模糊查询会使用索引 321%   其它的%321  %321%会全局扫描

应该创建索引的

索引是建立在数据库表中的某些列的上面。在创建索引的时候,应该考虑在哪些列上可以创建索引,在哪些列上不能创建索引。一般来说,应该在这些列上创建索引:

 

1 经常需要搜索的列上,可以加快搜索的速度;(字段的使用频率)

2 作为主键的列上,强制该列的唯一性和组织表中数据的排列结构;在经常用在连接的列上,这些列主要是一些外键,可以加快连接的速度;

3 经常需要根据范围进行搜索的列上创建索引,因为索引已经排序,其指定的范围是连续的;

4 经常需要排序的列上创建索引,因为索引已经排序,这样查询可以利用索引的排序,加快排序查询时间;

5经常使用在WHERE子句中的列上面创建索引,加快条件的判断速度。

6 经常用在连接的列上,这些列主要是一些外键,可以加快连接的速度;

 

不应该创建索引的

同样,对于有些列不应该创建索引。一般来说,不应该创建索引的的这些列具有下列特点:

 

1于那些在查询中很少使用或者参考的列不应该创建索引。这是因为,既然这些列很少使用到,因此有索引或者无索引,并不能提高查询速度。相反,由于增加了索引,反而降低了系统的维护速度和增大了空间需求。

 

2对于那些只有很少数据值的列也不应该增加索引。这是因为,由于这些列的取值很少,例如人事表的性别列,在查询的结果中,结果集的数据行占了表中数据行的很大比例,即需要在表中搜索的数据行的比例很大。增加索引,并不能明显加快检索速度。

 

3对于那些定义为text, imagebit数据类型的列不应该增加索引。这是因为,这些列的数据量要么相当大,要么取值很少。

 

4修改性能远远大于检索性能时,不应该创建索引。这是因为,修改性能和检索性能是互相矛盾的。当增加索引时,会提高检索性能,但是会降低修改性能。当减少索引时,会提高修改性能,降低检索性能。因此,当修改性能远远大于检索性能时,不应该创建索引。

 

其它高级知识点

索引新名词

覆盖索引

 

联合索引比如身份证+姓名 要频繁查名字

 

最左前缀原则 "where name like ‘张%’"

 

索引下推

https://blog.csdn.net/weixin_41563161/article/details/102457643

对于字符串索引来说

1. 直接创建完整索引,这样可能比较占用空间;

 

 2. 创建前缀索引,节省空间,但会增加查询扫描次数,并且不能使用覆盖索引;

 

3. 倒序存储,再创建前缀索引,用于绕过字符串本身前缀的区分度不够的问题;

 

4. 创建 hash 字段索引,查询性能稳定,有额外的存储和计算消耗,跟第三种方式一样,都不 支持范围扫描。 在实际应用中,你要根据业务字段的特点选择使用哪种方式

https://blog.csdn.net/weixin_41563161/article/details/102966786

索引选择异常和处理

1 一种方法是,像我们第一个例子一样,采用 force index 强行选择一个索引。一来这么写不优美,二来如果索引改了名字,这个语 句也得改,显得很麻烦。而且如果以后迁移到别的数据库的话,这个语法还可能会不兼容。

 

2 考虑修改语 句,引导 MySQL 使用我们期望的索引

既然优化器放弃了使用索引 a,说明 a 还不够合适,所以第二种方法就是,我们可以考虑修改语 句,引导 MySQL 使用我们期望的索引。比如,在这个例子里,显然把“order by b limit 1” 改成 “order by b,a limit 1” ,语义的逻辑是相同的。

3 第三种方法是,在有些场景下,我们可以新建一个更合适的索引,来提供给优化器做选择,或删 掉误用的索引

https://blog.csdn.net/weixin_41563161/article/details/102957941

普通索引和唯一索引,应该怎么选择?

change buffer

尽量选择普通索引。

redo log 主要节省的是随机写磁盘的 IO 消耗(转成顺序写),而 change buffer 主要节省的则是随机读磁盘的 IO 消耗。

9 优化查询方法

1使用索引

2优化Sql    

       1开启mysql慢查询 set slow_query_log =ON   

2(show processlist  查看当前的状态 加锁情况)

3( explain 命令看到的这条语句的执行情况。  Key  rows)

4( analyze table t新统计索引信息)

3 对表进行差分  (水平  垂直)

4硬件优化

5mysql优化(最大连接数max_connections  缓冲区大小query_cache_size)
6数据库连接池

7缓存 redis

 

https://blog.csdn.net/weixin_41563161/article/details/104267382

1 使用索引 首先在whereorder bygroup by建立索引

2 优化Sql语句

  1. 通过explain查看SQL语句执行的效果          explain select * from t
  2. 不要用 select * from t
  3. 不在索引处做运算或使用函数
  4. 尽可能使用limit减少返回行数

3优化数据库对象

  1. 使用procedure analyse()对表进行分析 select * from t procedure analyse()
  2. 对表进行拆分  垂直拆分  水平拆分
  3. 使用中间表提高查询速度

4 硬件优化

  1. CPU优化
  2. 内存优化
  3. 磁盘I/O优化

5 Mysql自身的优化

  1. 对配置文件参数优化
  2. 指定查询缓冲区大小
  3. 指定Mysql允许的最大连接数

6应用优化

  1. 使用数据库连接池
  2. 使用查询缓存

10 大访问量到数据库上,如何优化

1优化查询

2主从复制 读写分离

(1从数据库有一个I/O线程不断遍历2通过网络将变化传到从服务器日志 relay中继日志  3 binlog)

同步复制(所有从更新完)异步复制(无需等待) 半同步复制(其中一台)

 

1 优化查询

以上

2 主从复制,读写分离,负载均衡

3 数据库分表,分区,分库

11 SQL注入以及解决

 

12 SQL语句(这个是重点,最好总结一下)

 

https://blog.csdn.net/weixin_41563161/article/details/101227932  数据库基本知识

https://blog.csdn.net/weixin_41563161/article/details/101228148 mysql基本知识

 

13存储过程

 

https://blog.csdn.net/weixin_41563161/article/details/101271725 Mysql 进阶高级知识

1已经编译过了,运行快

2在服务端运行,减少客户端压力

3 复用

4 减少网络流量

5 增强使用的安全性

14 慢查询优化

 

  • (2)分析慢查询日志        

例如:执行EXPLAIN SELECT * FROM res_user ORDER BYmodifiedtime LIMIT 0,1000

得到如下结果: 显示结果分析:  

 

table |  type | possible_keys | key |key_len  | ref | rows | Extra  EXPLAIN列的解释:           

                table                 显示这一行的数据是关于哪张表的           

                  type                  这是重要的列,显示连接使用了何种类型。从最好到最差的连接类型为const、eq_reg、ref、range、indexhe和ALL 

                   rows                显示需要扫描行数

                   key                   使用的索引

(3)常见的慢查询优化

 

1索引没起作用的情况

2优化数据库结构

       3 这里要看看自己之前的那些

 

计算机网络(总结完)

1 http、https的连接过程,数字证书。

博客https://blog.csdn.net/weixin_41563161/article/details/104091201

http状态码 

https的缓存机制

 

http1.1 和http1.0区别

 

Get 和post区别

 

http 和https的区别

 

2 TCP的三次握手,四次挥手

博客https://blog.csdn.net/weixin_41563161/article/details/101054051

自己打印出来的材料

为什么不是2次握手P151

浪费服务器资源

为什么要4次挥手

SYN ACK是干什么的P148

3对称加密和非对称加密的区别以及应用。了解哪些常用的加密算法?MD5算法详解

  P192博客https://blog.csdn.net/weixin_41563161/article/details/104091794

4 五层协议详解

 博客https://blog.csdn.net/weixin_41563161/article/details/102233985

5 CSRF攻击防御

1 Ddos

2 XSS

内推军P188 博客https://blog.csdn.net/weixin_41563161/article/details/104163888

防御

1 及时清除Cookie

2 在客户端增加伪随机数

3 图片验证码

6 输入url回车会生什么

博客https://blog.csdn.net/weixin_41563161/article/details/101054831

1输入要网址

2浏览器通过DNS查找域名的IP地址

 

7 TCP如何保证可靠传输的

 

8 TCP三次握手漏洞

 

9 TCP与UDP区别

各自的优势

 

10 流量控制和拥塞控制

 

博客https://blog.csdn.net/weixin_41563161/article/details/104218014

说到底就是不发送较小的  不急于发送

流量控制

当接收方处理好数据,接受窗口 win > 0 时,接收方发个通知报文去通知发送方,告诉他可以继续发送数据了。当发送方收到窗口大于0的报文时,就继续发送数据。

拥塞控制

我们知道,两台主机在传输数据包的时候,如果发送方迟迟没有收到接收方反馈的ACK,那么发送方就会认为它发送的数据包丢失了,进而会重新传输这个丢失的数据包。

 

然而实际情况有可能此时有太多主机正在使用信道资源,导致网络拥塞了,而A发送的数据包被堵在了半路,迟迟没有到达B。这个时候A误认为是发生了丢包情况,会重新传输这个数据包。

 

结果就是不仅浪费了信道资源,还会使网络更加拥塞。因此,我们需要进行拥塞控制。

慢开始 拥塞避免 快重传 快恢复

11Cookie与Session

 

12 粘包原因解决办法

 

13 TCP头部有哪些字段

 

这个地方看自己能不能一口气串下来

https://blog.csdn.net/weixin_41563161/article/details/104229761

14 路由转发算法

内推军P205

 

数据结构(总结完)

1 TreeMap了解吗 红黑树

博客https://blog.csdn.net/weixin_41563161/article/details/104163994

https://blog.csdn.net/weixin_41563161/article/details/104452601#%E5%88%A0%E9%99%A4%E8%BF%87%E7%A8%8B

红黑树是一种自平衡二叉树,在平衡二叉树的基础上每个节点又增加了一个颜色的属性,节点的颜色只能是红色或黑色。具有以下性质:

(1)节点要么是红色,要么是黑色,

(2)根节点只能是黑色;

(3)红黑树中所有的叶子节点后面再接上左右两个空节点,这样可以保持算法的一致性,而且所有的空节点都是黑色;

(4)红色节点的父节点和左右孩子节点都是黑色,及黑红相间;

(5)在任何一棵子树中,从根节点向下走到空节点的路径上所经过的黑节点的数目相同,从而保证了是一个平衡二叉树。

 

左旋

 将右子树的左子树链接到父亲节点的右孩子结点,父亲节点作为ptr结点的左孩子结点便完成了旋转。

右旋

当前节点ptr,与父亲节点和当前节点的左孩子结点位于一条直线上时,使用右单旋进行平衡。 

2堆排序

https://blog.csdn.net/weixin_41563161/article/details/102835398最小的K个数

https://blog.csdn.net/weixin_41563161/article/details/101937543堆排序

3 B+

博客 https://blog.csdn.net/weixin_41563161/article/details/104163948

B

1 一颗m阶树中每个节点至多有m棵子树(即至多含有m-1个关键字);

2 若根节点不是叶子节点,则至少有2棵子树;

3 除根节点之外的所有非终端节点至少有[ m/2 ] ( 向上取整 )棵子树,即([ m/2 ]-1个关键字

4 每个节点中的信息结构为(A0,K1,A1,K2......Kn,An),其中n表示关键字个数,Ki为关键字,Ai为指针;且Ai-1所指子树中所有结点的关键字均小于Ki,An所指子树中所有结点的关键字均大于Kn;

5 所有的叶子节点都出现在同一层次上,且不带任何信息,也是为了保持算法的一致性。

B+树

B树和二叉查找树的性能对比

B树包括B+树的设计思想都是尽可能的降低树的高度,以此降低磁盘IO的次数,因为一个索引节点就表示一个磁盘页,页的换入换出次数越多,表示磁盘IO次数越多,越低效。

为什么数据库索引不用红黑树而用B+树?

红黑树当插入删除元素的时候会进行频繁的变色与旋转(左旋,右旋),来保证红黑树的性质,浪费时间。

但是当数据量较小,数据完全可以放入内存中,不需要进行磁盘IO,这时候,红黑树时间复杂度比B+树低。

 

4 排序总结

https://blog.csdn.net/weixin_41563161/article/details/101942811 排序总结

https://blog.csdn.net/weixin_41563161/article/details/100858281简单排序

 

5 快速排序

https://blog.csdn.net/weixin_41563161/article/details/101921177快速排序最全详解(java)

 

6 树的遍历

https://blog.csdn.net/weixin_41563161/article/details/101785757

https://blog.csdn.net/weixin_41563161/article/details/102639284二叉树的遍历

 

7 链表

https://blog.csdn.net/weixin_41563161/article/details/102498778单链表

 

https://blog.csdn.net/weixin_41563161/article/details/102510670双向链表 双端链表

8归并排序

https://blog.csdn.net/weixin_41563161/article/details/101942087归并排序

 

操作系统(总结完)

1 进程间通信

    博客https://blog.csdn.net/weixin_41563161/article/details/102235615

2 进程调度方法

      博客https://blog.csdn.net/weixin_41563161/article/details/104105468

3 磁盘臂调度算法

  博客https://blog.csdn.net/weixin_41563161/article/details/104106501

4死锁是什么?发生的条件?如何尽可能避免。

 

活锁是什么?

 

(其它锁)

 

预防死锁

1 破坏互斥条件

2 破坏不剥夺条件

3 破坏请求和保持条件

4 破坏环路等待条件

 

5 进程和线程之间的区别

 

6 缓存数据处理【说的LRU】

https://blog.csdn.net/weixin_41563161/article/details/104287186

7 线程同步和互斥有何异同,在什么情况下分别使用他们?举例说明

线程同步是指线程之间所具有的一种制约关系,一个线程的执行依赖另一个线程的消息,当它没有得到另一个线程的消息时应等待,直到消息到达时才被唤醒。

 

线程互斥是指对于共享的进程系统资源,在各单个线程访问时的排它性。当有若干个线程都要使用某一共享资源时,任何时刻最多只允许一个线程去使用,其它要使用该资源的线程必须等待,直到占用资源者释放该资源。

8线程同步的通信方式

线程间的同步方法大体可分为两类:用户模式和内核模式。顾名思义,内核模式就是指利用系统内核对象的单一性来进行同步,使用时需要切换内核态与用户态,而用户模式就是不需要切换到内核态,只在用户态完成操作。

用户模式下的方法有:原子操作(例如一个单一的全局变量),临界区。

内核模式下的方法有:事件,信号量,互斥量。

    1. 临界区(Critical Section):同一进程内实现线程互斥
    2. 互斥量(Mutex):可以跨进程实现线程互斥
    3. 信号量(Semaphores):可以跨进程实现线程同步
    4. 事件

 

1、临界区

保证在某一时刻只有一个线程能访问数据的简便办法。在任意时刻只允许一个线程对共享资源进行访问。如果有多个线程试图同时访问临界区,那么在有一个线程进入后其他所有试图访问此临界区的线程将被挂起,并一直持续到进入临界区的线程离开。临界区在被释放后,其他线程可以继续抢占,并以此达到用原子方式操作共享资源的目的。

2、互斥量(Mutex):可以跨进程实现线程互斥。

互斥量跟临界区很相似,只有拥有互斥对象的线程才具有访问资源的权限由于互斥对象只有一个,因此就决定了任何情况下此共享资源都不会同时被多个线程所访问。当前占据资源的线程在任务处理完后应将拥有的互斥对象交出,以便其他线程在获得后得以访问资源。互斥量比临界区复杂。因为使用互斥不仅仅能够在同一应用程序不同线程中实现资源的安全共享,而且可以在不同应用程序的线程之间实现对资源的安全共享。互斥量与临界区的作用非常相似,但互斥量是可以命名的,也就是说它可以跨越进程使用。所以创建互斥量需要的资源更多,所以如果只为了在进程内部是用的话使用临界区会带来速度上的优势并能够减少资源占用量。

3、信号量(Semaphores):可以跨进程实现线程同步。

信号量对象对线程的同步方式与前面几种方法不同,信号允许多个线程同时使用共享资源。它指出了同时访问共享资源的线程最大数目。它允许多个线程在同一时刻访问同一资源,但是需要限制在同一时刻访问此资源的最大线程数目。一般是将当前可用资源计数设置为最大资源计数,每增加一个线程对共享资源的访问,当前可用资源计数就会减1,只要当前可用资源计数是大于0的,就可以发出信号量信号。但是当前可用计数减小到0时则说明当前占用资源的线程数已经达到了所允许的最大数目,不能在允许其他线程的进入,此时的信号量信号将无法发出。

4、事件(Event):可以跨进程实现线程同步。

事件对象也可以通过通知操作的方式来保持线程的同步。并且可以实现不同进程中的线程同步操作。

设计模式(总结完)

博客https://blog.csdn.net/weixin_41563161/article/details/103071318

这篇博客是大师总结的。

1单例模式

博客https://blog.csdn.net/weixin_41563161/article/details/102470548

2 享元模式

博客https://blog.csdn.net/weixin_41563161/article/details/103651271

3桥接模式

https://blog.csdn.net/weixin_41563161/article/details/102990253

4观察者模式

https://blog.csdn.net/weixin_41563161/article/details/102942406

5简单工厂模式、工厂模式

https://blog.csdn.net/weixin_41563161/article/details/102931960

 

TopN问题(总结完)

https://blog.csdn.net/weixin_41563161/article/details/104370095

企业知识(还未总结完)

1 阿里

1 对阿里技术氛围有什么样的理解,用过哪些阿里的开源库

2 了解菜鸟吗?知道我们现在在做什么(自己经常看IT业内新闻,可能这个地方说的比较好,也和顺丰京东物流作了一个横向对比)

3 如何体现你的自学能力

4 平时如何自学(视频,博客,论坛,Google,Github...)

 

刷题

LeetCode(还未总结完)

动态规划

1 最长回文子串

还不行,要看答案,第二天背写一下 (经历了调试可以背写出来,但是还有问题)这个题目比较复杂。

https://blog.csdn.net/weixin_41563161/article/details/100899936

2 最大子序和

还不行,要看答案  第二天背写一下 (经历了调试可以背写出来)

https://blog.csdn.net/weixin_41563161/article/details/101027801

3 爬楼梯

自己能写出来

https://blog.csdn.net/weixin_41563161/article/details/101100016

4不同路径

还不行,要看答案  第二天背写一下  可以背写出来

https://blog.csdn.net/weixin_41563161/article/details/101037329

5最小路径和

还不行,要看答案,第二天背写一下(其实这道题思路知道,还是上和左边这个处理初始化的问题)

https://blog.csdn.net/weixin_41563161/article/details/101078175

6正则表达式匹配

还不行,要看答案,第二天背写一下(其实这道题没懂那个意思啥,就是为什么要,这道题是还是要好好的搞懂)

https://blog.csdn.net/weixin_41563161/article/details/100920889

7 不同路径 II

还不行,要看答案,第二天背写一下(这道题有点厉害。编码能力还是有待提高)

https://blog.csdn.net/weixin_41563161/article/details/101075456

8最长有效括号 

还不行,要看答案,第二天背写一下(这道题有点厉害。用栈会做,有思路,动态规划还没看懂)

https://blog.csdn.net/weixin_41563161/article/details/100934168

9 判断子序列

还不行,要看答案,第二天背写一下

https://blog.csdn.net/weixin_41563161/article/details/102733427

10编辑距离 

还不行,要看答案,第二天背写一下  还是动态规划最小值是为什么

https://blog.csdn.net/weixin_41563161/article/details/101151489

11 通配符匹配

还不行,要看答案,第二天背写一下还是动态规划的初始化不清楚,这次刷完清楚了

https://blog.csdn.net/weixin_41563161/article/details/100976776

12 丑数 II 

自己能写出来

https://blog.csdn.net/weixin_41563161/article/details/102882506

回溯法

1 电话号码的字母组合 

由于是这段时间第一次做回溯法的题目,所以手写不出来,但是知道是回溯法,而且知道三步法(,嗯慢慢理清楚思路了,差不多有感觉了),注意一下那个index++

https://blog.csdn.net/weixin_41563161/article/details/101199553

2 括号生成 

还不行,要看答案,第二天背写一下 自己能写出来

https://blog.csdn.net/weixin_41563161/article/details/101210492
3全排列

自己能写出来

https://blog.csdn.net/weixin_41563161/article/details/101479627

4子集 

https://blog.csdn.net/weixin_41563161/article/details/102823889

还不行,要看答案,第二天背写一下 这个有点难理解

5组合总和

还不行,要看答案  第二天背写一下

https://blog.csdn.net/weixin_41563161/article/details/101372139

6 第K个排列

写出来了,但是复杂度太高,还要想一种新的办法(自己用的是全排列的方法)新的方法看懂了,但是明天还要再看一下。这个方法有点6,剪枝策略,但是有点难

https://blog.csdn.net/weixin_41563161/article/details/101776699

7 单词搜索

还不行,要看答案  第二天背写一下

https://blog.csdn.net/weixin_41563161/article/details/103864466

8 组合 

确实和排列的那个不一样,值得对比 第二天背写一下

(如果传入的参数是i的话,那么就是组合,而且不重复,如果传入的是index,那么应该是求排列)

https://blog.csdn.net/weixin_41563161/article/details/102823478

9全排列II

这道题和全排列又不一样,很好的一道题,值得学习

https://blog.csdn.net/weixin_41563161/article/details/101523871

10 子集 II

这道题和子集又不一样,很好的一道题,值得学习

https://blog.csdn.net/weixin_41563161/article/details/104233758

子集,子集 II,全排列,全排列II,组合 区别 总结一下

https://blog.csdn.net/weixin_41563161/article/details/104235944

11组合总和II(回溯法)有时间做一下

https://blog.csdn.net/weixin_41563161/article/details/101421624

 

dfs深度优先搜索

1 二叉树的最大深度 

自己竟然不会,第二天背写

https://blog.csdn.net/weixin_41563161/article/details/102329514

2 对称二叉树 

自己竟然不会,第二天背写

https://blog.csdn.net/weixin_41563161/article/details/102308227

3 相同的树 

自己能写出来

https://blog.csdn.net/weixin_41563161/article/details/102303585

4 验证二叉搜索树

还不行,要看答案,第二天背写一下,其实还是大概知道怎么做,但是就是代码能力还不够

https://blog.csdn.net/weixin_41563161/article/details/101792909

5 路径总和

和剑指offer那道题有点区别,但是自己还是能够写出来

https://blog.csdn.net/weixin_41563161/article/details/102387415

6 二叉树的最小深度 

这道题和二叉树的最大深度相互呼应  这道题要好好做做

https://blog.csdn.net/weixin_41563161/article/details/102331588

7二叉树中的最大路径和 

还不行,要看答案  第二天背写一下 还是有点难度

https://blog.csdn.net/weixin_41563161/article/details/102395490

8恢复二叉搜索树

这道题怎么感觉用的还是老方法 自己有时间在用那个实现一下

https://blog.csdn.net/weixin_41563161/article/details/101913697

9 平衡二叉树 

自己能写出来

https://blog.csdn.net/weixin_41563161/article/details/102409294

10 朋友圈 

写不出来 第二天背写一下

https://blog.csdn.net/weixin_41563161/article/details/102464675

bfs 广度优先搜索

1 N叉树的层序遍历 

差不多自己能写出来

https://blog.csdn.net/weixin_41563161/article/details/102649550 树的层序遍历   

https://blog.csdn.net/weixin_41563161/article/details/102639284二叉树的遍历

2 被围绕的区域

这道题不会,没有想到,这个要好好的再背一下

https://blog.csdn.net/weixin_41563161/article/details/102651938

3岛屿数量

差不多自己能写出来

https://blog.csdn.net/weixin_41563161/article/details/102568302

4二叉树的层次遍历

自己把和回溯法搞混乱了

https://blog.csdn.net/weixin_41563161/article/details/102639284

5二叉树的层次遍历II

差不多自己能写出来  但是没有还是用的深度优先搜索的办法

https://blog.csdn.net/weixin_41563161/article/details/102639284

6二叉树的锯齿形层次遍历

差不多自己能写出来

https://blog.csdn.net/weixin_41563161/article/details/102639284

7二叉树的堂兄弟节点

有点难度第二天需要继续背写一下

https://blog.csdn.net/weixin_41563161/article/details/104356012

8二叉树的右视图

差不多自己能写出来

https://blog.csdn.net/weixin_41563161/article/details/102639284

二叉树的左视图

差不多自己能写出来

https://blog.csdn.net/weixin_41563161/article/details/102639284

9课程表

有点难度,拓扑排序,有点难度第二天需要继续背写一下

https://blog.csdn.net/weixin_41563161/article/details/102649159

10 完全平方数

有点难度,拓扑排序,有点难度第二天需要继续背写一下,这里用的是动态规划

https://blog.csdn.net/weixin_41563161/article/details/104377839

明天顺便准备树的遍历

1 前序遍历

2 中序遍历

3 后续遍历

4 从上往下打印二叉树

5 二叉树倒着遍历

6 二叉树自底向上的层次遍历

7 二叉树的锯齿形层次遍历

8 二叉树的右视图

9 二叉树的左视图

10 N叉树的层序遍历

https://blog.csdn.net/weixin_41563161/article/details/102649550

https://blog.csdn.net/weixin_41563161/article/details/102639284

贪心

1 跳跃游戏

第二天要重新写一下

https://blog.csdn.net/weixin_41563161/article/details/102251861

2 跳跃游戏 II

第二天要重新写一下,用动态规划可以,但是贪心的话刚学会,所以明天再试下

https://blog.csdn.net/weixin_41563161/article/details/102304311

3 买卖股票的最佳时机 II 

第二天要重新写一下

https://blog.csdn.net/weixin_41563161/article/details/102684843

4 分割平衡字符串

第二天要重新写一下

https://blog.csdn.net/weixin_41563161/article/details/102929762

5 判断子序列

差不多自己能写出来 但是第二个有难度的需要宏子哥支援(升级版还是不会)

https://blog.csdn.net/weixin_41563161/article/details/102733427

6 最后一块石头的重量

明天再试一下

https://blog.csdn.net/weixin_41563161/article/details/102720062

7 分发饼干

明天再试一下

https://blog.csdn.net/weixin_41563161/article/details/102930618

8 加油站

明天再试一下

https://blog.csdn.net/weixin_41563161/article/details/102689973

9 分发糖果

很有意思,

https://blog.csdn.net/weixin_41563161/article/details/102950529

剑指Offer(还未总结完)

1-10

1二维数组中的查找

自己能写出来

https://blog.csdn.net/weixin_41563161/article/details/102471409

2替换空格

自己能写出来

https://blog.csdn.net/weixin_41563161/article/details/102476568

3 从尾到头打印链表

自己能写出来

https://blog.csdn.net/weixin_41563161/article/details/102511668

4 重建二叉树

还不行,要看答案  第二天背写一下(经历了调试可以背写出来,但是还有问题)这个题目比较复杂。 还是要争取搞懂

https://blog.csdn.net/weixin_41563161/article/details/102486184

5 用两个栈实现队列

自己能写出来

https://blog.csdn.net/weixin_41563161/article/details/102488945

6 旋转数组的最小数字

自己能写出来

https://blog.csdn.net/weixin_41563161/article/details/102526639

7 斐波那契数列

自己能写出来

https://blog.csdn.net/weixin_41563161/article/details/102531688

8跳台阶

自己能写出来

https://blog.csdn.net/weixin_41563161/article/details/101100016

 变态跳台阶

https://blog.csdn.net/weixin_41563161/article/details/104132562

9 矩形覆盖

自己能写出来

https://blog.csdn.net/weixin_41563161/article/details/104132806

10二进制中1的个数

自己能写出来(这道题应该有该记录的方法)

https://blog.csdn.net/weixin_41563161/article/details/102544693

11-20

11 数值的整数次方

自己能写出来  看似简单的一道题要好好看看,好在自己写出来了

https://blog.csdn.net/weixin_41563161/article/details/102573248

12 调整数组顺序使奇数位于偶数前面

自己能写出来,

https://blog.csdn.net/weixin_41563161/article/details/102586537

13链表中倒数第k个结点

自己能写出来

https://blog.csdn.net/weixin_41563161/article/details/102589385

14反转链表

这道题还是没有背写出来。(自己可以写出来了)

https://blog.csdn.net/weixin_41563161/article/details/102593077

15合并两个排序链表

这道题还是没有背写出来。(其中有两个点很重要)

https://blog.csdn.net/weixin_41563161/article/details/102628639

16树的子结构

这个题有意思,之前就尝试过,

17树的子树

这个题有意思,之前就尝试过,(其中有1个点很重要,就是其中的区别,还有一个点就是在第二个函数的时候判断是否此节点相同,还有一个点就是记住第一个函数不要提前返回,)

https://blog.csdn.net/weixin_41563161/article/details/102631389

18 二叉树的镜像

自己能写出来

https://blog.csdn.net/weixin_41563161/article/details/102640444

19 顺时针打印矩阵

这道题还是没有背写出来。关键是每一次要考虑到只剩一行或者是一列,而不仅仅是每一次都是一个完整的循环还得再看一下

https://blog.csdn.net/weixin_41563161/article/details/102654478

20 合并min函数的栈

自己能写出来

https://blog.csdn.net/weixin_41563161/article/details/104196414

21-30

21 栈的压入、弹出序列

https://blog.csdn.net/weixin_41563161/article/details/102698942

自己能写出来

22 从上往下打印二叉树

用自己原来的旧方法可以实现,用两层List似乎不是很现实,这道题明天用队列做一做试试。

https://blog.csdn.net/weixin_41563161/article/details/102639284

23二叉搜索树的后序遍历序列

还不行,要看答案  第二天背写一下,这道题有点经典,所以要在看一下

https://blog.csdn.net/weixin_41563161/article/details/102639284

24二叉树中和为某一值的路径 (路径总和

还不行,经过调试可以做的出来

https://blog.csdn.net/weixin_41563161/article/details/102717518

25复杂链表的复制

这道题之前还给比尔讲过,但是自己的代码能力还不行,所以明天继续。差不多两种方法都再次写了一遍,理解了,明天再写一遍 差不多了还是有点小问题

https://blog.csdn.net/weixin_41563161/article/details/102731945

26 二叉搜索树与双向链表

还是有点问题 大概是没有理解了吧,所以还是有点小问题

https://blog.csdn.net/weixin_41563161/article/details/102777725

27 字符串的排列

明天再写一遍,差不多理解

https://blog.csdn.net/weixin_41563161/article/details/102785373

28数组中出现次数超过一半的数字

可能没想到这个书上的方法,

https://blog.csdn.net/weixin_41563161/article/details/102831519

29最小的K个数

这个地方是堆的数据结构,正好自己好好看看,好好复习一下

https://blog.csdn.net/weixin_41563161/article/details/102835398

30连续子数组最大和

自己能写出来

https://blog.csdn.net/weixin_41563161/article/details/101027801

31-40

31整数中1出现的次数

还是有点问题 需要背写一下 这个地方注意一下字符变成数字需要减‘0’

https://blog.csdn.net/weixin_41563161/article/details/103980125

32把数组排成最小的数

还是有点问题   而且自己还需要看看另一个解题方法

https://blog.csdn.net/weixin_41563161/article/details/102881429

33丑数

自己能写出来

https://blog.csdn.net/weixin_41563161/article/details/102882506

34 第一次只出现一次的字符

自己能写出来

https://blog.csdn.net/weixin_41563161/article/details/103241923

35 数组中的逆序对

这个自己暂时想不出来 第二天继续背写一下

https://blog.csdn.net/weixin_41563161/article/details/102918096

36两个链表的第一个公共结点

能做出来

https://blog.csdn.net/weixin_41563161/article/details/102910326

37数字在排序数组中出现的次数

能做出来 但是这道题依然要用二分法来实现,双指针的话可能太慢了

https://blog.csdn.net/weixin_41563161/article/details/103994964

38二叉树的深度

能做出来

39 平衡二叉树

能做出来

https://blog.csdn.net/weixin_41563161/article/details/102409294

40数组中只出现一次的数字

能做出来,首先自己先会了map的for(Integer key : maps.keySet()利用了位运算,自己也要实现一下位运算

https://blog.csdn.net/weixin_41563161/article/details/102969594

41-50

41和为S的连续正数序列

没有想到这个方法,要好好学习一下。

https://blog.csdn.net/weixin_41563161/article/details/103011812

42和为S的两个数字

自己调试出来了

43 左旋转字符串

能做出来

https://blog.csdn.net/weixin_41563161/article/details/103019785

44翻转单词顺序列

自己调试出来了+

https://blog.csdn.net/weixin_41563161/article/details/103019785

45扑克牌顺子

自己调试出来了

https://blog.csdn.net/weixin_41563161/article/details/103064297

46孩子们的游戏

没有想到这个方法,要好好学习一下。(差不多完成了)

https://blog.csdn.net/weixin_41563161/article/details/104079621

47求1+2+3+...+n

这个题也很有意思,要好好学习一下。

https://blog.csdn.net/weixin_41563161/article/details/103068905

48不用加减乘除做加法

这个题也很有意思,要好好学习一下。

https://blog.csdn.net/weixin_41563161/article/details/103070172

49将一个字符串转换成一个整数

自己调试出来了

https://blog.csdn.net/weixin_41563161/article/details/103119605

50数组中重复的数字

自己能写出来这个代码,但是有种更牛的,自己也要会。

https://blog.csdn.net/weixin_41563161/article/details/103156896

51-60

51构建乘积数组

自己要再写一遍 有机会再试试哈

https://blog.csdn.net/weixin_41563161/article/details/103159931

52正则表达式匹配

这个题也很有意思,要好好学习一下。

https://blog.csdn.net/weixin_41563161/article/details/100920889

53表示数值的字符串

自己调试出来了

https://blog.csdn.net/weixin_41563161/article/details/103178728

54字符流中第一个不重复的字符

自己调试出来了

https://blog.csdn.net/weixin_41563161/article/details/103241923

55该链表的环的入口结点

自己调试出来了

https://blog.csdn.net/weixin_41563161/article/details/103239650

56删除该链表中重复的结点

自己可以想出来,但是代码不敢往出写

https://blog.csdn.net/weixin_41563161/article/details/103245150

57二叉树的下一个结点

有点难度

https://blog.csdn.net/weixin_41563161/article/details/103253375

58对称的二叉树

自己可以想出来

https://blog.csdn.net/weixin_41563161/article/details/102308227

59按之字形顺序打印二叉树

自己可以想出来

https://blog.csdn.net/weixin_41563161/article/details/102639284

60二叉树打印成多行

自己可以想出来

https://blog.csdn.net/weixin_41563161/article/details/102639284

61序列化二叉树

再试一下

https://blog.csdn.net/weixin_41563161/article/details/104078198

62二叉搜索树的第k个结点

自己可以想出来

https://blog.csdn.net/weixin_41563161/article/details/104078421

63数据流中的中位数

 

https://blog.csdn.net/weixin_41563161/article/details/104069505

64滑动窗口的最大值

 

https://blog.csdn.net/weixin_41563161/article/details/104069497

65矩阵中的路径

 

https://blog.csdn.net/weixin_41563161/article/details/104070047

66机器人的运动范围

 

https://blog.csdn.net/weixin_41563161/article/details/104077535

67剪绳子

 

https://blog.csdn.net/weixin_41563161/article/details/104076800