wikijava

A. java解决逻辑问题-》“Zebra Puzzle” http://en.wikipedia.org/wiki/Zebra_puzzle

本来以为是很简单的，没想到越写越僵了...总之，我的思路就是不断的尝试，遇到发生矛盾的话就回溯，直到所有的条件都满足，下面贴的代码在main方法中调用ZebraPuzzle的方法创建题目中的条件，最后打印出推导出来的表格，有了表格就什么信息都有了。当然可能还有（几乎是肯定有）很多漏洞，因为一个测试例子是不足以检测所有逻辑的。。。另外这里也没有包括纠错的逻辑，比如如果题目本身是矛盾的话，我就不知道会发生什么了。。。

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

public class Test {

public static void main(String[] args) {
String[] attributeName =
{ "Color", "Nationality", "Drink", "Cigarette", "Pet" };
ZebraPuzzle puzzle = new ZebraPuzzle(5, attributeName);

puzzle.bindCondition("Nationality", "ENG", "Color", "Red");
puzzle.bindCondition("Nationality", "ESP", "Pet", "Dog");
puzzle.bindCondition("Drink", "Coffee", "Color", "Green");
puzzle.bindCondition("Nationality", "UKR", "Drink", "Tea");
puzzle.bindNeighbour("Color", "Ivory", "Color", "Green", true);
puzzle.bindCondition("Cigarette", "OldGold", "Pet", "Snail");
puzzle.bindCondition("Cigarette", "Kool", "Color", "Yellow");
puzzle.bindOrdinal("Drink", "Milk", 3);
puzzle.bindOrdinal("Nationality", "NOW", 1);
puzzle.bindNeighbour("Cigarette", "Chester", "Pet", "Fox", false);
puzzle.bindNeighbour("Cigarette", "Kool", "Pet", "Horse", false);
puzzle.bindCondition("Cigarette", "Lucky", "Drink", "Juice");
puzzle.bindCondition("Nationality", "JPN", "Cigarette", "Parliament");
puzzle.bindNeighbour("Nationality", "NOW", "Color", "Blue", false);

boolean result = puzzle.solve();
System.out.println(result);
puzzle.printTable();

}

}

class ZebraPuzzle {

private List<Fact> conditions;
private String[] attributes;
private Unit[] units;

public ZebraPuzzle(int n, String[] attrs) {
attributes = attrs;
conditions = new ArrayList<Fact>();
units = new Unit[n];
for (int i = 0; i < n; ++i) {
units[i] = new Unit(i+1, attributes);
}
}

public void bindCondition(String type1, String attr1, String type2, String attr2) {
conditions.add(new BinderFact(type1, attr1, type2, attr2));
}

public void bindNeighbour(String type1, String attr1, String type2,
String attr2, boolean sideSensitive) {
if (sideSensitive) {
conditions.add(new SideSensitiveNeighbourFact(type1, attr1, type2, attr2));
} else {
conditions.add(new NeighbourFact(type1, attr1, type2, attr2));
}
}

public void bindOrdinal(String type, String attr, int ordinal) {
conditions.add(new OrdinalFact(type, attr, ordinal));
}

public boolean solve() {
applyOrdinalFact();
applyDeterministicFactor();
return solve(0);
}

private boolean solve(int depth) {
if (depth == conditions.size()) {
return true;
}
Fact fact = conditions.get(depth);
List<PossibleFact> possibles = fact.getPossibleFacts(units);
if (possibles.size() == 0) {
return false;
}
for (PossibleFact pf : possibles) {
pf.apply(units);
if (solve(depth + 1)) {
return true;
}
pf.cancel(units);
}
return false;
}

private void directApply(OrdinalFact fact) {
units[fact.ordinal-1].setOrdinalFact(fact);
}

private void applyOrdinalFact() {
Iterator<Fact> iter = conditions.iterator();
while (iter.hasNext()) {
Fact fact = iter.next();
if (fact instanceof OrdinalFact) {
directApply((OrdinalFact) fact);
iter.remove();
}
}
}

private void applyDeterministicFactor() {
boolean modified;
while (!conditions.isEmpty()) {
modified = false;
Iterator<Fact> iter = conditions.iterator();
while (iter.hasNext()) {
Fact fact = iter.next();
if (fact.tryApply(units)) {
iter.remove();
modified = true;
}
}
if (!modified) {
break;
}
}
}

public void printTable() {
System.out.print("\t\t");
for (String attribute : attributes) {
System.out.printf("%s\t\t", attribute);
}
System.out.print("\n");
for (Unit unit : units) {
System.out.printf("%d\t\t", unit.ordinal);
for (String attribute : attributes) {
System.out.printf("%s\t\t", unit.getAttribute(attribute));
}
System.out.print("\n");
}
System.out.println();
}

}

