2007年7月25日 星期三

[Ubuntu] 使用 apt 進行套件升級發生「failed to write cache」的錯誤

恩......今天因為某個白痴原因重灌了 Ubuntu,不過在 apt 升級時出現了以下錯誤訊息:
Updating fontconfig cache...
/usr/share/fonts: failed to write cache
/usr/share/fonts/X11: failed to write cache
/usr/share/fonts/X11/100dpi: failed to write cache
/usr/share/fonts/X11/75dpi: failed to write cache
/usr/share/fonts/X11/Type1: failed to write cache
/usr/share/fonts/X11/encodings: failed to write cache
/usr/share/fonts/X11/encodings/large: failed to write cache
......... (more)
......... (more)

這時老大來救命,找到了以下 script 來解決了這個問題:
#!/bin/bash
#
# 修正 Ubuntu 7.04 fc-cache failed to write cache 錯誤
#

sudo touch /usr/share/fonts
sudo touch /usr/share/fonts/X11
sudo touch /usr/share/fonts/X11/100dpi
sudo touch /usr/share/fonts/X11/75dpi
sudo touch /usr/share/fonts/X11/Type1
sudo touch /usr/share/fonts/X11/encodings
sudo touch /usr/share/fonts/X11/encodings/large
sudo touch /usr/share/fonts/X11/misc
sudo touch /usr/share/fonts/X11/util
sudo touch /usr/share/fonts/truetype
sudo touch /usr/share/fonts/truetype/arphic
sudo touch /usr/share/fonts/truetype/baekmuk
sudo touch /usr/share/fonts/truetype/freefont
sudo touch /usr/share/fonts/truetype/kochi
sudo touch /usr/share/fonts/truetype/openoffice
sudo touch /usr/share/fonts/truetype/thai
sudo touch /usr/share/fonts/truetype/ttf-arabeyes
sudo touch /usr/share/fonts/truetype/ttf-bengali-fonts
sudo touch /usr/share/fonts/truetype/ttf-bitstream-vera
sudo touch /usr/share/fonts/truetype/ttf-dejavu
sudo touch /usr/share/fonts/truetype/ttf-devanagari-fonts
sudo touch /usr/share/fonts/truetype/ttf-gentium
sudo touch /usr/share/fonts/truetype/ttf-gujarati-fonts
sudo touch /usr/share/fonts/truetype/ttf-kannada-fonts
sudo touch /usr/share/fonts/truetype/ttf-lao
sudo touch /usr/share/fonts/truetype/ttf-malayalam-fonts
sudo touch /usr/share/fonts/truetype/ttf-mgopen
sudo touch /usr/share/fonts/truetype/ttf-oriya-fonts
sudo touch /usr/share/fonts/truetype/ttf-punjabi-fonts
sudo touch /usr/share/fonts/truetype/ttf-tamil-fonts
sudo touch /usr/share/fonts/truetype/ttf-telugu-fonts
sudo touch /usr/share/fonts/type1
sudo touch /usr/share/fonts/type1/gsfonts
sudo touch /usr/share/X11/fonts
sudo touch /usr/share/X11/fonts/100dpi
sudo touch /usr/share/X11/fonts/75dpi
sudo touch /usr/share/X11/fonts/Type1
sudo touch /usr/share/X11/fonts/encodings
sudo touch /usr/share/X11/fonts/encodings/large
sudo touch /usr/share/X11/fonts/misc
sudo touch /usr/share/X11/fonts/util
sudo touch /usr/local/share/fonts
sudo touch /var/lib/defoma/fontconfig.d
sudo touch /var/lib/defoma/fontconfig.d/A
sudo touch /var/lib/defoma/fontconfig.d/B
sudo touch /var/lib/defoma/fontconfig.d/C
sudo touch /var/lib/defoma/fontconfig.d/D
sudo touch /var/lib/defoma/fontconfig.d/E
sudo touch /var/lib/defoma/fontconfig.d/F
sudo touch /var/lib/defoma/fontconfig.d/G
sudo touch /var/lib/defoma/fontconfig.d/H
sudo touch /var/lib/defoma/fontconfig.d/J
sudo touch /var/lib/defoma/fontconfig.d/K
sudo touch /var/lib/defoma/fontconfig.d/L
sudo touch /var/lib/defoma/fontconfig.d/M
sudo touch /var/lib/defoma/fontconfig.d/N
sudo touch /var/lib/defoma/fontconfig.d/O
sudo touch /var/lib/defoma/fontconfig.d/P
sudo touch /var/lib/defoma/fontconfig.d/R
sudo touch /var/lib/defoma/fontconfig.d/S
sudo touch /var/lib/defoma/fontconfig.d/T
sudo touch /var/lib/defoma/fontconfig.d/U
sudo touch /var/lib/defoma/fontconfig.d/V
sudo touch /var/lib/defoma/fontconfig.d/a
sudo touch /var/lib/defoma/fontconfig.d/j
sudo touch /var/lib/defoma/fontconfig.d/m
sudo touch /var/lib/defoma/fontconfig.d/u
就是將上面的內容作成 shell script 執行一次就行了!

