javawiki
① VMI与JMI的区别
VMI和JMI两者之间有2点不同，具体介绍如下：
一、两者的特点不同：
1、VMI的特点：VMI可以信息共享、供应商拥有管理库存、需求准确预测。
2、JMI的特点：JMI为其他科学的供应链物流管理如连续补充货物、快速反应、准时化供货等创造了条件。
二、两者的作用不同：
1、VMI的作用：VMI打破了传统的各自为政的库存管理模式。体现了供应链的集成化管理思想，适应市场变化的要求，是一种新的、有代表性的库存管理思想。
2、JMI的作用：目的是解决供应链系统中由于各企业相互独立运作库存模式所导致的需求放大现象,提高供应链的效率。
(1)javawiki扩展阅读：
JMI的相关优势介绍：
1、信息优势。信息是企业的一项重要资源，而缺乏信息沟通也是上述库存管理中出现问题的主要原因。JMI通过在上下游企业之间建立起一种战略性的合作伙伴关系；
实现了企业间库存管理上的信息共享。这样既保证供应链上游企业可以通过下游企业及时准确地获得市场需求信息，又可以使各个企业的一切活动都围绕着顾客需求的变化而开展。
2、成本优势。 JMI实现了从分销商到制造商到供应商之间在库存管理方面的一体化，可以让三方都能够实现准时采购。准时采购不仅可以减少库存，还可以加快库存周转，缩短订货和交货提前期，从而降低企业的采购成本。
3、物流优势。在传统的库存管理中存在着各自为政的弊端，上下游企业之间都是各自管理自己的库存，这就不可避免地会出现需求预测扭曲现象，产生的“牛鞭效应”极大地降低了企业的运作效率并增加了企业的成本。
JMI则打破了传统的各自为政的库存管理局面，体现了供应链的一体化管理思想。JMI强调各方的同时参与，共同制定库存计划，共同分担风险，能够有效的消除库存过高以及“牛鞭效应”。
② 有没有开源的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不需要数据库支持，数据采用文件系统存储(但)并且易于安装。
③ 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为什么这样设计类库，在什么情况使用，应当如何使用。
④ java 参数中含有… 是什么意思啊
main方法的签名其实可以这样写:
public static void main(String... args)//方法1
它也可以运行.
并且,如果同时还存在
public static void main(String[] args)//方法2
会报已经存在重复的方法的错误.
由此可见,String... args跟String[] args对于虚拟机来说其实是一回事.
而且,在方法内,通过...传进来的参数的使用方法也跟一个数组完全无二,可以for循环,甚至可以直接转换:
public static void main(String... args)
{
String[] ss=args;
}
但对于程序员来说却还是有差别的.
1.调用
我们只能这样调用方法2:
main(new String[]{});
即,方法2只能接受String数组做参数.
而我们陌生的方法1可强了,用以下参数调用,照单全收:
main();
main(null);
main(null,null);
main(null,null,null);
......
main("a");
main("a","b");
main("a","b","c");
......
main(new String[]{});
(String...匹配String*,而null也可以是一个特殊的String)
2.参数位置
使用...的参数只能是最后一个参数.不然谁知道你调用的时候,点点点匹配到哪个实参?
public static void main(String[] args,int index)//可以
public static void main(String... args,int index)//不行!
3.重载
假设有以下两个方法:
public static void main(String... args)//方法1
public static void main(String a,String... args)//方法3
从语法上来看,这个重载完全没有错误,eclipse也没有报错.但是当调用时使用的参数个数大于这些方法中点点点参数前面的参数个数时,eclipse就会发现这个错误了.很拗口是不是?嘿嘿~还是举例来说吧.以上这两个方法,如果调用时
main();
编译器会认出这个调用的是方法1.但是如果调用时
main("");
编译器就疯了...因为一个String参数,既符合方法1的点点点,也符合方法3的String+点点点,编译器就不知道调用的是哪个方法了.
String[]参数不会有这种问题.
所以重载时要注意,如果点点点参数前面有跟它类型相同的参数...最好的方法,似乎就是换回数组形式了,要么就给方法改个名字吧.
4.遇上泛型加外包
用个实例来说
java.util.Arrays是个工具类,所有方法都是静态的,对数组的操作.里面有个方法asList(T... args),用来把类型T的数组转化成List<T>.
这是个很有用的方法,在绝大多数情况下都能如你所愿.
但是,你可以试试下面的写法
int[] is=...//自定义的数组,或者从什么地方获取来的数组
List<Integer> list=Arrays.asList(is);
很不幸,不要说执行,编译都通不过.错误的意思大概是:
不能将List<int[]>转化成List<Integer>
明白了吧?
你的设想是,把int[]中的每一个元素对应T...中的每一个点,
可编译器不这么想.因为int是原始类型,不是Object的子类.而泛型T隐含的条件是T extends Object.所以编译器不会把每一个int看做T,不会把int[]看做T点点点.虽然java已经支持自动将原始类型封包成外包类,但那是单个的情况.
而数组(不管什么类型)则是一种特殊的类型,是Object的子类,所以编译器觉得整个int[]对应一个T,你调用的方法是asList<int[]>(int[]... args)而不是你想象中的asList<Integer>(Integer...)
⑤ java 开发的wiki开源项目哪个比较好
https://hackpad.com/
https://www.oschina.net/p/xwiki
这两个你可以参考下。
⑥ 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;
}
}
⑦ JAVA 替换特殊字符 的 正则表达式
JAVA替换特殊字符的正则表达式
代码如下：
importjava.util.regex.*;
//表达式对象
Patternp=Pattern.compile("[\'\*\~]");
//创建Matcher对象
Matcherm=p.matcher("Stringstr="t'e*s~t";");
//替换
Stringnewstring=m.replaceAll("[$0]");
效果如下:
正则参考http://zh.wikipedia.org/wiki/%E6%AD%A3%E5%88%99%E8%A1%A8%E8%BE%BE%E5%BC%8F
⑧ 如何安装配置JIRA和CONFLUENCE WIKI
JIRA的安装
1.java安装和设置JAVA_HOME
首先下载到sun官网下载jdk-6u20-linux-i586.bin（版本根据实际决定）。linux下可以使用wget命令。由于url忘记了，详细命令不写了。由于我们的开发服务器不在本地，我只能通过wget下载。（当然还有很多别的方法，见下文）我先把jdk-6u20-linux-i586.bin下载到/home/acm，然后执行sh自解压脚本
sh jdk-6u20-linux-i586.bin
yes人家的相关条款。如果顺利的话，当前目录会多一个jdk1.6.0_20。将该目录移动到/usr/local/，并改为名java。
设置环境变量JAVA_HOME
这一步有很多方法，修改各种配置文件中的一个。我采取的方法是
vi /etc/profile
在文件后面两行加上
export JAVA_HOME=/usr/local/java
export CLASSPATH=$CLASSPATH:$JAVA_HOME/lib:$JAVA_HOME/jre/lib
export PATH=$JAVA_HOME/bin:$JAVA_HOME/jre/bin:$PATH:$HOME/bin
export JIRA_HOME=/usr/local/jira/
后面一行加粗的是后面配置JIRA_HOME时候加上去的www.linuxidc.com（可选，因为JIRA本身有配置文件配置这个路径）。
修改完了配置文件，echo $JAVA_HOME一下必定得到空值。因为配置文件还没有生效，最简单的方法是 source一下
source /etc/profile
这个时候echo $JAVA_HOME 就会圆满了。
[root@dev ~]# echo $JAVA_HOME
/usr/local/java
不放心的话也可以验证一下其他路径。可以输入
java -version
看看是否得到如下结果：
java version "1.6.0_20"
Java(TM) SE Runtime Environment (build 1.6.0_20-b02)
Java HotSpot(TM) Server VM (build 16.3-b01, mixed mode)
顺便提一句，我之前在安装CentOS时候，选安装了gcj，
rpm -aq|grep gcj
出来一堆东东。效果给不了了，因为写blog之前已经执行了如下命令
yum -y remove java-1.4*
删除gcj，JIRA官网说仅有这个的话。JIRA是不会正常工作的，常常会发生一些莫名其妙的bug。为了避免一起混乱，我首先删除之。