作者：gnuhpc
出處：http://www.cnblogs.com/gnuhpc/
1.特性——不用import
2.String
String x = "abc"; <=> String x= new String("abc");
因為public final class java.lang.String;
而String x="The number " + y;中，在JAVA中不管是什么變量或者對象，在對String進行加和時都轉化為String。
3.Annotation
注解（Annotation） 為我們在代碼中添加信息提供了一種形式化的方法，是我們可以在稍后某個時刻方便地使用這些數據（通過解析注解來使用這些數據）。注解的語法比較簡單，除了@符號的使用以外，它基本上與java的固有語法一致，java內置了三種注解，定義在java.lang包中。
@Override 表示當前方法是覆蓋父類的方法。
@Deprecated 表示當前元素是不贊成使用的。
@SuppressWarnings 表示關閉一些不當的編譯器警告信息。
# import java.lang.annotation.Documented;
# import java.lang.annotation.Inherited;
# import java.lang.annotation.Retention;
# import java.lang.annotation.Target;
# import java.lang.annotation.ElementType;
# import java.lang.annotation.RetentionPolicy;
# /*
# * 元注解@Target,@Retention,@Documented,@Inherited
# *
# * @Target 表示該注解用於什么地方，可能的 ElemenetType 參數包括：
# * ElemenetType.CONSTRUCTOR 構造器聲明
# * ElemenetType.FIELD 域聲明（包括 enum 實例）
# * ElemenetType.LOCAL_VARIABLE 局部變量聲明
# * ElemenetType.METHOD 方法聲明
# * ElemenetType.PACKAGE 包聲明
# * ElemenetType.PARAMETER 參數聲明
# * ElemenetType.TYPE 類，接口（包括注解類型）或enum聲明
# *
# * @Retention 表示在什么級別保存該注解信息。可選的 RetentionPolicy 參數包括：
# * RetentionPolicy.SOURCE 注解將被編譯器丟棄
# * RetentionPolicy.CLASS 注解在class文件中可用，但會被VM丟棄
# * RetentionPolicy.RUNTIME VM將在運行期也保留注釋，因此可以通過反射機制讀取注解的信息。
# *
# * @Documented 將此注解包含在 javadoc 中
# *
# * @Inherited 允許子類繼承父類中的注解
# *
# */
下面是一個使用注解 和 解析注解的實例
package Test_annotation;
import java.lang.reflect.Method;
public class Test_1 {
/*
* 被注解的三個方法
*/
@Test(id = 1, description = "hello method_1")
public void method_1() {
}
@Test(id = 2)
public void method_2() {
}
@Test(id = 3, description = "last method")
public void method_3() {
}
/*
* 解析注解，將Test_1類 所有被注解方法的信息打印出來
*/
public static void main(String[] args) {
Method[] methods = Test_1.class.getDeclaredMethods();
for (Method method : methods) {
/*
* 判斷方法中是否有指定注解類型的注解
*/
boolean hasAnnotation = method.isAnnotationPresent(Test.class);
if (hasAnnotation) {
/*
* 根據注解類型返回方法的指定類型注解
*/
Test annotation = method.getAnnotation(Test.class);
System.out.println("Test( method = " + method.getName()
+ " , id = " + annotation.id() + " , description = "
+ annotation.description() + " )");
}
}
}
}
輸出結果如下：
Test( method = method_1 , id = 1 , description = hello method_1 )
Test( method = method_2 , id = 2 , description = no description )
Test( method = method_3 , id = 3 , description = last method )
4.instrument
使用 Instrumentation，開發者可以構建一個獨立於應用程序的代理程序（Agent），用來監測和協助運行在 JVM 上的程序，甚至能夠替換和修改某些類的定義。有了這樣的功能，開發者就可以實現更為靈活的運行時虛擬機監控和 Java 類操作了，這樣的特性實際上提供了一種虛擬機級別支持的 AOP 實現方式，使得開發者無需對 JDK 做任何升級和改動，就可以實現某些 AOP 的功能了。在 Java SE 5 中，Instrument 要求在運行前利用命令行參數或者系統參數來設置代理類，在實際的運行之中，虛擬機在初始化之時（在絕大多數的 Java 類庫被載入之前），instrumentation 的設置已經啟動，並在虛擬機中設置了回調函數，檢測特定類的加載情況，並完成實際工作。但是在實際的很多的情況下，我們沒有辦法在虛擬機啟動之時就為其設定代理，這樣實際上限制了 instrument 的應用。而 Java SE 6 的新特性改變了這種情況，通過 Java Tool API 中的 attach 方式，我們可以很方便地在運行過程中動態地設置加載代理類，以達到 instrumentation 的目的。
舉例說明：我們想把如下程序中的6改為7
public class HelloWorld {
public static void main(String arg[]) {
System.out.println("The number six is 6");
}
}
那么我們要設定一個Agent，這個類就會attach在主程序上了~
import java.lang.instrument.Instrumentation;
public class MySimpleAgent {
public static void premain(String agentArgs,Instrumentation inst) {
inst.addTransformer(new MySimpleTransformer());
}
}
在這個Agent中有一個MySimpleTransformer類派生出對象作為轉換器。我們看看如何定義MySimpleTransformer類。
import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.IllegalClassFormatException;
import java.security.ProtectionDomain;
public class MySimpleTransformer implements ClassFileTransformer {
public byte[] transform(ClassLoader classloader,
String classname,
Class redefinedclass,
ProtectionDomain protectiondomain,
byte b[]) throws IllegalClassFormatException {
if(!classname.endsWith("HelloWorld"))
return(null);
String line = "";
for(int i=0; i<b.length; i++) {
line += Byte.toString(b[i]) + " ";
if(line.length() > 60) {
System.out.println(line);
line = "";
}
if(b[i] == (byte)'6')
b[i] = (byte)'7';
}
System.out.println(line);
System.out.println("The number of bytes in HelloWorld: " + b.length);
return(b);
}
}
使用下列命令創建一個JAR包：
javac *.java 2>&1 | more
jar -cfm MyAgent.jar agentmantext MySimpleAgent.class MySimpleTransformer.class
其中的agentmantext的內容如下：
Premain-Class: MySimpleAgent
而運行方法則如下：
java -javaagent:MyAgent.jar HelloWorld
5.java.lang.ref
Java 2 平台引入了 java.lang.ref 包，其中包括的類可以讓您引用對象，而不將它們留在內存中。這些類還提供了與垃圾收集器（garbage collector）之間有限的交互。
先“由強到弱”（只的是和垃圾回收器的關系）明確幾個基本概念：
strong references是那種你通常建立的reference，這個reference就是強可及的。這個不會被自動回收。例如：StringBuffer buffer = new StringBuffer();其中這個buffer就是強引用，之所以稱為“強”是取決於它如何處理與Garbage Collector的關系的：它是無論如何都不會被回收的。夠強的。強引用在某些時候是有個問題的，下邊的一個哈希表實例就是很好的說明。而且還有一個問題就是在緩沖上，尤其是諸如圖片等大的結構上。我們在內存中開辟一塊區域放置圖片緩沖，那我們就希望有個指針指向那塊區域。此時若是使用強引用則回強迫圖片留在內存，當你覺得不需要的時候你需要手動移除，否則就是內存泄漏。
WeakReference則類似於可有可無的東西。在垃圾回收器線程掃描它所管轄的內存區域的過程中，一旦發現了只具有弱引用的對象，不管當前內存空間足夠與否，都會回收它的內存，說白了就是一個沒那么strong要求垃圾回收器將一個對象保留在內存中。不過，由於垃圾回收器是一個優先級很低的線程，因此不一定會很快發現那些只具有弱引用的對象。常說的Unreachable和弱引用指代的是一個意思。這可能還是說不清楚，那么我舉個例子：
你有一個類叫做Widget，但是由於某種原因它不能通過繼承來添加一項功能。當我們想從這個對象中取出一些信息的時候怎么辦呢？假設我們需要監視每個Widget的serial Number，但是這個Widget卻偏偏沒有這個屬性，而且還不可繼承...這時候我們想到了用HashMaps：serialNumberMap.put(widget, widgetSerialNumber);
這不就截了嘛~表面上看起來是ok的，但是正是Widget這個Strong Reference產生了問題。當我們設定某個Widget的SerialNumber不需要的時候，那么要從這個映射表中除去這個映射對，否則我們就有了內存泄漏或者是出錯（移除了有效的SerialNumber）。這個問題聽起來很耳熟，是的，在沒有垃圾管理機制的語言中這是個常見問題，在JAVA中我們不用擔心。因為我們有WeakReference。我們使用內置的WeakHashMap類，這個類和哈希表HashMap幾乎一樣，但就是在鍵key的地方使用了WeakReference，若一個WeakHashMap key成為了垃圾，那么它對應的入口就會自動被移除。這就解決了上述問題~
SoftReference則也類似於可有可無的東西。如果內存空間足夠，垃圾回收器就不會回收它，如果內存空間不足了，就會回收這些對象的內存。只要垃圾回收器沒有回收它，該對象就可以被程序使用。軟引用可用來實現內存敏感的高速緩存。弱引用與軟引用的區別在於：具有WeakReference的對象擁有更短暫的生命周期。或者說SoftReference比WeakReference對回收它所指的對象不敏感。一個WeakReference對象會在下一輪的垃圾回收中被清理，而SoftReference對象則會保存一段時間。SoftReferences並不會主動要求與WeakReference有什么不同，但是實際上SoftReference對象一般在內存充裕時一般不會被移除，這就是說對於創建緩沖區它們是不錯的選擇。它兼有了StrongReference和WeakReference的好處，既能停留在內存中，又能在內存不足是去處理，這一切都是自動的！
PhantomReference為"虛引用"，顧名思義，就是形同虛設，與其他幾種引用都不同，虛引用並不會決定對象的生命周期。如果一個對象僅持有虛引用，那么它就和沒有任何引用一樣，在任何時候都可能被垃圾回收，也就是說其get方法任何時間都會返回null。虛引用主要用來跟蹤對象被垃圾回收的活動。其必須和引用隊列（ReferenceQueue）聯合使用，這是與弱引用和軟引用最大的不同。WeakReference是在垃圾回收活動之前將對象入隊的，理論上講這個對象還可以使用finalize()方法使之重生，但是WeakReference仍然是死掉了。PhantomReferences對象是在對象從內存中清除出去的時候才入隊的。也就是說當垃圾回收器准備回收一個對象時，如果發現它還有虛引用，就會在回收對象的內存之前，把這個虛引用加入到與之關聯的引用隊列中。程序可以通過判斷引用隊列中是否已經加入了虛引用，來了解被引用的對象是否將要被垃圾回收。程序如果發現某個虛引用已經被加入到引用隊列，那么就可以在所引用的對象的內存被回收之前采取必要的行動。它限制了finalize()方法的使用，更安全也更高效。
我們看看這個包給我們提供了什么類？
WeakReference 類
WeakReference weakref = new WeakReference(ref);
這樣 weakref 就是 ref 指向對象的一個 weak reference。要引用這個 weak reference 指向的對象可以用 get 方法。把對象的 weak reference 放入 Hashtable 或者緩存中，當沒有 strong reference 指向他們的時候，對象就可以被垃圾收集器回收了。實際上，有一個 WeakHashMap 就是專門做這個事的。一旦WeakReference使用get方法返回null的時候，它指向的對象已經變成了垃圾，這個weakref對象也沒什么用處了。這就需要有一些清理工作了。而ReferenceQueue類就是做這個的，要是你向ReferenceQueue類傳遞了一個WeakReference的構造方法，那么當引用所指的對象成為垃圾時，這個引用的對象就會被自動插入到這個引用隊列中。你可以在一定時間間隔內處理這個隊列。
SoftReference 類
可用來實現智能緩存（java.lang.ref.SoftReference is a relatively new class, used to implement smart caches.）假定你有一個對象引用，指向一個大數組：
Object obj = new char[1000000];
並且如果可能的話，你打算一直保存這個數組，但是如果內存極其短缺的話，你樂於釋放這個數組。你可以使用一個
soft reference:
SoftReference ref = new SoftReference(obj);
Obj是這個soft reference的引用。在以后你用以下的方式檢測這個引用：
if (ref.get() == null)// (referent has been cleared)
else// (referent has not been cleared)
如果這個引用已經被清除了，那么垃圾回收器會收回它所使用的空間，並且你緩存的對象也已經消失。需要注意的是，如果這個指示物還有對它的別的引用，那么垃圾回收器將不會清除它。這個方案可以被用來實現各種不同類型的緩存，這些緩存的特點是只要有可能對象就會被一直保存下來，但是如果內存緊張對象就被清除掉。
注意：軟引用可以和一個引用隊列（ReferenceQueue）聯合使用，如果軟引用所引用的對象被垃圾回收，Java虛擬機就會把這個軟引用加入到與之關聯的引用隊列中。
PhantomReference 類
略
舉個例子：
import java.lang.ref.*;
public class References {
public static void main(String[] args) {
Object weakObj, phantomObj;
Reference ref;
WeakReference weakRef;
PhantomReference phantomRef;
ReferenceQueue weakQueue, phantomQueue;
weakObj = new String("Weak Reference");
phantomObj = new String("Phantom Reference");
weakQueue = new ReferenceQueue();
phantomQueue = new ReferenceQueue();
weakRef = new WeakReference(weakObj, weakQueue);
phantomRef = new PhantomReference(phantomObj, phantomQueue);
// Print referents to prove they exist. Phantom referents
// are inaccessible so we should see a null value.
System.out.println("Weak Reference: " + weakRef.get());
System.out.println("Phantom Reference: " + phantomRef.get());
// Clear all strong references
weakObj = null;
phantomObj = null;
// Invoke garbage collector in hopes that references
// will be queued
System.gc();
// See if the garbage collector has queued the references
System.out.println("Weak Queued: " + weakRef.isEnqueued());
// Try to finalize the phantom references if not already
if(!phantomRef.isEnqueued()) {
System.out.println("Requestion finalization.");
System.runFinalization();
}
System.out.println("Phantom Queued: " + phantomRef.isEnqueued());
// Wait until the weak reference is on the queue and remove it
try {
ref = weakQueue.remove();
// The referent should be null
System.out.println("Weak Reference: " + ref.get());
// Wait until the phantom reference is on the queue and remove it
ref = phantomQueue.remove();
System.out.println("Phantom Reference: " + ref.get());
// We have to clear the phantom referent even though
// get() returns null
ref.clear();
} catch(InterruptedException e) {
e.printStackTrace();
return;
}
}
}
5.java.lang.reflect
可以讓你從public的方法和變臉中獲取信息，稱為reflect是因為Java稱之為reflective，本來用來設計優化器和調試器的，可以使用getclass()方法得到相關類。getFields()方法使我們能得到其中的一些變量信息。而getMethods()方法則得到類的相關方法信息。getInterfaces()方法可以得到相關接口信息。
例如：
import java.lang.reflect.Field;
public class FieldList {
public int x;
public double y;
public static void main(String arg[]) {
FieldList flist = new FieldList();
Class thisClass = flist.getClass();
Field field[] = thisClass.getFields();
for(int i=0; i<field.length; i++)
System.out.println(field[i]);
}
}
-------------------------------------
import java.lang.reflect.Method;
public class MethodList {
public static void main(String arg[]) {
MethodList mlist = new MethodList();
Class mlistClass = mlist.getClass();
Method method[] = mlistClass.getMethods();
for(int i=0; i<method.length; i++)
System.out.println(method[i]);
}
public double sum(int x,float y) {
return((double)(x + y));
}
}
----------------------------------------
import javax.swing.event.ChangeListener;
import javax.swing.event.ChangeEvent;
import java.awt.event.ItemListener;
import java.awt.event.ItemEvent;
public class InterfaceList implements ChangeListener, ItemListener {
public static void main(String arg[]) {
InterfaceList ilist = new InterfaceList();
Class thisClass = ilist.getClass();
Class iface[] = thisClass.getInterfaces();
for(int i=0; i<iface.length; i++)
System.out.println(iface[i]);
}
public void stateChanged(ChangeEvent e) {
}
public void itemStateChanged(ItemEvent e) {
}
}
----------------------------------
import java.lang.reflect.Modifier;
import java.lang.reflect.Constructor;
public class ModifierList {
public ModifierList() {
}
public static void main(String arg[]) {
ModifierList mlist = new ModifierList();
Class mlistClass = mlist.getClass();
Constructor constructor[] = mlistClass.getConstructors();
int mod = constructor[0].getModifiers();
System.out.println("The constructor is:");
if(Modifier.isAbstract(mod))
System.out.println("abstract");
else
System.out.println("not abstract");
if(Modifier.isFinal(mod))
System.out.println("final");
else
System.out.println("not final");
if(Modifier.isInterface(mod))
System.out.println("interface");
else
System.out.println("not interface");
if(Modifier.isNative(mod))
System.out.println("native");
else
System.out.println("not native");
if(Modifier.isPrivate(mod))
System.out.println("private");
else
System.out.println("not private");
if(Modifier.isProtected(mod))
System.out.println("protected");
else
System.out.println("not protected");
if(Modifier.isPublic(mod))
System.out.println("public");
else
System.out.println("not public");
if(Modifier.isStatic(mod))
System.out.println("static");
else
System.out.println("not static");
if(Modifier.isStrict(mod))
System.out.println("strict");
else
System.out.println("not strict");
if(Modifier.isSynchronized(mod))
System.out.println("synchronized");
else
System.out.println("not synchronized");
if(Modifier.isTransient(mod))
System.out.println("transient");
else
System.out.println("not transient");
if(Modifier.isVolatile(mod))
System.out.println("volatile");
else
System.out.println("not volatile");
}
}
--------------------------------------------------
6.java.lang.management
你可以看看JVM是怎么處理內存的。JVM處理內存分為兩部分：
Heap堆，加載類和對象的，這個就是垃圾回收器作用的地方。
Non-Heap，有些Garbage Collector也作用於此。
看下邊這個例子：
import java.lang.management.ManagementFactory;
import java.lang.management.MemoryMXBean;
import java.lang.management.MemoryUsage;
public class ShowMemory {
static String x;
public static void main(String arg[]) {
ShowMemory sm = new ShowMemory();
sm.show();
x = "";
for(int i=0; i<1000; i++)
x += " string number " + i;
sm.show();
x = null;
sm.show();
MemoryMXBean mem = ManagementFactory.getMemoryMXBean();
mem.gc();
sm.show();
}
void show() {
MemoryMXBean mem = ManagementFactory.getMemoryMXBean();
MemoryUsage heap = mem.getHeapMemoryUsage();
System.out.println("Heap committed=" + heap.getCommitted() +
" init=" + heap.getInit() +
" max=" + heap.getMax() +
" used=" + heap.getUsed());
}
}
還可以支持你看看系統信息：
import java.lang.management.ManagementFactory;
import java.lang.management.OperatingSystemMXBean;
public class ShowSystem {
public static void main(String arg[]) {
OperatingSystemMXBean op = ManagementFactory.getOperatingSystemMXBean();
System.out.println("Architecture: " + op.getArch());
System.out.println("Processors: " + op.getAvailableProcessors());
System.out.println("System name: " + op.getName());
System.out.println("System version: " + op.getVersion());
System.out.println("Last minute load: " + op.getSystemLoadAverage());
}
}
還可以知道編譯信息、類加載信息、JVM的信息、線程信息。