BlogJava-zhb8015-文章分类-interview

Nutch vs Lucene(转)

zhb8015 — Wed, 10 Apr 2013 13:53:00 GMT

原文：：：
http://wangfei4553693.blog.163.com/blog/static/270104772011451312819/

Lucene其实是一个提供全文文本搜索的函数库，它不是一个应用软件。它提供很多API函数让你可以运用到各种实际应用程序中。现在，它已经成为Apache的一个项目并被广泛应用着。这里列出一些已经使用Lucene的系统。

Nutch 是一个建立在Lucene核心之上的Web搜索的实现，它是一个真正的应用程序。也就是说，你可以直接下载下来拿过来用。它在Lucene的基础上加了网络爬虫和一些和Web相关的东东。其目的就是想从一个简单的站内索引和搜索推广到全球网络的搜索上，就像Google和Yahoo一样。当然，和那些巨人竞争，你得动一些脑筋，想一些办法。我们已经测试过100M的网页，并且它的设计用在超过1B的网页上应该没有问题。当然，让它运行在一台机器上，搜索一些服务器，也运行的很好。

总的来说，我认为LUCENE会应用在本地服务器的网站内部搜索，而Nutch则扩展到整个网络、Internet的检索。当然LUCENE加上爬虫程序等就会成为Nutch，这样理解应该没错吧。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/rokii/archive/2008/03/01/2137450.aspx

简单的说:
z Lucene 不是完整的应用程序，而是一个用于实现全文检索的软件库。
z Nutch 是一个应用程序，可以以 Lucene 为基础实现搜索引擎应用。
Lucene 为 Nutch 提供了文本索引和搜索的 API。一个常见的问题是；我应
该使用 Lucene 还是Nutch？最简单的回答是：如果你不需要抓取数据的话，应该
使用Lucene。常见的应用场合是：你有数据源，需要为这些数据提供一个搜索页
面。在这种情况下，最好的方式是直接从数据库中取出数据并用 Lucene API 建立
索引。

zhb8015 2013-04-10 21:53 发表评论

ArrayList空间增长是怎么样的

zhb8015 — Sat, 02 Mar 2013 05:49:00 GMT

题目：RT
分析源码：ensureCapacity会保证ArrayList每次的增长不小于minCapacity，大概增长为原容量的2/3
ArrayList.add(E e)

1 public boolean add(E e) {
2     ensureCapacity(size + 1);  // Increments modCount!!
3     elementData[size++] = e;
4     return true;
5     }

ArrayList.ensureCapacity(int minCapacity)

1 public void ensureCapacity(int minCapacity) {
2     modCount++;
3     int oldCapacity = elementData.length;
4     if (minCapacity > oldCapacity) {
5         Object oldData[] = elementData;
6         int newCapacity = (oldCapacity * 3)/2 + 1;
7             if (newCapacity < minCapacity)
8         newCapacity = minCapacity;
9             // minCapacity is usually close to size, so this is a win:
10             elementData = Arrays.copyOf(elementData, newCapacity);
11     }
12     }

zhb8015 2013-03-02 13:49 发表评论

手工打包（jar）

zhb8015 — Wed, 08 Aug 2012 07:59:00 GMT

一个小工具用到了手工打包，头疼了一段时间，现在把自己的经验记录一下，希望对遇到同样问题的朋友有帮助。

一、需求
二、手工打包
三、fat jar 上场

