<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[xdugucc的博客]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/xdugucc</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; xdugucc]]></copyright><item><title><![CDATA[Generate Parentheses]]></title><link>https://blog.youkuaiyun.com/xdugucc/article/details/78604000</link><guid>https://blog.youkuaiyun.com/xdugucc/article/details/78604000</guid><author>xdugucc</author><pubDate>Thu, 23 Nov 2017 09:21:45 +0800</pubDate><description><![CDATA[原题链接：https://leetcode.com/problems/generate-parentheses/description/


思路：
这道题要求出n对括号能够正确排列的所有情况，重点是要找到符合条件排列的特点。我们可以将长度为2n的排列，看成是n个（与n个）一次次从左往右拼接而成。如果，这个排列是合理的，那么它有着如下的特点：
1. 在拼接符号的过程中，（的个数一定是小于]]></description><category></category></item><item><title><![CDATA[Valid Parentheses]]></title><link>https://blog.youkuaiyun.com/xdugucc/article/details/78586897</link><guid>https://blog.youkuaiyun.com/xdugucc/article/details/78586897</guid><author>xdugucc</author><pubDate>Mon, 20 Nov 2017 21:39:12 +0800</pubDate><description><![CDATA[原题链接：
https://leetcode.com/problems/valid-parentheses/description/



思路：
括号匹配问题，之前在严蔚敏的数据结构那本书里见到过，C语言版在49页。思路是，将输入的字符串中的每一个符号c1和栈顶符号c2比较，看是否匹配（比如"（）"就是匹配，"）（"或者"（｛"就是不匹配），如果不匹配，将c1入栈，如果匹配了，将c2]]></description><category></category></item><item><title><![CDATA[Letter Combinations of a Phone Number]]></title><link>https://blog.youkuaiyun.com/xdugucc/article/details/78573793</link><guid>https://blog.youkuaiyun.com/xdugucc/article/details/78573793</guid><author>xdugucc</author><pubDate>Sun, 19 Nov 2017 13:35:42 +0800</pubDate><description><![CDATA[原题链接：
https://leetcode.com/problems/letter-combinations-of-a-phone-number/description/



思路：
输入一串0-9的数字，每个数字对应着电话上的1个或多个字符，要求出所有可能的字符组合，以List形式返回。
假设输入“23”,先取第一个字符2，对应的字符串是“abc”，那么此时的List内元素是“]]></description><category></category></item><item><title><![CDATA[基本类型与自动装箱与拆箱]]></title><link>https://blog.youkuaiyun.com/xdugucc/article/details/78527164</link><guid>https://blog.youkuaiyun.com/xdugucc/article/details/78527164</guid><author>xdugucc</author><pubDate>Tue, 14 Nov 2017 16:16:17 +0800</pubDate><description><![CDATA[先说几个要注意的地方，然后根据以下的结论来分析两个题目。


1.所有数值类型都有正负号
2.浮点数值有后缀f或F，表示float类型，没有的话默认为double类型，double可加可不加后缀d或D。long型有后缀l或L
3.不同类型运算结果向右靠齐 char
4.计算机进行运算是以补码形式进行
5.正数的补码就是原码，负数的补码是除符号位以外其余各位取反+1
6.对象包装器类]]></description><category></category></item><item><title><![CDATA[3Sum]]></title><link>https://blog.youkuaiyun.com/xdugucc/article/details/78442792</link><guid>https://blog.youkuaiyun.com/xdugucc/article/details/78442792</guid><author>xdugucc</author><pubDate>Sat, 04 Nov 2017 12:42:50 +0800</pubDate><description><![CDATA[原题链接：https://leetcode.com/problems/3sum/description/


