java jdk1.5的新特性——泛型 ForEach 枚舉 可變參數 靜態導入 線程併發庫 內省

泛型
加泛型的目的
1.數據安全
一般在使用集合的時候，我們都會給它加一些泛型，限制添加數據的類型
2.少寫幾個類
例如在屬性類中添加泛型：

public class Person<T>
{
    private int pid;
    private T age;
    private String name;
}

在使用時再添加類型：

Person <Integer> p=new Person<>();

T默認的類型是Object
基本數據類型不能作爲泛型
也可以在泛型中繼承接口，使用時必須是接口的實現類：

<T extends List>

表示當前的泛型對象一定是List的實現類或者是List本身

如果將一個泛型當作參數的時候，可以給當前的泛型類設置範圍,設置參數類型：

public void sayhello（Person<? extends String> p）

表示傳遞的參數必須是一個泛型對象，String類型或String類型的子類

Person<? super String> p

表示傳遞的參數必須是一個泛型對象，String類型或String類型的父類
普通類實現泛型接口，必須將泛型也一起繼承
泛型作爲方法的時候，如果父類中沒有泛型，可以使用？來代替泛型

public void say(List<? extends String> list){
}

泛型作爲一個返回值類型

public List<? extends String> getList()
{
    return new ArrayList<String>();
}

ForEach
foreach其實就是迭代器，它可以用來遍歷數組和集合（除了map之外）
1.先獲取到集合或數組長度
2.判斷是否有數據
3.如果存在數據，就將數據取出來

int[ ] i={1,2,3,4,5,6,7,8};
for(int k:i)
{
    System.out.println(k);
}

使用一次，指針就加一
主要用於數組或集合的遍歷，是迭代器的簡寫方式

枚舉
枚舉就是有一定範圍的可選值
枚舉是特殊的類
枚舉的對象一般都是大寫
在枚舉的對象後面加分號，後面可以寫方法，可以寫屬性

public enum Color
{
	RED,GREEN,YELLOW;
	private int color;
	public void run()
	{
		System.out.println("helloword");
	}
	public static void main(String[] args)
	{
		Color c=Color.RED;
		Color c2=Color.GREEN;
		Color c3=Color.YELLOW;
	}
}

一旦構造器修改，裏面定義的對象必須根據我們的構造器來實例化
枚舉會給每一個對象分配一個name和（當前名稱）ordinal（序號）
枚舉一般使用在switch-case語句中

可變參數
數據類型…變量
表示可以傳遞任意多個該數據類型的數據
在使用的時候可以當做數組來看待
例如：計算幾個數的和

public class VarMethod
{

	public void dosomething(int...one)
	{
		int sum=0;
		for(int a:one)
		{
			sum+=a;
		}
		System.out.println(sum);
	}
	public static void main(String[] args)
	{
		new VarMethod().dosomething(1,2,3);
	}
}

可變參數必須放在最後面

public void dosomething2(int a,int...b)
	{	
                       System.out.println(b[0]);
	}

靜態導入
直接導入方法的路徑，就可以直接使用該方法，不通過方法名、類名去調用
import static 包名.類名.靜態方法
優點：
使用靜態導入可以使被導入的所有靜態變量和靜態方法在當前類直接可見，
使這些靜態成員無需再給出它們的類名
缺點：
可讀性差

import static java.lang.System.out;
public class StaticImport
{
	public static void main(String[] args)
	{
		out.println("helloworld");
	}

}

線程併發庫
線程池:
用來存放並且運行線程的管理工具
所在包：
java.util.concurrent類庫下的ExecutorService
Executor是線程池最頂級的接口，線程類的祖宗
Executors 工具類 創建線程池
ExecutorService 線程池的服務員 負責加入線程
用法1：
定義了線程池的大小爲2，放5個線程進去，就會先執行2個，再執行2個，再執行1個

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadGroup
{
	public static class MyThread implements Runnable
	{
		public void run()
		{
			for(int i=0;i<50;i++)
			{
				System.out.println(Thread.currentThread().getName()+"="+i);
			}
		}
	}
	public static void main(String[] args)
	{
//		定義線程池，自己去確定它的大小
		ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(2);
		newFixedThreadPool.submit(new MyThread());
		newFixedThreadPool.submit(new MyThread());
		newFixedThreadPool.submit(new MyThread());
		newFixedThreadPool.submit(new MyThread());
		newFixedThreadPool.submit(new MyThread());
//      關閉線程池
		newFixedThreadPool.shutdown();

	}

}

用法2:
使用線程池計算1到100的和

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class ThreadGroup2
{
	public static class MyCallAble implements Callable
	{
		public Integer call() throws Exception
		{
			int sum=0;
			for(int i=1;i<=100;i++)
			{
				sum+=i;
			}
			return sum;
		}
	}
	public static void main(String[] args)
	{
//		定義線程池，自己去確定它的大小
		ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(2);
		Future submit = newFixedThreadPool.submit(new MyCallAble());
		Future submit2 = newFixedThreadPool.submit(new MyCallAble());
		Future submit3 = newFixedThreadPool.submit(new MyCallAble());
		Future submit4 = newFixedThreadPool.submit(new MyCallAble());
		Future submit5 = newFixedThreadPool.submit(new MyCallAble());
		try
		{
			System.out.println(submit.get());
			System.out.println(submit2.get());
			System.out.println(submit3.get());
			System.out.println(submit4.get());
			System.out.println(submit5.get());
		}
		catch (InterruptedException e)
		{
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		catch (ExecutionException e)
		{
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
//      關閉線程池
		newFixedThreadPool.shutdown();

	}

}

內省
java.beans包下
內省最核心的一個類：Introspector
內省可以獲取類的所有屬性和方法，但是不能改變這些信息

BeanInfo beanInfo = Introspector.getBeanInfo(p.getClass());
			PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
		    for(PropertyDescriptor property:propertyDescriptors)
		    {
		    	Method writeMethod = property.getWriteMethod();
		        System.out.println(writeMethod);
		    }
		    MethodDescriptor[] methodDescriptors = beanInfo.getMethodDescriptors();
		    for(MethodDescriptor md:methodDescriptors)
		    {
		    	System.out.println(md.getName());
		    }

內省一般用於後臺的架構，例如xml解析
xml可以存放不規則並且少量的數據
XML的解析技術：
DOM4J 是一個第三方的jar包 使用頻率非常高
核心類：SAXReader