msb_110050
/
note
1
0
Code Issues Pull Requests Projects Releases Wiki Activity

链表和SpringBean流程图

Browse Source
master
kn5886348135 3 years ago
parent 228bd5aef9
commit 11adcc341e
8 changed files with 247 additions and 454 deletions
Show Stats Download Patch File Download Diff File

0
algorithm/位运算.md → algorithm/1、位运算.md
Unescape View File

0
algorithm/算法.md → algorithm/2、算法.md
Unescape View File

0
algorithm/数据结构.md → algorithm/3、数据结构.md
Unescape View File

0
algorithm/时间复杂度.md → algorithm/4、时间复杂度.md
Unescape View File

56
algorithm/5、单链表.md
Unescape View File

@ -0,0 +1,56 @@
#### 单链表反转
使用while循环，保存next节点，设置当前节点的next，保存pre，移动head，最后返回pre
```Java
private static Node reverseLinkedList(Node head) {
Node pre = null;
Node next = null;
while (head != null) {
next = head.getNext();
head.setNext(pre);
pre = head;
head = next;
}
return pre;
}
```
#### 双链表反转
使用while循环，保存next节点，设置当前节点的last和pre，保存pre，移动head，最后返回pre
```Java
private static Node reverDoubleLinkedList(Node head) {
Node pre = null;
Node next = null;
while (head != null) {
next = head.getLast();
head.setLast(pre);
head.setPre(next);
pre = head;
head = next;
}
return pre;
}
```
单链表实现队列和栈
### 使用双链表实现双端队列
单链表和双链表的新增、删除，主要注意处理好前驱和后继指针，必要的时候添加中间变量保存。双链表注意处理头尾重合、为空的边界条件。
#### K个节点的组内逆序调整 LeetCode25
#### 两个链表相加 LeetCode2、LeetCode445
根据链表长度分三段处理，第一段处理短链表，第二段处理长链表多出的部分，第三段处理长链表最后的进位
#### 合并两个有序链表 LeetCode21
### 位图
位图的功能
位图的好处
位图的用法

326
algorithm/单链表.md
Unescape View File

@ -1,326 +0,0 @@
单链表反转
使用while循环，保存next节点，设置当前节点的next，保存pre，移动head，最后返回pre
```Java
private static Node reverseLinkedList(Node head) {
Node pre = null;
Node next = null;
while (head != null) {
next = head.getNext();
head.setNext(pre);
pre = head;
head = next;
}
return pre;
}
```
双链表反转
使用while循环，保存next节点，设置当前节点的last和pre，保存pre，移动head，最后返回pre
```Java
private static Node reverDoubleLinkedList(Node head) {
Node pre = null;
Node next = null;
while (head != null) {
next = head.getLast();
head.setLast(pre);
head.setPre(next);
pre = head;
head = next;
}
return pre;
}
```
单链表实现队列和栈
```Java
public class CustomQueue<V> {
private Node<V> head;
private Node<V> tail;
private int size;
public boolean isEmpty(){
return size == 0;
}
public void offer(V value) {
Node<V> node = new Node<>(value);
if (tail == null) {
head = node;
tail = node;
} else {
tail.setNext(node);
tail = node;
}
size++;
}
public V poll(){
if (head == null) {
return null;
}
V ans = head.getValue();
head = head.getNext();
size--;
return ans;
}
public V peek() {
if (head == null) {
return null;
}
return head.getValue();
}
private class Node<V> {
private V value;
private Node<V> next;
public V getValue() {
return value;
}
public void setValue(V value) {
this.value = value;
}
public Node<V> getNext() {
return next;
}
public void setNext(Node<V> next) {
this.next = next;
}
public Node(V value) {
this.value = value;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Node<?> node = (Node<?>) o;
return value.equals(node.value) &&
next.equals(node.next);
}
@Override
public int hashCode() {
return Objects.hash(value, next);
}
}
}
```
```Java
public class CustomStack<V> {
private Node<V> head;
private int size;
public boolean isEmpty(){
return size == 0;
}
public void push(V value){
Node<V> node = new Node<>(value);
if (head == null) {
head = node;
} else {
node.setNext(head);
head = node;
}
size++;
}
public V pop(){
if (head == null) {
return null;
}
V ans = null;
ans = head.getValue();
head.setNext(head.getNext());
size--;
return ans;
}
public V peek() {
return head == null ? null : head.getValue();
}
class Node<V>{
private V value;
private Node<V> next;
public V getValue() {
return value;
}
public void setValue(V value) {
this.value = value;
}
public Node<V> getNext() {
return next;
}
public void setNext(Node<V> next) {
this.next = next;
}
public Node(V value) {
this.value = value;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Node<?> node = (Node<?>) o;
return Objects.equals(value, node.value) &&
Objects.equals(next, node.next);
}
@Override
public int hashCode() {
return Objects.hash(value, next);
}
}
}
```
### 使用双链表实现双端队列
```Java
public class CustomDeque<V> {
private Node<V> head;
private Node<V> tail;
private int size;
public boolean isEmpty() {
return size == 0;
}
public void pushHead(V value){
Node<V> node = new Node<>(value);
if (head == null) {
head = node;
tail = node;
} else {
node.setLast(head);
head.setPre(node);
head = node;
}
size++;
}
public void pushTail(V value){
Node<V> node = new Node<>(value);
if (head == null) {
head = node;
tail = node;
} else {
tail.setLast(node);
node.setPre(tail);
tail = node;
}
size++;
}
public V pollHead(){
if (head == null) {
return null;
}
V ans = head.getValue();
if (head.equals(tail)) {
head = null;
tail = null;
} else {
head = head.getLast();
head.setPre(null);
}
size--;
return ans;
}
public V pollTail(){
if (tail == null) {
return null;
}
V ans = tail.getValue();
if (head.equals(tail)) {
head = null;
tail = null;
} else {
tail = tail.getPre();
tail.setLast(null);
}
size--;
return ans;
}
public V peekHead(){
return head == null ? null : head.getValue();
}
public V peekTail(){
return tail == null ? null : tail.getValue();
}
class Node<V>{
private V value;
private Node<V> last;
private Node<V> pre;
public Node(V value) {
this.value = value;
}
public V getValue() {
return value;
}
public void setValue(V value) {
this.value = value;
}
public Node<V> getLast() {
return last;
}
public void setLast(Node<V> last) {
this.last = last;
}
public Node<V> getPre() {
return pre;
}
public void setPre(Node<V> pre) {
this.pre = pre;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Node<?> node = (Node<?>) o;
return Objects.equals(value, node.value);
}
@Override
public int hashCode() {
return Objects.hash(value);
}
}
}
```
单链表和双链表的新增、删除，主要注意处理好前驱和后继指针，必要的时候添加中间变量保存。双链表注意处理头尾重合、为空的边界条件。
K个节点的组内逆序调整