所有文件及脚本，fat jar 都可下载(

http://www.blogjava.net/zhb8015/admin/Files.aspx)

************
一、需求：包涉及到三个类(src)，几个jar包(lib)，两个属性配置文件，一个jar包内(config/db.properties)一个jar包外(bams.properties)，简单路径如下,
全路径在最后。我遇到的难点：A 属性文件的读取，包内包外相对路径获取。B 三方jar包如何打入。

C:\TEST\JARTEST
├─1.5
├─build
│  ├─classes
│  │  ├─com
│  │  │  └─vanceinfo
│  │  │      └─jvmmem
│  │  ├─config
│  │  └─lib
│  └─jar
├─config
├─lib
├─src
│  └─com
│      └─vanceinfo
│          └─jvmmem

C:\test\jartest>tree /F src
卷 system 的文件夹 PATH 列表
卷序列号为 2099-0161
C:\TEST\JARTEST\SRC
└─com
    └─vanceinfo
        └─jvmmem
                MessageData.java
                ParsingLogFile.java
                ParsingLogFileTest.java

二、手工打包：
打包前先讲一下文件的读取，包内和包外相对路径：

if(isDir) {
                //read from user.dir
                inputStream = new FileInputStream(new File(fileName));
            } else {
                //read from jar
                inputStream = getClass().getResourceAsStream("/" + fileName);
            }

说明：//read from jar是从jar包中读取congfig/db.properties属性文件 fileName= "config/db.properties";
         //read from user.dir 这里采用的是从绝对路径读取的fileName = System.getProperty("user.dir") + "/";读取bams.properties
A、命令行编译: C:\test\jartest>javac -cp (第三方jar路径) src\com\vanceinfo\jvmmem\*.java
     进入C:\test\jartest\src,并拷贝必须的属性文件进行打包，属性文件为 config/db.properties-->.../src/
     编写MANIFEST.MF,这里一定要注意格式（这里不再详述，网上文章很多）

Manifest-Version: 1.0
Ant-Version: Apache Ant 1.7.1
Created-By: 20.2-b06 (Sun Microsystems Inc.)
Main-Class: com.vanceinfo.jvmmem.ParsingLogFile
Class-Path: lib/junit lib/junit-3.8.1.jar config/db.properties lib/ojd
bc14.jar lib/log4j-1.2.8.jar lib/mysql-connector-java-5.0.8-bin.jar l
ib/ojdbc14.jar

运行打包命令 java cvfm parsing.jar MANIFEST.MF com config lib 生成parsing.jar ，至此包已打完。
注意：运行java -jar parsing.jar是找不到jar包的，也就是它不能读到jar包中的第三方包。
B、上面的文件路径其实是为Ant的准备的，有兴趣的朋友可以看一下下载下build.xml研究一下。
三、fat jar打包工具
查了好多资料还是没有解决，不过找到了一个比较好的打包工具 fat jar。
这个插件的介绍：

http://fhqdddddd.blog.163.com/blog/static/186991542011427104124407/

真的很方便，几步就搞定了。最好新建一个工程，拷贝所需要的文件.截图如下：

选择第三方包，还能导出ant

点击finish,搞定！运行时拷贝bams.propreties属性文件到同目录，直接运行即可。

全路径：

C:\TEST\JARTEST
│  bams.properties
│  build.xml
│  Info.log
│  log4j.properties
│  readme.txt
│
├─1.5
│      bams.properties
│      build.xml
│      Info.log
│      parsing.jar
│
├─build
│  ├─classes
│  │  │  log4j.properties
│  │  │
│  │  ├─com
│  │  │  └─vanceinfo
│  │  │      └─jvmmem
│  │  │              MessageData.class
│  │  │              ParsingLogFile.class
│  │  │              ParsingLogFileTest.class
│  │  │
│  │  ├─config
│  │  │      db.properties
│  │  │
│  │  └─lib
│  │          junit-3.8.1.jar
│  │          junit.jar
│  │          log4j-1.2.8.jar
│  │          mysql-connector-java-5.0.8-bin.j
│  │          ojdbc14.jar
│  │
│  └─jar
│          bams.properties
│          Info.log
│          parsing.jar
│
├─config
│      db.properties
│
├─lib
│      junit-3.8.1.jar
│      junit.jar
│      log4j-1.2.8.jar
│      mysql-connector-java-5.0.8-bin.jar
│      ojdbc14.jar
│
├─src
│  └─com
│      └─vanceinfo
│          └─jvmmem
│                  MessageData.java
│                  ParsingLogFile.java
│                  ParsingLogFileTest.java

zhb8015 2012-08-08 15:59 发表评论

TW interview experience(转)

zhb8015 — Fri, 27 Jul 2012 10:48:00 GMT

TW来了
   12/23 收到了ThoughtWorks的HomeWork, 通知我简历筛选已经过了，发给我三个题目，是写程序的题。要求我从中选择一个作答，在2-3天内上交。能够通过TW的简历的筛选让我喜出望外，对这个公司的兴趣源于公司名称。思想工作？通过进一步了解，让我对他们平等的组织机构有了了解，于是更增加了一份向往。如今有了这次机会，实在是太幸运了。
做作业:
   程序题对输入输出没有要求，从题目说明中示范的输入输出来看，用控制台足以解决问题。但是为了方便以后通过其他的方式输入，接受用户输入的函数由外边传入一个inputStream即可，这样你用System.in就是控制台输入，用StringBufferInputStream就是从字符串输入。程序逻辑非常简单，但如何设计的可扩展确实值得下一番功夫的。因为后面的结对编程阶段将会对这份代码提出新的需求，并进行重构。花了一天的时间研究设计模式，用ArgoUML画了UML图。这里前列推荐一下ArgoUML,这是一个JAVA写的UML工具，界面用的是SWING,跨平台性应该不错。关键是麻雀虽小，五脏俱全，我原来用过RationalRose,只用了1个小时就基本适应了这个工具。看完设计模式以后，有点模式上瘾的感觉，看到什么都想套个模式……但是本着循序渐进的原则，我还是先写了一个较为简单的版本，已实现基本功能为目的。只设计了3个类。之后开始着手重构。在一番刻意的设计之后，决定把原来的工程推倒重做……因为改动实在太大了。状态、命令模式的引入使得类的数量增长到10个，并增加了3-4个接口。设计完之后，感觉自己的程序像是变形金刚了……甚是满意。于是写测试，写Ant脚本，写文档……经过一番体力劳动，打包上交了。静候消息……

笔试:
   2008年过去了，第二年我终于收到了TW下一阶段的指示。1月6号下午让我去笔试。想了半天觉得也没什么可准备的，因为据说都是推理题。提前半小时来到了TW在东直门的办公室。在门外观察了一下，很干净，确实是外企的风格。然后就进去了，里边的工作人员问我找谁，我说面试，然后就让我先坐下等着。TW 的办公区分为两大块，整体布局呈哑铃形状。桌子跟网上说的一样，没有隔板，是很自由的大家围着坐的布局。拿着资料看了几分钟，HR的MM就要请我进入了一间写着'元'的房间，才意识到这里的办公室都是用中国朝代进行标记的. 一起的还有一个研究生，我们聊了聊天，气氛很融洽，也比较放松。之后就是漫长的笔试过程。首先是逻辑测试，在这个过程中还签署了保密协议，要求不能外泄题目。题目确实还是设计的比较有针对性的，并不是平时见过的那种智力题。我想如果平时写过程序的话，应该能比较好适应里边的思维模式。但要命的是题目全部是英文描述，尤其是碰到有一堆从句或者修饰语嵌套在一起的时候，让人想暴走……提前10分钟前偶就全部做完了，但是太过自信，就在那里等着，到最后两分钟的时候想最后检查一下就交。结果连续发现了问题，主要是对于题意的理解……赶忙改完2道题后，卷子就收上去了T_T听后来HRMM说还改错了……之后是英文的快速反应题，HR说题比较多，时间很短，一般都做不完。反正能多做就多做呗……一共15分钟的时间，这15分钟也比较痛苦，文字推理题换成英文的真是让我感叹自己的英文水平，连单词都不认识，怎么选则反义词啊……只能蒙！再往后是OpenQuestion,有大概12到题目，要求用英文任意作答。主要考察综合素质和与公司文化的契合程度。由于当时感觉又疲惫又晕又饿，所以感觉打得并不怎么好，枉费了我的口才了……我比研究生早很多就交了。HR把我单独待到一房间，问我有什么问题么，我就问了问后边还有什么筛选环节。MM很亲切的告诉我后边如果能继续，还会有结对编程，技术面试，HR主管面试……God Bless Me，忐忑的回了家。

   本来以为笔试完了隔一天会进行结对编程，谁知道刚坐车回家就接到HRMM电话说第二天要来结对编程……得了，也没的准备了，改什么样就什么样，是骡子是马拉出去给他们溜溜。晚上看了看Extreme Programming Cook Book 中的Junit，特别复习了一下Eclipse的快捷键,然后在期待与不安中入睡……。
   迎着下午一点的太阳和北京特有的刺骨的寒风，我再次出现在了东直门的国华投资大厦下面。经过HR的介绍，我和一位TW的帅哥开始pair. 我们共用一台Mac Book,连接一个液晶显示器，两套键盘和鼠标。首先我解释了我的代码，帅哥很认真的听，不时提出几个问题。问题不断深入，考查设计模式的使用，及设计 OO的概念。我对自己这方面还是比较有自信的，回答的也比较流畅。并且在解释的过程中着重的强调了自己对于扩展性的一些基本想法。并自揭老底告诉他有可能涉及过度了。都怪前一阵看设计模式看得有点着了魔，什么玩意都想往模式上套，一看就是新手，呵呵！之后提出了几个两个新的需求。于是我们讨论了新的设计，当我着手开始写代码的时候，才发现这Mac的键盘实在是……具然没有Ctrl! 结果Eclipse里的快捷键全不能用了……昨天晚上白准备了。打字的时候尤其不适应，都怪我是土人一个，用Mac键盘写程序，感觉自己的动作像是小脑出了问题一般。动不动就按错，最后小心翼翼的一个字母一个字母的按……两个需求变更，最终完成了其中的第一个，但对于第二个变更，我跟TWer进行了建设性的讨论，并交换了意见，但是由于时间所限，最后没来得及完成。在这个过程中，我看到了我设计和开发习惯的种种不足，学到了很多。比如一定要在测试全部通过之后才能引入新的变化，并且面向对象的概念很重要的就是根据问题域，逻辑来划分对象，应该就是所谓的领域对象的思想。真的非常感谢那位TWer的指导，花了两个小时帮助我改进代码。
   HRMM又出现了，问我还有没有其他的问题，于是我问了问安排，被告知Office Interview将是Boss战，能否通关拿到Offer在此一举了。临走之前MM说 “我们讨论之后，如果我想起来，明天就能告诉你pair的结果”，我赶紧笑着说"那就麻烦您尽量想起来。”

   总算没有白等。结对编程的结果也还算不错。本以为下一轮很快就会结束，却被告知最后如果想通关，还要进行N连战……这让我想起了玩洛克人的感觉……一关一关有一关。相隔了一周左右。N连战开始了。
   早上便来到了ThoughWorks办公室。开始Round1 Presentation。一共8个人。4个人一组开始做。我跟3个MM分在一组。我是最后一个讲的，为了能够更清晰的表示我的意思，我决定用中文+ppt的形式进行表达(英文水平还不太够)。平时在学校里大大小小的课设和项目也算做了不少，所以对于Presentation我还是比较有信心的。对于后来HR问我的问题:你认为好Presentation的标准是什么。我的解释是让听众和自己都感觉舒服，并能可取所需。具体的标准可能包括保持目光接触；虽然有不少人说，演讲的时候把人头当作西瓜，或者朝无限远的地方延伸(这样大家都以为你是在看他)。这两种做法我都试过，效果并不好。我尝试过把人当西瓜，但是没用，脑袋和西瓜长得实在太不像了，而且关键在于让演讲者害怕的其实不是脑袋，而是嵌在一颗颗西瓜，噢不，是脑袋上的一双双注视你的眼睛。至于把目光放到无限远，可能人多的时候是比较实用的。但我总觉得这样做会让我感觉眩晕，而且自我感觉很痴呆的样子。我认为保持目光接触，这是最好的办法。随机得看每个人的眼睛，就像跟同一个人在对话一样。把他们想象成一个人，这样就不会紧张了。
   Round2 是协作游戏。8人分两组，每组四人。在沟通受限，时间受限的情况下，齐力完成一项手工。这个环节由多名TWer监视着。考察协作和沟通能力。我感觉我们表现得并不好。大家都有点失望:(
   Round3是面谈。迎接我的是Jessie。并没有什么让我觉得特别有压力的问题。交流是在轻松的气氛下进行的。我也坦诚的回答了所有的问题。坦诚是很重要的，该什么样就是什么样，自己轻松，也防止误解。
3连战就这样结束了。经历了最长的等待（大概一周多），我终于成功了！接到通知电话的时候感觉好像范进中举……虽然找工作的这段时间，不断在痛苦，迷茫，中徘徊。但是终于能够拿到喜欢的公司的Offer也算是老天对我不薄了。ThoughtWorks真的很不错，从我面试的一开始我就喜欢上了这个公司，平等，开放，互相尊重。我想这是每一个热爱技术的人都向往的氛围。待遇也还可以，我觉得在这里我应该可以更好的学习技术，更好的享受技术和生活。这也是我选择ThoughtWorks的原因吧……

zhb8015 2012-07-27 18:48 发表评论

排序算法（转）

zhb8015 — Thu, 26 Jul 2012 09:31:00 GMT

原文：

http://blog.csdn.net/luosijin123/article/details/4795177

。并总结成API供大家参考：

软件包

类

使用

树

已过时

索引

帮助

上一个类下一个类

框架 无框架

摘要：嵌套 | 字段 | 构造函数 | 方法

详细信息：字段 | 构造函数 | 方法

org.luosijin.test
类 Sort

java.lang.Object   org.luosijin.test.Sort

public class Sort
extends java.lang.Object
extends java.lang.Object

Java实现几种常见排序方法:冒泡排序、快速排序、选择排序、插入排序、希尔排序，甚至还有基数排序、鸡尾酒排序、桶排序、鸽巢排序、归并排序等。

版本：: V5.0
作者：: 罗嗣金

构造函数摘要
`Sort()`

方法摘要
`static void`	`bubbleSort(int[] nums)` 冒泡法排序比较相邻的元素。
`static void`	`insertSort(int[] nums)` 插入排序从第一个元素开始，该元素可以认为已经被排序取出下一个元素，在已经排序的元素序列中从后向前扫描如果该元素（已排序）大于新元素，将该元素移到下一位置重复步骤3，直到找到已排序的元素小于或者等于新元素的位置将新元素插入到该位置中重复步骤2
`static void`	`merge(int[] data, int p, int q, int r)` 归并算法实现
`static void`	`mergeSort(int[] nums, int left, int right)` 归并排序申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列设定两个指针，最初位置分别为两个已经排序序列的起始位置比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置重复步骤3直到某一指针达到序列尾将另一序列剩下的所有元素直接复制到合并序列尾算法参考：Java部落
`static void`	`quickSort(int[] nums, int start, int end)` 快速排序从数列中挑出一个元素，称为“基准” 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。
`static void`	`selectSort(int[] nums)` 选择排序在未排序序列中找到最小元素，存放到排序序列的起始位置再从剩余未排序元素中继续寻找最小元素，然后放到排序序列末尾。

从类 java.lang.Object 继承的方法
`equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

构造函数详细信息

Sort

public Sort()

方法详细信息

bubbleSort

public static void bubbleSort(int[] nums)

冒泡法排序

比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

参数：: nums - 需要排序的整型数组

" src="/CuteSoft_Client/CuteEditor/Images/anchor.gif">

quickSort

public static void quickSort(int[] nums,                              int start,                              int end)

快速排序

从数列中挑出一个元素，称为“基准”
重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分割之后，该基准是它的最后位置。这个称为分割（partition）操作。
递归地把小于基准值元素的子数列和大于基准值元素的子数列排序。

参数：: nums -; start -; end -

selectSort

public static void selectSort(int[] nums)

选择排序

在未排序序列中找到最小元素，存放到排序序列的起始位置
再从剩余未排序元素中继续寻找最小元素，然后放到排序序列末尾。
以此类推，直到所有元素均排序完毕。

参数：: nums -

insertSort

public static void insertSort(int[] nums)

插入排序

从第一个元素开始，该元素可以认为已经被排序
取出下一个元素，在已经排序的元素序列中从后向前扫描
如果该元素（已排序）大于新元素，将该元素移到下一位置
重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
将新元素插入到该位置中
重复步骤2

参数：: nums -

" src="/CuteSoft_Client/CuteEditor/Images/anchor.gif">

mergeSort

public static void mergeSort(int[] nums,                              int left,                              int right)

归并排序

申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
设定两个指针，最初位置分别为两个已经排序序列的起始位置
比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
重复步骤3直到某一指针达到序列尾
将另一序列剩下的所有元素直接复制到合并序列尾

算法参考：Java部落

参数：: nums -; left -; right -

" src="/CuteSoft_Client/CuteEditor/Images/anchor.gif">

merge

public static void merge(int[] data,                          int p,                          int q,                          int r)

归并算法实现

参数：: data -; p -; q -; r -

软件包

类

使用

树

已过时

索引

帮助

上一个类下一个类

框架 无框架

摘要：嵌套 | 字段 | 构造函数 | 方法

详细信息：字段 | 构造函数 | 方法

zhb8015 2012-07-26 17:31 发表评论

加密算法（转）

zhb8015 — Thu, 26 Jul 2012 07:05:00 GMT

加密算法分类：
http://baike.baidu.com/view/7510.htm

JDK1.4 JCE 使用方法，介绍的比较详细

http://hi.baidu.com/bluewhale84/blog/item/f3bb20a1f538a9884710648c.html#0

zhb8015 2012-07-26 15:05 发表评论

软件设计过程一些术语 AN BD FD DD CD CT

zhb8015 — Wed, 18 Jul 2012 10:04:00 GMT

BD FD DD

分类： c++ uml 2012-02-08 22:24 59人阅读评论(0) 收藏举报

N BD FD DD C UT CT TT IT OP
今天填简历,工程一栏给出这样的选项、网上没有查到准确解释.
跟朋友讨论了一下,大体上猜测出几个,也有两个不知道何意,如果有知道正解的请不吝赐教!
AN-要求分析
BD-基本设计
FD-结构设计
DD-详细设计
C -编码
UT-单体测试
CT-不知道
TT-结合测试
IT-系统测试
OP-发布

以上只是个人理解,像OP这样的纯属猜测...欢迎指摘!

软件开发测试过程的一些缩写和解释,感觉不太准确,望补充

正解 AN BD FD DD CD UT CT TT IT ST UAT OP

2011-3-9 15:55

提问者：lily_dy|浏览次数：677次

AN...???                         英文(__) BD...基本设计                 英文(__) FD...结构设计                 英文(__)  DD...详细设计                 英文(__) CD...编码                     英文(Coding) UT...单元测试                 英文(unit testing) CT...组件测试                 英文(Component testing) TT...???                                      英文(__) IT ...集成测试                 英文(integration testing) ST...系统测试                 英文(system testing)   UAT...俗称:验收测试           英文(User acceptance testing) OP...???                                     英文(__)  有哪位高手了解,请帮忙给出正解,谢谢!

2011-3-9 16:11

最佳答案

AN...???                         英文(_Analysis_) BD...基本设计                 英文(_Basic Design_) FD...结构设计                 英文(_Functional Design_)  DD...详细设计                 英文(_Detail Design_) CD...编码                     英文(Coding) UT...单元测试                 英文(unit testing) CT...组件测试                 英文(Component testing) TT...???                                      英文(_Technical Test_) IT ...集成测试                 英文(integration testing) ST...系统测试                 英文(system testing)   UAT...俗称:验收测试           英文(User acceptance testing) OP...???                                     英文(_Operation_)  供参考。

zhb8015 2012-07-18 18:04 发表评论

Log4j详细配置（转）

zhb8015 — Mon, 09 Jul 2012 08:57:00 GMT

log4j.appender.CONSOLE.layout.ConversionPattern=[framework] %d - %c -%r [%t] %-10p %c %x - %m%n

%-10p //'-'左对齐 10宽度

原文地址：Log4j.properties配置详解作者：大海巨浪
http://blog.sina.com.cn/s/blog_7774a1fe01013msb.html

一、Log4j简介

Log4j有三个主要的组件：Loggers(记录器)，Appenders (输出源)和Layouts(布局)。这里可简单理解为日志类别，日志要输出的地方和日志以何种形式输出。综合使用这三个组件可以轻松地记录信息的类型和级别，并可以在运行时控制日志输出的样式和位置。

1、Loggers

Loggers组件在此系统中被分为五个级别：DEBUG、INFO、WARN、ERROR和FATAL。这五个级别是有顺序的，DEBUG < INFO < WARN < ERROR < FATAL，分别用来指定这条日志信息的重要程度，明白这一点很重要，Log4j有一个规则：只输出级别不低于设定级别的日志信息，假设Loggers级别设定为INFO，则INFO、WARN、ERROR和FATAL级别的日志信息都会输出，而级别比INFO低的DEBUG则不会输出。

2、Appenders

禁用和使用日志请求只是Log4j的基本功能，Log4j日志系统还提供许多强大的功能，比如允许把日志输出到不同的地方，如控制台（Console）、文件（Files）等，可以根据天数或者文件大小产生新的文件，可以以流的形式发送到其它地方等等。

常使用的类如下：

org.apache.log4j.ConsoleAppender（控制台）
org.apache.log4j.FileAppender（文件）
org.apache.log4j.DailyRollingFileAppender（每天产生一个日志文件）
org.apache.log4j.RollingFileAppender（文件大小到达指定尺寸的时候产生一个新的文件）
org.apache.log4j.WriterAppender（将日志信息以流格式发送到任意指定的地方）

配置模式：
log4j.appender.appenderName = className
log4j.appender.appenderName.Option1 = value1
…
log4j.appender.appenderName.OptionN = valueN

3、Layouts

有时用户希望根据自己的喜好格式化自己的日志输出，Log4j可以在Appenders的后面附加Layouts来完成这个功能。Layouts提供四种日志输出样式，如根据HTML样式、自由指定样式、包含日志级别与信息的样式和包含日志时间、线程、类别等信息的样式。

常使用的类如下：

org.apache.log4j.HTMLLayout（以HTML表格形式布局）
org.apache.log4j.PatternLayout（可以灵活地指定布局模式）
org.apache.log4j.SimpleLayout（包含日志信息的级别和信息字符串）
org.apache.log4j.TTCCLayout（包含日志产生的时间、线程、类别等信息）

配置模式：

log4j.appender.appenderName.layout =className
log4j.appender.appenderName.layout.Option1 = value1
…
log4j.appender.appenderName.layout.OptionN = valueN

二、配置详解

在实际应用中，要使Log4j在系统中运行须事先设定配置文件。配置文件事实上也就是对Logger、Appender及Layout进行相应设定。Log4j支持两种配置文件格式，一种是XML格式的文件，一种是properties属性文件。下面以properties属性文件为例介绍log4j.properties的配置。

1、配置根Logger：
log4j.rootLogger = [ level ] , appenderName1, appenderName2, …
log4j.additivity.org.apache=false：表示Logger不会在父Logger的appender里输出，默认为true。
level ：设定日志记录的最低级别，可设的值有OFF、FATAL、ERROR、WARN、INFO、DEBUG、ALL或者自定义的级别，Log4j建议只使用中间四个级别。通过在这里设定级别，您可以控制应用程序中相应级别的日志信息的开关，比如在这里设定了INFO级别，则应用程序中所有DEBUG级别的日志信息将不会被打印出来。
appenderName：就是指定日志信息要输出到哪里。可以同时指定多个输出目的地，用逗号隔开。
例如：log4j.rootLogger＝INFO,A1,B2,C3

2、配置日志信息输出目的地（appender）：
log4j.appender.appenderName = className
appenderName：自定义appderName，在log4j.rootLogger设置中使用；
className：可设值如下：
(1)org.apache.log4j.ConsoleAppender（控制台）
(2)org.apache.log4j.FileAppender（文件）
(3)org.apache.log4j.DailyRollingFileAppender（每天产生一个日志文件）
(4)org.apache.log4j.RollingFileAppender（文件大小到达指定尺寸的时候产生一个新的文件）
(5)org.apache.log4j.WriterAppender（将日志信息以流格式发送到任意指定的地方）
(1)ConsoleAppender选项：
Threshold=WARN：指定日志信息的最低输出级别，默认为DEBUG。
ImmediateFlush=true：表示所有消息都会被立即输出，设为false则不输出，默认值是true。
Target=System.err：默认值是System.out。
(2)FileAppender选项：
Threshold=WARN：指定日志信息的最低输出级别，默认为DEBUG。
ImmediateFlush=true：表示所有消息都会被立即输出，设为false则不输出，默认值是true。
Append=false：true表示消息增加到指定文件中，false则将消息覆盖指定的文件内容，默认值是true。
File=D:/logs/logging.log4j：指定消息输出到logging.log4j文件中。
(3)DailyRollingFileAppender选项：
Threshold=WARN：指定日志信息的最低输出级别，默认为DEBUG。
ImmediateFlush=true：表示所有消息都会被立即输出，设为false则不输出，默认值是true。
Append=false：true表示消息增加到指定文件中，false则将消息覆盖指定的文件内容，默认值是true。
File=D:/logs/logging.log4j：指定当前消息输出到logging.log4j文件中。
DatePattern='.'yyyy-MM：每月滚动一次日志文件，即每月产生一个新的日志文件。当前月的日志文件名为logging.log4j，前一个月的日志文件名为logging.log4j.yyyy-MM。
另外，也可以指定按周、天、时、分等来滚动日志文件，对应的格式如下：
1)'.'yyyy-MM：每月
2)'.'yyyy-ww：每周
3)'.'yyyy-MM-dd：每天
4)'.'yyyy-MM-dd-a：每天两次
5)'.'yyyy-MM-dd-HH：每小时
6)'.'yyyy-MM-dd-HH-mm：每分钟
(4)RollingFileAppender选项：
Threshold=WARN：指定日志信息的最低输出级别，默认为DEBUG。
ImmediateFlush=true：表示所有消息都会被立即输出，设为false则不输出，默认值是true。
Append=false：true表示消息增加到指定文件中，false则将消息覆盖指定的文件内容，默认值是true。
File=D:/logs/logging.log4j：指定消息输出到logging.log4j文件中。
MaxFileSize=100KB：后缀可以是KB, MB 或者GB。在日志文件到达该大小时，将会自动滚动，即将原来的内容移到logging.log4j.1文件中。
MaxBackupIndex=2：指定可以产生的滚动文件的最大数，例如，设为2则可以产生logging.log4j.1，logging.log4j.2两个滚动文件和一个logging.log4j文件。

3、配置日志信息的输出格式（Layout）：
log4j.appender.appenderName.layout=className
className：可设值如下：
(1)org.apache.log4j.HTMLLayout（以HTML表格形式布局）
(2)org.apache.log4j.PatternLayout（可以灵活地指定布局模式）
(3)org.apache.log4j.SimpleLayout（包含日志信息的级别和信息字符串）
(4)org.apache.log4j.TTCCLayout（包含日志产生的时间、线程、类别等等信息）
(1)HTMLLayout选项：
LocationInfo=true：输出java文件名称和行号，默认值是false。
Title=My Logging：默认值是Log4J Log Messages。
(2)PatternLayout选项：
ConversionPattern=%m%n：设定以怎样的格式显示消息。

格式化符号说明：

%p：输出日志信息的优先级，即DEBUG，INFO，WARN，ERROR，FATAL。
%d：输出日志时间点的日期或时间，默认格式为ISO8601，也可以在其后指定格式，如：%d{yyyy/MM/dd HH:mm:ss,SSS}。
%r：输出自应用程序启动到输出该log信息耗费的毫秒数。
%t：输出产生该日志事件的线程名。
%l：输出日志事件的发生位置，相当于%c.%M(%F:%L)的组合，包括类全名、方法、文件名以及在代码中的行数。例如：test.TestLog4j.main(TestLog4j.java:10)。
%c：输出日志信息所属的类目，通常就是所在类的全名。
%M：输出产生日志信息的方法名。
%F：输出日志消息产生时所在的文件名称。
%L:：输出代码中的行号。
%m:：输出代码中指定的具体日志信息。
%n：输出一个回车换行符，Windows平台为"rn"，Unix平台为"n"。
%x：输出和当前线程相关联的NDC(嵌套诊断环境)，尤其用到像java servlets这样的多客户多线程的应用中。
%%：输出一个"%"字符。
另外，还可以在%与格式字符之间加上修饰符来控制其最小长度、最大长度、和文本的对齐方式。如：
1) c：指定输出category的名称，最小的长度是20，如果category的名称长度小于20的话，默认的情况下右对齐。
2)%-20c："-"号表示左对齐。
3)%.30c：指定输出category的名称，最大的长度是30，如果category的名称长度大于30的话，就会将左边多出的字符截掉，但小于30的话也不会补空格。

附：Log4j比较全面的配置

Log4j配置文件实现了输出到控制台、文件、回滚文件、发送日志邮件、输出到数据库日志表、自定义标签等全套功能。
log4j.rootLogger=DEBUG,console,dailyFile,im
log4j.additivity.org.apache=true
# 控制台(console)
log4j.appender.console=org.apache.log4j.ConsoleAppender
log4j.appender.console.Threshold=DEBUG
log4j.appender.console.ImmediateFlush=true
log4j.appender.console.Target=System.err
log4j.appender.console.layout=org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=[%-5p] %d(%r) --> [%t] %l: %m %x %n

# 日志文件(logFile)
log4j.appender.logFile=org.apache.log4j.FileAppender
log4j.appender.logFile.Threshold=DEBUG
log4j.appender.logFile.ImmediateFlush=true
log4j.appender.logFile.Append=true
log4j.appender.logFile.File=D:/logs/log.log4j
log4j.appender.logFile.layout=org.apache.log4j.PatternLayout
log4j.appender.logFile.layout.ConversionPattern=[%-5p] %d(%r) --> [%t] %l: %m %x %n
# 回滚文件(rollingFile)
log4j.appender.rollingFile=org.apache.log4j.RollingFileAppender
log4j.appender.rollingFile.Threshold=DEBUG
log4j.appender.rollingFile.ImmediateFlush=true
log4j.appender.rollingFile.Append=true
log4j.appender.rollingFile.File=D:/logs/log.log4j
log4j.appender.rollingFile.MaxFileSize=200KB
log4j.appender.rollingFile.MaxBackupIndex=50
log4j.appender.rollingFile.layout=org.apache.log4j.PatternLayout
log4j.appender.rollingFile.layout.ConversionPattern=[%-5p] %d(%r) --> [%t] %l: %m %x %n
# 定期回滚日志文件(dailyFile)
log4j.appender.dailyFile=org.apache.log4j.DailyRollingFileAppender
log4j.appender.dailyFile.Threshold=DEBUG
log4j.appender.dailyFile.ImmediateFlush=true
log4j.appender.dailyFile.Append=true
log4j.appender.dailyFile.File=D:/logs/log.log4j
log4j.appender.dailyFile.DatePattern='.'yyyy-MM-dd
log4j.appender.dailyFile.layout=org.apache.log4j.PatternLayout
log4j.appender.dailyFile.layout.ConversionPattern=[%-5p] %d(%r) --> [%t] %l: %m %x %n
# 应用于socket
log4j.appender.socket=org.apache.log4j.RollingFileAppender
log4j.appender.socket.RemoteHost=localhost
log4j.appender.socket.Port=5001
log4j.appender.socket.LocationInfo=true
# Set up for Log Factor 5
log4j.appender.socket.layout=org.apache.log4j.PatternLayout
log4j.appender.socket.layout.ConversionPattern=[%-5p] %d(%r) --> [%t] %l: %m %x %n
# Log Factor 5 Appender
log4j.appender.LF5_APPENDER=org.apache.log4j.lf5.LF5Appender
log4j.appender.LF5_APPENDER.MaxNumberOfRecords=2000
# 发送日志到指定邮件
log4j.appender.mail=org.apache.log4j.net.SMTPAppender
log4j.appender.mail.Threshold=FATAL
log4j.appender.mail.BufferSize=10
log4j.appender.mail.From = xxx@mail.com
log4j.appender.mail.SMTPHost=mail.com
log4j.appender.mail.Subject=Log4J Message
log4j.appender.mail.To= xxx@mail.com
log4j.appender.mail.layout=org.apache.log4j.PatternLayout
log4j.appender.mail.layout.ConversionPattern=[%-5p] %d(%r) --> [%t] %l: %m %x %n
# 应用于数据库
log4j.appender.database=org.apache.log4j.jdbc.JDBCAppender
log4j.appender.database.URL=jdbc:mysql://localhost:3306/test
log4j.appender.database.driver=com.mysql.jdbc.Driver
log4j.appender.database.user=root
log4j.appender.database.password=
log4j.appender.database.sql=INSERT INTO LOG4J (Message) VALUES('=[%-5p] %d(%r) --> [%t] %l: %m %x %n')
log4j.appender.database.layout=org.apache.log4j.PatternLayout
log4j.appender.database.layout.ConversionPattern=[%-5p] %d(%r) --> [%t] %l: %m %x %n

# 自定义Appender
log4j.appender.im = net.cybercorlin.util.logger.appender.IMAppender
log4j.appender.im.host = mail.cybercorlin.net
log4j.appender.im.username = username
log4j.appender.im.password = password
log4j.appender.im.recipient = corlin@cybercorlin.net
log4j.appender.im.layout=org.apache.log4j.PatternLayout
log4j.appender.im.layout.ConversionPattern=[%-5p] %d(%r) --> [%t] %l: %m %x %n

log4j的强大功能无可置疑，但实际应用中免不了遇到某个功能需要输出独立的日志文件的情况，怎样才能把所需的内容从原有日志中分离，形成单独的日志文件呢？其实只要在现有的log4j基础上稍加配置即可轻松实现这一功能。

　　先看一个常见的log4j.properties文件，它是在控制台和myweb.log文件中记录日志：

log4j.rootLogger=DEBUG, stdout, logfile

log4j.category.org.springframework=ERROR

log4j.category.org.apache=INFO

log4j.appender.stdout=org.apache.log4j.ConsoleAppender

log4j.appender.stdout.layout=org.apache.log4j.PatternLayout

log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - %m%n

log4j.appender.logfile=org.apache.log4j.RollingFileAppender

log4j.appender.logfile.File=${myweb.root}/WEB-INF/log/myweb.log

log4j.appender.logfile.MaxFileSize=512KB

log4j.appender.logfile.MaxBackupIndex=5

log4j.appender.logfile.layout=org.apache.log4j.PatternLayout

log4j.appender.logfile.layout.ConversionPattern=%d %p [%c] - %m%n

如果想对不同的类输出不同的文件(以cn.com.Test为例)，先要在Test.java中定义:

private static Log logger = LogFactory.getLog(Test.class);

　　然后在log4j.properties中加入:

log4j.logger.cn.com.Test= DEBUG, test

log4j.appender.test=org.apache.log4j.FileAppender

log4j.appender.test.File=${myweb.root}/WEB-INF/log/test.log

log4j.appender.test.layout=org.apache.log4j.PatternLayout

log4j.appender.test.layout.ConversionPattern=%d %p [%c] - %m%n

　　也就是让cn.com.Test中的logger使用log4j.appender.test所做的配置。

　　但是，如果在同一类中需要输出多个日志文件呢？其实道理是一样的，先在Test.java中定义:

private static Log logger1 = LogFactory.getLog("myTest1");

private static Log logger2 = LogFactory.getLog("myTest2");

　　然后在log4j.properties中加入:

log4j.logger.myTest1= DEBUG, test1

log4j.appender.test1=org.apache.log4j.FileAppender

log4j.appender.test1.File=${myweb.root}/WEB-INF/log/test1.log

log4j.appender.test1.layout=org.apache.log4j.PatternLayout

log4j.appender.test1.layout.ConversionPattern=%d %p [%c] - %m%n

log4j.logger.myTest2= DEBUG, test2

log4j.appender.test2=org.apache.log4j.FileAppender

log4j.appender.test2.File=${myweb.root}/WEB-INF/log/test2.log

log4j.appender.test2.layout=org.apache.log4j.PatternLayout

log4j.appender.test2.layout.ConversionPattern=%d %p [%c] - %m%n

　　也就是在用logger时给它一个自定义的名字(如这里的"myTest1")，然后在log4j.properties中做出相应配置即可。别忘了不同日志要使用不同的logger(如输出到test1.log的要用logger1.info("abc"))。

　　还有一个问题，就是这些自定义的日志默认是同时输出到log4j.rootLogger所配置的日志中的，如何能只让它们输出到自己指定的日志中呢？别急，这里有个开关：

log4j.additivity.myTest1 = false

　　它用来设置是否同时输出到log4j.rootLogger所配置的日志中，设为false就不会输出到其它地方啦！注意这里的"myTest1"是你在程序中给logger起的那个自定义的名字！

如果你说，我只是不想同时输出这个日志到log4j.rootLogger所配置的logfile中，stdout里我还想同时输出呢！那也好办，把你的log4j.logger.myTest1 = DEBUG, test1改为下式就OK啦！

log4j.logger.myTest1=DEBUG, test1

参考：
http://www.cnblogs.com/ITEagle/archive/2010/04/23/1718365.html

zhb8015 2012-07-09 16:57 发表评论

log4j详解

zhb8015 — Mon, 02 Jul 2012 09:32:00 GMT

Log4J的配置文件(Configuration File)就是用来设置记录器的级别、存放器和布局的，它可接key=value格式的设置或xml格式的设置信息。通过配置，可以创建出Log4J的运行环境。

1. 配置文件
Log4J配置文件的基本格式如下：

#配置根Logger
log4j.rootLogger = [ level ] , appenderName1 , appenderName2 , …

#配置日志信息输出目的地Appender
log4j.appender.appenderName = fully.qualified.name.of.appender.class
　　log4j.appender.appenderName.option1 = value1
　　…
　　log4j.appender.appenderName.optionN = valueN

#配置日志信息的格式（布局）
log4j.appender.appenderName.layout = fully.qualified.name.of.layout.class
　　log4j.appender.appenderName.layout.option1 = value1
　　…
　　log4j.appender.appenderName.layout.optionN = valueN

其中 [level] 是日志输出级别，共有5级：

FATAL       0
ERROR      3
WARN       4
INFO         6
DEBUG      7

Appender 为日志输出目的地，Log4j提供的appender有以下几种：

org.apache.log4j.ConsoleAppender（控制台），
org.apache.log4j.FileAppender（文件），
org.apache.log4j.DailyRollingFileAppender（每天产生一个日志文件），
org.apache.log4j.RollingFileAppender（文件大小到达指定尺寸的时候产生一个新的文件），
org.apache.log4j.WriterAppender（将日志信息以流格式发送到任意指定的地方）

Layout：日志输出格式，Log4j提供的layout有以下几种：

org.apache.log4j.HTMLLayout（以HTML表格形式布局），
org.apache.log4j.PatternLayout（可以灵活地指定布局模式），
org.apache.log4j.SimpleLayout（包含日志信息的级别和信息字符串），
org.apache.log4j.TTCCLayout（包含日志产生的时间、线程、类别等等信息）

打印参数: Log4J采用类似C语言中的printf函数的打印格式格式化日志信息，如下:

　 %m   输出代码中指定的消息
　　%p   输出优先级，即DEBUG，INFO，WARN，ERROR，FATAL
　　%r   输出自应用启动到输出该log信息耗费的毫秒数
　　%c   输出所属的类目，通常就是所在类的全名
　　%t   输出产生该日志事件的线程名
　　%n   输出一个回车换行符，Windows平台为“\r\n”，Unix平台为“\n”
　　%d   输出日志时间点的日期或时间，默认格式为ISO8601，也可以在其后指定格式，比如：%d{yyy MMM dd HH:mm:ss , SSS}，输出类似：2002年10月18日 22 ： 10 ： 28 ， 921
　　%l   输出日志事件的发生位置，包括类目名、发生的线程，以及在代码中的行数。举例：Testlog4.main(TestLog4.java: 10 )

2. 在代码中初始化Logger:
1）在程序中调用BasicConfigurator.configure()方法：给根记录器增加一个ConsoleAppender，输出格式通过PatternLayout设为"%-4r [%t] %-5p %c %x - %m%n"，还有根记录器的默认级别是Level.DEBUG.
2）配置放在文件里，通过命令行参数传递文件名字，通过PropertyConfigurator.configure(args[x])解析并配置；
3）配置放在文件里，通过环境变量传递文件名等信息，利用log4j默认的初始化过程解析并配置；
4）配置放在文件里，通过应用服务器配置传递文件名等信息，利用一个特殊的servlet来完成配置。

3. 为不同的 Appender 设置日志输出级别：
当调试系统时，我们往往注意的只是异常级别的日志输出，但是通常所有级别的输出都是放在一个文件里的，如果日志输出的级别是BUG！？那就慢慢去找吧。
这时我们也许会想要是能把异常信息单独输出到一个文件里该多好啊。当然可以，Log4j已经提供了这样的功能，我们只需要在配置中修改Appender的Threshold 就能实现,比如下面的例子：

[配置文件]

### set log levels ###
log4j.rootLogger = debug , stdout , D , E

### 输出到控制台 ###
log4j.appender.stdout = org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target = System.out
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern = %d{ABSOLUTE} %5p %c{ 1 }:%L - %m%n

### 输出到日志文件 ###
log4j.appender.D = org.apache.log4j.DailyRollingFileAppender
log4j.appender.D.File = logs/log.log
log4j.appender.D.Append = true
log4j.appender.D.Threshold = DEBUG ## 输出DEBUG级别以上的日志
log4j.appender.D.layout = org.apache.log4j.PatternLayout
log4j.appender.D.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss} [ %t:%r ] - [ %p ] %m%n

### 保存异常信息到单独文件 ###
log4j.appender.D = org.apache.log4j.DailyRollingFileAppender
log4j.appender.D.File = logs/error.log ## 异常日志文件名
log4j.appender.D.Append = true
log4j.appender.D.Threshold = ERROR ## 只输出ERROR级别以上的日志!!!
log4j.appender.D.layout = org.apache.log4j.PatternLayout
log4j.appender.D.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss} [ %t:%r ] - [ %p ] %m%n

[代码中使用]

public class TestLog4j {
     public static void main(String[] args) {
        PropertyConfigurator.configure( " D:/Code/conf/log4j.properties " );
        Logger logger = Logger.getLogger(TestLog4j. class );
        logger.debug( " debug " );
        logger.error( " error " );
    }
}

运行一下，看看异常信息是不是保存在了一个单独的文件error.log中

log4j.properties 使用
一.参数意义说明
输出级别的种类
ERROR、WARN、INFO、DEBUG
ERROR 为严重错误主要是程序的错误
WARN 为一般警告，比如session丢失
INFO 为一般要显示的信息，比如登录登出
DEBUG 为程序的调试信息
配置日志信息输出目的地
log4j.appender.appenderName = fully.qualified.name.of.appender.class
1.org.apache.log4j.ConsoleAppender（控制台）
2.org.apache.log4j.FileAppender（文件）
3.org.apache.log4j.DailyRollingFileAppender（每天产生一个日志文件）
4.org.apache.log4j.RollingFileAppender（文件大小到达指定尺寸的时候产生一个新的文件）
5.org.apache.log4j.WriterAppender（将日志信息以流格式发送到任意指定的地方）
配置日志信息的格式
log4j.appender.appenderName.layout = fully.qualified.name.of.layout.class
1.org.apache.log4j.HTMLLayout（以HTML表格形式布局），
2.org.apache.log4j.PatternLayout（可以灵活地指定布局模式），
3.org.apache.log4j.SimpleLayout（包含日志信息的级别和信息字符串），
4.org.apache.log4j.TTCCLayout（包含日志产生的时间、线程、类别等等信息）
控制台选项
Threshold=DEBUG:指定日志消息的输出最低层次。
ImmediateFlush=true:默认值是true,意谓着所有的消息都会被立即输出。
Target=System.err：默认情况下是：System.out,指定输出控制台
FileAppender 选项
Threshold=DEBUF:指定日志消息的输出最低层次。
ImmediateFlush=true:默认值是true,意谓着所有的消息都会被立即输出。
File=mylog.txt:指定消息输出到mylog.txt文件。
Append=false:默认值是true,即将消息增加到指定文件中，false指将消息覆盖指定的文件内容。
RollingFileAppender 选项
Threshold=DEBUG:指定日志消息的输出最低层次。
ImmediateFlush=true:默认值是true,意谓着所有的消息都会被立即输出。
File=mylog.txt:指定消息输出到mylog.txt文件。
Append=false:默认值是true,即将消息增加到指定文件中，false指将消息覆盖指定的文件内容。
MaxFileSize=100KB: 后缀可以是KB, MB 或者是 GB. 在日志文件到达该大小时，将会自动滚动，即将原来的内容移到mylog.log.1文件。
MaxBackupIndex=2:指定可以产生的滚动文件的最大数。
log4j.appender.A1.layout.ConversionPattern=%-4r %-5p %d{yyyy-MM-dd HH:mm:ssS} %c %m%n
日志信息格式中几个符号所代表的含义：
-X号: X信息输出时左对齐；
%p: 输出日志信息优先级，即DEBUG，INFO，WARN，ERROR，FATAL,
%d: 输出日志时间点的日期或时间，默认格式为ISO8601，也可以在其后指定格式，比如：%d{yyy MMM dd HH:mm:ss,SSS}，输出类似：2002年10月18日 22：10：28，921
%r: 输出自应用启动到输出该log信息耗费的毫秒数
%c: 输出日志信息所属的类目，通常就是所在类的全名
%t: 输出产生该日志事件的线程名
%l: 输出日志事件的发生位置，相当于%C.%M(%F:%L)的组合,包括类目名、发生的线程，以及在代码中的行数。举例：Testlog4.main (TestLog4.java:10)
%x: 输出和当前线程相关联的NDC(嵌套诊断环境),尤其用到像java servlets这样的多客户多线程的应用中。
%%: 输出一个"%"字符
%F: 输出日志消息产生时所在的文件名称
%L: 输出代码中的行号
%m: 输出代码中指定的消息,产生的日志具体信息
%n: 输出一个回车换行符，Windows平台为"\r\n"，Unix平台为"\n"输出日志信息换行
可以在%与模式字符之间加上修饰符来控制其最小宽度、最大宽度、和文本的对齐方式。如：
1)%20c：指定输出category的名称，最小的宽度是20，如果category的名称小于20的话，默认的情况下右对齐。
2)%-20c:指定输出category的名称，最小的宽度是20，如果category的名称小于20的话，"-"号指定左对齐。
3)%.30c:指定输出category的名称，最大的宽度是30，如果category的名称大于30的话，就会将左边多出的字符截掉，但小于30的话也不会有空格。
4)%20.30c:如果category的名称小于20就补空格，并且右对齐，如果其名称长于30字符，就从左边较远输出的字符截掉。
二.文件配置Sample1
log4j.rootLogger=DEBUG,A1,R
#log4j.rootLogger=INFO,A1,R
# ConsoleAppender 输出
log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=%-d{yyyy-MM-dd HH:mm:ss,SSS} [%c]-[%p] %m%n
# File 输出一天一个文件,输出路径可以定制,一般在根路径下
log4j.appender.R=org.apache.log4j.DailyRollingFileAppender
log4j.appender.R.File=blog_log.txt
log4j.appender.R.MaxFileSize=500KB
log4j.appender.R.MaxBackupIndex=10
log4j.appender.R.layout=org.apache.log4j.PatternLayout
log4j.appender.R.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss,SSS} [%t] [%c] [%p] - %m%n
文件配置Sample2
下面给出的Log4J配置文件实现了输出到控制台，文件，回滚文件，发送日志邮件，输出到数据库日志表，自定义标签等全套功能。
log4j.rootLogger=DEBUG,CONSOLE,A1,im
#DEBUG,CONSOLE,FILE,ROLLING_FILE,MAIL,DATABASE
log4j.addivity.org.apache=true
###################
# Console Appender
###################
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.Threshold=DEBUG
log4j.appender.CONSOLE.Target=System.out
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n
#log4j.appender.CONSOLE.layout.ConversionPattern=[start]%d{DATE}[DATE]%n%p[PRIORITY]%n%x[NDC]%n%t[THREAD] n%c[CATEGORY]%n%m[MESSAGE]%n%n
#####################
# File Appender
#####################
log4j.appender.FILE=org.apache.log4j.FileAppender
log4j.appender.FILE.File=file.log
log4j.appender.FILE.Append=false
log4j.appender.FILE.layout=org.apache.log4j.PatternLayout
log4j.appender.FILE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n
# Use this layout for LogFactor 5 analysis
########################
# Rolling File
########################
log4j.appender.ROLLING_FILE=org.apache.log4j.RollingFileAppender
log4j.appender.ROLLING_FILE.Threshold=ERROR
log4j.appender.ROLLING_FILE.File=rolling.log
log4j.appender.ROLLING_FILE.Append=true
log4j.appender.ROLLING_FILE.MaxFileSize=10KB
log4j.appender.ROLLING_FILE.MaxBackupIndex=1
log4j.appender.ROLLING_FILE.layout=org.apache.log4j.PatternLayout
log4j.appender.ROLLING_FILE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n
####################
# Socket Appender
####################
log4j.appender.SOCKET=org.apache.log4j.RollingFileAppender
log4j.appender.SOCKET.RemoteHost=localhost
log4j.appender.SOCKET.Port=5001
log4j.appender.SOCKET.LocationInfo=true
# Set up for Log Facter 5
log4j.appender.SOCKET.layout=org.apache.log4j.PatternLayout
log4j.appender.SOCET.layout.ConversionPattern=[start]%d{DATE}[DATE]%n%p[PRIORITY]%n%x[NDC]%n%t[THREAD]%n%c[CATEGORY]%n%m[MESSAGE]%n%n
########################
# Log Factor 5 Appender
########################
log4j.appender.LF5_APPENDER=org.apache.log4j.lf5.LF5Appender
log4j.appender.LF5_APPENDER.MaxNumberOfRecords=2000
########################
# SMTP Appender
#######################
log4j.appender.MAIL=org.apache.log4j.net.SMTPAppender
log4j.appender.MAIL.Threshold=FATAL
log4j.appender.MAIL.BufferSize=10
log4j.appender.MAIL.From=chenyl@yeqiangwei.com
log4j.appender.MAIL.SMTPHost=mail.hollycrm.com
log4j.appender.MAIL.Subject=Log4J Message
log4j.appender.MAIL.To=chenyl@yeqiangwei.com
log4j.appender.MAIL.layout=org.apache.log4j.PatternLayout
log4j.appender.MAIL.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n
########################
# JDBC Appender
#######################
log4j.appender.DATABASE=org.apache.log4j.jdbc.JDBCAppender
log4j.appender.DATABASE.URL=jdbc:mysql://localhost:3306/test
log4j.appender.DATABASE.driver=com.mysql.jdbc.Driver
log4j.appender.DATABASE.user=root
log4j.appender.DATABASE.password=
log4j.appender.DATABASE.sql=INSERT INTO LOG4J (Message) VALUES ('[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n')
log4j.appender.DATABASE.layout=org.apache.log4j.PatternLayout
log4j.appender.DATABASE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n
log4j.appender.A1=org.apache.log4j.DailyRollingFileAppender
log4j.appender.A1.File=SampleMessages.log4j
log4j.appender.A1.DatePattern=yyyyMMdd-HH'.log4j'
log4j.appender.A1.layout=org.apache.log4j.xml.XMLLayout
###################
#自定义Appender
###################
log4j.appender.im = net.cybercorlin.util.logger.appender.IMAppender
log4j.appender.im.host = mail.cybercorlin.net
log4j.appender.im.username = username
log4j.appender.im.password = password
log4j.appender.im.recipient = corlin@yeqiangwei.com
log4j.appender.im.layout=org.apache.log4j.PatternLayout
log4j.appender.im.layout.ConversionPattern =[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n
三.高级使用
实验目的：
1.把FATAL级错误写入2000NT日志
2. WARN，ERROR，FATAL级错误发送email通知管理员
3.其他级别的错误直接在后台输出
实验步骤：
输出到2000NT日志
1.把Log4j压缩包里的NTEventLogAppender.dll拷到WINNT\SYSTEM32目录下
2.写配置文件log4j.properties
# 在2000系统日志输出
log4j.logger.NTlog=FATAL, A8
# APPENDER A8
log4j.appender.A8=org.apache.log4j.nt.NTEventLogAppender
log4j.appender.A8.Source=JavaTest
log4j.appender.A8.layout=org.apache.log4j.PatternLayout
log4j.appender.A8.layout.ConversionPattern=%-4r %-5p [%t] %37c %3x - %m%n
3.调用代码：
Logger logger2 = Logger.getLogger("NTlog"); //要和配置文件中设置的名字相同
logger2.debug("debug!!!");
logger2.info("info!!!");
logger2.warn("warn!!!");
logger2.error("error!!!");
//只有这个错误才会写入2000日志
logger2.fatal("fatal!!!");
发送email通知管理员：
1. 首先下载JavaMail和JAF,
http://java.sun.com/j2ee/ja/javamail/index.html
http://java.sun.com/beans/glasgow/jaf.html
在项目中引用mail.jar和activation.jar。
2. 写配置文件
# 将日志发送到email
log4j.logger.MailLog=WARN,A5
# APPENDER A5
log4j.appender.A5=org.apache.log4j.net.SMTPAppender
log4j.appender.A5.BufferSize=5
log4j.appender.A5.To=chunjie@yeqiangwei.com
log4j.appender.A5.From=error@yeqiangwei.com
log4j.appender.A5.Subject=ErrorLog
log4j.appender.A5.SMTPHost=smtp.263.net
log4j.appender.A5.layout=org.apache.log4j.PatternLayout
log4j.appender.A5.layout.ConversionPattern=%-4r %-5p [%t] %37c %3x - %m%n
3.调用代码：
//把日志发送到mail
Logger logger3 = Logger.getLogger("MailLog");
logger3.warn("warn!!!");
logger3.error("error!!!");
logger3.fatal("fatal!!!");
在后台输出所有类别的错误：
1. 写配置文件
# 在后台输出
log4j.logger.console=DEBUG, A1
# APPENDER A1
log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=%-4r %-5p [%t] %37c %3x - %m%n
2．调用代码
Logger logger1 = Logger.getLogger("console");
logger1.debug("debug!!!");
logger1.info("info!!!");
logger1.warn("warn!!!");
logger1.error("error!!!");
logger1.fatal("fatal!!!");
--------------------------------------------------------------------
全部配置文件：log4j.properties
# 在后台输出
log4j.logger.console=DEBUG, A1
# APPENDER A1
log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=%-4r %-5p [%t] %37c %3x - %m%n
# 在2000系统日志输出
log4j.logger.NTlog=FATAL, A8
# APPENDER A8
log4j.appender.A8=org.apache.log4j.nt.NTEventLogAppender
log4j.appender.A8.Source=JavaTest
log4j.appender.A8.layout=org.apache.log4j.PatternLayout
log4j.appender.A8.layout.ConversionPattern=%-4r %-5p [%t] %37c %3x - %m%n
# 将日志发送到email
log4j.logger.MailLog=WARN,A5
# APPENDER A5
log4j.appender.A5=org.apache.log4j.net.SMTPAppender
log4j.appender.A5.BufferSize=5
log4j.appender.A5.To=chunjie@yeqiangwei.com
log4j.appender.A5.From=error@yeqiangwei.com
log4j.appender.A5.Subject=ErrorLog
log4j.appender.A5.SMTPHost=smtp.263.net
log4j.appender.A5.layout=org.apache.log4j.PatternLayout
log4j.appender.A5.layout.ConversionPattern=%-4r %-5p [%t] %37c %3x - %m%n
全部代码：Log4jTest.java

/*
* 创建日期 2003-11-13
*/
package edu.bcu.Bean;
import org.apache.log4j.*;
//import org.apache.log4j.nt.*;
//import org.apache.log4j.net.*;
/**
* @author yanxu
*/
public class Log4jTest
{
public static void main(String args[])
{
   PropertyConfigurator.configure("log4j.properties");
   //在后台输出
   Logger logger1 = Logger.getLogger("console");
   logger1.debug("debug!!!");
   logger1.info("info!!!");
   logger1.warn("warn!!!");
   logger1.error("error!!!");
   logger1.fatal("fatal!!!");
//在NT系统日志输出
   Logger logger2 = Logger.getLogger("NTlog");
   //NTEventLogAppender nla = new NTEventLogAppender();
   logger2.debug("debug!!!");
   logger2.info("info!!!");
   logger2.warn("warn!!!");
   logger2.error("error!!!");
   //只有这个错误才会写入2000日志
   logger2.fatal("fatal!!!");
//把日志发送到mail
   Logger logger3 = Logger.getLogger("MailLog");
   //SMTPAppender sa = new SMTPAppender();
   logger3.warn("warn!!!");
   logger3.error("error!!!");
   logger3.fatal("fatal!!!");
}
}

zhb8015 2012-07-02 17:32 发表评论

时间复杂度

zhb8015 — Mon, 18 Jun 2012 10:25:00 GMT

同一问题可用不同算法解决，而一个算法的质量优劣将影响到算法乃至程序的效率。算法分析的目的在于选择合适算法和改进算法。

算法复杂度

时间复杂度

空间复杂度

展开

编辑本段 算法复杂度

　　算法复杂度分为时间复杂度和空间复杂度。其作用：时间复杂度是度量算法执行的时间长短；而空间复杂度是度量算法所需存储空间的大小。

编辑本段 时间复杂度

1.时间频度

　　一个算法执行所耗费的时间，从理论上是不能算出来的，必须上机运行测试才能知道。但我们不可能也没有必要对每个算法都上机测试，只需知道哪个算法花费的时间多，哪个算法花费的时间少就可以了。并且一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。一个算法中的语句执行次数称为语句频度或时间频度。记为T(n)。

2.计算方法

　　1. 一般情况下，算法的基本操作重复执行的次数是模块n的某一个函数f（n），因此，算法的时间复杂度记做：T（n）=O（f（n））　　分析：随着模块n的增大，算法执行的时间的增长率和f（n）的增长率成正比，所以f（n）越小，算法的时间复杂度越低，算法的效率越高。　　2. 在计算时间复杂度的时候，先找出算法的基本操作，然后根据相应的各语句确定它的执行次数，再找出T（n）的同数量级（它的同数量级有以下：1，Log2n ，n ，nLog2n ，n的平方，n的三次方，2的n次方，n！），找出后，f（n）=该数量级，若T(n)/f(n)求极限可得到一常数c，则时间复杂度 T（n）=O（f（n））　　例：算法：　　for（i=1;i<=n;++i）　　{ 　　for(j=1;j<=n;++j) 　　{ 　　c[ i ][ j ]=0; //该步骤属于基本操作执行次数：n的平方次　　for(k=1;k<=n;++k) 　　c[ i ][ j ]+=a[ i ][ k ]*b[ k ][ j ]; //该步骤属于基本操作执行次数：n的三次方次　　} 　　} 　　则有 T（n）= n的平方+n的三次方，根据上面括号里的同数量级，我们可以确定 n的三次方为T（n）的同数量级　　则有f（n）= n的三次方，然后根据T（n）/f（n）求极限可得到常数c 　　则该算法的时间复杂度：T（n）=O（n^3）注：n^3即是n的3次方。

3.分类

　　按数量级递增排列，常见的时间复杂度有：　　常数阶O(1),对数阶O(log2n),线性阶O(n), 　　线性对数阶O(nlog2n),平方阶O(n^2)，立方阶O(n^3),...，　　k次方阶O(n^k), 指数阶O(2n) 。随着问题规模n的不断增大，上述时间复杂度不断增大，算法的执行效率越低。

编辑本段 空间复杂度

　　一个程序的空间复杂度是指运行完一个程序所需内存的大小。利用程序的空间复杂度，可以对程序的运行所需要的内存多少有个预先估计。一个程序执行时除了需要存储空间和存储本身所使用的指令、常数、变量和输入数据外，还需要一些对数据进行操作的工作单元和存储一些为现实计算所需信息的辅助空间。程序执行时所需存储空间包括以下两部分。　　（1）固定部分。这部分空间的大小与输入/输出的数据的个数多少、数值无关。主要包括指令空间（即代码空间）、数据空间（常量、简单变量）等所占的空间。这部分属于静态空间。　　（2）可变空间，这部分空间的主要包括动态分配的空间，以及递归栈所需的空间等。这部分的空间大小与算法有关。　　一个算法所需的存储空间用f(n)表示。　　S(n)=O(f(n)) 　　其中n为问题的规模，S(n)表示空间复杂度。

zhb8015 2012-06-18 18:25 发表评论

Java栈与堆（转）

zhb8015 — Wed, 13 Jun 2012 09:27:00 GMT

摘自 chenghai2011的专栏

-------------------------------------------------------------------------------------------------------------------

Java栈与堆

1. 栈(stack)与堆(heap)都是Java用来在Ram中存放数据的地方。与C++不同，Java自动管理栈和堆，程序员不能直接地设置栈或堆。

2. 栈的优势是，存取速度比堆要快，仅次于直接位于CPU中的寄存器。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。另外，栈数据可以共享，详见第3点。堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是，由于要在运行时动态分配内存，存取速度较慢。

3. Java中的数据类型有两种。

一种是基本类型(primitive types), 共有8种，即int, short, long, byte, float, double, boolean, char(注意，并没有string的基本类型)。这种类型的定义是通过诸如int a = 3; long b = 255L;的形式来定义的，称为自动变量。值得注意的是，自动变量存的是字面值，不是类的实例，即不是类的引用，这里并没有类的存在。如int a = 3; 这里的a是一个指向int类型的引用，指向3这个字面值。这些字面值的数据，由于大小可知，生存期可知(这些字面值固定定义在某个程序块里面，程序块退出后，字段值就消失了)，出于追求速度的原因，就存在于栈中。

另外，栈有一个很重要的特殊性，就是存在栈中的数据可以共享。假设我们同时定义：
复制内容到剪贴板代码:
int a = 3;
int b = 3；
编译器先处理int a = 3；首先它会在栈中创建一个变量为a的引用，然后查找有没有字面值为3的地址，没找到，就开辟一个存放3这个字面值的地址，然后将a指向3的地址。接着处理int b = 3；在创建完b的引用变量后，由于在栈中已经有3这个字面值，便将b直接指向3的地址。这样，就出现了a与b同时均指向3的情况。

特别注意的是，这种字面值的引用与类对象的引用不同。假定两个类对象的引用同时指向一个对象，如果一个对象引用变量修改了这个对象的内部状态，那么另一个对象引用变量也即刻反映出这个变化。相反，通过字面值的引用来修改其值，不会导致另一个指向此字面值的引用的值也跟着改变的情况。如上例，我们定义完a与b的值后，再令a=4；那么，b不会等于4，还是等于3。在编译器内部，遇到a=4；时，它就会重新搜索栈中是否有4的字面值，如果没有，重新开辟地址存放4的值；如果已经有了，则直接将a指向这个地址。因此a值的改变不会影响到b的值。

另一种是包装类数据，如Integer, String, Double等将相应的基本数据类型包装起来的类。这些类数据全部存在于堆中，Java用new()语句来显示地告诉编译器，在运行时才根据需要动态创建，因此比较灵活，但缺点是要占用更多的时间。 4. String是一个特殊的包装类数据。即可以用String str = new String("abc");的形式来创建，也可以用String str = "abc"；的形式来创建(作为对比，在JDK 5.0之前，你从未见过Integer i = 3;的表达式，因为类与字面值是不能通用的，除了String。而在JDK 5.0中，这种表达式是可以的！因为编译器在后台进行Integer i = new Integer(3)的转换)。前者是规范的类的创建过程，即在Java中，一切都是对象，而对象是类的实例，全部通过new()的形式来创建。Java 中的有些类，如DateFormat类，可以通过该类的getInstance()方法来返回一个新创建的类，似乎违反了此原则。其实不然。该类运用了单例模式来返回类的实例，只不过这个实例是在该类内部通过new()来创建的，而getInstance()向外部隐藏了此细节。那为什么在String str = "abc"；中，并没有通过new()来创建实例，是不是违反了上述原则？其实没有。

5. 关于String str = "abc"的内部工作。Java内部将此语句转化为以下几个步骤：

(1)先定义一个名为str的对String类的对象引用变量：String str；

(2)在栈中查找有没有存放值为"abc"的地址，如果没有，则开辟一个存放字面值为"abc"的地址，接着创建一个新的String类的对象o，并将o的字符串值指向这个地址，而且在栈中这个地址旁边记下这个引用的对象o。如果已经有了值为"abc"的地址，则查找对象o，并返回o的地址。

(3)将str指向对象o的地址。

值得注意的是，一般String类中字符串值都是直接存值的。但像String str = "abc"；这种场合下，其字符串值却是保存了一个指向存在栈中数据的引用！

为了更好地说明这个问题，我们可以通过以下的几个代码进行验证。
复制内容到剪贴板代码:
String str1 = "abc";
String str2 = "abc";
System.out.println(str1==str2); //true
注意，我们这里并不用str1.equals(str2)；的方式，因为这将比较两个字符串的值是否相等。==号，根据JDK的说明，只有在两个引用都指向了同一个对象时才返回真值。而我们在这里要看的是，str1与str2是否都指向了同一个对象。
结果说明，JVM创建了两个引用str1和str2，但只创建了一个对象，而且两个引用都指向了这个对象。

我们再来更进一步，将以上代码改成：
复制内容到剪贴板代码:
String str1 = "abc";
String str2 = "abc";
str1 = "bcd";
System.out.println(str1 + "," + str2); //bcd, abc
System.out.println(str1==str2); //false
这就是说，赋值的变化导致了类对象引用的变化，str1指向了另外一个新对象！而str2仍旧指向原来的对象。上例中，当我们将str1的值改为"bcd"时，JVM发现在栈中没有存放该值的地址，便开辟了这个地址，并创建了一个新的对象，其字符串的值指向这个地址。

事实上，String类被设计成为不可改变(immutable)的类。如果你要改变其值，可以，但JVM在运行时根据新值悄悄创建了一个新对象，然后将这个对象的地址返回给原来类的引用。这个创建过程虽说是完全自动进行的，但它毕竟占用了更多的时间。在对时间要求比较敏感的环境中，会带有一定的不良影响。

再修改原来代码：
复制内容到剪贴板代码:
String str1 = "abc";
String str2 = "abc";

str1 = "bcd";

String str3 = str1;
System.out.println(str3); //bcd

String str4 = "bcd";
System.out.println(str1 == str4); //true
str3这个对象的引用直接指向str1所指向的对象(注意，str3并没有创建新对象)。当str1改完其值后，再创建一个String的引用str4，并指向因str1修改值而创建的新的对象。可以发现，这回str4也没有创建新的对象，从而再次实现栈中数据的共享。

我们再接着看以下的代码。
复制内容到剪贴板代码:
String str1 = new String("abc");
String str2 = "abc";
System.out.println(str1==str2); //false 创建了两个引用。创建了两个对象。两个引用分别指向不同的两个对象。

String str1 = "abc";
String str2 = new String("abc");
System.out.println(str1==str2); //false
创建了两个引用。创建了两个对象。两个引用分别指向不同的两个对象。

以上两段代码说明，只要是用new()来新建对象的，都会在堆中创建，而且其字符串是单独存值的，即使与栈中的数据相同，也不会与栈中的数据共享。

6. 数据类型包装类的值不可修改。不仅仅是String类的值不可修改，所有的数据类型包装类都不能更改其内部的值。

7. 结论与建议：

(1)我们在使用诸如String str = "abc"；的格式定义类时，总是想当然地认为，我们创建了String类的对象str。担心陷阱！对象可能并没有被创建！唯一可以肯定的是，指向 String类的引用被创建了。至于这个引用到底是否指向了一个新的对象，必须根据上下文来考虑，除非你通过new()方法来显要地创建一个新的对象。因此，更为准确的说法是，我们创建了一个指向String类的对象的引用变量str，这个对象引用变量指向了某个值为"abc"的String类。清醒地认识到这一点对排除程序中难以发现的bug是很有帮助的。

(2)使用String str = "abc"；的方式，可以在一定程度上提高程序的运行速度，因为JVM会自动根据栈中数据的实际情况来决定是否有必要创建新对象。而对于String str = new String("abc")；的代码，则一概在堆中创建新对象，而不管其字符串值是否相等，是否有必要创建新对象，从而加重了程序的负担。这个思想应该是享元模式的思想，但JDK的内部在这里实现是否应用了这个模式，不得而知。

(3)当比较包装类里面的数值是否相等时，用equals()方法；当测试两个包装类的引用是否指向同一个对象时，用==。

(4)由于String类的immutable性质，当String变量需要经常变换其值时，应该考虑使用StringBuffer类，以提高程序效率。

zhb8015 2012-06-13 17:27 发表评论

也说Java循环优化(转)

zhb8015 — Tue, 12 Jun 2012 09:47:00 GMT

http://hi.baidu.com/freish/blog/item/b793042433594a3fd40742bf.html

近有不少人提出Java循环优化问题，问题分为两类：

1）

for(int i=0; i<10000; i--){。。。}

与

for(int i = 100000; i > 0; i--){。。。}

这个比较无非是i++和i—的比较。

2）

for(int i=0; i<1000; i++) {

for(int j=0; j<100000; j++) {

。。。

}

与

for (int i = 0; i < 100000; i++) {

for (int j = 0; j < 1000; j++) {

。。。

}

这个比较主要问题在于循环次数多的放在里面还是外面的问题。

我的观点：首先，这种代码上自以为是的优化是没有意义的；其次，拿C语言的思维来考虑这个问题表示Java基本常识都不懂。

分析：

在具体阐明我的观点前有必要做一点Java常识的普及。（注，若没有特别说明，文中sun的指的是被Oracle收购的那个sun，也用来表示Oracle接手的sun公司的一些产品，如sun的jvm，既指Oracle接手sun后的虚拟机，也指未收购时的sun的虚拟机）

1） jvm。

众所周知，这是java虚拟机。但是，很多人，包括初学者甚至一些工作了的人，对jvm的认识仅仅是sun的hotspot虚拟机，就是从sun官网上下载的那个。

而实际上，sun公司制定的是一个规范，即Java虚拟机规范，搜索jvmspec即可得。同时sun也提供了该规范的一个标准实现，就是sun的hotspot虚拟机（N年前的版本就不说了）。但很多人不知道的是，除了sun实现了虚拟机外，还有很多公司也根据自己的需要实现了Java虚拟机，比较常见的有IBM的J9（Websphere中用的），Oracle的JRockit（Weblogic中用的），Apache的Harmony（由于利益等原因，sun和Oracle都没有给它提供兼容性测试），还有openJDK。这些都是比较流行的。诸如此类，还有很多很多。

2） Java指令集

jvm规范中，为Java定义了一套指令集。如iadd，iinc等，指令集用单字节表示，也就是说不超过255个。

关于规范中jvm指令集最需要注意的一点是：指令集指描述了指令该做什么事情，对于如何去做，是留给jvm实现者自己去思考的，所以不同的jvm实现对于同一段代码在效率上可能会有很大的差别。譬如，对于iadd指令，两个int相加，既可以直接交给硬件去做，也可以拐弯抹角的去做，只要最终结果符合jvm规范的描述即可。

3） Java栈

需要知道的是，Java考虑到跨平台的需要，所有指令的操作都不是基于寄存器的，而是内存中的Java栈。在C语言中，有个寄存器用于pc计数器，而在Java中，pc计数器是内存中的一个字。Java栈由栈帧组成，栈帧分为局部变量区，操作数栈和帧数据区。jvm指令的操作数大都源于操作数栈。这与一些语言从寄存器中取操作数是不同的。而局部变量区和操作数栈的大小在编译Java文件时就已经确定了。

对于问题一，我们有必要看一下Java中对于i++和i—所使用的指令

public class Test {

public static void main(String... args) {

int i = 0;

i++;

i--;

}

上面的代码编译后再用javap –c Test查看用到的指令：

Compiled from "Test.java"

public class Test extends java.lang.Object{

public Test();

Code:

0: aload_0

1: invokespecial #1; //Methodjava/lang/Object."":()V

4: return

public static void main(java.lang.String[]);

Code:

0: iconst_0

1: istore_1

2: iinc 1, 1

5: iinc 1, -1

8: return

}

从上面我们发现i++和i--其实用的是同一个指令，即iinc，不过操作数不一样罢了；该指令直接修改局部变量区的值，而不需要压栈。至于如何去实现这个指令，不同的人在实现jvm的时候有自己的想法。所以问题一的比较是毫无意义的。你在jvm实现1上运行很快，可能在jvm实现2上面就运行很慢。

对于问题二，如上面普及常识所言，不同的jvm可以有不同的实现，不同的优化。与C语言不同之处在于，java的局部变量区在运行一个方法的时候已经分配好了，不需要遇到一个新变量就去分配。另外一点，因为由jvm来执行，这种循环是jvm内部是存在优化余地的，譬如，对于里层的循环变量，在重新下一次循环时就没用了，一些jvm实现就可以重用这个变量。一些JVM可能是纯粹的解释执行字节码，一些JVM可能在启动的时候就把字节码编译成c++本地代码，一些jvm可能用纯硬件芯片来执行指令集，还有一些jvm在运行了一段时间后找出程序热区，仔细优化并将这部分代码编译成c++本地代码来达到最佳效果。所有你能想到的优化都可以在这里做掉。所以不同的jvm实现对于这样的代码效率可能会有很大的差别。

经过本人实测（循环体是数值计算），IBM J9 1.6中两种都很快，Sun hotspot跟J91.6相比不是一个数量级的。但是IBM J9 1.5的实现则相当的慢，跟hotspot比慢的不是一个数量级。有兴趣的可能分别试试openJDK，IBM J9，Jrockit 这些实现的1.5和1.6版本的效率，另外一些jvm还有server和client运行版本的区别，效率也是大不一样的

总结，隔了一层虚拟机，什么都有可能！

zhb8015 2012-06-12 17:47 发表评论

javap

zhb8015 — Tue, 12 Jun 2012 09:38:00 GMT

一直在学习Java,碰到了很多问题，碰到了很多关于i++和++i的难题，以及最经典的String str = "abc" 共创建了几个对象的疑难杂症。知道有一日知道了java的反汇编命令 javap。现将学习记录做一小结，以供自己以后翻看。如果有错误的地方，请指正

1.javap是什么：

where options include:
-c Disassemble the code
-classpath Specify where to find user class files
-extdirs Override location of installed extensions
-help Print this usage message
-J Pass directly to the runtime system
-l Print line number and local variable tables
-public Show only public classes and members
-protected Show protected/public classes and members
-package Show package/protected/public classes
and members (default)
-private Show all classes and members
-s Print internal type signatures
-bootclasspath Override location of class files loaded
by the bootstrap class loader
-verbose Print stack size, number of locals and args for met
hods
If verifying, print reasons for failure　

以上为百度百科里对它的描述，只是介绍了javap的一些参数和使用方法，而我们要用的就是这一个：-c Disassemble the code。

明确一个问题：javap是什么？网上有人称之为反汇编器，可以查看java编译器为我们生成的字节码。通过它，我们可以对照源代码和字节码，从而了解很多编译器内部的工作。

2.初步认识javap

从一个最简单的例子开始：

这个例子中，我们只是简单的声明了两个int型变量并赋上初值。下面我们看看javap给我们带来了什么：（当然执行javap命令前，你得首先配置好自己的环境，能用javac编译通过了，即：javac TestJavap.java )

我们只看（方便起见，将注释写到每句后面）

Code:
   0:   iconst_2    //把2放到栈顶
   1:   istore_1    //把栈顶的值放到局部变量1中，即i中
   2:   iconst_3    //把3放到栈顶
   3:   istore_2    //把栈顶的值放到局部变量1中，即j中
   4:   return

是不是很简单？（当然，估计需要点数据结构的知识），那我们就补点java的关于堆栈的知识：

对于 int i = 2;首先它会在栈中创建一个变量为i的引用，然后查找有没有字面值为2的地址，没找到，就开辟一个存放2这个字面值的地址，然后将i指向2的地址。

看了这段话，再比较下上面的注释，是不是完全吻合？

为了验证上面这一说法，我们继续实验：

我们将 i 和 j的值都设为2。按照以上理论，在声明j的时候，会去栈中招有没有字面值为2的地址，由于在栈中已经有2这个字面值，便将j直接指向2的地址。这样，就出现了i与j同时均指向2的情况。

拿出javap -c进行反编译：结果如下：

Code:
   0:   iconst_2    //把2放到栈顶
   1:   istore_1    //把栈顶的值放到局部变量1中，即i中
   2:   iconst_2    //把2放到栈顶
   3:   istore_2    //把栈顶的值放到局部变量2中，即j中(i 和 j同时指向2)
   4:   return

虽然这里说i和j同时指向2，但这里不等于说i和j指向同一块地址（java是不允许程序员直接修改堆栈中的数据的，所以就不要想着，我是不是可以修改栈中的2，那样岂不是i和j的值都会变化。另：在编译器内部，遇到j=2；时，它就会重新搜索栈中是否有2的字面值，如果没有，重新开辟地址存放2的值；如果已经有了，则直接将j指向这个地址。因此,就算j另被赋值为其他值，如j=4,j值的改变不会影响到i的值。）

再来一个例子：

还是javap -c

Code:
   0:   iconst_2    //把2放到栈顶
   1:   istore_1    //把栈顶的值放到局部变量1中，即i中
   2:   iload_1     //把i的值放到栈顶，也就是说此时栈顶的值是2
   3:   istore_2    //把栈顶的值放到局部变量2中，即j中
   4:   return

看到这里是不是有点明确了？

zhb8015 2012-06-12 17:38 发表评论

java对象池技术（Jakarta对象池）

zhb8015 — Tue, 12 Jun 2012 08:55:00 GMT

http://www.blogjava.net/baoyaer/articles/218460.html

zhb8015 2012-06-12 16:55 发表评论

浅谈java内存模型 (转经经典)

zhb8015 — Tue, 12 Jun 2012 03:29:00 GMT

http://www.blogjava.net/qileilove/archive/2011/09/22/359262.html

不同的平台，内存模型是不一样的，但是jvm的内存模型规范是统一的。其实java的多线程并发问题最终都会反映在java的内存模型上，所谓线程安全无非是要控制多个线程对某个资源的有序访问或修改。总结java的内存模型，要解决两个主要的问题：可见性和有序性。
我们都知道计算机有高速缓存的存在，处理器并不是每次处理数据都是取内存的。JVM定义了自己的内存模型，屏蔽了底层平台内存管理细节，对于java开发人员，要清楚在jvm内存模型的基础上，如果解决多线程的可见性和有序性。
那么，何谓可见性？多个线程之间是不能互相传递数据通信的，它们之间的沟通只能通过共享变量来进行。Java内存模型（JMM）规定了jvm有主内存，主内存是多个线程共享的。当new一个对象的时候，也是被分配在主内存中，每个线程都有自己的工作内存，工作内存存储了主存的某些对象的副本，当然线程的工作内存大小是有限制的。当线程操作某个对象时，执行顺序如下：
(1) 从主存复制变量到当前工作内存 (read and load)
(2) 执行代码，改变共享变量值 (use and assign)
(3) 用工作内存数据刷新主存相关内容 (store and write)

JVM规范定义了线程对主存的操作指令：read，load，use，assign，store，write。当一个共享变量在多个线程的工作内存中都有副本时，如果一个线程修改了这个共享变量，那么其他线程应该能够看到这个被修改后的值，这就是多线程的可见性问题。
那么，什么是有序性呢？线程在引用变量时不能直接从主内存中引用,如果线程工作内存中没有该变量,则会从主内存中拷贝一个副本到工作内存中,这个过程为read-load,完成后线程会引用该副本。当同一线程再度引用该字段时,有可能重新从主存中获取变量副本(read-load-use),也有可能直接引用原来的副本 (use),也就是说 read,load,use顺序可以由JVM实现系统决定。
线程不能直接为主存中中字段赋值，它会将值指定给工作内存中的变量副本(assign),完成后这个变量副本会同步到主存储区(store- write)，至于何时同步过去，根据JVM实现系统决定.有该字段,则会从主内存中将该字段赋值到工作内存中,这个过程为read-load,完成后线程会引用该变量副本，当同一线程多次重复对字段赋值时,比如：

Java代码

for(int i=0;i<10;i++)
a++;

线程有可能只对工作内存中的副本进行赋值,只到最后一次赋值后才同步到主存储区，所以assign,store,weite顺序可以由JVM实现系统决定。假设有一个共享变量x，线程a执行 x=x+1。从上面的描述中可以知道x=x+1并不是一个原子操作，它的执行过程如下：
1 从主存中读取变量x副本到工作内存
2 给x加1
3 将x加1后的值写回主存
如果另外一个线程b执行x=x-1，执行过程如下：
1 从主存中读取变量x副本到工作内存
2 给x减1
3 将x减1后的值写回主存
那么显然，最终的x的值是不可靠的。假设x现在为10，线程a加1，线程b减1，从表面上看，似乎最终x还是为10，但是多线程情况下会有这种情况发生：
1：线程a从主存读取x副本到工作内存，工作内存中x值为10
2：线程b从主存读取x副本到工作内存，工作内存中x值为10
3：线程a将工作内存中x加1，工作内存中x值为11
4：线程a将x提交主存中，主存中x为11
5：线程b将工作内存中x值减1，工作内存中x值为9
6：线程b将x提交到中主存中，主存中x为9
同样，x有可能为11，如果x是一个银行账户，线程a存款，线程b扣款，显然这样是有严重问题的，要解决这个问题，必须保证线程a和线程b是有序执行的，并且每个线程执行的加1或减1是一个原子操作。看看下面代码：

Java代码

public class Account {
private int balance;
public Account(int balance) {
this.balance = balance;
}
public int getBalance() {
return balance;
}
public void add(int num) {
balance = balance + num;
}
public void withdraw(int num) {
balance = balance - num;
}
public static void main(String[] args) throws InterruptedException {
Account account = new Account(1000);
Thread a = new Thread(new AddThread(account, 20), "add");
Thread b = new Thread(new WithdrawThread(account, 20), "withdraw");
a.start();
b.start();
a.join();
b.join();
System.out.println(account.getBalance());
}
static class AddThread implements Runnable {
Account account;
int amount;
public AddThread(Account account, int amount) {
this.account = account;
this.amount = amount;
}
public void run() {
for (int i = 0; i < 200000; i++) {
account.add(amount);
}
}
}
static class WithdrawThread implements Runnable {
Account account;
int amount;
public WithdrawThread(Account account, int amount) {
this.account = account;
this.amount = amount;
}
public void run() {
for (int i = 0; i < 100000; i++) {
account.withdraw(amount);
}
}
}
}

第一次执行结果为10200，第二次执行结果为1060，每次执行的结果都是不确定的，因为线程的执行顺序是不可预见的。这是java同步产生的根源，synchronized关键字保证了多个线程对于同步块是互斥的，synchronized作为一种同步手段，解决java多线程的执行有序性和内存可见性，而volatile关键字之解决多线程的内存可见性问题。后面将会详细介绍。

synchronized关键字
上面说了，java用synchronized关键字做为多线程并发环境的执行有序性的保证手段之一。当一段代码会修改共享变量，这一段代码成为互斥区或临界区，为了保证共享变量的正确性，synchronized标示了临界区。典型的用法如下：

Java代码

synchronized(锁){
临界区代码
}

为了保证银行账户的安全，可以操作账户的方法如下：

Java代码

public synchronized void add(int num) {
balance = balance + num;
}
public synchronized void withdraw(int num) {
balance = balance - num;
}

刚才不是说了synchronized的用法是这样的吗：

Java代码

synchronized(锁){
临界区代码
}

那么对于public synchronized void add(int num)这种情况，意味着什么呢？其实这种情况，锁就是这个方法所在的对象。同理，如果方法是public static synchronized void add(int num)，那么锁就是这个方法所在的class。
理论上，每个对象都可以做为锁，但一个对象做为锁时，应该被多个线程共享，这样才显得有意义，在并发环境下，一个没有共享的对象作为锁是没有意义的。假如有这样的代码：

Java代码

public class ThreadTest{
public void test(){
Object lock=new Object();
synchronized (lock){
//do something
}
}
}

lock变量作为一个锁存在根本没有意义，因为它根本不是共享对象，每个线程进来都会执行Object lock=new Object();每个线程都有自己的lock，根本不存在锁竞争。
        每个锁对象都有两个队列，一个是就绪队列，一个是阻塞队列，就绪队列存储了将要获得锁的线程，阻塞队列存储了被阻塞的线程，当一个被线程被唤醒 (notify)后，才会进入到就绪队列，等待cpu的调度。当一开始线程a第一次执行account.add方法时，jvm会检查锁对象account 的就绪队列是否已经有线程在等待，如果有则表明account的锁已经被占用了，由于是第一次运行，account的就绪队列为空，所以线程a获得了锁，执行account.add方法。如果恰好在这个时候，线程b要执行account.withdraw方法，因为线程a已经获得了锁还没有释放，所以线程 b要进入account的就绪队列，等到得到锁后才可以执行。
一个线程执行临界区代码过程如下：
1 获得同步锁
2 清空工作内存
3 从主存拷贝变量副本到工作内存
4 对这些变量计算
5 将变量从工作内存写回到主存
6 释放锁
可见，synchronized既保证了多线程的并发有序性，又保证了多线程的内存可见性。

生产者/消费者模式
        生产者/消费者模式其实是一种很经典的线程同步模型，很多时候，并不是光保证多个线程对某共享资源操作的互斥性就够了，往往多个线程之间都是有协作的。
        假设有这样一种情况，有一个桌子，桌子上面有一个盘子，盘子里只能放一颗鸡蛋，A专门往盘子里放鸡蛋，如果盘子里有鸡蛋，则一直等到盘子里没鸡蛋，B专门从盘子里拿鸡蛋，如果盘子里没鸡蛋，则等待直到盘子里有鸡蛋。其实盘子就是一个互斥区，每次往盘子放鸡蛋应该都是互斥的，A的等待其实就是主动放弃锁，B 等待时还要提醒A放鸡蛋。
如何让线程主动释放锁
很简单，调用锁的wait()方法就好。wait方法是从Object来的，所以任意对象都有这个方法。看这个代码片段：

Java代码

Object lock=new Object();//声明了一个对象作为锁
synchronized (lock) {
balance = balance - num;
//这里放弃了同步锁，好不容易得到，又放弃了
lock.wait();
}

如果一个线程获得了锁lock，进入了同步块，执行lock.wait()，那么这个线程会进入到lock的阻塞队列。如果调用 lock.notify()则会通知阻塞队列的某个线程进入就绪队列。
声明一个盘子，只能放一个鸡蛋

Java代码

import java.util.ArrayList;
import java.util.List;
public class Plate {
List eggs = new ArrayList();
public synchronized Object getEgg() {
if (eggs.size() == 0) {
try {
wait();
} catch (InterruptedException e) {
}
}
Object egg = eggs.get(0);
eggs.clear();// 清空盘子
notify();// 唤醒阻塞队列的某线程到就绪队列
System.out.println("拿到鸡蛋");
return egg;
}
public synchronized void putEgg(Object egg) {
if (eggs.size() > 0) {
try {
wait();
} catch (InterruptedException e) {
}
}
eggs.add(egg);// 往盘子里放鸡蛋
notify();// 唤醒阻塞队列的某线程到就绪队列
System.out.println("放入鸡蛋");
}
static class AddThread extends Thread{
private Plate plate;
private Object egg=new Object();
public AddThread(Plate plate){
this.plate=plate;
}
public void run(){
for(int i=0;i<5;i++){
plate.putEgg(egg);
}
}
}
static class GetThread extends Thread{
private Plate plate;
public GetThread(Plate plate){
this.plate=plate;
}
public void run(){
for(int i=0;i<5;i++){
plate.getEgg();
}
}
}
public static void main(String args[]){
try {
Plate plate=new Plate();
Thread add=new Thread(new AddThread(plate));
Thread get=new Thread(new GetThread(plate));
add.start();
get.start();
add.join();
get.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("测试结束");
}
}

执行结果：

Html代码

放入鸡蛋
拿到鸡蛋
放入鸡蛋
拿到鸡蛋
放入鸡蛋
拿到鸡蛋
放入鸡蛋
拿到鸡蛋
放入鸡蛋
拿到鸡蛋
测试结束

声明一个Plate对象为plate，被线程A和线程B共享，A专门放鸡蛋，B专门拿鸡蛋。假设
1 开始，A调用plate.putEgg方法，此时eggs.size()为0，因此顺利将鸡蛋放到盘子，还执行了notify()方法，唤醒锁的阻塞队列的线程，此时阻塞队列还没有线程。
2 又有一个A线程对象调用plate.putEgg方法，此时eggs.size()不为0，调用wait()方法，自己进入了锁对象的阻塞队列。
3 此时，来了一个B线程对象，调用plate.getEgg方法，eggs.size()不为0，顺利的拿到了一个鸡蛋，还执行了notify()方法，唤醒锁的阻塞队列的线程，此时阻塞队列有一个A线程对象，唤醒后，它进入到就绪队列，就绪队列也就它一个，因此马上得到锁，开始往盘子里放鸡蛋，此时盘子是空的，因此放鸡蛋成功。
4 假设接着来了线程A，就重复2；假设来料线程B，就重复3。
整个过程都保证了放鸡蛋，拿鸡蛋，放鸡蛋，拿鸡蛋。

volatile关键字
volatile是java提供的一种同步手段，只不过它是轻量级的同步，为什么这么说，因为volatile只能保证多线程的内存可见性，不能保证多线程的执行有序性。而最彻底的同步要保证有序性和可见性，例如synchronized。任何被volatile修饰的变量，都不拷贝副本到工作内存，任何修改都及时写在主存。因此对于Valatile修饰的变量的修改，所有线程马上就能看到，但是volatile不能保证对变量的修改是有序的。什么意思呢？假如有这样的代码：

Java代码

public class VolatileTest{
public volatile int a;
public void add(int count){
a=a+count;
}
}

当一个VolatileTest对象被多个线程共享，a的值不一定是正确的，因为a=a+count包含了好几步操作，而此时多个线程的执行是无序的，因为没有任何机制来保证多个线程的执行有序性和原子性。volatile存在的意义是，任何线程对a的修改，都会马上被其他线程读取到，因为直接操作主存，没有线程对工作内存和主存的同步。所以，volatile的使用场景是有限的，在有限的一些情形下可以使用 volatile 变量替代锁。要使 volatile 变量提供理想的线程安全,必须同时满足下面两个条件:
1)对变量的写操作不依赖于当前值。
2)该变量没有包含在具有其他变量的不变式中
volatile只保证了可见性，所以Volatile适合直接赋值的场景，如

Java代码

public class VolatileTest{
public volatile int a;
public void setA(int a){
this.a=a;
}
}

在没有volatile声明时，多线程环境下，a的最终值不一定是正确的，因为this.a=a;涉及到给a赋值和将a同步回主存的步骤，这个顺序可能被打乱。如果用volatile声明了，读取主存副本到工作内存和同步a到主存的步骤，相当于是一个原子操作。所以简单来说，volatile适合这种场景：一个变量被多个线程共享，线程直接给这个变量赋值。这是一种很简单的同步场景，这时候使用volatile的开销将会非常小。站内很多人都问我，所谓线程的“工作内存”到底是个什么东西？有的人认为是线程的栈，其实这种理解是不正确的。看看JLS（java语言规范）对线程工作内存的描述，线程的working memory只是cpu的寄存器和高速缓存的抽象描述。

可能很多人都觉得莫名其妙，说JVM的内存模型，怎么会扯到cpu上去呢？在此，我认为很有必要阐述下，免得很多人看得不明不白的。先抛开java虚拟机不谈，我们都知道，现在的计算机，cpu在计算的时候，并不总是从内存读取数据，它的数据读取顺序优先级是：寄存器－高速缓存－内存。线程耗费的是CPU，线程计算的时候，原始的数据来自内存，在计算过程中，有些数据可能被频繁读取，这些数据被存储在寄存器和高速缓存中，当线程计算完后，这些缓存的数据在适当的时候应该写回内存。当个多个线程同时读写某个内存数据时，就会产生多线程并发问题，涉及到三个特性：原子性，有序性，可见性。在《线程安全总结》这篇文章中，为了理解方便，我把原子性和有序性统一叫做“多线程执行有序性”。支持多线程的平台都会面临这种问题，运行在多线程平台上支持多线程的语言应该提供解决该问题的方案。

那么，我们看看JVM，JVM是一个虚拟的计算机，它也会面临多线程并发问题，java程序运行在java虚拟机平台上，java程序员不可能直接去控制底层线程对寄存器高速缓存内存之间的同步，那么java从语法层面，应该给开发人员提供一种解决方案，这个方案就是诸如 synchronized, volatile,锁机制（如同步块，就绪队列，阻塞队列）等等。这些方案只是语法层面的，但我们要从本质上去理解它，不能仅仅知道一个 synchronized 可以保证同步就完了。 在这里我说的是jvm的内存模型，是动态的，面向多线程并发的，沿袭JSL的“working memory”的说法，只是不想牵扯到太多底层细节，因为《线程安全总结》这篇文章意在说明怎样从语法层面去理解java的线程同步，知道各个关键字的使用场景。

今天有人问我，那java的线程不是有栈吗？难道栈不是工作内存吗？工作内存这四个字得放到具体的场景中描述，方能体现它具体的意义，在描述JVM的线程同步时，工作内存指的是寄存器和告诉缓存的抽象描述，具体请自行参阅JLS。上面讲的都是动态的内存模型，甚至已经超越了JVM的范围，那么JVM的内存静态存储是怎么划分的？今天还有人问我，jvm的内存模型不是有eden区吗？也不见你提起。我跟他说，这是两个角度去看的，甚至是两个不同的范围，动态的线程同步的内存模型，涵盖了cpu，寄存器，高速缓存，内存；JVM的静态内存储模型只是一种对内存的物理划分而已，它只局限在内存，而且只局限在JVM 的内存。那些什么线程栈，eden区都仅仅在JVM内存。

说说JVM的线程栈和有个朋友反复跟我纠结的eden区吧。JVM的内存，被划分了很多的区域：

1.程序计数器
每一个Java线程都有一个程序计数器来用于保存程序执行到当前方法的哪一个指令。
2.线程栈
线程的每个方法被执行的时候，都会同时创建一个帧（Frame）用于存储本地变量表、操作栈、动态链接、方法出入口等信息。每一个方法的调用至完成，就意味着一个帧在VM栈中的入栈至出栈的过程。如果线程请求的栈深度大于虚拟机所允许的深度，将抛出StackOverflowError异常；如果VM栈可以动态扩展（VM Spec中允许固定长度的VM栈），当扩展时无法申请到足够内存则抛出OutOfMemoryError异常。
3.本地方法栈
4.堆
每个线程的栈都是该线程私有的，堆则是所有线程共享的。当我们new一个对象时，该对象就被分配到了堆中。但是堆，并不是一个简单的概念，堆区又划分了很多区域，为什么堆划分成这么多区域，这是为了JVM的内存垃圾收集，似乎越扯越远了，扯到垃圾收集了，现在的jvm的gc都是按代收集，堆区大致被分为三大块：新生代，旧生代，持久代（虚拟的）；新生代又分为eden区，s0区，s1区。新建一个对象时，基本小的对象，生命周期短的对象都会放在新生代的 eden区中，eden区满时，有一个小范围的gc（minor gc），整个新生代满时，会有一个大范围的gc（major gc），将新生代里的部分对象转到旧生代里。
5.方法区
其实就是永久代（Permanent Generation），方法区中存放了每个Class的结构信息，包括常量池、字段描述、方法描述等等。VM Space描述中对这个区域的限制非常宽松，除了和Java堆一样不需要连续的内存，也可以选择固定大小或者可扩展外，甚至可以选择不实现垃圾收集。相对来说，垃圾收集行为在这个区域是相对比较少发生的，但并不是某些描述那样永久代不会发生GC（至少对当前主流的商业JVM实现来说是如此），这里的GC主要是对常量池的回收和对类的卸载，虽然回收的“成绩”一般也比较差强人意，尤其是类卸载，条件相当苛刻。
6.常量池
Class 文件中除了有类的版本、字段、方法、接口等描述等信息外，还有一项信息是常量表(constant_pool table)，用于存放编译期已可知的常量，这部分内容将在类加载后进入方法区（永久代）存放。但是Java语言并不要求常量一定只有编译期预置入 Class的常量表的内容才能进入方法区常量池，运行期间也可将新内容放入常量池（最典型的String.intern()方法）。

关于垃圾收集，在此不多说，流到垃圾收集那一章再详细说吧。关于java的同步，其实还有基于CPU原语的比较并交换的非阻塞算法（CAS），不过这个在java的并发包里已经实现了很多，因此关于这点，就留到java并发包那一章介绍吧。后面我会专门写一篇文章，JVM内存与垃圾收集。

zhb8015 2012-06-12 11:29 发表评论

设计模式大集锦程序员面试(转)

zhb8015 — Wed, 06 Jun 2012 09:33:00 GMT

设计模式大集锦程序员面试全攻略

http://sd.csdn.net/a/20120604/2806324.html

无论你是参与Java面试还是C#面试，设计模式和软件设计问题在程序员面试中是必不可少的一部分。编程和设计技两者相得益彰，一名出色的程序员也是一名出色的设计师，他们懂得如何利用代码来解决问题或者软件设计，但是这些技能需要不断提升。这就要求你不断的保持设计理念，无论编程项目的大小，从失败中总结经验。

从面向对象的设计原则开始学习是个不错的起点。本文总结了在各种面试过程中经常被提及的一些设计问题。文中分为两部分，一类为初学者，另一类专为中高级技术人员准备。

一、入门级程序员的面试题：

这些软件设计和设计模式的先关问题大多会出现在初学者面试情景中，什么是设计模式？特定的设计模式又是什么？等等这些概念，也许你很轻易回答这些概念，但文内提供的这些问题也许能给你带来更多价值。

1. 什么是设计模式？在你编码过程中使用了哪些设计模式？

每位程序员都会利用自身经历来回答这些特定的设计问题。设计模式是代码重用的扩展。

2. 你能说出在标准的JDK库中使用的一些设计模式吗？

Decorator设计模式常被用于各种Java IO类中，Singleton模式常被用在运行环节中，Calendar以及各种其他类，Factory（工厂）模式常被用于各种不可变类，比如Boolean。Boolean.valueOf和Observer模式常被用于Swing和许多事件监听器框架中。

3. 在Java中Singleton设计模式是什么？为线程安全Singleton编码。

Singleton模式在整个系统中主要是共享模式。在整个应用程序实例中只保持一个特定的类，这是由所以模块共享决定的。Java.lang.Runtime是Singleton设计模式中一个典型范例。关于此问题你可以查看更多。从Java 5版本开始，你可以为安全线程singleton模式使用enum。

4. 使用Factory模式主要优势是什么？你会在哪种情况下使用？

Factory模式最主要的优势在于当创建对象时可提高封装水平。如果你使用Factory模式来创建对象，你可以在后期重置最初产品的装置或者无须任何客户层就可实现更先进更高性能的类。可以查看我曾发表过的有关Factory模式的更多细节及优点。

5. Java中Observer设计模式是什么？

Observer设计模式基于对象的变化而改变。比如：天气系统，在这里必须将天气变化的视图呈现给观众。这里天气项目是主体而非不同的观察者。通过这篇文章，查看在Java中Observer模式。

6. 例举一个在Java中使用Decorator模式的案例？它从事的是对象级别还是类级别？

Decorator模式可提高个体对象的能力。Java IO广泛使用Decorator模式和Buffered类型的一些经典例子，比如BufferedReader和BufferedWriter，增强读者和作家执行Buffer级别的阅读和写作从而提高性能。了解更多。

7. 什么是MVC设计模式？请例举一个MVC设计模式案例。

8. Java中FrontController设计模式是什么？请例举一个FrontController设计模式案例。

9. Responsibility设计模式是什么？

10. Adapter设计模式是什么？请例举一个在Java中的Adapter设计模式案例。

二、进阶级程序员的面试题：

1. 举例说明你什么时候会用抽象类，什么时候更愿意使用接口？

这是一个很常见的面试问题，并不算难。接口和抽象类都按照“不为实现写代码”的设计原则，这是为了增加代码的灵活性，以应付不断变化的要求。下面是一些帮助你回答这个问题的指南：

在Java中，你只能继承一个类，但实现多个接口。所以你继承一个类的时候就无法再继承别的类了。
接口是用来代表形容词或行为，例如Runnable、Clonable、Serializable等。因此，如果您使用一个抽象类来实现Runnable和Clonacle，你就不可以使你的类同时实现这两个功能，而如果接口的话就没问题。
抽象类是比接口稍快，所以很在乎时间的应用尽量使用抽象类。
如果多个继承层次的共同行为在在同一个地方编写更好，那么抽象类会是更好的选择。有时候可以在接口里定义函数但是在抽象类里默认功能就能实现接口和抽象类共同工作了。了解Java接口。

2. 设计一个能接收不同硬币、出售不同货物的自动售货机。

这是一个比较开放的设计问题，你可以使用它练习文档设计、写代码和JUnit单元测试，而不是仅仅是解决问题。这道题的目标绝不会仅仅是想测出你多久能够得到解决方案。理想情况下，这个问题应该在3小时内给出一个可工作版本。

3. 你有一个Smartphone类和它派生类iPhone、 AndroidPhone、WindowsPhone等，以及以品牌名称命名的派生类如SonyPhone等。你该如何设计这一类的系统？

这是另一种设计模式的练习，你充分利用面向对象的设计技巧，保证它有足够的灵活性来支持新产品，并且在现有模型改变时能够保证足够的稳定性。

4. 在Java中，什么时候该使用overload，什么时候使用override？

对于一个经验丰富的设计师来说这是一个非常简单的问题。重载和覆盖在Java里实现的都是同一个功能，但overload的输入变量不同，override则完全相同。

5. 设计ATM机

我们几乎都使用过ATM机，但你想过该怎么设计它吗？金融系统的设计原则之一就是必须能在所有预期情况下都能够正常运行。所以无论是发生断电还是什么其它暴力问题，ATM机都必须能够保证正确的状态。考虑下锁、事务处理、错误状态、临界条件等等。即使你拿不定确切的设计方案，但是能够指出非功能性需求、提出一些问题或者考虑考虑临界条件都会对你有帮助。

6. 假设你正在设计市场数据类来保证能够切换不同的信息供应商，比如Reuters、wombat等等，或者直接交换信息，你该如何设计这个市场信息系统？

这是非常有趣的设计面试问题，实际上在大型投资银行里是个很普遍的问题。关键在于你需要提供拥有getBid()、getPrice()和getLevel()方法的MarketData接口供客户请求，同时还需要有一个使用依赖注入的MarketDataProvider组件。这样在你改变MarketDataProvider时就不会对系统产生影响，因为客户是通过MarketData接口或者类调用方法的。

7. 为什么Java里不允许从静态方法中获取非静态变量？

Java里不允许从静态方法中获取非静态变量仅仅是因为非静态变量会和特定的对象实例相关联，而静态变量不会。你也可以看看这篇文章的详细解释。

8. 用Java设计一个并发规则管道？

并发编程和并行设计非常热门，因为它能更高效地利用现在越来越先进的处理器，而且Java被认为是多线程语言也主要因为此原因。设计一个并发系统的关键在于线程安全、不可变性、本地变量，还有避免使用局部变量和实例变量。你只需要保证多个线程能够在同一时间执行同一个类，所以最佳解决方案就是每个线程只操作自己的数据，尽量使用最小的同步，尤其是在管道开始时。这个问题可以从初始讨论到最终类和接口的编写实现，但是只要你记得注意并发问题的关键，比如竞争状态、死锁、内存冲突、原子操作、ThreadLocal变量等等，尽量绕过这些问题。

以上这些设计模式经常出现在面试环节中，比如Google，Amazon, Microsoft等。如果您在面试过程中遇到了一些有趣的话题，不妨与我们分享下。

zhb8015 2012-06-06 17:33 发表评论

什么是hashcode （转）

zhb8015 — Wed, 30 May 2012 08:31:00 GMT

什么是hashcode （转）

http://www.iteye.com/topic/838030

分析HashMap之前先介绍下什么Hashcode(散列码)。它是一个int，每个对象都会有一个hashcode，它在内存的存放位置是放在对象的头部（对象头部存放的信息有hashcode，指向Class的引用，和一些有关垃圾回收信息）。具体如何生成hashcode，这个相当复杂，由于我们的主题是“浅析”，所以不深入探讨。有个问题需要讲的是，如果在你的类中覆盖了Object的equals(Object)方法，那么你必须覆盖 hashCode方法，不然，当你使用HashMap，HashSet，HashTable时会出现问题。具体原因下文会详细描述。
String类的hashcode
String类重写了Object类中的equals和hashCode方法，原因很简单，Object中的equals方法是指比较两个对象是不是指向同一个引用对象，而String类指需要比较内容相不相等就可以了。所以String覆盖了equals方法，同时覆盖了hashCode方法。这里需要提一下Object规范里规定：如果两个对象根据equals(Object)方式是相等的，那么这两个对象的hashCode一定要相等。
String中的hashcode算法很简单如下：

Java代码

for (int i = 0; i < len; i++) {
h = 31*h + val[off++];
}

Val是一个char[]，存放的是字符串的各个字符；Len是字符串长度；off从0开始；h从0开始。比如一个字符串“abc”(a的ascii码是97)，它的hashcode算法是：
h = 31 * 0 + 97 ==> h = 97;
h = 31 * 97 + 98 ==> h = 3105;
h = 31 * 3105 + 99 ==> h = 96354;
所以“abc”的hashCode就是96354
存储方式
    列表的存储方式是基于数组，如下图：

    链表的存储方式是基于指针，如下图：（单向链表）

    HashMap的存储方式是上面两种的结合，如下图：

HashMap的存取
    HashMap的功能是通过“键(key)”能够快速的找到“值”。下面我们分析下HashMap存数据的基本流程：
    1、当调用put(key,value)时，首先获取key的hashcode，int hash = key.hashCode();
    2、再把hash通过一下运算得到一个int h.
hash ^= (hash >>> 20) ^ (hash >>> 12);
int h = hash ^ (hash >>> 7) ^ (hash >>> 4);
为什么要经过这样的运算呢？这就是HashMap的高明之处。先看个例子，一个十进制数32768(二进制1000 0000 0000 0000)，经过上述公式运算之后的结果是35080(二进制1000 1001 0000 1000)。看出来了吗？或许这样还看不出什么，再举个数字61440(二进制1111 0000 0000 0000)，运算结果是65263(二进制1111 1110 1110 1111)，现在应该很明显了，它的目的是让“1”变的均匀一点，散列的本意就是要尽量均匀分布。那这样有什么意义呢？看第3步。
    3、得到h之后，把h与HashMap的承载量（HashMap的默认承载量length是16，可以自动变长。在构造HashMap的时候也可以指定一个长度。这个承载量就是上图所描述的数组的长度。）进行逻辑与运算，即 h & (length-1)，这样得到的结果就是一个比length小的正数，我们把这个值叫做index。其实这个index就是索引将要插入的值在数组中的位置。第2步那个算法的意义就是希望能够得出均匀的index，这是HashTable的改进，HashTable中的算法只是把key的 hashcode与length相除取余，即hash % length，这样有可能会造成index分布不均匀。还有一点需要说明，HashMap的键可以为null，它的值是放在数组的第一个位置。
    4、我们用table[index]表示已经找到的元素需要存储的位置。先判断该位置上有没有元素（这个元素是HashMap内部定义的一个类Entity，基本结构它包含三个类，key，value和指向下一个Entity的next）,没有的话就创建一个Entity对象，在 table[index]位置上插入，这样插入结束；如果有的话，通过链表的遍历方式去逐个遍历，看看有没有已经存在的key，有的话用新的value替换老的value；如果没有，则在table[index]插入该Entity，把原来在table[index]位置上的Entity赋值给新的 Entity的next，这样插入结束。
再回头看看前面提到的为什么覆盖了equals方法之后一定要覆盖hashCode方法，很简单，比如，String a = new String(“abc”);String b = new String(“abc”);如果不覆盖hashCode的话，那么a和b的hashCode就会不同，把这两个类当做key存到HashMap中的话就会出现问题，就会和key的唯一性相矛盾。

    HashMap取的过程也类似。太累了，不写了。赶紧结束。
    文中可能会有错误的地方请指出，谢谢！

zhb8015 2012-05-30 16:31 发表评论

hashcode面试题

zhb8015 — Wed, 30 May 2012 08:08:00 GMT

Java code

public class ValuePair {    public int a = 4,b;    public boolean equals(Object other){       try{          ValuePair o = (ValuePair) other;          return (a==o.a&&b==o.b)||(a==o.b&&b==o.a);       }catch(ClassCastException cce){          return false;       }    }    public int hashCode(){       //请选择下边的答案（多选）    } }

A。return 0;
B. return a;
C. return a+b;
D. return a-b;
E. return a^b;
F. return (a<<16)|b;
请说明理由。

根据一般约定，如果2个对象 equals 比较为true,那么hashCode也最好(不是必须)相同。
如果2个对象 equals 比如为false,那么hashCode也最好(不是必须)不同

因此对于这个题目，如果从纯语法层面考虑，全部都是可选的
但是从程序运行效率来看，最好是该hashCode里，a,b值可以互换，而又尽可能做到不同的a,b值返回不同的值。因为C,E最好.

A。return 0; 效率太低
B. return a; 不满足a,b的互换性
D. return a-b; 不满足a,b的互换性
F. return (a < <16)|b; 不满足a,b的互换性

另外，比如 a * b 也满足互换性，但是效率稍低，毕竟没加法和位运算快

* Whenever it is invoked on the same object more than once during an execution of a Java application, the hashCode method must consistently return the same integer, provided no information used in equals comparisons on the object is modified. This integer need not remain consistent from one execution of an application to another execution of the same application.
* If two objects are equal according to the equals(Object) method, then calling the hashCode method on each of the two objects must produce the same integer result.
* It is not required that if two objects are unequal according to the equals(java.lang.Object) method, then calling the hashCode method on each of the two objects must produce distinct integer results. However, the programmer should be aware that producing distinct integer results for unequal objects may improve the performance of hashtables.

zhb8015 2012-05-30 16:08 发表评论

JVM小结

zhb8015 — Sat, 28 Apr 2012 02:45:00 GMT

摘要: 1、 Java总体（java编程语言、java API、java文件格式和虚拟机） 1 2、 java虚拟机结束生命周期 1 3、类的加载、连接和初始化 2 4、 java对类的使用方式分为两种： 2 4、类的加载 2 5、加载.class文件的方式 2 6、两种类加载器 3 7、类的... 阅读全文

zhb8015 2012-04-28 10:45 发表评论

JVM内存管理机制

zhb8015 — Fri, 27 Apr 2012 07:58:00 GMT

1.JVM内存管理的机制

内存空间划分为：Sun JDK在实现时遵照JVM规范，将内存空间划分为堆、JVM方法栈、方法区、本地方法栈、PC寄存器。

堆：堆用于存储对象实例及数组值，可以认为Java中所有通过new创建的对象的内存都在此分配，Heap中对象所占用的内存由GC进行回收，在32位操作系统上最大为2GB，在64位操作系统上则没有限制，其大小可通过-Xms和-Xmx来控制，-Xms为JVM启动时申请的最小Heap内存，默认为物理内存的1/64但小于1GB；-Xmx为JVM可申请的最大Heap内存，默认为物理内存的1/4但小于1GB，默认当空余堆内存小于40%时，JVM会增大Heap到-Xmx指定的大小，可通过-XX:MinHeapFreeRatio=来指定这个比例；当空余堆内存大于70%时，JVM会减小Heap的大小到-Xms指定的大小，可通过-XX:MaxHeapFreeRatio=来指定这个比例，对于运行系统而言，为避免在运行时频繁调整Heap 的大小，通常将-Xms和-Xmx的值设成一样。

JVM方法栈：为线程私有，其在内存分配上非常高效。当方法运行完毕时，其对应的栈帧所占用的内存也会自动释放。当JVM方法栈空间不足时，会抛出StackOverflowError的错误，在Sun JDK中可以通过-Xss来指定其大小。

方法区：要加载的类的信息（名称、修饰符等）、类中的静态变量、类中定义为final类型的常量、类中的Field信息、类中的方法信息。方法区域也是全局共享的，在一定条件下它也会被GC，当方法区域要使用的内存超过其允许的大小时，会抛出OutOfMemory的错误信息。在Sun JDK中这块区域对应Permanet Generation，又称为持久代，默认最小值为16MB，最大值为64MB，可通过-XX:PermSize及-XX:MaxPermSize来指定最小值和最大值。

本地方法栈：用于支持native方法的执行，存储了每个native方法调用的状态。在Sun JDK的实现中，和JVM方法栈是同一个。

PC寄存器：占用的可能为CPU寄存器或操作系统内存。

2.Java堆和栈的区别

Java把内存划分成两种：一种是栈内存，一种是堆内存。

在函数中定义的一些基本类型的变量和对象的引用变量都在函数的栈内存中分配。当在一段代码块定义一个变量时，Java就在栈中为这个变量分配内存空间，当超过变量的作用域后，Java会自动释放掉为该变量所分配的内存空间，该内存空间可以立即被另作他用。

堆内存用来存放由new创建的对象和数组。在堆中分配的内存，由Java虚拟机的自动垃圾回收器来管理。在堆中产生了一个数组或对象后，还可以在栈中定义一个特殊的变量，让栈中这个变量的取值等于数组或对象在堆内存中的首地址，在栈中的这个特殊的变量就变成了数组或者对象的引用变量，以后就可以在程序中使用栈内存中的引用变量来访问堆中的数组或者对象，引用变量相当于为数组或者对象起的一个别名，或者代号。

引用变量是普通变量，定义时在栈中分配内存，引用变量在程序运行到作用域外释放。而数组＆对象本身在堆中分配，即使程序运行到使用new产生数组和对象的语句所在地代码块之外，数组和对象本身占用的堆内存也不会被释放，数组和对象在没有引用变量指向它的时候，才变成垃圾，不能再被使用，但是仍然占着内存，在随后的一个不确定的时间被垃圾回收器释放掉。这个也是java比较占内存的主要原因。但是在写程序的时候，可以人为的控制。

3.Java内存泄露和内存溢出

内存泄漏：分配出去的内存回收不了

内存溢出：指系统内存不够用了

4.Java类加载机制

JVM将类加载过程划分为三个步骤：装载、链接和初始化。

装载（Load）：装载过程负责找到二进制字节码并加载至JVM中，JVM通过类的全限定名（com.bluedavy. HelloWorld）及类加载器（ClassLoaderA实例）完成类的加载；
链接（Link）：链接过程负责对二进制字节码的格式进行校验、初始化装载类中的静态变量及解析类中调用的接口、类；
初始化（Initialize）：执行类中的静态初始化代码、构造器代码及静态属性的初始化。

5.内存回收

收集器：引用计数收集器、跟踪收集器

引用计数收集器：对于Java这种面向对象的会形成复杂引用关系(如ObjectB和ObjectC互相引用)的语言而言，引用计数收集器不是非常适合，Sun JDK在实现GC时也未采用这种方式。

跟踪收集器实现算法：复制（Copying）、标记-清除（Mark-Sweep）和标记-压缩（Mark-Compact）

复制：当要回收的空间中存活对象较少时，复制算法会比较高效，其带来的成本是要增加一块空的内存空间及进行对象的移动。

标记-清除：在空间中存活对象较多的情况下较为高效，但由于标记-清除采用的为直接回收不存活对象所占用的内存，因此会造成内存碎片。

标记-压缩：在标记-清除的基础上还须进行对象的移动，成本相对更高，好处则是不产生内存碎片。

zhb8015 2012-04-27 15:58 发表评论

一场IBM面试题引发的讨论：创建String对象过程中【内存分配】(转)

zhb8015 — Fri, 27 Apr 2012 07:42:00 GMT

前不久，一个IBM面试题的帖子引发了很多关于创建String对象过程中的内存分配的讨论，既然大家对这个问题这么感兴趣，那么这篇帖子就通过深入Java虚拟机(JVM)解读其内部指令流程，来分析创建String对象的几种情况下的内存分配过程。

先来了解一下JVM运行时数据区的内存模型。
《深入Java虚拟机》书中是这样描述的：JVM运行时数据区的内存模型由五部分组成：
【1】方法区
【2】堆
【3】Java栈
【4】PC寄存器
【5】本地方法栈

对于String s = "hello" ,它的虚拟机指令：

Java code

0: ldc #16; //string hello 2: astore_1 3: return

对于上面虚拟机指令，其各自的指令流程在《深入Java虚拟机》这样描述到(结合上面实例)：

ldc指令格式：ldc,index
ldc指令过程：
要执行ldc指令，jvm首先查找index所指定的常量池入口，在index指向的常量池入口，jvm将会查找constant_integer_info，constant_float_info和constant_string_info入口。如果还没有这些入口，jvm会解析它们。而对于上面的hahajvm会找到constant_string_info入口，同时，将把指向被拘留String对象（由解析该入口的进程产生）的引用压入操作数栈。

astore_1指令格式：astore_1
astore_1指令过程：
要执行astore_1指令，jvm从操作数栈顶部弹出一个引用类型或者returnaddress类型值，然后将该值存入由索引1指定的局部变量中,即将引用类型或者returnaddress类型值存入局部变量1。

return 指令的过程：
从方法中返回，返回值为void。

谈一下我个人理解：
从上面的ldc指令的执行过程可以得出：s的值是来自被拘留string对象（由解析该入口的进程产生）的引用，即可以理解为是从被拘留string对象的引用复制而来的，故我个人的理解是s的值是存在栈当中。上面是对于s值得分析，接着是对于"hello"值的分析,我们知道，对于string s = "hello" 其中"hello"值在java程序编译期就确定下来了的。简单一点说，就是haha的值在程序编译成class文件后，就在class文件中生成了（大家可以用ue编辑器或其它文本编辑工具在打开class文件后的字节码文件中看到这个hello值）。执行java程序的过程中，第一步是class文件生成，然后被jvm装载到内存执行。那么jvm装载这个class到内存中，其中的hello这个值，在内存中是怎么为其开辟空间并存储在哪个区域中呢？

说到这里，我们不妨先来了解一下jvm常量池这个结构，《深入Java虚拟机》书中有这样的描述：

常量池
虚拟机必须为每个被装载的类型维护一个常量池。常量池就是该类型所用到常量的一个有序集和，包括直接常量（string,integer和floating point常量）和对其他类型，字段和方法的符号引用。对于string常量，它的值是在常量池中的。而jvm中的常量池在内存当中是以表的形式存在的，对于string类型，有一张固定长度的constant_string_info表用来存储文字字符串值，注意：该表只存储文字字符串值，不存储符号引用。说到这里，对常量池中的字符串值的存储位置应该有一个比较明了的理解了。

在介绍完jvm常量池的概念后，接着谈开始提到的"hello"的值的内存分布的位置。对于haha的值，实际上是在class文件被jvm装载到内存当中并被引擎在解析ldc指令并执行ldc指令之前，jvm就已经为haha这个字符串在常量池的constant_string_info表中分配了空间来存储hello这个值。既然hello这个字符串常量存储在常量池中，根据《深入java虚拟机》书中描述：常量池是属于类型信息的一部分，类型信息也就是每一个被转载的类型，这个类型反映到jvm内存模型中是对应存在于jvm内存模型的方法区中，也就是这个类型信息中的常量池概念是存在于在方法区中，而方法区是在jvm内存模型中的堆中由jvm来分配的。所以，hello的值是应该是存在堆空间中的。

而对于string s = new string("hello") ,它的jvm指令：

Java code

0: new #16; //class string 3: dup 4: ldc #18; //string hello 6: invokespecial #20; //method java/lang/string."":(ljava/lang/string;)v 9: astore_1 10: return

对于上面虚拟机指令，其各自的指令流程在《深入java虚拟机》这样描述到(结合上面实例)：

new指令格式：new indexbyte1,indexbyte2
new指令过程：
要执行new指令，jvm通过计算(indextype1<<8)|indextype2生成一个指向常量池的无符号16位索引。然后jvm根据计算出的索引查找常量池入口。该索引所指向的常量池入口必须为constant_class_info。如果该入口尚不存在，那么jvm将解析这个常量池入口，该入口类型必须是类。jvm从堆中为新对象映像分配足够大的空间，并将对象的实例变量设为默认值。最后jvm将指向新对象的引用objectref压入操作数栈。

dup指令格式：dup
dup指令过程：
要执行dup指令，jvm复制了操作数栈顶部一个字长的内容，然后再将复制内容压入栈。本指令能够从操作数栈顶部复制任何单位字长的值。但绝对不要使用它来复制操作数栈顶部任何两个字长(long型或double型)中的一个字长。上面例中，即复制引用objectref，这时在操作数栈存在2个引用。

ldc指令格式：ldc,index
ldc指令过程：
要执行ldc指令，jvm首先查找index所指定的常量池入口，在index指向的常量池入口，jvm将会查找constant_integer_info，constant_float_info和constant_string_info入口。如果还没有这些入口，jvm会解析它们。而对于上面的haha,jvm会找到constant_string_info入口，同时，将把指向被拘留string对象（由解析该入口的进程产生）的引用压入操作数栈。

invokespecial指令格式：invokespecial,indextype1,indextype2
invokespecial指令过程：对于该类而言，该指令是用来进行实例初始化方法的调用。鉴于该指令篇幅，具体可以查阅《深入java虚拟机》中描述。上面例子中，即通过其中一个引用调用string类的构造器，初始化对象实例，让另一个相同的引用指向这个被初始化的对象实例，然后前一个引用弹出操作数栈。

astore_1指令格式：astore_1
astore_1指令过程：
要执行astore_1指令，jvm从操作数栈顶部弹出一个引用类型或者returnaddress类型值，然后将该值存入由索引1指定的局部变量中,即将引用类型或者returnaddress类型值存入局部变量1。

return 指令的过程:
从方法中返回，返回值为void。

要执行astore_1指令，jvm从操作数栈顶部弹出一个引用类型或者returnaddress类型值，然后将该值存入由索引1指定的局部变量中,即将引用类型或者returnaddress类型值存入局部变量1。

通过上面6个指令，可以看出，string s = new string("hello");中的hello存储在堆空间中，而s则是在操作数栈中。
上面是对s和haha值的内存情况的分析和理解；那对于string s = new string("hello");语句,到底创建了几个对象呢?
我的理解：这里"hello"本身就是常量池中的一个对象，而在运行时执行new string()时，将常量池中的对象复制一份放到堆中，并且把堆中的这个对象的引用交给s持有。所以这条语句就创建了2个string对象。

下面是一些string相关的常见问题：
String中的final用法和理解
final stringbuffer a = new stringbuffer("111");
final stringbuffer b = new stringbuffer("222");
a=b;//此句编译不通过
final stringbuffer a = new stringbuffer("111");
a.append("222");//编译通过
可见，final只对引用的"值"(即内存地址)有效，它迫使引用只能指向初始指向的那个对象，改变它的指向会导致编译期错误。至于它所指向的对象的变化，final是不负责的。

String 常量池问题的几个例子
下面是几个常见例子的比较分析和理解：
【1】

Java code

String a = "a1"; String b = "a" + 1; System.out.println((a == b)); //result = true String a = "atrue"; String b = "a" + "true"; System.out.println((a == b)); //result = true String a = "a3.4"; String b = "a" + 3.4; System.out.println((a == b)); //result = true

分析：jvm对于字符串常量的"+"号连接，将程序编译期，jvm就将常量字符串的"+"连接优化为连接后的值，拿"a" + 1来说，经编译器优化后在class中就已经是a1。在编译期其字符串常量的值就确定下来，故上面程序最终的结果都为true。

【2】

Java code

String a = "ab"; String bb = "b"; String b = "a" + bb; System.out.println((a == b)); //result = false

分析：jvm对于字符串引用，由于在字符串的"+"连接中，有字符串引用存在，而引用的值在程序编译期是无法确定的，即"a" + bb无法被编译器优化，只有在程序运行期来动态分配并将连接后的新地址赋给b。所以上面程序的结果也就为false。

【3】

Java code

String a = "ab"; final String bb = "b"; String b = "a" + bb; System.out.println((a == b)); //result = true

分析：和[3]中唯一不同的是bb字符串加了final修饰，对于final修饰的变量，它在编译时被解析为常量值的一个本地拷贝存储到自己的常量池中或嵌入到它的字节码流中。所以此时的"a" + bb和"a" + "b"效果是一样的。故上面程序的结果为true。

【4】

Java code

String a = "ab"; final String bb = getbb(); String b = "a" + bb; System.out.println((a == b)); //result = false private static string getbb() { return "b"; }

分析：jvm对于字符串引用bb，它的值在编译期无法确定，只有在程序运行期调用方法后，将方法的返回值和"a"来动态连接并分配地址为b，故上面程序的结果为false。

通过上面4个例子可以得出得知：
string s = "a" + "b" + "c";
就等价于string s = "abc";

string a = "a";
string b = "b";
string c = "c";
string s = a + b + c;
这个就不一样了，最终结果等于：
stringbuffer temp = new stringbuffer();
temp.append(a).append(b).append(c);
string s = temp.tostring();
由上面的分析结果，可就不难推断出string 采用连接运算符（+）效率低下原因分析，形如这样的代码：

Java code

public class test { public static void main (String args[]) { String s = null; for (int i = 0; i < 100; i++) { s += "a"; } } }

每做一次 + 就产生个stringbuilder对象，然后append后就扔掉。下次循环再到达时重新产生个stringbuilder对象，然后 append 字符串，如此循环直至结束。如果我们直接采用 stringbuilder 对象进行 append 的话，我们可以节省 n - 1 次创建和销毁对象的时间。所以对于在循环中要进行字符串连接的应用，一般都是用stringbuffer或stringbulider对象来进行append操作。

string对象的intern方法理解和分析：

Java code

public class test4 { private static String a = "ab"; public static void main (String[] args){ String s1 = "a"; String s2 = "b"; String s = s1 + s2; System.out.println(s == a);//false System.out.println(s.intern() == a);//true } }

这里用到java里面是一个常量池的问题。对于s1+s2操作，其实是在堆里面重新创建了一个新的对象,s保存的是这个新对象在堆空间的的内容，所以s与a的值是不相等的。而当调用s.intern()方法，却可以返回s在常量池中的地址值，因为a的值存储在常量池中，故s.intern和a的值相等。

zhb8015 2012-04-27 15:42 发表评论

openssl生成https证书 (转)

zhb8015 — Mon, 23 Apr 2012 10:31:00 GMT

1.首先要生成服务器端的私钥(key文件):
openssl genrsa -des3 -out server.key 1024
运行时会提示输入密码,此密码用于加密key文件
去除key文件口令的命令:
openssl rsa -in server.key -out server.key

2.openssl req -new -key server.key -out server.csr -config openssl.cfg
生成Certificate Signing Request（CSR）,生成的csr文件交给CA签名后形成服务端自己的证书.屏幕上将有提示,依照其指示一步一步输入要求的个人信息即可.

3.对客户端也作同样的命令生成key及csr文件:
openssl genrsa -des3 -out client.key 1024
openssl req -new -key client.key -out client.csr -config openssl.cfg

4.CSR文件必须有CA的签名才可形成证书.可将此文件发送到verisign等地方由它验证.自己生成：
openssl req -new -x509 -keyout ca.key -out ca.crt -config openssl.cfg

5.用生成的CA的证书为刚才生成的server.csr,client.csr文件签名:
Openssl ca -in server.csr -out server.crt -cert ca.crt -keyfile ca.key -config openssl.cfg
Openssl ca -in client.csr -out client.crt -cert ca.crt -keyfile ca.key -config openssl.cfg

PS:如报update database之类的错误，把index.txt.attr 文件内容更新为 unique_subject = no

注意: 此时会出错：Using configuration from /usr/share/ssl/openssl.cfg I am unable to access the ./demoCA/newcerts directory ./demoCA/newcerts: No such file or directory
解决方法： 1).mkdir -p ./demoCA/newcerts
       　　 2).touch demoCA/index.txt
    　　　　 3).touch demoCA/serial
   　　　　　4).echo 01 > demoCA/serial

6.合并证书文件（crt）和私钥文件（key）

1).cat client.crt client.key > client.pem

2).cat server.crt server.key > server.pem

7.合并成pfx证书

1).openssl pkcs12 -export -clcerts -in client.crt -inkey client.key -out client.p12
2).openssl pkcs12 -export -clcerts -in server.crt -inkey server.key -out server.p12
8.文本化证书

1).openssl pkcs12 -in client.p12 -out client.txt

2).openssl pkcs12 -in server.p12 -out server.txt

9.屏幕模式显式：（证书、私钥、公钥）

1).openssl x509 -in client.crt -noout -text -modulus

2).openssl rsa -in server.key -noout -text -modulus

3).openssl rsa -in server.pub -noout -text -modulus

10.得到DH

1).openssl dhparam -out dh1024.pem 1024

(8) 编辑apache的配置文件httpd.cfg
开启: LoadModule ssl_module modules/mod_ssl.so
去掉以下语句的注释, Include conf/extra/httpd-ssl.cfg
# Secure (SSL/TLS) connections
Include conf/extra/httpd-ssl.cfg
#
(9) 编辑 conf/extra/httpd-ssl.cfg

   SSLEngine On
   SSLCertificateFile conf/ssl/server.crt
   SSLCertificateKeyFile conf/ssl/server.key
   SSLCertificateChainFile conf/ssl/ca.crt

cd /usr/local/apache/conf
openssl genrsa -des3 -out server.key 1024
openssl req -new -key server.key -out server.csr -config /usr/local/ssl/openssl.cfg
openssl req -new -x509 -keyout ca.key -out ca.crt -config /usr/local/ssl/openssl.cfg
mkdir -p ./demoCA/newcerts
touch demoCA/index.txt
touch demoCA/serial
echo 01 > demoCA/serial
openssl ca -in server.csr -out server.crt -cert ca.crt -keyfile ca.key -config /usr/local/ssl/openssl.cfg
bin/apachectl start

zhb8015 2012-04-23 18:31 发表评论

java深浅复制

zhb8015 — Fri, 13 Apr 2012 06:47:00 GMT

摘要: 一、概念二、实现方式及简单原理三、实例四、参考五、单元测试六、代码下载（deepCopy.rar）一、概念 A、浅复制：浅复制仅仅复制所考虑的对象，而不复制它所引用的对象被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。 B、深复制：深复制把要复制的对象所引用的对象都复制了一遍被复制对象的所有变量都含有与原来的对... 阅读全文

zhb8015 2012-04-13 14:47 发表评论

求质数，难以理解的代码，有兴趣可以看一下

zhb8015 — Thu, 12 Apr 2012 08:21:00 GMT

摘要: 求1.。x的质数？这样的问题相信大家都很熟悉，我这里有两个版本，其中有一点不太明白，希望大家指点一下。一、简单的版本二、复杂但艺术的版本(write by Robert C. Martin）问题：都用到了Math.sqrt(x),为什么用平方根，原理是什么呢？一、简单的版本 Code highlighting produced by Actipro CodeHighlighter (freewa... 阅读全文

zhb8015 2012-04-12 16:21 发表评论

JUnit 4使用手册(转)

zhb8015 — Wed, 11 Apr 2012 03:12:00 GMT

JUnit 4使用手册

笔者此前使用过JUnit 3，工作关系很长时间没再碰Java了。最近重新接触了一下，发现JUnit 4和3有较大区别，特总结一下JUnit 4的基本用法，供自己查阅也供朋友们参考。

一、JUnit简介

JUnit由Kent Beck和ErichGamma开发，几乎毫无疑问是迄今所开发的最重要的第三方Java库，它也成为了Java语言事实上的标准单元测试库。正如Martin Fowler所说，“在软件开发领域，从来就没有如此少的代码起到了如此重要的作用”。JUnit引导并促进了测试先行的编程和测试驱动的开发。
JUnit 4是该库三年以来最具里程碑意义的一次发布。它的新特性主要是通过采用Java 5中的标记annotation）而不是利用子类、反射或命名机制来识别测试，从而简化测试代码。用Kent的话来说，“JUnit 4 的主题是通过进一步简化 JUnit，鼓励更多的开发人员编写更多的测试。”

二、JUnit4实践

选择一款IDE（Eclipse, NetBean, Idea等），基本上它们都全面支持JUnit了。创建工程后，为了避免代码混乱，建议为单元测试代码与被测试代码分别创建单独的目录。首先，写一个很简单的方法，判断输入的邮箱地址是否符合规范：

1
public static boolean checkEmail(String email) { 

2
    if (!email.matches("[\\w\\.\\-]+@([\\w\\-]+\\.)+[\\w\\-]+")) { 

3
        return false; 

4
    } 

5
    return true; 

6
}

OK，一切准备就绪，我们开始编写这个方法的单元测试用例。

1、测试由@Test注释开始

1
@Test 

2
public void checkEmail(){ 

3
    assertEquals(true, RegexUtil.checkEmail("add.dd@sina.com")); 

4
}

以前版本的JUnit通过命名约定和反射来定位测试用例，要求测试方法以”test”开头+方法名，并且测试类需要继承TestCase。JUnit 4中简化了这个操作，只需要在测试类中引入org.junit.Test，在测试方法前使用注解@Test，JUnit就可以侦测该测试方法了，保持了代码的简洁。
注：在JUnit4中仍然可以以原来的方式进行测试（继承TestCase并在方法前加test）。但是如果这样就最好不要使用注解。因为一旦继承了TestCase，注解会失效，如果没有test前缀，会报：AssertionFailedError: No tests found…异常。

2、Fixture
它是指在执行一个或者多个测试方法时需要的一系列公共资源或者数据，例如测试环境，测试数据等。JUnit专门提供了设置公共Fixture的方法，同一测试类中的所有测试方法都可以共用它来初始化Fixture和注销Fixture。在以前的版本，JUnit使用SetUp和TearDown方法。在JUnit4中，使用注解org,junit.Before和org.junit.After。例如：

1
@Before 

2
public void initialize (){……} 

3
@After 

4
public void dispose (){……}

       这样，在每一个测试方法执行之前，JUnit会保证注解了Before的方法提前执行。当测试方法执行完毕后，JUnit调用注解了After的方法注销测试环境。
       注：@Before和@After修饰的是方法级别的。它们都可以修饰多个方法，但是方法执行的顺序不能保证。
       在JUnit 4中还引入了类级别的Fixture设置方法，即使用注解 BeforeClass和AfterClass。这两种方法都使用 public static void 修饰，且不能带有任何参数。类级别的Fixture仅会在测试类中所有测试方法执行之前和之后执行。

3、异常和测试时间
JUnit 4中引入了异常的测试，以前版本中异常测试是在抛出异常的代码中放入try块，然后在try块的末尾加入fail语句。在JUnit 4中，可以使用@Test中的expected参数，它表示测试方法期望抛出的异常，如果运行测试并没有抛出这个异常，则JUnit会认为这个测试没有通过。例如：

1
@Test(expected= IndexOutOfBoundsException.class) 

2
public void empty() { 

3
    new ArrayList().get(1); 

4
}

@Test的另一个参数timeout，用来指定被测试方法被允许运行的最长时间。如果测试方法运行时间超过了指定的毫秒数，则JUnit认为测试失败。例如：

1
@Test(timeout = 10) 

2
public void checkEmail(){ 

3
    assertEquals(true, RegexUtil.checkEmail("add.dd@sina.com")); 

4
}

4、忽略测试方法
JUnit 4提供注解org.junit.Ignore用于暂时忽略某个测试方法。例如：

1
@Ignore(“db is down”) 

2
@Test(expected=UnsupportedDBVersionException.class) 

3
public void unsupportedDBCheck(){　……  }

5、测试用例的执行
JUnit中所有的测试用例都是由测试运行器执行的。JUnit提供了默认的测试运行器，但并没有限制我们必须使用默认的运行器（所有的运行器都继承自Runner）。相反，我们不仅可以定制自己的运行器，而且还可以为每个测试类指定使用某个运行器（使用@RunWith）。例如JUnit的自测代码：

01
public class RunWithTest { 

02
    private static String log; 

03
    public static class ExampleRunner extends Runner { 

04
        public ExampleRunner(Class klass) { 

05
            log+= "initialize"; 

06
        } 

07
        @Override

08
        public void run(RunNotifier notifier) { 

09
            log+= "run"; 

10
        } 

11
        @Override

12
        public Description getDescription() { 

13
            log+= "plan"; 

14
            return Description.createSuiteDescription("example"); 

15
        } 

16
    } 

17
    @RunWith(ExampleRunner.class) 

18
    public static class ExampleTest { 

19
    } 

20
    @Test public void run() { 

21
        log= ""; 

22
        JUnitCore.runClasses(ExampleTest.class); 

23
        assertTrue(log.contains("plan")); 

24
        assertTrue(log.contains("initialize")); 

25
        assertTrue(log.contains("run")); 

26
    } 

27
}

显而易见，如果测试类没有显式的声明使用哪一个测试运行器，JUnit 会启动默认的测试运行器执行测试类。一般情况下，默认测试运行器可以应对绝大多数的测试要求；当使用 JUnit 提供的一些高级特性或者针对特殊需求定制 JUnit 测试方式时，显式的声明测试运行器就必不可少了。

6、测试套件Suite
正如JUnit以前版本中提供的Suite一样，JUnit4提供了一种批量运行测试类的方法，以方便我们在每次进行系统测试时，只需执行若干测试套件而不是执行无数测试用例。我们只需创建一个空类，并填写两个注解。例如：

1
@RunWith(Suite.class) 

2
@Suite.SuiteClasses({TestCheckEmail.class, TestTimeUtil.class}) 

3
public class CustomizeRunner{ 

4
}

测试套件中不仅可以包含基本的测试类，而且可以包含其它的测试套件。但是，一定要保证测试套件之间没有循环包含关系，否则将出现死循环。

7、参数化测试
当我们编写了大量的单元测试方法后，我们发现这些方法其实大同小异，只是参数不同（测试边界值或者测试异常值）。在以前的 JUnit版本上，并没有好的解决方法，而现在我们可以使用JUnit提供的参数化测试方式解决这个问题。
首先在测试类中指定参数运行期@RunWith(Parameterized.class)。例如：

01
@RunWith(Parameterized.class) 

02
public class TestWithParam { 

03
    @Parameterized.Parameters 

04
    public static List data() { 

05
        return Arrays.asList(new Object[][]{ 

06
            {0, 0}, {1, 1}, {2, 1}, {3, 2}, {4, 3}, {5, 5}, {6, 8},{10,55} 

07
        }); 

08
    } 

09
    private int fInput; 

10
    private int fExpected; 

11
    public testWithParam(int input, int expected) { 

12
        fInput = input; 

13
        fExpected = expected; 

14
    } 

15
    @Test

16
    public void test() { 

17
        assertEquals(fExpected, Fibonacci.compute(fInput)); 

18
    } 

19
    private static class Fibonacci{ 

20
        public static int compute(int input){ 

21
            if(input ==0) 

22
                return 0; 

23
            else if (input==1) 

24
                return 1; 

25
            else if (input==2) 

26
                return 1; 

27
            else return compute(input-1)+compute(input-2); 

28
        } 

29
    } 

30
}

在静态方法data中，我们使用二维数组来构建测试所需要的参数列表，其中每个数组中的元素的放置顺序只要和构造函数中的顺序保持一致就可以了。

参考文献：

1.单元测试利器 JUnit 4：http://www.ibm.com/developerworks/cn/java/j-lo-junit4/
2.JUnit 4 JavaDoc

zhb8015 2012-04-11 11:12 发表评论

BlogJava-zhb8015-文章分类-interview

Nutch vs Lucene(转)

ArrayList空间增长是怎么样的

手工打包（jar）

TW interview experience(转)

排序算法（转）

org.luosijin.test 类 Sort

Sort

bubbleSort

quickSort

selectSort

insertSort

mergeSort

merge

加密算法（转）

软件设计过程一些术语 AN BD FD DD CD CT

BD FD DD

软件开发测试过程的一些缩写和解释,感觉不太准确,望补充

正解 AN BD FD DD CD UT CT TT IT ST UAT OP

Log4j详细配置（转）

log4j详解

时间复杂度

编辑本段算法复杂度

编辑本段时间复杂度

1.时间频度

2.计算方法

3.分类

编辑本段空间复杂度

Java栈与堆（转）

也说Java循环优化(转)

javap

java对象池技术（Jakarta对象池）

浅谈java内存模型 (转 经经典)

设计模式大集锦 程序员面试(转)

设计模式大集锦 程序员面试全攻略

什么是hashcode （转）

hashcode面试题

JVM小结

JVM内存管理机制

1.JVM内存管理的机制

2.Java堆和栈的区别

3.Java内存泄露和内存溢出

4.Java类加载机制

5.内存回收

一场IBM面试题引发的讨论：创建String对象过程中【内存分配】(转)

openssl生成https证书 (转)

java深浅复制

求质数，难以理解的代码，有兴趣可以看一下

JUnit 4使用手册(转)

JUnit 4使用手册

一、JUnit简介

二、JUnit4实践

org.luosijin.test
类 Sort

浅谈java内存模型 (转经经典)

设计模式大集锦程序员面试(转)

设计模式大集锦程序员面试全攻略