2007年7月23日 星期一

產生 ERD 的工具

由於最近有畫 ERD 的需求,加上又不想用 Visio 畫....(畫出來真的不知道啥東西...)

所以上網搜尋了一下,找到了以下工具:

Web Tools:
  1. ERWeb
  2. aSVERD
Application Tools:
  1. DBDesigner 4
  2. System Architect
  3. JUmlErd

Java 學習筆記 (5) - Enumerated Type

Enumerated Type 的基本使用方式

Enumerated Type 有以下特性存在:
  1. public
    除非在 class 內部中宣告其為 private,否則就會是 public
  2. static
    可透過 Enumerated Type 名稱直接使用
  3. final
    不可改變


Enumerated Type(列舉型態) 的使用方式:

使用外部檔案定義 Enumerated Type

Action.java (Enumerated Type 設定檔)
public enum Action {
TURN_LEFT,
TURN_RIGHT,
SHOOT
}
EnumDemo.java
public class EnumDemo {
public static void main(String[] args) {
doAction(Action.TURN_RIGHT);
}

//此傳入的參數型態為 "Action" enumerated type
public static void doAction(Action action) {
switch(action) {
case TURN_LEFT:
System.out.println("向左轉");
break;
case TURN_RIGHT:
System.out.println("向右轉");
break;
case SHOOT:
System.out.println("射擊");
break;
}
}
}

直接在 class 內部定義 Enumerated Type

用此種方式定義 Enumerated Type,則是將 Enumerated Type 視為 inner class 來使用,因此若是用以下範例,編譯後會有 EnumDemo2$InnerAction.class 這個檔案出現。

public class EnumDemo2 {
private enum InnerAction {TURN_LEFT, TURN_RIGHT, SHOOT};

public static void main(String[] args) {
doAction(InnerAction.TURN_RIGHT);
}

public static void doAction(InnerAction action) {
switch(action) {
case TURN_LEFT:
System.out.println("向左轉");
break;
case TURN_RIGHT:
System.out.println("向右轉");
break;
case SHOOT:
System.out.println("射擊");
break;
}
}
}

列出 Enumerated Type 中的成員

public class EnumIndex {
public static void main(String[] args) {
for(Action action: Action.values())
System.out.println(action.ordinal() + " " + action);
}
}


定義 method 或 constructor 至 Enumerated Type 中

定義 method

DetailAction.java
public enum DetailAction {
TURN_LEFT, TURN_RIGHT, SHOOT;

public String getDescription() {
switch(this.ordinal()) {
case 0:
return "向左轉";
case 1:
return "向右轉";
case 2:
return "射擊";
default:
return null;
}
}
}
DetailActionDemo.java
public class DetailActionDemo {
public static void main(String[] args) {
for(DetailAction action : DetailAction.values())
System.out.println(action + ":" + action.getDescription());
}
}