enum AttributeState { UNKNOWN, DIFFERENT, SELF }

class Unit {

Unit(int ordinal, String[] attributes) {
this.ordinal = ordinal;
map = new HashMap<String, String>();
for (String attr : attributes) {
map.put(attr, Fact.UNKNOWN);
}
}

void setOrdinalFact(OrdinalFact fact) {
map.put(fact.type, fact.attribute);
}

void setAttribute(String type, String attribute) {
map.put(type, attribute);
}

boolean containsAttribute(String type, String attribute) {
return attribute.equals(map.get(type));
}

boolean containsDifferentOne(String type, String attribute) {
String s = map.get(type);
return s != Fact.UNKNOWN && !s.equals(attribute);
}

AttributeState consultAttribute(String type, String attribute) {
String s = map.get(type);
if (s == Fact.UNKNOWN) {
return AttributeState.UNKNOWN;
}
if (s.equals(attribute)) {
return AttributeState.SELF;
}
return AttributeState.DIFFERENT;
}

Unit getRightUnit(Unit[] units) {
if (ordinal == units.length) {
return null;
}
return units[ordinal];
}

String getAttribute(String attributeName) {
return map.get(attributeName);
}

Map<String, String> map;
int ordinal;

}

interface Fact {
static final String UNKNOWN = "Unknown";
public List<PossibleFact> getPossibleFacts(Unit[] units);
public boolean tryApply(Unit[] units);
}

interface PossibleFact {
public void apply(Unit[] units);
public void cancel(Unit[] units);
}

abstract class AbstractFact implements Fact {
public boolean tryApply(Unit[] units) {
return false;
}

protected Unit findOwner(Unit[] units, String type, String attribute) {
for (Unit unit : units) {
if (unit.containsAttribute(type, attribute)) {
return unit;
}
}
return null;
}

public List<PossibleFact> getPossibleFacts(Unit[] units) {
return Collections.emptyList();
}
}

class BinderFact extends AbstractFact {
String type1, attribute1;
String type2, attribute2;

BinderFact(String t1, String attr1, String t2, String attr2) {
type1 = t1;
attribute1 = attr1;
type2 = t2;
attribute2 = attr2;
}

public boolean tryApply(Unit[] units) {
Unit unit = super.findOwner(units, type1, attribute1);
if (unit != null) {
return tryApply(unit, type2, attribute2);
}
unit = super.findOwner(units, type2, attribute2);
if (unit != null) {
return tryApply(unit, type1, attribute1);
}
return false;
}

protected boolean tryApply(Unit unit, String type, String attribute) {
if (unit.containsDifferentOne(type, attribute)) {
throw new RuntimeException();
}
unit.setAttribute(type, attribute);
return true;
}

public List<PossibleFact> getPossibleFacts(Unit[] units) {
List<PossibleFact> list = new ArrayList<PossibleFact>();
for (Unit unit : units) {
AttributeState as1 = unit.consultAttribute(type1, attribute1), as2 = unit.consultAttribute(type2, attribute2);
if (as1 != AttributeState.DIFFERENT && as2 != AttributeState.DIFFERENT) {
list.add(new PossiblebBinderFact(unit.ordinal, this,
as1 == AttributeState.UNKNOWN,
as2 == AttributeState.UNKNOWN
));
}

}
return list;
}

private static class PossiblebBinderFact implements PossibleFact {
BinderFact fact;
boolean firstNew, secondNew;
int n;
PossiblebBinderFact(int n, BinderFact fact, boolean fn, boolean sn) {
this.fact = fact;
firstNew = fn;
secondNew = sn;
this.n = n;
}
public void apply(Unit[] units) {
if (firstNew) {
units[n-1].setAttribute(fact.type1, fact.attribute1);
}
if (secondNew) {
units[n-1].setAttribute(fact.type2, fact.attribute2);
}
}

public void cancel(Unit[] units) {
if (firstNew) {
units[n-1].setAttribute(fact.type1, Fact.UNKNOWN);
}
if (secondNew) {
units[n-1].setAttribute(fact.type2, Fact.UNKNOWN);
}
}

}
}

