<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[open_the_windows的博客]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/open_the_windows</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; open_the_windows]]></copyright><item><title><![CDATA[矩阵遍历-Java]]></title><link>https://blog.youkuaiyun.com/open_the_windows/article/details/120460518</link><guid>https://blog.youkuaiyun.com/open_the_windows/article/details/120460518</guid><author>open_the_windows</author><pubDate>Fri, 24 Sep 2021 18:14:33 +0800</pubDate><description><![CDATA[对于矩阵，直观上可以想象的遍历方式按行、列，有些题目还有螺旋遍历，实际题目很多是需要BFS或者DFS的。技巧是结果空间遍历其实是4个方向的选择。
这里简单记录一个比较典型的题目–矩阵中最长递增序列[leetcode-329]。原问题还有一点是考察任意点开始的最长路径，这里简化了下，毕竟只想研究BFS和DFS。
其实在图的遍历过程中，辅助isVisited数组是很常用的，这里BFS没有使用isVisited数组是因为最大增序保证了不会往回走。而DFS的辅助数组是不是就是isVisited数组呢，起码起到了部分]]></description><category></category></item><item><title><![CDATA[图的两种遍历-Java]]></title><link>https://blog.youkuaiyun.com/open_the_windows/article/details/120458042</link><guid>https://blog.youkuaiyun.com/open_the_windows/article/details/120458042</guid><author>open_the_windows</author><pubDate>Fri, 24 Sep 2021 16:33:05 +0800</pubDate><description><![CDATA[图遍历基本就是广度有限和深度优先，基本思想和树遍历一致。需要注意的一点就是图的连通性，有时从图中一点出发并不能到达所有节点。
import java.util.*;

public class Graph {
    private static int [][] graph;
    private static int size;
    static int[] isVisited = new int[10];
    public static void main(String[] args) {
]]></description><category></category></item><item><title><![CDATA[快排-Java]]></title><link>https://blog.youkuaiyun.com/open_the_windows/article/details/120437629</link><guid>https://blog.youkuaiyun.com/open_the_windows/article/details/120437629</guid><author>open_the_windows</author><pubDate>Thu, 23 Sep 2021 16:28:05 +0800</pubDate><description><![CDATA[快排中需要注意一点是，当选择最左边的值作为pivot时，向比较高位，j–。因为最后有次交换i位置，可能i直接就遍历到i==j。此时交换就产生了问题。
public class quickSort {
    public static void main(String[] args) {
        int [] ints = new int[]{3,2,4,1,5,8,6,7,10,15,14,12,13};
        quickSort(ints, 0, ints.length-1);
   ]]></description><category></category></item><item><title><![CDATA[堆排序-Java]]></title><link>https://blog.youkuaiyun.com/open_the_windows/article/details/120437551</link><guid>https://blog.youkuaiyun.com/open_the_windows/article/details/120437551</guid><author>open_the_windows</author><pubDate>Thu, 23 Sep 2021 16:25:03 +0800</pubDate><description><![CDATA[堆分为最大堆和最小堆，是对数组的完全二叉树的表示方式。
import java.util.ArrayList;

public class heapsort {
    static ArrayList&lt;Integer&gt; res = new ArrayList&lt;&gt;();
    public static void main(String[] args) {
        int [] ints = new int[]{3,2,4,1,5,8,6,7,10,15,14,12,13}]]></description><category></category></item><item><title><![CDATA[排列算法模板-Java]]></title><link>https://blog.youkuaiyun.com/open_the_windows/article/details/120437438</link><guid>https://blog.youkuaiyun.com/open_the_windows/article/details/120437438</guid><author>open_the_windows</author><pubDate>Thu, 23 Sep 2021 16:22:04 +0800</pubDate><description><![CDATA[记录比较通用排列模板，k表示待排长度，k==length为全排列
import java.util.*;