定義 constructor

DetailAction2.java
public enum DetailAction2 {
TURN_LEFT("向左轉"), TURN_RIGHT("向右轉"), SHOOT("射擊");

private String description;

//使用 constructor 來指定 description 的值
//上面三筆資料就是以這個 constructor 所指定進來而產生相對應的結果
private DetailAction2(String description) {
this.description = description;
}

public String getDescription() {
return description;
}
}
使用這個 Enumerated Type 時,只要將 DetailActionDemo.java 中的「DetailAction」改為「DetailAction2」即可。

2007年7月22日 星期日

Java 學習筆記 (4) - Exception

若是 Exception 在 RuntimeException 的 child class 中有引發的可能,而由於這些 Exception 是可以預期的,因此必須在程式中明確指定處理的方式,才能編譯成功,所以稱為 Checked Exception。

例如使用到 BufferedReader class 中的 readLine() method 時,便有可能引發 IOException 這個 Checked Exception,因此要在程式中明確指定處理,有兩種方式:

在程式中以 try catch 指定要捕捉的例外:
import java.io.*;

public class CheckedExceptionDemo {
public static void main(String[] args) {
try {
BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));
System.out.print("請輸入整數:");
int intput = Integer.parseInt(buf.readLine());
System.out.println("input x 10 = " + (intput * 10));
}
catch(IOException e) { //使用 try catch 結構捕捉 checked exception
System.out.println("I/O 錯誤");
}
}
}
聲明丟出例外,由呼叫者負責處理(此處指的呼叫者是JVM):
import java.io.*;

public class CheckedExceptionDemo2 {
//聲明丟出例外,由呼叫者負責處理(此處指的呼叫者是JVM)
public static void main(String[] args) throws IOException {
BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));
System.out.print("請輸入整數:");
int intput = Integer.parseInt(buf.readLine());
System.out.println("input x 10 = " + (intput * 10));
}
}

此外,有別於 Checked Exception,Runtime Exception 則是屬於 Unchecked Exception,因此程式設計師是否要在程式中指定這些 Exception 的處理方式,可由程式設計師自行決定,即使程式中沒處理 Runtime Exception,compiler 並不會產生錯誤。


推薦連結

在 PHP 中使用 sudo 執行系統命令

最近有這個需求,因此上網找到了幾個連結,先留下來之後備查......
  1. PHP 透過 Sudo 執行 root 指令
  2. PHP 修改 Linux 系統密碼
  3. PHP Manual (exec — Execute an external program) =>搜尋 stdin
基本上,還有很多資料可以看,而搜尋關鍵字就是 php、sudo、stdin

2007年7月21日 星期六

Java 學習筆記 (3) - 管理類別檔案

Inner Class (內部類別)

此種 class 的存在有以下幾點好處:
  1. inner class 可以直接存取 outer class 的 private 成員
  2. 當 inner class 僅被 outer class 一個 class 專屬使用時,相當適合使用
  3. 對外部隱藏 inner class 的存在

接著以下用簡單範例來說明:

一般的 inner class

PointDemo.java (outer class 宣告,其中有 inner class)
public class PointDemo {

//內部類別(Inner Class) ======= Begin
private class Point {
private int x, y;

public void setPoint(int x, int y) {
this.x = x;
this.y = y;
}

public int getX() {
return x;
}

public int getY() {
return y;
}
}
//內部類別(Inner Class) ======= End

private Point[] points;

public PointDemo(int length) {
points = new Point[length];

for(int i = 0 ; i < points.length ; i++) {
points[i] = new Point();
points[i].setPoint(i * 5, i * 5);
}
}

public void showPoints() {
for(int i = 0 ; i < points.length ; i++) {
System.out.printf("Point[%d]: x = %d, y = %d\n", i, points[i].getX(), points[i].getY());
}
}
}
PointShow.java
public class PointShow {
public static void main(String[] args) {
PointDemo demo = new PointDemo(5);
demo.showPoints();
}
}