class NeighbourFact extends BinderFact {

NeighbourFact(String t1, String attr1, String t2, String attr2) {
super(t1, attr1, t2, attr2);
}

public boolean tryApply(Unit[] units) {
if (tryApply(units, type1, attribute1, type2, attribute2)) {
return true;
}
if (tryApply(units, type2, attribute2, type1, attribute1)) {
return true;
}
return false;
}

protected boolean tryApply(Unit[] units, String t1, String attr1,
String t2, String attr2) {
Unit unit = super.findOwner(units, t1, attr1);
if (unit == null) {
return false;
}
Unit right = unit.getRightUnit(units);
if (right == null) {
return false;
}
return super.tryApply(right, t2, attr2);
}

public List<PossibleFact> getPossibleFacts(Unit[] units) {
List<PossibleFact> list = new ArrayList<PossibleFact>();
getPossibleFacts(units, list, type1, attribute1, type2, attribute2);
getPossibleFacts(units, list, type2, attribute2, type1, attribute1);
return list;
}

protected void getPossibleFacts(Unit[] units, List<PossibleFact> list,
String t1, String attr1, String t2, String attr2) {
for (int i = 0; i < units.length - 1; ++i) {
Unit unit1 = units[i], unit2 = units[i + 1];
AttributeState as1 = unit1.consultAttribute(t1, attr1), as2 = unit2.consultAttribute(t2, attr2);
if (as1 != AttributeState.DIFFERENT && as2 != AttributeState.DIFFERENT) {
list.add(new PossibleNeighbourFact(t1, attr1, t2, attr2,
i, i+1, as1 == AttributeState.UNKNOWN,
as2 == AttributeState.UNKNOWN
));
}
}
}

private static class PossibleNeighbourFact implements PossibleFact {
String type1, attribute1, type2, attribute2;
boolean firstNew, secondNew;
int n1, n2;

PossibleNeighbourFact(String t1, String a1, String t2, String a2,
int n1, int n2, boolean fn, boolean sn) {
type1 = t1;
attribute1 = a1;
type2 = t2;
attribute2 = a2;
firstNew = fn;
secondNew = sn;
this.n1 = n1;
this.n2 = n2;
}
public void apply(Unit[] units) {
if (firstNew) {
units[n1].setAttribute(type1, attribute1);
}
if (secondNew) {
units[n2].setAttribute(type2, attribute2);
}
}

public void cancel(Unit[] units) {
if (firstNew) {
units[n1].setAttribute(type1, Fact.UNKNOWN);
}
if (secondNew) {
units[n2].setAttribute(type2, Fact.UNKNOWN);
}
}

}

}

class SideSensitiveNeighbourFact extends NeighbourFact {

SideSensitiveNeighbourFact(String t1, String attr1, String t2, String attr2) {
super(t1, attr1, t2, attr2);
}

public boolean tryApply(Unit[] units) {
return super.tryApply(units, type1, attribute1, type2, attribute2);
}

public List<PossibleFact> getPossibleFacts(Unit[] units) {
List<PossibleFact> list = new ArrayList<PossibleFact>();
getPossibleFacts(units, list, type1, attribute1, type2, attribute2);
return list;
}

}

class OrdinalFact extends AbstractFact {
String type, attribute;
int ordinal;

OrdinalFact(String t, String attr, int ord) {
type = t;
attribute = attr;
ordinal = ord;
}

}

B. 什么是JAVA

Java手机软件平台采用的基本Java平台是CLDC (Connected Limited Device Configuration)和MIDP (Mobile Information Device Profile)，是J2ME (Java 2 Micro Edition)的一部分，在中国一般称为“无线Java”技术。此前，有人把它叫做“K-Java”；其实，K-Java的叫法只是Sun公司在开发 KVM Java虚拟机时的项目代号，在该技术被正式命名为KVM后，就不再用K-Java了。
Java技术的开放性、安全性和庞大的社会已有资源，以及其跨平台性，即“编写一次，到处运行”的特点，使Java技术成为智能手机软件平台的事实标准。

Java，是一种可以编写跨平台应用软件的面向对象的程序设计语言，由升阳（太阳微电子，Sun Microsystems）公司的James Gosling等人于1990年代初开发

