Java語言已經霸占語言排行榜第一名很多年，雖然Java開發效率總是被人詬病，但性價比還是相對很高的（運行效率/開發效率），下面整理了Java語言的部分特性：
泛型
泛型，即“參數化類型”，也就是把具體的類型變成參數形式進行定義和調用。舉個例子：
public interface List<E> extends Collection<E> {
int size();
boolean isEmpty();
boolean contains(Object o);
Iterator<E> iterator();
<T> T[] toArray(T[] a);
.....
}
List<String> strList = new ArrayList<>();
泛型的作用：
- 編譯時進行類型檢查，減少運行時錯誤
- 省去了類型轉換的麻煩
可變參數
“可變參數”適用于參數個數不確定的情況，Java把可變參數當成數組來處理。
需要注意的是：** 可變參數必須位于參數列表的最后一項 **
可變參數舉例：
private int sumUp(int... values) {
int sum = 0;
for (int i = 0; i < values.length; i++) {
sum += values[i];
}
return sum;
}
雖然可變參數最后也會轉換為數組形式，但直接用數組做參數的好處是，不用事先確定參數的個數（當然，運行時，也會慢那么一點點）。
回調
先舉個回調的例子：
星期天你的一個朋友B要來你家做客，左等右等就是不來，然后你(A)打電話問“到哪兒了？”，你朋友B說“馬上到，再等五分鐘”，你說“好吧，到樓下了震我電話，我去門口接你”。
你朋友可以跑著去接你，可以走著去，也可以走一段跑一段，怎么接就是回調函數。
代碼實現如下：
interface CallBack{ //回調接口
public void pickupMe();
}
public class B {
public void pickupMe(CallBack callback){
callback.pickupMe();
}
}
public class A{
public void whenBCallA(){
B b = new B();
b.pickupMe(new CallBack(){
public void pickupMe(){
System.out.println("飛奔過去。。。。");
}
})
}
}
閉包
“閉包”簡單說，就是返回一個方法的方法。但是，Java的方法不能單獨存在，所以需要通過“接口+內部類”的方式實現，舉例如下：
public class DemoClass1 {
private int length =0;
//private|public
private class InnerClass implements ILog
{
@Override
public void Write(String message) {
//DemoClass1.this.length = message.length();
length = message.length();
System.out.println("DemoClass1.InnerClass:" + length);
}
}
public ILog logger() {
return new InnerClass();
}
public static void main(String[] args){
DemoClass1 demoClass1 = new DemoClass1();
demoClass1.logger().Write("abc");
//.new
DemoClass1 dc1 = new DemoClass1();
InnerClass ic = dc1.new InnerClass();
ic.Write("abcde");
}
}
反射
“反射”就是對運行狀態中的類，獲取/調用其屬性和方法的機制。
舉例如下：
// 實例化類
Class<?> clazz = Class.forName("com.baidu.xxx");
Class<?> clazz1 = new TestReflect().getClass();
Class<?> clazz2 = TestReflect.class;
// 獲取父類
Class<?> parentClass = clazz.getSuperclass();
// 獲取所有接口
Class<?> intes[] = clazz.getInterfaces();
// 獲取全部構造方法
Constructor<?> cons[] = clazz.getConstructors();
// 獲取全部屬性
Field[] field = clazz.getDeclaredFields();
// 獲取全部方法
Method method[] = clazz.getMethods();
下面是JDK1.8新增加的幾個特性
lambda函數
老版本Java排列字符串的方式
List<String> names = Arrays.asList("peter", "anna", "mike", "xenia");
Collections.sort(names, new Comparator<String>() {
@Override
public int compare(String a, String b) {
return b.compareTo(a);
}
});
使用Lambda排列字符串的方式
Collections.sort(names, (String a, String b) -> {
return b.compareTo(a);
});
或者
Collections.sort(names, (String a, String b) -> b.compareTo(a));
或者
Collections.sort(names, (a, b) -> b.compareTo(a));
Java中一切都是對象，所以Lambda表達式也是通過函數式的接口來實現的。用到的注解為：@FunctionalInterface
靜態方法引用
Java 8 允許使用 :: 關鍵字來傳遞方法或者構造函數引用。
上面的例子用靜態方法實現如下
Converter<String, Integer> converter = Integer::valueOf;
Integer converted = converter.convert("123");
System.out.println(converted); // 123
流運算
JDK1.8對集合也增加了流運算處理方式，java.util.Stream 表示能應用在一組元素上一次執行的操作序列。舉例如下
List<String> stringCollection = Arrays.asList("aa","cc","bb");
stringCollection
.stream()
.filter((s) -> s.startsWith("a"))
.forEach(System.out::println);
stringCollection
.stream()
.sorted()
.filter((s) -> s.startsWith("a"))
.forEach(System.out::println);
stringCollection
.stream()
.map(String::toUpperCase)
.sorted((a, b) -> b.compareTo(a))
.forEach(System.out::println);
stringCollection
.stream()
.filter((s) -> s.startsWith("b"))
.count();
當然，Java還有很多的其他特性，比如 try-with-resources、枚舉、二進制字面量、長數字下劃線分割、內省等等。
所有語言的特性都是針對某些業務場景設計的，所以了解更多的特性，以便在遇到具體問題時，能夠有更多的解決方案。
