<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[qq_27576813的博客]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/qq_27576813</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; qq_27576813]]></copyright><item><title><![CDATA[类加载过程]]></title><link>https://blog.youkuaiyun.com/qq_27576813/article/details/115116355</link><guid>https://blog.youkuaiyun.com/qq_27576813/article/details/115116355</guid><author>qq_27576813</author><pubDate>Tue, 23 Mar 2021 14:47:23 +0800</pubDate><description><![CDATA[下图为Loading过程


]]></description><category></category></item><item><title><![CDATA[每日算法-合并K个升序链表]]></title><link>https://blog.youkuaiyun.com/qq_27576813/article/details/113031973</link><guid>https://blog.youkuaiyun.com/qq_27576813/article/details/113031973</guid><author>qq_27576813</author><pubDate>Sat, 23 Jan 2021 11:00:07 +0800</pubDate><description><![CDATA[LeetCode地址：https://leetcode-cn.com/problems/merge-k-sorted-lists/

1、解题思路

利用小顶堆实现，Java中利用PriorityQueue进行实现，下面是实现的图解



2、实现代码


import java.util.Comparator;
import java.util.PriorityQueue;
//leetcode原题地址：
class Solution{
	public class ListNode {
		int val]]></description><category></category></item><item><title><![CDATA[算法基础-归并排序]]></title><link>https://blog.youkuaiyun.com/qq_27576813/article/details/108863528</link><guid>https://blog.youkuaiyun.com/qq_27576813/article/details/108863528</guid><author>qq_27576813</author><pubDate>Tue, 29 Sep 2020 17:51:28 +0800</pubDate><description><![CDATA[一、归并排序（merge sort）定义

采用分治法去进行排序的一种方式。

二、时间复杂度

O(n log n) 此时间复杂度可根据上一篇文章

三、利用递归方式实现


        //归并排序 分而治之   
	public static void mergeSort(int[] arr){
		if (arr == null || arr.length &lt; 2) {
			return;
		}
		process(arr, 0, arr.length - 1);
	}
	public]]></description><category></category></item><item><title><![CDATA[算法基础-递归]]></title><link>https://blog.youkuaiyun.com/qq_27576813/article/details/108845882</link><guid>https://blog.youkuaiyun.com/qq_27576813/article/details/108845882</guid><author>qq_27576813</author><pubDate>Mon, 28 Sep 2020 11:58:36 +0800</pubDate><description><![CDATA[一、何为递归

在运行的过程中调用自己。即将一个大的问题拆分，再拆分，从而得到最后想要的结果。

二、递归条件

1. 子问题须与原始问题为同样的事，且更为简单；

2. 不能无限制地调用本身，须有个出口，化简为非递归状况处理。

三、实际问题及代码编写

问题：求数组arr[L..R]中的最大值，怎么用递归方法实现。

解决思路：

1）将[L..R]范围分成左右两半。左：[L..Mid] 右[Mid+1..R]
2）左部分求最大值，右部分求最大值
3） [L..R]范围上的最大值，是max{左部分最大.]]></description><category></category></item><item><title><![CDATA[算法基础-栈和队列（怎么利用数组和链表实现）]]></title><link>https://blog.youkuaiyun.com/qq_27576813/article/details/108827944</link><guid>https://blog.youkuaiyun.com/qq_27576813/article/details/108827944</guid><author>qq_27576813</author><pubDate>Sun, 27 Sep 2020 16:40:37 +0800</pubDate><description><![CDATA[一、逻辑概念

栈：数据先进后出，犹如弹匣

队列：数据先进先出，好似排队

二、栈和队列的实现（自己实现）

1、双向链表实现


public static class Node&lt;T&gt; {
		public T value;
		public Node&lt;T&gt; last;
		public Node&lt;T&gt; next;

		public Node(T data) {
			value = data;
		}
	}
	//栈  队列 
	//双向链表的添加及弹出操作
	p]]></description><category></category></item><item><title><![CDATA[算法基础-链表]]></title><link>https://blog.youkuaiyun.com/qq_27576813/article/details/108664159</link><guid>https://blog.youkuaiyun.com/qq_27576813/article/details/108664159</guid><author>qq_27576813</author><pubDate>Mon, 21 Sep 2020 21:25:32 +0800</pubDate><description><![CDATA[一、链表