参考资料：zh.wikipedia.org/wiki/Java

Java好象随处可见 - 甚至在TV中。尽管如此，说清楚Java是什
么和它能做什么却不那么容易。刚开始接触Java的人通常有三
个问题：

什么是Java？
Java能做什么？
Java怎样改变我的生活？

让我们先回答第一个问题：什么是Java？

Java既是一种编程语言，又是一个平台。

Java程序语言

Java是具有以下特征的高级程序语言：

* 简单
* 面向对象
* 可分布
* 可解释
* 强壮
* 安全性
* 结构化
* 轻便
* 功能强大
* 多线程
* 动态

Java既可以被编译，也可以被解释。通过编译器，可以把Java
程序翻译成一种中间代码 - 称为字节码 - 可以被Java解释器
解释的独立于平台的代码。通过解释器，每条Java字节指令被
分析，然后在计算机上运行。只需编译一次，程序运行时解释
执行。下图说明了它是如何工作的：

1flow.gif (3652 bytes)

可以把Java字节码看作运行在Java虚拟机（Java VM）上的机器
代码指令。每中Java解释器，不管是Java开发工具还是可以运
行Java小应用程序的Web浏览器，都是一种Java VM的实例。Java
VM也可以由硬件实现。

Java字节码使“写一次，到处运行”成为可能。可以在任何有
Java编译器的平台上把Java程序编译成字节码。这个字节码可以
运行在任何Java VM上。例如，同一个Java程序可以运行在Windows
NT、Solaris和Macintosh上。

2comp.gif (6076 bytes)

Java平台

平台是程序运行的硬件或软件环境。Java平台与大多数其它平台
不同之处在于它是运行于其它基于硬件平台的纯软件平台。大
多数其它平台是硬件和操作系统的结合。

Java平台由两部分组成：

* Java虚拟机（Java VM）
* Java应用程序界面（Java API）

我们已经介绍了Java VM，它是Java平台的基础，可以移植到各
种基于硬件的平台上。

Java API是软件组件的集合，它们提供了很多有用的功能，如图
形用户界面（GUI）。Java API被分组为相关组件的库（包）。

下图描述了一个运行在Java平台上的Java程序，如应用程
序（application）或小应用程序（applet）。如图中显示的，Java
API和VM把Java程序从硬件依赖中分离出来。

3play.gif (1479 bytes)

作为一种独立于平台的环境，Java比本地代码慢一些。然而，聪
明的编译器、很好地调制过的解释器和即时字节码编译器可以
在不牺牲可移植性的条件下使Java的表现接近本地代码。

C. java 开发的wiki开源项目哪个比较好

https://hackpad.com/
https://www.oschina.net/p/xwiki
这两个你可以参考下。

D. java 正则表达提取字符串";/w ;/w INFORMATION EXTRACTION/KW ;/w ;/w WIKI系统/KW"中的子串。

Java正则表达式:(?<=^|/KW)([\s\S]+?)/KW

完整的Java程序如下:(你字符串中的;/w我理解为空格或者tab字符,我用trim()函数去掉它)

importjava.util.regex.Matcher;

importjava.util.regex.Pattern;

publicclassA{

publicstaticvoidmain(String[]args){

Strings="INFORMATIONEXTRACTION/KWWIKI系统/KW";

Stringregex="(?<=^|/KW)([\s\S]+?)/KW";

Patternp=Pattern.compile(regex);

Matcherm=p.matcher(s);

while(m.find()){

System.out.println(m.group(1).trim());

}

}

}

运行结果:

INFORMATION EXTRACTION
WIKI系统

E. [关于xwiki]如何使用java实现向xwiki中去import一个xar。麻烦带个例子，谢谢。