public class Permutation {
    public static void main(String[] args) {
        String[] ins = new String[]{"0", "1", "2"};
        StringBuilder tmp = new StringBuilder();
        permutation(ins, 2, t]]></description><category></category></item><item><title><![CDATA[二叉树遍历（Java）]]></title><link>https://blog.youkuaiyun.com/open_the_windows/article/details/119951492</link><guid>https://blog.youkuaiyun.com/open_the_windows/article/details/119951492</guid><author>open_the_windows</author><pubDate>Fri, 27 Aug 2021 13:50:32 +0800</pubDate><description><![CDATA[前言
参考：
[1]优快云-Yadoer
[2]jianshu-阿菜的博客
代码
二叉树数据结构以及基本操作如下，具体思路看参考。
package com.company;

import sun.reflect.generics.tree.Tree;

import java.util.Arrays;
import java.util.LinkedList;
import java.util.Stack;

/**
 *  binary tree's structure is like this:
 *]]></description><category></category></item><item><title><![CDATA[Java中线程池简单总结]]></title><link>https://blog.youkuaiyun.com/open_the_windows/article/details/119733091</link><guid>https://blog.youkuaiyun.com/open_the_windows/article/details/119733091</guid><author>open_the_windows</author><pubDate>Mon, 16 Aug 2021 15:41:27 +0800</pubDate><description><![CDATA[前言
池化技术在很多领域都有应用，比如数据库连接池，HTTP连接池以及线程池。实际上都是预先建立一些连接缓存，有具体的任务时就可以直接分配，减少新建立资源时的消耗，提供更快的响应速度。
基本原理
jdk1.8中封装了Executors工具类作为初始化线程池的入口。该类提供好几种线程池初始化方法。我就简单研究了public static ExecutorService newFixedThreadPool(int nThreads)方法。
	public static ExecutorService newF]]></description><category></category></item><item><title><![CDATA[Java中Label的使用]]></title><link>https://blog.youkuaiyun.com/open_the_windows/article/details/119731508</link><guid>https://blog.youkuaiyun.com/open_the_windows/article/details/119731508</guid><author>open_the_windows</author><pubDate>Mon, 16 Aug 2021 14:20:49 +0800</pubDate><description><![CDATA[前言
在研究线程池相关代码的过程中发现了jdk1.8下rt.jar/java/util/concurrent/ThreadPoolExecutor.java中在addWorker()里判断线程池使用状态时使用了：Label,break Label,continue Label。不禁想起golang中也有类似的使用。
介绍
Java中，一般通过break和continue只能影响一层循环，而通过声明Label配合continue Label以及break Label可以影响到多层循环。简单测试如下
 	pub]]></description><category></category></item><item><title><![CDATA[Java中HashMap扩容机制]]></title><link>https://blog.youkuaiyun.com/open_the_windows/article/details/119669227</link><guid>https://blog.youkuaiyun.com/open_the_windows/article/details/119669227</guid><author>open_the_windows</author><pubDate>Fri, 13 Aug 2021 11:26:58 +0800</pubDate><description><![CDATA[前言
jdk1.8中源码位于rt.jar/java/util/HashMap.java
机制
初始值设置从源码可以看出，初始容量16，装载因子0.75，碰撞的结果初始以链表形式存储，当链表长度大于8时，调整为红黑树存储，保证最坏情况下查询、插入、删除的效率[wiki]。

    /**
     * The default initial capacity - MUST be a power of two.
     */
    static final int DEFAULT_INITIAL_CAPA]]></description><category></category></item><item><title><![CDATA[Java中System.arraycopy和Arrays.copyOf]]></title><link>https://blog.youkuaiyun.com/open_the_windows/article/details/119642188</link><guid>https://blog.youkuaiyun.com/open_the_windows/article/details/119642188</guid><author>open_the_windows</author><pubDate>Thu, 12 Aug 2021 13:41:04 +0800</pubDate><description><![CDATA[前言
在ArrayList扩容机制中注意到，数组的深拷贝有用到两种方法：System.arraycopy()和Arrays.copyOf()。
比较
System.arraycopy()是native方法，参数需要传递源数组和目标数组。
public static native void arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,
         ]]></description><category></category></item><item><title><![CDATA[Java中ArrayList扩容机制]]></title><link>https://blog.youkuaiyun.com/open_the_windows/article/details/119639161</link><guid>https://blog.youkuaiyun.com/open_the_windows/article/details/119639161</guid><author>open_the_windows</author><pubDate>Thu, 12 Aug 2021 11:34:48 +0800</pubDate><description><![CDATA[前言
jdk1.8源码位于rt.jar/lang/util/ArrayList.java
源码解读
先看下一些初始设置

    /**
     * Default initial capacity.
     */
    private static final int DEFAULT_CAPACITY = 10;

    /**
     * Shared empty array instance used for empty instances.
     */
    private stat]]></description><category></category></item><item><title><![CDATA[Java中StringBuffer和StringBuilder扩容机制]]></title><link>https://blog.youkuaiyun.com/open_the_windows/article/details/119635745</link><guid>https://blog.youkuaiyun.com/open_the_windows/article/details/119635745</guid><author>open_the_windows</author><pubDate>Thu, 12 Aug 2021 10:36:10 +0800</pubDate><description><![CDATA[前言
了解一些java底层设计最直接最准确的的方法就是源码了。
StringBuffer和StringBuilder都继承自AbstractStringBuilder。jdk1.8中源码位于rt.jar/java/lang/路径下。
相关源码
初始的空闲容量都是16，当调用append方法时调用的都是super.append即AbstractStringBuilder中方法，所以扩容机制相同。
	// StringBuffer.java 
    public StringBuffer() {
      ]]></description><category></category></item><item><title><![CDATA[深入理解Java虚拟机-4：垃圾回收器与内存分配策略（3）HotSpot算法实现]]></title><link>https://blog.youkuaiyun.com/open_the_windows/article/details/115802918</link><guid>https://blog.youkuaiyun.com/open_the_windows/article/details/115802918</guid><author>open_the_windows</author><pubDate>Mon, 19 Apr 2021 23:28:06 +0800</pubDate><description><![CDATA[前言