思路：这道题要找出不重复的合为0的三元组，做过了2Sum那道题会很容易想到借助HashMap，但是笔者尝试过，这样的方式很难解决重复的问题。暴力破解的做法是每次挑出一个元素值叫做a，然后从剩余的数组中找出和为-a的两元素，两个步骤的合在一块的时间复杂度为o(n*n^2)=o(n^3)]]></description><category></category></item><item><title><![CDATA[Container With Most Water]]></title><link>https://blog.youkuaiyun.com/xdugucc/article/details/78435851</link><guid>https://blog.youkuaiyun.com/xdugucc/article/details/78435851</guid><author>xdugucc</author><pubDate>Fri, 03 Nov 2017 15:08:28 +0800</pubDate><description><![CDATA[原题链接：https://leetcode.com/problems/container-with-most-water/description/


思路：这道题说白了就是求（j-i）*min(height[j],height[i])的最大值，其中i,j在[0,height.length-1]中。如果暴力破解一共要算n^2个值找出最大的，算法的目的就是减少需要计算的值，也就是说剔除掉肯定不]]></description><category></category></item><item><title><![CDATA[Longest Palindromic Substring]]></title><link>https://blog.youkuaiyun.com/xdugucc/article/details/78428238</link><guid>https://blog.youkuaiyun.com/xdugucc/article/details/78428238</guid><author>xdugucc</author><pubDate>Thu, 02 Nov 2017 19:07:09 +0800</pubDate><description><![CDATA[原题链接：https://leetcode.com/problems/longest-palindromic-substring/description/
思路：
这题要求一个字符串的最长回文串，注意到回文串有着中心对称的特点，而且有两种对称方式。一种是字符串所含字符串是单数个，比如aba，另外一种偶数情况，比如baab。那么我们要求字符串的最长回文串，如果字符串为空或者只含一个字符那么直接返]]></description><category></category></item><item><title><![CDATA[G1垃圾收集器]]></title><link>https://blog.youkuaiyun.com/xdugucc/article/details/78324146</link><guid>https://blog.youkuaiyun.com/xdugucc/article/details/78324146</guid><author>xdugucc</author><pubDate>Mon, 23 Oct 2017 22:17:54 +0800</pubDate><description><![CDATA[G1:Garbage First


特点：
1.并行与并发：G1能充分利用多CPU，多核环境下的硬件优势来缩短Stop the world停顿的时间。并行：Parallel,多个GC进程一起执行。并发：Concurrent,GC进程与用户进程一起执行。
2.分代收集：G1不需要其他垃圾收集器就能独立管理整个GC堆，但它能采用不同的方式来回收新对象与旧对象来获得更好的收集效果。
3.空]]></description><category></category></item><item><title><![CDATA[CMS垃圾收集器]]></title><link>https://blog.youkuaiyun.com/xdugucc/article/details/78323643</link><guid>https://blog.youkuaiyun.com/xdugucc/article/details/78323643</guid><author>xdugucc</author><pubDate>Mon, 23 Oct 2017 21:30:12 +0800</pubDate><description><![CDATA[CMS收集器


特点：
1.以获取最短回收停顿时间为目标
2.CMS全称是 Concurrent Mark Sweep。从名字就可以看出来两个特点，一是并发,这里并发并不是指多条GC进程一起工作，而是指GC进程可以与用户进程一起工作。二是，该垃圾收集器使用标记清除算法的方式回收垃圾。