xwiki是一个开源网络系统，网上的二次开发介绍挺少的，这里会根据我开发中的具体问题进行总结。由于我是边开发边写本文，最开始我也会很多都不清楚，请大家多指教。
目前xwiki的版本是5.2.1，我本地测试的版本是4.4.1 可能会有一些差异。
需要环境：tomcat服务器、mysql数据库，jdk，
1、下载xwiki
地址：http://enterprise.xwiki.org/xwiki/bin/view/Main/Download
其中包含了安装包和源代码包。（打开源代码你会发现是一堆maven项目，可能会修改的代码主要在xwiki-platform-master项目中。基本我们都是不需要修改java代码的，不过这个项目下面是很多你能接触到的，比如说搜索）
你最需要下载的包是war file。如下图：
下载的文件里面应该有一个xar结尾的文件，这个是xwiki的模板，如果没有，请寻找对应的版本下载一个。
下载地址在改页面能够找到。
2、tomcat下安装xwiki，并配置相关环境
前期准备：tomcat服务器，和mysql数据库。（这个安装就不用介绍了，我也是做测试使用，tomcat是使用版本6）
将xwiki的war文件放在tomcat目录下的webapps文件夹下，然后启动tomcat。（双击tomcat目录下bin文件夹中的startup.bat就好了，linux下是startup.sh）
此时xwiki项目会解压缩，并且在xwiki下部署一个项目。你会发现tomcat会报错，先不用管它。
3、进行参数配置
将mysql的驱动jar文件放到tomcat目录下的lib文件夹下面（也可以放到对应项目下面的lib文件夹）。
将xwiki.cfg文件下的xwiki.superadminpassword=system这个一行前面的注释去掉，这样可以你就可以使用帐号superadmin/system登陆了，这个是管理员权限。
建议将hsqldb数据库部分注释掉。（我就不截图啦）
放开mysql连接部分的注释，并且配置对应的值，注意，将mysql的驱动名编码格式选择正确（使用utf-8编码格式），配置正确的用户名和密码。
在对应的数据库中建立一个名为xwiki的数据库，注意使用编码格式是utf-8（与你上面的配置相对应，如果你修改的jar当中写死了一个连接，你还要与这个连接数据库名称一致）。
修改mysql的配置文件my.ini，在[mysqld]这一样下面增加一行
max_allowed_packet=32M（因为mysql默认包大小最多是1兆，不修改这个参数的话你今后导入模板包的时候会报错）。
重新启动tomcat（保证mysql是开着的哈）。这时候xwiki会自动在你刚才建立的xwiki数据库中自动建立表格，并且导入部分数据。其中第一个表格，记录了url响应和类的对应关系哦，有兴趣的大神研究一下吧。
4、调试配置xwiki
此时在本地输入localhost/xwiki（如果你tomcat配置不是默认的80端口，请加上你的tomcat服务器的对应端口号，xwiki是我的项目名称，如果你的项目名称，也就是文件夹名字不是这个，请修改为对应的名称）就能进入xwiki的页面了。这个时候你看不到任何文档，也没有模板。
使用上面的帐号superadmin/system进行登录，按照下图进行，找到你下载的xwiki的初始模板.war文件，进行文件导入。

点击你上传的模板，在页面的右边会出现该模板的所以文件。将滚动条移动到最下方会发现有个导入按钮（import）。点击这个按钮导入模板。今后你可能会根据开发需要还要导入很多其他模板，请按照这个过程进行导入。

设置xwiki的语言为中文，en代表因为，zh代表中文（因为不同版本的翻译可能不一样，而且开发文档全部是英文的，可以的话就是用英文吧）

5、简单使用
好了，现在xwiki已经搭建起来了，目前可以基于这个进行开发了。
xwiki的基本模式是先建空间，空间下面可以建立页面（不能再建立空间了），页面下面可以建立子页面。页面和子页面的关系在每个页面information下面能够看到。
如果要进行xwiki的二次开发，那么您需要准备以下知识。
velocity（重要，据说阿里也推崇这个）和groovy，如果需要整体运行java代码的话，您还需要maven的知识。因为你开发xwiki的宏、对象和皮肤都需要可能会使用到这些知识，这些对于大神们肯定都不是问题。

F. 请问在win环境中怎么安装confluence-3.0-std的Java的wiki程序。

打开CRACK文件夹下的KEYGEN.exe
这时候会弹出一个方框.然后你就按照逻辑进行下一步.让他生成一个序列号.然后你再打开安装文件,会让你输入安装序列号.你再把刚才生成的给填进去就成了.希望我的话能对你有所帮助

G. pmwiki 有没有java版本

安装步骤：1、将yalmip放到你的MATLAB的toolbox文件夹下；2、将yalmip文件目录添加到MATLAB的path里（方法：matlab主界面：file->setpath）可直接选Addwithsubfolders注意：要将下面每一个文件目录都添到matlab的path中/yalmip/yalmip/extras/yalmip/demos/yalmip/solvers/yalmip/moles/yalmip/moles/parametric/yalmip/moles/moment/yalmip/moles/global/yalmip/moles/robust/yalmip/moles/sos/yalmip/operators3、重启matlab检验yalmip工具箱是否添成功。键入“whichsdpvar”。就可以了。