主要分为单向链表和双向链表，下面用代码实现一下：


//单向链表
public class Node {
    public int value;
    public Node next;

    public Node(int data) {
        value = data;
    }
}
//双向链表
public class DoubleNode {
    public int value;
    public DoubleNode last;
    public]]></description><category></category></item><item><title><![CDATA[算法基础-认识异或运算]]></title><link>https://blog.youkuaiyun.com/qq_27576813/article/details/108635327</link><guid>https://blog.youkuaiyun.com/qq_27576813/article/details/108635327</guid><author>qq_27576813</author><pubDate>Fri, 18 Sep 2020 12:45:09 +0800</pubDate><description><![CDATA[一、异或运算，同或运算

 异或运算：相同为0，不同为1（无相位相加）
 同或运算：相同以1，不同为0

二、异或运算的一些性质

 1）0^N == N N^N == 0
 2）异或运算满足交换律和结合率

三、实际问题（通过实际问题来认识异或运算）

问题一、如何不用额外变量交换两个数（主要采用第一个性质）


	//如何不用额外变量交换两个数 
	public static void exchangeNum(){
		int a = 3...]]></description><category></category></item><item><title><![CDATA[分布式事务-2阶段提交]]></title><link>https://blog.youkuaiyun.com/qq_27576813/article/details/108263277</link><guid>https://blog.youkuaiyun.com/qq_27576813/article/details/108263277</guid><author>qq_27576813</author><pubDate>Thu, 27 Aug 2020 17:46:46 +0800</pubDate><description><![CDATA[分布式事务
何为分布式事务？
随着互联网的发展与技术的更新，单机服务器已经不能满足业务的需求，所以就诞生了分布式的概念，既然有分布式的诞生，那么以前的事务的参与者，支持者也要考虑在不同节点上如何完整的运行。（分布式事务是指事务的参与者、支持事务的服务器、资源服务器以及事务管理器分别位于不同的分布式系统的不同节点之上。）
2阶段提交
以最常见的订单、支付系统来举例说明，首先先说明两个概念：
1、TM（Transaction Manager）事务管理器，负责协调和管理事务。
2、RM（Resource Mana]]></description><category></category></item><item><title><![CDATA[事务ACID及事务隔离级别]]></title><link>https://blog.youkuaiyun.com/qq_27576813/article/details/107843127</link><guid>https://blog.youkuaiyun.com/qq_27576813/article/details/107843127</guid><author>qq_27576813</author><pubDate>Fri, 07 Aug 2020 10:45:48 +0800</pubDate><description><![CDATA[事务特性及隔离什么叫做事务（Transaction）事务的四个特性（ACID）原子性（Atomicity）一致性（Consistency）隔离性（Isolation）持久性（Durability）由事务引发的问题脏读：不可重复读：幻读（虚读）：四种隔离级别设置
什么叫做事务（Transaction）
访问并可能更新数据库中各种数据项的一个程序执行单元(unit)，事务是恢复和并发控制的基本单位。
事务的四个特性（ACID）
原子性（Atomicity）
一个事务有多个操作，原子性保证要么都完成，要么都不完成]]></description><category></category></item><item><title><![CDATA[设计模式-状态模式（state）]]></title><link>https://blog.youkuaiyun.com/qq_27576813/article/details/105379178</link><guid>https://blog.youkuaiyun.com/qq_27576813/article/details/105379178</guid><author>qq_27576813</author><pubDate>Wed, 08 Apr 2020 09:40:46 +0800</pubDate><description><![CDATA[定义：类的行为是基于它的状态改变的。

个人理解：相同的动作在不同的状态下有不同的表现，例如每个人都会哭、笑，对应的状态可能为开心，伤心，所以就有开心的笑，伤心的笑不同状态不同动作。

UML图解：



优点：封装转换状态，将某个状态有关的行为放到一个类中，状态改变行为也随之改变。

缺点：结构比较复杂，系统类和对象的数量会增多。

代码：