Anonymous Inner Class (匿名的內部類別)


此種 class 是沒有名稱的,直接宣告在定義的 object 之後,以下為範例說明:

AnonymousClassDemo.java
public class AnonymousClassDemo {
public static void main(String[] args) {
//Anonymous Class 就宣告在此
Object obj = new Object() {
public String toString() {
return "匿名類別物件";
}
};
System.out.println(obj);
}
}
【註】若要在 inner class 中使用 outer class 的區域變數,必須要在該變數的宣告前加上「final」關鍵字,


package

這個部分較為容易,一般可使用自己的 domain name 作為 package name,如此一來與其他 package 名稱衝突的機會就會大大降低。而若非使用 default package,在檔案與目錄的結構上就會有所差異,以下有一段範例程式碼:
package net.twcic;

public class Point2D {
private int x;
private int y;

public Point2D() {}

public Point2D(int x, int y) {
this.x = x;
this.y = y;
}

public int getX() {
return x;
}

public int getY() {
return y;
}
}
如此一來,目錄結構就會變成「$ClassPath/net/twcic/Point2D.class」,這樣 compiler 才知道要去哪裡找檔案進行編譯。


import

import 有分為一般的 import 以及在 SE 5.0 中所提供的 static import,一般的 import 比較容易就不說明了,以下給一段 static import 的程式碼:
import static java.lang.System.out;
import static java.util.Arrays.sort;

public class ImportStaticDemo {
public static void main(String[] args) {
int[] array = {2, 5, 3, 1, 7, 6, 8};

//static method 已經 import 進來
sort(array);

for(int i = 0 ; i < array.length ; i++)
out.print(array[i] + " "); //static method 已經 import 進來
}
}
當然,使用 import static 有可能會發生 method 名稱重複的問題,當然在 compiler 中會有其機制來處理這個問題,不過重要的還是在撰寫時,把名稱部分的細節給處理好才是正確之道。

推薦參考連結

2007年7月19日 星期四

Java 學習筆記 (2) - Object Oriented

this

關鍵字 this 在 Java 中,為參考到呼叫 method 的實際 object 之用。

假設在某個 class 中,分別有以下內容:

attribute
  • myName
  • myAge
method
  • showName()
  • showAge()

當使用該 class 產生出兩個 object 後,每個 object 擁有各自的 attribute,亦即 myName、myAge 各有兩份;但 showName()、showAge() 兩個 method 卻還是只佔了一份記憶體空間。

因此就會有問題出現了,那要如何判斷是那個 object 呼叫 method 的呢? 答案就是 this 關鍵字!

在 JavaWorld@TW 有一篇文章說明的很詳細:給新手 - this 到底是什麼?


Overload

此機制可用來統一 method 的名稱,但卻可根據參數列各參數型態、數量的不同(僅有 return type 不同,compiler 會把 methods 視為相同而產生錯誤喔!)而自動呼叫對應的 method,例如:String class 中的 valueOf() 方法。

以下用一段程式碼測試 overload 與 boxing 機制的搭配:
public class OverloadDemo {
public static void main(String[] args) {
//測試 overload & boxing
myMethod(10); //int 版本被呼叫
myMethod(new Integer(10)); //Integer 版本被呼叫
}

public static void myMethod(int i) {
System.out.println("int 版本被呼叫");
}

public static void myMethod(Integer i) {
System.out.println("Integer 版本被呼叫");
}
}
【註】以前竟然把這個機制當作是 Polymorphism(多型),真是完全搞錯....Orz


Variable-length Argument (不定長度引數)

當呼叫 method 但 argument 的數量無法事先確定時,這種機制就很好用啦! 這是在 J2SE 5.0 版以後才提供的功能,所使用的關鍵字為「...」,以下用範例說明:
public class VarLenArgs {
public static void main(String[] args) {
//2個參數
System.out.println("1 + 2 = " + sum(1, 2));
//3個參數
System.out.println("1 + 2 + 3 = " + sum(1, 2, 3));
//4個參數
System.out.println("1 + 2 + 3 + 4 = " + sum(1, 2, 3, 4));
}

//Variable-length Arguments
public static int sum(int... intNums) {
int intSum = 0;
for(int intNum : intNums)
intSum += intNum;
return intSum;
}
}
【註】有一點很重要,若要使用不定長度的引數時,必須宣告在參數列的最後一個! 否則會產生錯誤!