H. 推荐一款用 java 开发的，好用的wiki～谢谢

如果你是要做网站开发的话就用
MyEclipse
,如果是做桌面应用程序的话就用
Sun公司的
NetBeans

I. java的monitor机制中,为什么阻塞队列用list等待队列用set

java阻塞队列应用于生产者消费者模式、消息传递、并行任务执行和相关并发设计的大多数常见使用上下文。

BlockingQueue在Queue接口基础上提供了额外的两种类型的操作，分别是获取元素时等待队列变为非空和添加元素时等待空间变为可用。

BlockingQueue新增操作的四种形式：

3.2.1.3 HashMap类

对Map类的另外一个实现是HashMap。HashMap使用Hash表数据结构。HashMap假定哈希函数能够将元素适当的分布在各桶之间，提供一种接近O(1)的查询和更新操作。但是如果需要对集合进行迭代，则与HashMap的容量和桶的大小有关，因此HashMap的迭代效率不会很高（尤其是你为HashMap设置了较大的容量时）。

与HashMap性能有影响的两个参数是，初始容量和加载因子。容量是哈希表中桶的数量，初始容量是哈希表在创建时的容量。加载因子是哈希表在容器容量被自动扩充之前，HashMap能够达到多满的一种程度。当hash表中的条目数超出了加载因子与当前容量的乘积时，Hash表需要进行rehash操作，此时Hash表将会扩充为以前两倍的桶数，这个扩充过程需要进行完全的拷贝工作，效率并不高，因此应当尽量避免。合理的设置Hash表的初始容量和加载因子会提高Hash表的性能。HashMap自身不是线程安全的，可以通过Collections的synchronizedMap方法对HashMap进行包装。

3.2.1.4 ConcurrentHashMap类

ConcurrentHashMap类实现了ConcurrentMap接口，并提供了与HashMap相同的规范和功能。实际上Hash表具有很好的局部可操作性，因为对Hash表的更新操作仅会影响到具体的某个桶（假设更新操作没有引发rehash），对全局并没有显着影响。因此ConcurrentHashMap可以提供很好的并发处理能力。可以通过concurrencyLevel的设置，来控制并发工作线程的数目（默认为16），合理的设置这个值，有时很重要，如果这个值设置的过高，那么很有可能浪费空间和时间，使用的值过低，又会导致线程的争用，对数量估计的过高或过低往往会带来明显的性能影响。最好在创建ConcurrentHashMap时提供一个合理的初始容量，毕竟rehash操作具有较高的代价。

3.2.2 ConcurrentSkipListSet类

实际上Set和Map从结构来说是很像的，从底层的算法原理分析，Set和Map应当属于同源的结构。所以Java也提供了TreeSet和ConcurrentSkipListSet两种SortedSet，分别适合于非多线程（或低并发多线程）和多线程程序使用。具体的算法请参考前述的Map相关介绍，这里不在累述。

3.2.3 CopyOnWriteArrayList类

CopyOnWriteArrayList是ArrayList的一个线程安全的变体，其中对于所有的可变操作都是通过对底层数组进行一次新的复制来实现的。

由于可变操作需要对底层的数据进行一次完全拷贝，因此开销一般较大，但是当遍历操作远远多于可变操作时，此方法将会更有效，这是一种被称为“快照”的模式，数组在迭代器生存期内不会发生更改，因此不会产生冲突。创建迭代器后，迭代器不会反映列表的添加、移除或者更改。不支持在迭代器上进行remove、set和add操作。CopyOnWriteArraySet与CopyOnWriteArrayList相似，只不过是Set类的一个变体。

3.2.3 Collections提供的线程安全的封装

Collections中提供了synchronizedCollection、synchronizedList、synchronizedMap、synchronizedSet、synchronizedSortedMap、synchronizedSortedMap等方法可以完成多种集合的线程安全的包装，如果在并发度不高的情况下，可以考虑使用这些包装方法，不过由于Concurrent相关的类的出现，已经不这么提倡使用这些封装了，这些方法有些人称他们为过时的线程安全机制。

3.2.4简单总结

