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、枚举、二进制字面量、长数字下划线分割、内省等等。
所有语言的特性都是针对某些业务场景设计的，所以了解更多的特性，以便在遇到具体问题时，能够有更多的解决方案。