//状态抽象类
public abstract c...]]></description><category></category></item><item><title><![CDATA[设计模式-模板方法模式]]></title><link>https://blog.youkuaiyun.com/qq_27576813/article/details/105369146</link><guid>https://blog.youkuaiyun.com/qq_27576813/article/details/105369146</guid><author>qq_27576813</author><pubDate>Tue, 07 Apr 2020 17:33:06 +0800</pubDate><description><![CDATA[定义：一个抽象类公开定义了执行它的方法的方式/模板。它的子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行。

个人理解：将一些方法放抽象类里，然后子类将方法重写，最后调用的时候用抽象类的方法（看代码就懂了）。

UML图解：



优点：将不变的封装起来，可变的部分可以拓展（子类）。

缺点：不同的类就需要一个子类来实现，数量大了，子类也多了，比较复杂。

代码：


public c...]]></description><category></category></item><item><title><![CDATA[设计模式-原型模式（Prototype）]]></title><link>https://blog.youkuaiyun.com/qq_27576813/article/details/105366014</link><guid>https://blog.youkuaiyun.com/qq_27576813/article/details/105366014</guid><author>qq_27576813</author><pubDate>Tue, 07 Apr 2020 16:01:07 +0800</pubDate><description><![CDATA[定义：是用于创建重复的对象，同时又能保证性能。

个人理解：Java的复制clone方法，但是要区分好浅克隆和深克隆。

UML图解：



优点：新建一个一模一样的对象直接用这个方法即可。

缺点：必须要实现Cloneable接口以及注意深克隆。

代码：


public class Test {
    public static void main(String[] args) throw...]]></description><category></category></item><item><title><![CDATA[设计模式-命令模式]]></title><link>https://blog.youkuaiyun.com/qq_27576813/article/details/105364599</link><guid>https://blog.youkuaiyun.com/qq_27576813/article/details/105364599</guid><author>qq_27576813</author><pubDate>Tue, 07 Apr 2020 15:21:29 +0800</pubDate><description><![CDATA[定义：是一种数据驱动的设计模式。请求以命令的形式包裹在对象中，并传给调用对象。调用对象寻找可以处理该命令的合适的对象，并把该命令传给相应的对象，该对象执行命令。

个人理解：最常用对这个模式的理解就是撤销，比如csdn写了一段话不小心删除了，按Ctrl+Z就可以撤销，还原操作。

UML图解：



优点：新的命令容易添加

缺点：（选自菜鸟编程）使用命令模式可能会导致某些系统有过多的具体命令类。...]]></description><category></category></item><item><title><![CDATA[设计模式-桥接模式]]></title><link>https://blog.youkuaiyun.com/qq_27576813/article/details/105362800</link><guid>https://blog.youkuaiyun.com/qq_27576813/article/details/105362800</guid><author>qq_27576813</author><pubDate>Tue, 07 Apr 2020 14:36:34 +0800</pubDate><description><![CDATA[定义：把抽象化和实现化解耦，二者都可以独立变化发展，需要一个作为桥接的接口，使得实体类的功能独立于接口实现类。

个人理解：分离抽象与具体实现，让他们可以独自发展。下面举例使用一个礼物，礼物可以抽象为多种，而实现类也可以自己独立拓展。

UML图解：



优点：抽象类和实现类分离，可以独立发展，有很好的的扩展性。

缺点：（选自菜鸟教程）桥接模式的引入会增加系统的理解与设计难度，由于聚合关联关系...]]></description><category></category></item><item><title><![CDATA[设计模式-适配器模式]]></title><link>https://blog.youkuaiyun.com/qq_27576813/article/details/105361439</link><guid>https://blog.youkuaiyun.com/qq_27576813/article/details/105361439</guid><author>qq_27576813</author><pubDate>Tue, 07 Apr 2020 12:27:42 +0800</pubDate><description><![CDATA[定义：是作为两个不兼容的接口之间的桥梁。

个人理解：不同于桥接模式，这个模式我理解为像买一个mac本吧，可能买的欧版的它的充电器接口是圆头110伏，但是国内通用220伏，这个时候就需要一个转换器，这个转换器就是一个适配器。

UML图解（里面还有一些常用数据库的适配器图解）：



优点：主要是让两个没有关联的类一起用。