提供线程安全的集合简单概括分为三类，首先，对于并发性要求很高的需求可以选择以Concurrent开头的相应的集合类，这些类主要包括：ConcurrentHashMap、ConcurrentLinkedQueue、ConcurrentSkipListMap、ConcurrentSkipSet。其次对于可变操作次数远远小于遍历的情况，可以使用CopyOnWriteArrayList和CopyOnWriteArraySet类。最后，对于并发规模比较小的并行需求可以选择Collections类中的相应方法对已有集合进行封装。

此外，本章还对一些集合类的底层实现进行简单探讨，对底层实现的了解有利于对何时使用何种方式作出正确判断。希望大家能够将涉及到原理（主要有循环队列、堆、HashMap、红黑树、SkipList）进行仔细研究，这样才能更深入了解Java为什么这样设计类库，在什么情况使用，应当如何使用。

J. 有没有开源的java制作的类似“百科”或者“维基”的组件

JspWiki 是一套非常容易安装的系统，使用到JSP与Servlet技术。

DevWiki是一个把页面存储在CVS中的Wiki引擎。

Chiki 点击次数：944
基于Struts的Wiki系统。

SnipSnap 是一个基于java的wiki + WebLog

FITNesse是一个 基于FIT的测试环境，. 它内建Wiki服务器，简单易用。

Friki部署简单，非常小只有67k

XWiki是一个强大的Java开源的Wiki引擎。它支持一些受欢迎的特性如：
* 内容管理(浏览/编辑/预览/保存)，
* 支持附件，
* 版本控制，
* 全文本搜索，
* 权限管理
* 使用Hibernate进行数据存储，
* RSS输出与显示外部的RSS feeds，
* 多语言支持，
* 提供XML/RPC的API,
* WYSIWYG HTML编辑器,
* 导出为PDF
* Groovy脚本支持等等....。

ButorWiki这是一个基于java的Wiki,它是一个web应用程序，使用Butor Java 框架与struts MVC 框架。ButorWiki不需要数据库，而是使用文件系统进行数据存储。

Very Quick Wiki是一个JSPs与JavaServlets开发的WikiWiki。在Tomcat或其它容器上安装与运行都很简单。

UseModj这个Wiki引荐运用到Struts框架与Velocity模板。它具有一些新的特性：多语言支持，支持RSS 1.0(rdf),文件/图片的上传与下载,图片大小调整,可以用多种语言命名文件/图片

Platypus Wiki一个Semantic(语义的) Wiki Wiki Web.它提供一个简单的使用基于W3C标准元数据(metadata)的用户接口来创建Wiki页面.Platypus Wiki使用RDF(Resource Description Framework:资源描述框架),RDF Schema和OWL(Web Ontology Language:Web实体语言)来创建实体(Ontology)与管理元数据.

CsaWiki是一个利用Java开发的wiki引擎。它具有以下特点：100%Java(J2EE没有EJB),基于文件没有数据库，版本控制，PDF导出，简单的Wiki sintax等。

Elsie是一个用Java开发的Wiki引擎。它支持大多数流行wiki所应具备的特性包括：简单的wiki markup语法,内容管理(查看, 编辑,附件等...), 版本控制,访问控制列表和用户/组管理,可使用布局模板和CSS来控制外观,一个用于创建公共文档的文档模板,支持I18N和多种语言,搜索等. Elsie实现一个基于IoC的wiki内核并提供一组定义清晰,独立于servlet的wiki API 以便于使整个Wiki易于扩展和可定制。

Corendal Wiki是一个开源并已经被实际公司所使用的Wiki应用软件。它的界面非常简洁；不需要学习wiki语法, 通过使用WYSIWYG在线编辑器来代替；不需要用户管理，它实时连到活动目录(Active Directory)来重复使用用户账号和组，它应该是唯一一个与活动目录组相集成的Wiki，本地账号和组都可以用它来创建；所有的文章都具有一个层次结构，以使得内容易于管理；可以针对每一个页面设置不同的访问权限或自由更新或锁定或发布；用户可以使用订阅机制来获得更新通知，更新可以是每天或每周或立即通知；可以自定义界面布局(使用Velocity模板和CSS实现) 。Corendal Wiki基于Tomcat和MySQL运行。

JAMWiki采用Java/JSP开发的Wiki引擎。它提供许多MediaWiki应具有大部份的功能。JAMWiki不需要数据库支持，数据采用文件系统存储(但)并且易于安装。