Polymorphism (多型)

Polymorphism 即是用相同的 interface 來操作不同的 object,進而降低對 interface 的依賴程度,增進程式架構的彈性與可維護性,可透過 abstract class(抽象類別) 或是 interface(介面) 兩種方式來達成,以下分別用範例來介紹:

使用 abstract class (抽象類別)


AbstractGuessGame.java (定義共通 interface 的 abstract class)
public abstract class AbstractGuessGame {
private int number;

public void setNumber(int number) {
this.number = number;
}

public void start() {
showMessage("歡迎");
int guess = 0;
do {
guess = getUserInput();
if(guess > number)
showMessage("輸入的數字較大");
else if(guess < number)
showMessage("輸入的數字較小");
else
showMessage("猜中囉!");
} while(guess != number);
}

protected abstract void showMessage(String message);
protected abstract int getUserInput();
}
TextModeGame.java (繼承 abstract class 並實作其 abstract method)
import java.util.Scanner;

public class TextModeGame extends AbstractGuessGame {
private Scanner scanner;

public TextModeGame() {
scanner = new Scanner(System.in);
}

protected void showMessage(String message) {
for(int i = 0 ; i < message.length() ; i++)
System.out.print("*");
System.out.println("\n" + message);
for(int i = 0 ; i < (message.length() * 2) ; i++)
System.out.print("*");
}

protected int getUserInput() {
System.out.print("\n輸入數字:");
return scanner.nextInt();
}
}
GuessGameDemo.java (使用 Parent Class 宣告 object 來作為 interface 操作)
public class GuessGameDemo {
public static void main(String[] args) {
AbstractGuessGame guessGame = new TextModeGame();
guessGame.setNumber(50);
guessGame.start();
}
}
從上面可以看出,Polymorphism 透過 abstract clsas 來實作的方式,可透過 Parent Class 的型態,去操作 Child Class 中重新被定義的方法,亦即透過 Parent Class 的型態,進行多型操作。

使用 interface (介面)

IRequest.java (interface 的定義)
public interface IRequest {
public void execute();
}
HelloRequest.java (實作 interface 的 class)
public class HelloRequest implements IRequest {
private String name;

public HelloRequest(String name) {
this.name = name;
}

public void execute() {
System.out.printf("哈囉 %s! \n", name);
}
}
WelcomeRequest.java (實作 interface 的 class)
public class WelcomeRequest implements IRequest {
private String place;

public WelcomeRequest(String place) {
this.place = place;
}

public void execute() {
System.out.printf("歡迎來到 %s!\n", place);
}
}
RequestDemo.java (透過 interface 達成多型)
public class RequestDemo {
public static void main(String[] args) {
for(int i = 0 ; i < 10 ; i++) {
int n = (int)(Math.random() * 10) % 2;
switch(n) {
case 0:
//傳入實作 IRequest 介面的 HelloRequest
doRequest(new HelloRequest("Hello"));
break;
case 1:
//傳入實作 IRequest 介面的 WelcomeRequest
doRequest(new WelcomeRequest("Welcome"));
break;
}
}
}

//參數中定義的是 IRequest 介面
//只要有實作 IRequest 介面的 class 所產生的 object,都可以傳進來
public static void doRequest(IRequest request) {
request.execute();
}
}
將 interface 與 abstract class 兩種實作 Polymorphism 的方式拿來比較,可以看出透過 abstract class 去實作,會造成依賴某個特定型別;但若是透過 interface 來實作,只要 class 有實作該 interface 即可,不需要是特定 class 所產生出來的 obejct,因此在運用上更多了一些彈性。