收集过程：
1.初始标记：这个过程需要Stop the world，初始化标记仅仅只是标记]]></description><category></category></item><item><title><![CDATA[java方法调用中的单分派与多分派]]></title><link>https://blog.youkuaiyun.com/xdugucc/article/details/78268031</link><guid>https://blog.youkuaiyun.com/xdugucc/article/details/78268031</guid><author>xdugucc</author><pubDate>Tue, 17 Oct 2017 22:55:59 +0800</pubDate><description><![CDATA[方法的接受者与方法的参数统称为方法的宗量。根据分派基于多少宗量，可以将分派分为单分派与多份派。
《深入理解java虚拟机》一书中写到，java是静态多分派动态单分派的语言，我一直没有理解，我觉得静态分派是根据方法参数的类型和顺序来决定调用哪一个重载方法。
而动态分派就是在运行期根据方法调用者的实际类型来决定调用哪一个重写的方法。这不都是单分派么？我不知道有没有读者有或者曾经有过与我相似的困惑，]]></description><category></category></item><item><title><![CDATA[java中的方法调用-解析与分派]]></title><link>https://blog.youkuaiyun.com/xdugucc/article/details/78260435</link><guid>https://blog.youkuaiyun.com/xdugucc/article/details/78260435</guid><author>xdugucc</author><pubDate>Tue, 17 Oct 2017 14:52:44 +0800</pubDate><description><![CDATA[在本文开始之前，先搞清楚一个概念。对于People p = new Man();这句代码，我们把People叫做静态类型，Man叫做动态类型。静态类型在编译期可知，实际类型在运行期才可以确定下来。
解析
所有方法调用中的目标方法在Class文件里面都是一个常量池中的符号引用，在类加载的解析阶段，会将其中一部分符号引用转化为直接引用，这种解析能成立的前提是：方法在程序真正运行之前就有一个可确定的]]></description><category></category></item><item><title><![CDATA[java 中的向前引用]]></title><link>https://blog.youkuaiyun.com/xdugucc/article/details/78239920</link><guid>https://blog.youkuaiyun.com/xdugucc/article/details/78239920</guid><author>xdugucc</author><pubDate>Sun, 15 Oct 2017 13:06:39 +0800</pubDate><description><![CDATA[在学习《深入理解java虚拟机》一书中，关于类的初始化一章中提到了一句：静态语句块中只能访问到定义在静态语句块之前的变量，定义在它之后的变量，在前面的静态语句块中可以赋值，但是不能访问。
并给出一个示例：
public class MyClass {
	static {
		i = 0; //给变量赋值可以正常通过
		System.out.println(i); //编译器提示非法向前引用]]></description><category></category></item><item><title><![CDATA[java中关于final方法与static方法不具备多态性的理解]]></title><link>https://blog.youkuaiyun.com/xdugucc/article/details/78222571</link><guid>https://blog.youkuaiyun.com/xdugucc/article/details/78222571</guid><author>xdugucc</author><pubDate>Fri, 13 Oct 2017 10:02:02 +0800</pubDate><description><![CDATA[先说明一下这里的多态性特指方法的重写。方法的重载不会受到final,static修饰符的影响，一个类中当然可以有多个static或者final修饰的同名但不同参数类型的方法，重载根据传入参数的实际类型来确定调用哪一个方法。


那为什么final(private方法是一种隐式的final方法)和static方法不能够被重写呢？
1.final方法很好理解，因为不可以被继承，自然不可以被子类]]></description><category></category></item><item><title><![CDATA[构造器的多态行为]]></title><link>https://blog.youkuaiyun.com/xdugucc/article/details/78220518</link><guid>https://blog.youkuaiyun.com/xdugucc/article/details/78220518</guid><author>xdugucc</author><pubDate>Thu, 12 Oct 2017 22:10:55 +0800</pubDate><description><![CDATA[我们知道，在调用父类构造器时，得先要调用子类构造器。如果父类有方法f(),子类对其重写了，恰好父类构造器中用到了这个f()方法，那么这个f()调用的是父类中的f()还是子类中已经重写的f()呢？


