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。為了避免一起混亂，我首先刪除之。