缺点：Java里面继承只能继承一个类，最多只能一个适配者类，且目标类还得...]]></description><category></category></item><item><title><![CDATA[设计模式-构建器(建造者)模式]]></title><link>https://blog.youkuaiyun.com/qq_27576813/article/details/105359983</link><guid>https://blog.youkuaiyun.com/qq_27576813/article/details/105359983</guid><author>qq_27576813</author><pubDate>Tue, 07 Apr 2020 11:55:14 +0800</pubDate><description><![CDATA[定义：使用多个简单的对象构建成一个复杂的对象。

个人理解：讲一个整体的各个部分组合到一起，例如一个人有年龄、身高等属性，统计信息时可能会用到这个人某几个属性，那么需要什么就把什么组合到一起。

UML图解：



优点：建造者建造自己的东西，也可扩展。

缺点：当内部比较复杂的时候，就会对应的建造很多类。

代码：


public class Person {
    int id;
    ...]]></description><category></category></item><item><title><![CDATA[设计模式-访问者模式]]></title><link>https://blog.youkuaiyun.com/qq_27576813/article/details/105358709</link><guid>https://blog.youkuaiyun.com/qq_27576813/article/details/105358709</guid><author>qq_27576813</author><pubDate>Tue, 07 Apr 2020 10:48:21 +0800</pubDate><description><![CDATA[定义：使用一个访问者类，元素的执行算法可以随着访问者改变而改变。

个人理解：企业购买电脑配件和个人购买配件，零件供应商会根据购买的人群分配不同的优惠，而购买的人群就是访问者。

UML图解：



优点：使用灵活，可扩展性强，符合单一职责原则。

缺点：里面具体元素对访问者公布了细节，违反迪米特原则。

代码：


public class Computer {
    ComputerPart...]]></description><category></category></item><item><title><![CDATA[设计模式-迭代器模式]]></title><link>https://blog.youkuaiyun.com/qq_27576813/article/details/105357198</link><guid>https://blog.youkuaiyun.com/qq_27576813/article/details/105357198</guid><author>qq_27576813</author><pubDate>Tue, 07 Apr 2020 09:42:29 +0800</pubDate><description><![CDATA[定义：提供一种方法顺序访问一个聚合对象中各个元素, 而又无须暴露该对象的内部表示。

个人理解：Java中的iterator，就是一个很好的迭代器实现的例子，下面代码我也是模拟一下Java中ArrayList和LinkedList的实现。

UML图解：



优点：它支持以不同的方式遍历一个聚合对象（底层是集合和链表）、简化了聚合类、增加新的聚合类和迭代器类方便。

缺点：新的聚合类增加，迭代器...]]></description><category></category></item><item><title><![CDATA[设计模式-代理模式]]></title><link>https://blog.youkuaiyun.com/qq_27576813/article/details/105345335</link><guid>https://blog.youkuaiyun.com/qq_27576813/article/details/105345335</guid><author>qq_27576813</author><pubDate>Mon, 06 Apr 2020 18:44:59 +0800</pubDate><description><![CDATA[定义：一个类代表另一个类的功能，提供一种代理以控制对这个对象的访问。（感觉听这个定义还是挺迷糊的）

个人理解：用另外一个类代替这个类去做，然后加上自己的一些功能，比如加上日志。比如我在学习的时候老师举的例子在坦克移动的时候计算出移动的时间。

UML图解：



优点：职责清晰、高扩展性

缺点：有些代理模式实现非常复杂

代码：（我在学习这个模式的时候老师讲了多个版本）


/**
 * 问题...]]></description><category></category></item><item><title><![CDATA[设计模式-享元模式]]></title><link>https://blog.youkuaiyun.com/qq_27576813/article/details/105345127</link><guid>https://blog.youkuaiyun.com/qq_27576813/article/details/105345127</guid><author>qq_27576813</author><pubDate>Mon, 06 Apr 2020 15:52:42 +0800</pubDate><description><![CDATA[定义：主要用于减少创建对象的数量，以减少内存占用和提高性能。

个人理解：各种池，常量池（String为代表），线程池，数据库连接池等等。

UML图解：



优点：大大减少对象的创建，降低系统的内存，效率及空间利用率大大提高。

缺点：会增加出来很多池，提高了系统的复杂性。

代码:


class Bullet{
    public UUID id = UUID.randomUUID();...]]></description><category></category></item></channel></rss>