因此,建議實作 Polymorphism 時,多用 interface 讓設計架構上更為彈性。


觀念釐清
  1. 若是 override Parent Class 的 method,只能擴大其 method 的權限(例如:protected -> public),不能縮小其權限(例如:public -> private)
  2. static method 是無法被 override 的
  3. Object Class 是所有 Java Class 的 Parent Class,當定義一個 Class 後,預設即為繼承 Object Class


推薦參考連結

2007年7月14日 星期六

Java 學習筆記 (1) - 入門篇

用來接收使用者輸入的新 class - Scanner

在 Java SE 5.0,在 package java.util 中提供了 Scanner class,用來取得使用者輸入的值,範圍為一個 word,而非僅僅是一個 byte;此外,在 package java.lang 中的 System class 中還提供了 C 語言中的 printf() 功能,以下用個範例簡單介紹:
import java.util.Scanner;

public class myScanner {
public static void main(String[] args) {
Scanner scn = new Scanner(System.in);
System.out.print("請輸入您的名字:");
System.out.printf("哈囉! %s\n", scn.next());
}
}
【註】關於各種不同資料型態的展示方式,可參考 package java.util 中的 Formatter class 中的說明。


接收包含空白的字串

在 Java 中要接收包含空白的字串,必須使用在 package java.io 中的 BufferedReader class,而為了擷取完整一行內容,一般都是使用 method readLine() 來處理,以下有一段範例程式:
import java.io.IOException;
import java.io.InputStreamReader;import java.io.BufferedReader;

public class myBufferReader {
public static void main(String[] args) throws IOException {
//要讀取包含空白的字串,則用 BufferedReader class
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
System.out.print("請輸入一列文字(可包括空白):");
String strInput = br.readLine();
System.out.println("您輸入的文字:" + strInput);
}
}


宣告不可改變的變數

在日常生活中,有某些數值是固定無須改變的,例如:圓周率。

而若要在程式中定義此種變數,必須使用「final」關鍵字,以下是範例語法:
final float myPI = 3.14;
而若是程式中有對此變數嘗試進行修改,compile 時就會出現錯誤。


位元運算

位元運算的部分可使用 bit operator(& 以及 |) 或是位元左移(<<)以及右移(>>),以下用一個範例來作簡單說明:
public class bitOperate {
public static void main(String[] args) {
//使用 logic operator 作 AND 運算
Integer intA = new Integer(10);
//與 1 進行 AND 運算,若為奇數,則為 TRUE
System.out.println(intA.toString() + " 是否為奇數:" + ((intA.intValue() & 1) != 0 ? "是" : "否"));

Integer intB = new Integer(1); // 0001
System.out.println("2 的 0 次方 = " + intB.toString());
intB = Integer.valueOf(intB <<= 1); // 0010
System.out.println("2 的 1 次方 = " + intB.toString());
intB = Integer.valueOf(intB <<= 1); // 0100
System.out.println("2 的 2 次方 = " + intB.toString());
intB = Integer.valueOf(intB <<= 1); // 1000
System.out.println("2 的 3 次方 = " + intB.toString());
}
}


變數宣告方式的不同

這個部分以整數為例,宣告整數有兩種方式,而使用起來卻有差異,以下用一個簡單的範例來說明:
public class AutoBox {
public static void main(String[] args) {
// 定義 Integer 物件
Integer intA = new Integer(100);
Integer intB = new Integer(100);

// 使用 logical operator 比較
if(intA == intB)
System.out.println("intA == intB");
else
System.out.println("intA != intB"); //兩個object參考名稱指向不同的object

//使用 equals() 作比較
if(intA.equals(intB))
System.out.println("intA == intB"); //兩個object中儲存的整數值相同
else
System.out.println("intA != intB");

//一般常用的宣告方式
int intC = 100;
int intD = 100;
if(intC == intD)
System.out.println("intC == intD"); //結果則合乎預期
else
System.out.println("intC != intD");
}
}


