jdk7 新特性测试-1 -（demo来源于网上）

package jdk7;

import java.io.IOException;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

public class Jdk7Test {

public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
System.out.println(switchString("Monday"));

//抛出异常
catchTest();
}

//Switch语句支持string类型
public static String switchString(String dayOfWeekArg){
String typeOfDay;
switch (dayOfWeekArg) {
case "Monday":
typeOfDay = "Start of work week";
break;
case "Tuesday":
case "Wednesday":
case "Thursday":
typeOfDay = "Midweek";
break;
case "Friday":
typeOfDay = "End of work week";
break;
case "Saturday":
case "Sunday":
typeOfDay = "Weekend";
break;
default:
throw new IllegalArgumentException("Invalid day of the week: " + dayOfWeekArg);
}
return typeOfDay;
}

//1.4 catch
public static void catchTest( ) throws Exception {
String zipFileName = "";
try {
System.out.println("error");
if(true){
throw new IOException();
}else{
throw new SQLException();
}
} catch (IOException|SQLException ex) {
throw ex;
}
}

//1.6 泛型实例的创建可以通过类型推断来简化 可以去掉后面new部分的泛型类型，只用<>就可以了
public static void listTest( ) throws Exception {
List<String> list = new ArrayList<>();
list.add("A");
}


}

fork-join

package jdk7;

import java.util.Date;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.Future;
import java.util.concurrent.RecursiveTask;


//最大的增强，充分利用多核特性，将大问题分解成各个子问题，
//由多个cpu可以同时解决多个子问题，最后合并结果，继承RecursiveTask，
//实现compute方法，然后调用fork计算，最后用join合并结果

//算法很简单，在100个数以内的我们直接迭代计算和值。否则采用Fork/Join框架分治计算。
public class PlusPlus extends RecursiveTask<Long>{
private static final int THRESHOLE=100;
private int start;
private int end;
public PlusPlus(int start,int end){
this.start=start;
this.end=end;
}

@Override
protected Long compute() {
// TODO Auto-generated method stub
Long sum=0l;
if(end-start<THRESHOLE){
for(int i=start;i<=end;i++){
sum+=i;
}
}else{
int middle=(start+end)/2;
PlusPlus left=new PlusPlus(start, middle);
PlusPlus right=new PlusPlus(middle+1, end);

left.fork();
right.fork();
sum=left.join()+right.join();
}
return sum;
}

public Long sumall(){
long sum=0;
for(int i=start;i<=end;i++){
sum = sum+ i;
}
return sum;
}

public static void main(String args[]) throws InterruptedException, ExecutionException{
long t1 = new Date().getTime();

ForkJoinPool pool=new ForkJoinPool();
Future<Long> result=pool.submit(new PlusPlus(1, 800000));

long t2 = new Date().getTime();
long sum = new PlusPlus(1, 800000).sumall();
long t3 = new Date().getTime();
System.out.println(result.get()+"耗时:"+(t2-t1));
System.out.println(sum+"耗时:"+(t3-t2));
// System.err.println(10001*5000);
}

}


320000400000耗时:2
320000400000耗时:3

注：
使用fork 有个局限 800000 变成 1000000时候 出现 OutOfMemory
而后面一种方式 就不会出现这个错误