不妨用一个例子试试看，这个例子引用自Thinking in java。
class Glyph {
	void draw() {
		System.out.println("Glyph.dra]]></description><category></category></item><item><title><![CDATA[java中涉及继承关系的初始化顺序]]></title><link>https://blog.youkuaiyun.com/xdugucc/article/details/78219873</link><guid>https://blog.youkuaiyun.com/xdugucc/article/details/78219873</guid><author>xdugucc</author><pubDate>Thu, 12 Oct 2017 21:09:15 +0800</pubDate><description><![CDATA[在http://blog.youkuaiyun.com/xdugucc/article/details/78217098这篇博文中对单个类成员变量初始化和构造器初始化顺序做了介绍。
而这篇将讲解具有继承关系的类中的初始化顺序。


一个类中具有静态成员和静态代码块，非静态成员和非静态代码块，构造器这些需要初始化的东西。现在他有一个父类。那么当生成一个子类对象时，必然需要对父类中需要初始化的东西进行初始]]></description><category></category></item><item><title><![CDATA[java中的访问权限控制]]></title><link>https://blog.youkuaiyun.com/xdugucc/article/details/78218691</link><guid>https://blog.youkuaiyun.com/xdugucc/article/details/78218691</guid><author>xdugucc</author><pubDate>Thu, 12 Oct 2017 19:29:18 +0800</pubDate><description><![CDATA[访问权限修饰词
java中提供了四种访问权限修饰词，分别为private,default,protected,public。这四种修饰词用来修饰成员变量与方法（下面统称为成员），从前往后访问权限越来越宽。现在分别进行介绍
1.private
private修饰的成员只能被该类本身所访问，其他类都不可访问到private修饰的成员。
2.default
默认的权限修饰符，默认的（不加修饰符]]></description><category></category></item><item><title><![CDATA[java中成员初始化与构造器初始化的顺序]]></title><link>https://blog.youkuaiyun.com/xdugucc/article/details/78217098</link><guid>https://blog.youkuaiyun.com/xdugucc/article/details/78217098</guid><author>xdugucc</author><pubDate>Thu, 12 Oct 2017 17:04:20 +0800</pubDate><description><![CDATA[1.初始化顺序
先看一个例子
class Counter {
	int i;
	Counter() {
		//i = 7;
	}
}
public class Test {
	public static void main(String[] args) {
		System.out.println(new Counter().i);
	}
}我们执行这段程序，当i=7被注释掉，打印出0。这说]]></description><category></category></item><item><title><![CDATA[一个关于字符串常量池的问题]]></title><link>https://blog.youkuaiyun.com/xdugucc/article/details/78205342</link><guid>https://blog.youkuaiyun.com/xdugucc/article/details/78205342</guid><author>xdugucc</author><pubDate>Wed, 11 Oct 2017 16:36:10 +0800</pubDate><description><![CDATA[看一个例子
public class Test4 {
	public static void main(String[] args) {
		String s1 = "b";
		String s2 = "a";
		String s3 = s1 + "d";
		String s4 = "e" + "f";
		String s5 = s1 + s2;
	}
	
}
问题是，现在字符串常量池]]></description><category></category></item><item><title><![CDATA[String.intern()方法]]></title><link>https://blog.youkuaiyun.com/xdugucc/article/details/78202667</link><guid>https://blog.youkuaiyun.com/xdugucc/article/details/78202667</guid><author>xdugucc</author><pubDate>Wed, 11 Oct 2017 13:31:13 +0800</pubDate><description><![CDATA[本文介绍String.intern()方法
这个方法在jdk1.6与idk1.7之后发生了变化。主要是因为jdk1.7之后，方法区中常量池的位置从方法区变成了堆上，intern()方法也做了相应的修改。


直接看一个网上很流行的例子。
		String s = new String("1");  
		s.intern();  
		String s2 = "1";  
		Syste]]></description><category></category></item><item><title><![CDATA[String之常量池小结]]></title><link>https://blog.youkuaiyun.com/xdugucc/article/details/78193805</link><guid>https://blog.youkuaiyun.com/xdugucc/article/details/78193805</guid><author>xdugucc</author><pubDate>Tue, 10 Oct 2017 16:07:37 +0800</pubDate><description><![CDATA[转载自http://blog.youkuaiyun.com/xsf50717

1、String 常量池


为了减少在JVM中创建的字符串的数量，字符串类维护了一个字符串池，每当代码创建字符串常量时，JVM会首先检查字符串常量池。如果字符串已经存在池中，就返回池中的实例引用。如果字符串不在池中，就会实例化一个字符串并放到池中。




Note：常量池在java用于保存在编译期已确定的，]]></description><category></category></item></channel></rss>