包含不同長度的一維陣列的的二維陣列

定義一個二維陣列,並指定不同長度的一維陣列在其中,以下用一個簡單範例來說明:
public class TwoDimArray {
public static void main(String[] args) {
//宣告一個 2-dimension array,長度不指定
int ary[][] = new int[2][];
//分別宣告兩個不同長度的 1-dimension array
ary[0] = new int[3];
ary[1] = new int[5];

for(int i = 0 ; i < ary.length ; i++) {
for(int j = 0 ; j < ary[i].length ; j++)
ary[i][j] = j + 1;
}

/*
* 結果如下:
* 1 2 3
* 1 2 3 4 5
*/

for(int i = 0 ; i < ary.length ; i++) {
for(int j = 0 ; j < ary[i].length ; j++)
System.out.print(ary[i][j] + " ");
System.out.println();
}
}
}


String Pool

JVM 為了讓字串處理工作更有效率,使用了 String Pool 的方式,讓同樣的字串可以重複使用,不需浪費無謂的記憶體空間,以下用一個範例來說明:
public class InternString {
public static void main(String[] args) {
//兩個為不同的 String object
String str1 = new String("flyweight");
String str2 = new String("flyweight");
System.out.println(str1 == str2); //false
System.out.println(str1.equals(str2)); //true

//JVM 會讓兩個 String object 指向 String pool 中的同一個字串
String str3 = "flyweight";
String str4 = "flyweight";
System.out.println(str3 == str4); //true

String strA = "fly";
String strB = "weight";
String strC = "flyweight";
String strD = null;
strD = strA + strB; //此時 String pool 中多了一個字串為 flyweight
System.out.println(strC == strD); //false
//intern() method 會去 String pool 中尋找是否有結合起來的字串
//若是有(此範例中為 strC),就會參考到該字串
System.out.println(strC == (strA + strB).intern()); //true
}
}


String Append

若在程式中有一堆 String Append 的部分,那這邊就要仔細看了!

使用一般的 String Append,會讓 String Pool 中不斷的產生新的 String Instance,不僅浪費資源,而且速度也很慢.....

因此 JDK 提供了 StringBuilder class,可以透過動態配置記憶體的方式,快速的進行 String Append 的工作,以下用一個範例程式來說明:
public class AppendStringTest {
//展示一般 string append 與 StringBuilder append 的速度差異
public static void main(String[] args) {
String strText = "";
long beginTime = System.currentTimeMillis();
for(int i = 0 ; i < 20000 ; i++)
strText += i;
long endTime = System.currentTimeMillis();
System.out.println(endTime - beginTime); //13219

StringBuilder sb = new StringBuilder("");
beginTime = System.currentTimeMillis();
for(int i = 0 ; i < 20000 ; i++)
sb.append(i);
endTime = System.currentTimeMillis();
System.out.println(endTime - beginTime); //10
}
}
從上面結果應該就可以很清楚看出兩種方法速度上的差異了吧!

Regular Expression

Regular Expression(正規表示式) 的強大,應該是很多人都知道的! 但是.....要寫出很精確又複雜的 regular expression,還真不是一件容易的事情,以下介紹使用在 java.util.regex package 中的 Pattern class 來產生 object 進行字串比對:
import java.util.regex.*;

public class RegExp {
public static void main(String[] args) {
String strPhones = new String("Justin的手機號碼:0939-100391\n" + "bush的手機號碼:0923-512345n" + "mormor的手機號碼:0939-666888");
//定義 regular expression
Pattern pt = Pattern.compile(".*0939-\\d{6}");
//字串比對
Matcher mt = pt.matcher(strPhones);
while(mt.find())
System.out.println(mt.group()); //印出符合 regular expression 的字串

//以下範例程式功能同上
String strText = new String("abcdebcadxbc");
Pattern ptn = Pattern.compile(".bc");
Matcher mth = ptn.matcher(strText);
while(mth.find())
System.out.print(mth.group() + " "); //abc ebc xbc
}
}