63
framework-source-code/Spring启动流程.md
Unescape View File

@ -0,0 +1,63 @@
## Spring启动流程
### prepareRefresh()
记录时间、active标记、获取environment(系统环境变量和System.setProperty()设置的)、初始化监听器和事件集合。
### obtainFreshBeanFactory()
关闭以前的BeanFactory，创建一个新的BeanFactory供上下文生命周期的各阶段使用。
父beanDefinition、bean可覆盖、循环引用，
loadBeanDefinitions()通过inputStream读取并解析xml文档，拿到beanDefinition。
### prepareBeanFactory()
准备BeanFactory，设置ClassLoader、SPEL解析器、propertyEditor、BeanPostProcessor(ApplicationContextAwareProcessor)、ignoreDependencyInterface(各种Aware接口)、registerResolvableDependency、BeanPostProcessor(ApplicationListenerDetector）、environment单例。
### postProcessBeanFactory(beanFactory)
继承ClassPathXmlApplicationContext的子类可以修改beanFactory，用于实现一些自定义的功能。
### invokeBeanFactoryPostProcessors(beanFactory)
BeanDefinitionRegistryPostProcessors和BeanFactoryPostProcessors按照实现PriorityOrdered、Ordered接口、没有实现这两个接口的PostProcessors处理执行顺序，@Order注解在这里是不考虑的。
// Register bean processors that intercept bean creation.
### registerBeanPostProcessors(beanFactory)
BeanPostProcessor按照实现PriorityOrdered、Ordered接口、没有实现这两个接口的PostProcessors处理执行顺序，@Order注解在这里是不考虑的。
BeanPostProcessorChecker用来记录日志。
### initMessageSource()
初始化MessageSource，<font color=red>MessageSource是格式化字符串的?</font>
### initApplicationEventMulticaster()
初始化应用事件监听器，SimpleApplicationEventMulticaster通过线程池往各种监听器添加事件。
### onRefresh()
由子类实现，比如Spring Boot创建web server。
### registerListeners()
注册所有实现了ApplicationListener接口的监听器，并发布早起应用事件。
### finishBeanFactoryInitialization(beanFactory)
实例化所有非懒加载的单例。
ConversionService(转换系统的一个入口，<font color=red>可用于常见的日期格式转换？</font>)、添加EmbeddedValueResolver、BeanFactory方式获取LoadTimeWeaverAware、置空temporary ClassLoader、冻结配置、预实例化单例。
preInstantiateSingletons()
遍历beanNames，触发所有非懒加载bean实例化。
遍历beanNames，触发所有适用 bean 的初始化后回调。
getBean(beanName) -> doGetBean -> getSingleton(三级缓存) -> createBean -> doCreateBean -> 代理和反射创建bean(三级缓存) -> populateBean -> initializeBean
### finishRefresh()
清理资源缓存、初始化LifecycleProcessor、发布最终事件
### resetCommonCaches()
### contextRefresh.end()

BIN
framework-source-code/spring/BeanFactory相关类图.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 28 KiB

Write Preview
Loading…
Cancel
Save