阅读《深入理解Java虚拟机》相关笔记。
根节点枚举
固定可作为GC Roots的节点主要在全局性的引用（例如常量或类静态属性）与执行上下文（例如栈帧中的本地变量表）。
迄今为止，所有收集器在根节点枚举这一步骤都是必须暂停用户线程的。
目前主流的Java虚拟机使用的都是准确式垃圾收集（虚拟机可以知道内存中某个位置的数据具体是什么类型），当用户线程停顿下来时，其实并不需要一个不漏的检查完所有执行上下文和全局的引用位置，虚拟机是有办法直接得到哪些地方存放着对象引用的。
HotSpot使用一组称为OopMa]]></description><category></category></item><item><title><![CDATA[深入理解Java虚拟机-2：垃圾回收器与内存分配策略（1）收集对象]]></title><link>https://blog.youkuaiyun.com/open_the_windows/article/details/115712166</link><guid>https://blog.youkuaiyun.com/open_the_windows/article/details/115712166</guid><author>open_the_windows</author><pubDate>Thu, 15 Apr 2021 23:35:07 +0800</pubDate><description><![CDATA[前言
阅读《深入理解Java虚拟机》相关笔记。
判断哪些对象应该呗收集。

]]></description><category></category></item><item><title><![CDATA[组合算法-golang]]></title><link>https://blog.youkuaiyun.com/open_the_windows/article/details/115728027</link><guid>https://blog.youkuaiyun.com/open_the_windows/article/details/115728027</guid><author>open_the_windows</author><pubDate>Thu, 15 Apr 2021 15:45:29 +0800</pubDate><description><![CDATA[记录一个很简洁的组合算法递归求解。
func main(){

	var res []int
	src := []int{1,2,3,4,5}
	combina(src, res, 0)
	fmt.Print(allres)
}

func combina(src []int, str []int, pos int) {
	if (pos == len(src)){
		if len(str) != 0 {
			allres  = append(allres, str)
		}
		return
	}
	]]></description><category></category></item><item><title><![CDATA[全排列-golang]]></title><link>https://blog.youkuaiyun.com/open_the_windows/article/details/115655323</link><guid>https://blog.youkuaiyun.com/open_the_windows/article/details/115655323</guid><author>open_the_windows</author><pubDate>Tue, 13 Apr 2021 10:07:08 +0800</pubDate><description><![CDATA[在labuladong公众号看到一篇回溯法的模板，通过遍历决策树暴力递归。感觉比较简单直观，遂用golang试着写了一个全排列。
func TestTrace(t *testing.T){
	nums := []int{1,2,3,4,5}
	var list List
	traceBack(nums, list)
	fmt.Println(res)
}

var res [][]int
type List []int
func (l *List) contains(x int)bool{
	for _, ]]></description><category></category></item><item><title><![CDATA[深入理解Java虚拟机-3：垃圾回收器与内存分配策略（2）垃圾收集算法]]></title><link>https://blog.youkuaiyun.com/open_the_windows/article/details/115572614</link><guid>https://blog.youkuaiyun.com/open_the_windows/article/details/115572614</guid><author>open_the_windows</author><pubDate>Mon, 12 Apr 2021 22:48:09 +0800</pubDate><description><![CDATA[前言
阅读《深入理解Java虚拟机》相关笔记。
程序计数器、虚拟机栈、本地方法栈3个区域随线程而生，随线程而灭，栈中的栈帧随着方法的进入和退出而有条不紊的执行出栈和入栈操作。二米一个栈帧中分配多少内存基本是在类结构确定下来时就已知的（尽管在运行期间会由即时编译器进行一些优化，但在基本概念模型的讨论里，大体上可以认为编译器已知的），不需要考虑回收，当方法结束或线程结束时，内存自然就跟随着回收了。
而Java堆和方法区这两个区域则有着很显著的不确定性：一个接口的多个实现类需要的内存可能会不一样，一个方法所执行的]]></description><category></category></item><item><title><![CDATA[深入理解Java虚拟机-1：Java内存区域]]></title><link>https://blog.youkuaiyun.com/open_the_windows/article/details/115442741</link><guid>https://blog.youkuaiyun.com/open_the_windows/article/details/115442741</guid><author>open_the_windows</author><pubDate>Mon, 05 Apr 2021 16:40:01 +0800</pubDate><description><![CDATA[前言
阅读《深入理解Java虚拟机》相关笔记.
内存区域
Java运行时内存区域

程序计数器
虚拟机栈
本地方法栈
堆
方法区

程序计数器
线程级别
可以看作是当前线程所执行的字节码的行号指示器。
《Java虚拟机规范》唯一没有规定任何OutOfMemoryError情况的区域。
虚拟机栈
线程级别

局部变量表
…


线程所请求的栈深度大于虚拟机所允许的深度，抛出StackOverflowError。
如果栈容量可以动态扩展，无法申请到足够的内存，抛出OutOfMemoryError。
本地方法栈
]]></description><category></category></item></channel></rss>