java [33] jdk5新特性
阿新 • • 發佈：2018-11-10
Jdk5新特性：
- 靜態匯入
- 自動裝箱/拆箱
- 增強for迴圈
- 可變引數
- 列舉 反射型別
- 泛型
- 元資料
一、靜態匯入
匯入靜態方法，使用起來更加簡潔，不好用；
目錄
import static java.lang.System.out; public class demo1 { public static void main(String[] args) { out.println("靜態匯入"); } }
二、自動裝箱/拆箱
自動裝箱：開發人員可以把一個基本的資料型別直接賦值給對應的包裝類。
自動拆箱：開發人員可以把一個包裝類物件直接賦值給物件的基本資料型別。
典型應用：
List list = new ArrayList（）；
List.add(1)；
Int j = (integer) list.get(0);
import java.util.ArrayList; import java.util.List; public class demo1 { public static void main(String[] args) { //1.5 jvm Integer i =1; //裝箱 int j = i; //拆箱 //典型應用 List list = new ArrayList(); list.add(new Integer(1)); //1.5以前 list.add(2); list.add(3); } }
三、增強for迴圈
增強for迴圈只能應用在陣列或者實現Iterable介面的集合類上。比如set list.使用map時需要轉換
語法格式：
for (變數型別 變數 ： 需要迭代的陣列或者集合){
}
package demo; import java.util.ArrayList; import java.util.HashMap; import java.util.Iterator; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.Map.Entry; import java.util.Set; import org.junit.Test; public class demo2 { @Test public void test1() { int arr[] = {1,2,3}; for (int i:arr){ System.out.println(i); } } @Test public void test2(){ List list = new ArrayList(); list.add(1); list.add(2); list.add(3); for (Object obj:list){ int i = (Integer)obj; System.out.println(i); } } @Test public void test3(){ //結果是無序的 Map map = new HashMap(); map.put("1", "apple"); map.put("2", "banana"); map.put("3", "orange"); //傳統方式一 Set set = map.keySet(); Iterator it = set.iterator(); while(it.hasNext()){ String key=(String) it.next(); String value = (String) map.get(key); System.out.println(key + "=" + value); } //傳統方式2 Set set1 = map.entrySet();//entrySet() 返回此對映中包含的對映關係的 Set 檢視。 Iterator it1 = set1.iterator(); while (it1.hasNext()){ Map.Entry entry = (Entry) it1.next(); String key = (String) entry.getKey(); String value = (String) entry.getValue(); System.out.println(key + "=" + value); } } @Test public void test4(){ //結果是有序的 Map map = new LinkedHashMap(); map.put("1", "apple"); map.put("2", "banana"); map.put("3", "orange"); //傳統方式一 //Iterator<E> iterator() //返回此對映中包含的鍵的 Set 檢視 Set set = map.keySet(); // 返回在此 set 中的元素上進行迭代的迭代器。 Iterator it = set.iterator(); //hasNext() 如果仍有元素可以迭代，則返回 true。 while(it.hasNext()){ String key=(String) it.next(); //next() 返回迭代的下一個元素。 String value = (String) map.get(key); System.out.println(key + "=" + value); } } @Test public void test5(){ //結果是無序的 Map map = new HashMap(); map.put("1", "apple"); map.put("2", "banana"); map.put("3", "orange"); //增強for取map的第一種方式 for (Object obj:map.keySet()){ String key = (String) obj; String value = (String) map.get(obj); System.out.println(key + "=" + value); } //增強for取map的第2種方式 for (Object obj : map.entrySet()){ Map.Entry entry = (Entry) obj; String key = (String) entry.getKey(); String value = (String) entry.getValue(); System.out.println(key + "=" + value); } } //使用增強for迴圈注意事項：增強for 適合取數值，不適合做更改。 @Test public void test6(){ int arr[] = {1,2,3}; for (int i:arr){ i=10; } System.out.println(arr[0]); System.out.println(arr[1]); System.out.println(arr[2]); } }
例項：
四、可變引數
格式：
public void sum(int ...nums){
//可變引數可看成陣列
}
例項
package demo;
import java.util.Arrays;
import java.util.List;
import org.junit.Test;
public class demo3 {
@Test
public void testsum(){
sum(1,2,3,4,5,6);
}
public void sum(int ...nums){
//可變引數可看成陣列
int sum =0;
for (int i:nums){
sum+=i;
}
System.out.println(sum);
}
//可變引數需要注意事項
public void aa(int x,int ...nums){
}
@Test
public void bb(){
List list = Arrays.asList("1","2","3");
System.out.println(list);
String arrs[] ={"1","2","3","4"};
list = Arrays.asList(arrs);
System.out.println(list);
int nums[] = {1,2,3,5}; //返回記憶體
list = Arrays.asList(nums);
System.out.println(list);
Integer sums[] = {1,2,3,6};
list = Arrays.asList(sums);
System.out.println(list);
}
}
五、列舉
https://blog.csdn.net/qq_38125626/article/details/81873547
六、反射
https://blog.csdn.net/qq_38125626/article/details/81741980
七、內省（xing）操作javabean的屬性
package test1;
public class People { //javabean
public String name; //欄位 ，只有欄位提供了get和set方法才有了屬性
private String passwd;
public int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPasswd() {
return passwd;
}
public void setPasswd(String passwd) {
this.passwd = passwd;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getab(){
return null;
}
}
package test1;
import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;
import org.junit.Test;
//類 Introspector
//Introspector 類為通過工具學習有關受目標 Java Bean 支援的屬性、事件和方法的知識提供了一個標準方法。
//public static BeanInfo getBeanInfo(Class<?> beanClass) throws IntrospectionException
//在 Java Bean 上進行內省，瞭解其所有屬性、公開的方法和事件。
//使用內省api操作bean屬性
public class Demo4 {
//得到bean的所有屬性
@Test
public void test1() throws IntrospectionException{
//內省 瞭解其內省、公開的方法和事件(包含從父類繼承的屬性)
BeanInfo info = Introspector.getBeanInfo(People.class);
//不獲取父類的屬性
//BeanInfo info = Introspector.getBeanInfo(People.class,Object.class);
//返回描述受此 bean 支援的可編輯屬性的 PropertyDescriptor 陣列。
PropertyDescriptor[] pds= info.getPropertyDescriptors();
for (PropertyDescriptor pd:pds){
System.out.println(pd.getName());
}
}
//操縱bean的指定屬性
@Test
public void test2() throws Exception{
People obj = new People();
PropertyDescriptor pd = new PropertyDescriptor("age", People.class);
Method md = pd.getWriteMethod();
md.invoke(obj, 15);
System.out.println(obj.getAge());
md = pd.getReadMethod();
System.out.println(md.invoke(obj, null));
}
}
使用beanUtils操縱bean的屬性
package test1;
import java.lang.reflect.InvocationTargetException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.beanutils.ConversionException;
import org.apache.commons.beanutils.ConvertUtils;
import org.apache.commons.beanutils.Converter;
import org.apache.commons.beanutils.locale.converters.DateLocaleConverter;
import org.junit.Test;
//使用beanUtils操縱bean的屬性
public class Demo5 {
@Test
public void test1() throws IllegalAccessException, InvocationTargetException{
People p = new People();
BeanUtils.setProperty(p, "name", "xxf");
System.out.println(p.getName());
}
@Test
public void test2() throws IllegalAccessException, InvocationTargetException{
People p = new People();
String name = "aaa";
String passwd = "1234";
String age = "15";
BeanUtils.setProperty(p, "name", name);
BeanUtils.setProperty(p, "passwd", passwd);
BeanUtils.setProperty(p, "age", age);
System.out.println(p.getName());
System.out.println(p.getAge());
System.out.println(p.getPasswd());
}
@Test
public void test3() throws IllegalAccessException, InvocationTargetException{
People p = new People();
String birthday = "1989-08-28";
//beanUtils只支援基本資料型別的資料轉換。
//為了將日期賦值到bean的birthday屬性上，給beanUtils註冊一個日期轉換器
ConvertUtils.register(new Converter() {
public <T> T convert(Class<T> type, Object value) {
if (value ==null){
return null;
}
if (!(value instanceof String)){
throw new ConversionException("只支援string型別的轉換");
}
String str = (String) value;
if (str.trim().equals("")){
return null;
}
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
try {
return (T) sdf.parse(str);
} catch (ParseException e) {
// TODO Auto-generated catch block
throw new RuntimeException(e);
}
}
},Date.class);
BeanUtils.setProperty(p, "birthday", birthday);
System.out.println(p.getBirthday());
Date date = p.getBirthday();
System.out.println(date.toString());
System.out.println(date.toLocaleString());
}
//在實際開發過程中beanutils自己已經寫好了轉換器
@Test
public void test4() throws IllegalAccessException, InvocationTargetException{
People p = new People();
String birthday = "1989-08-28";
ConvertUtils.register(new DateLocaleConverter(), Date.class);
BeanUtils.setProperty(p, "birthday", birthday);
Date date = p.getBirthday();
System.out.println(date.toLocaleString());
}
@Test
public void test5(){
Map map = new HashMap();
map.put("name", "aaa");
map.put("passwd", "123");
map.put("age", "15");
map.put("birthday", "1989-08-28");
ConvertUtils.register(new DateLocaleConverter(), Date.class);
People p = new People();
try {
BeanUtils.populate(p, map); //用map集合中的值，填充bean屬性
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(p.getName());
System.out.println(p.getAge());
System.out.println(p.getPasswd());
Date date = p.getBirthday();
System.out.println(date.toLocaleString());
}
}八、泛型
使用泛型的注意事項：
使用泛型時，泛型型別須為引用型別，不能是基本資料型別 可以是interger 不能是int
泛型時提供給javac編譯器使用的，他用於限定集合的輸入型別，讓編譯器在原始碼級別上，即擋入向集合中插入非法資料，當編譯器編譯帶有泛型的java程式後，生成的class檔案將不再帶有泛型資訊，依次使程式的執行效率不收影響，這個過程稱之為擦除。
泛型的基本術語，以ArreyList<E>為例，<> type of
ArreyList<E>中的E稱為型別引數變數
ArreyList<Interger> 中的interger稱為實際型別引數
ArreyList<E> 泛型型別
ArreyList<Interger>稱為引數化的型別parameterizedtype
package cn.generic;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.junit.Test;
public class demo1 {
public static void main(String[] args) {
/*List list = new ArrayList();
list.add("aaa");
Integer i = (Integer) list.get(0);*/ //java.lang.String cannot be cast to java.lang.Integer
List<String> list2 = new ArrayList<String>();
list2.add("123");
list2.get(0);
}
@Test
public void test1(){
List<String> list = new ArrayList<String>();
list.add("aa");
list.add("bb");
list.add("cc");
//返回一個迭代器
Iterator<String> it = list.iterator();
while(it.hasNext()){
String value =it.next();
System.out.println(value);
}
}
@Test
public void test2(){
List<String> list = new ArrayList<String>();
list.add("aa");
list.add("bb");
list.add("cc");
for (String s :list){
System.out.println(s);
}
}
@Test
public void test3(){
Map<Integer, String> map = new HashMap<Integer,String>();
map.put(1,"aa");
map.put(2, "bb");
map.put(3, "cc");
//傳統keyset entryset
Set<Map.Entry<Integer, String>> set = map.entrySet();
Iterator<Map.Entry<Integer, String>> it = set.iterator();
while (it.hasNext()){
Map.Entry<Integer, String> entry= it.next();
int key = entry.getKey();
String value = entry.getValue();
System.out.println(key + ":" + value);
}
//增強for
for (Map.Entry<Integer, String> entry:map.entrySet()){
int key = entry.getKey();
String value = entry.getValue();
System.out.println(key + ":" + value);
}
}
}自定義泛型方法
Java程式中的普通方法，構造方法和靜態方法，都可以使用泛型，方法使用泛型前，必須對泛型進行宣告，語法<T>,T可以是任意字母，但通常必須要大寫。<T>通常需要放在方法的返回值宣告之前。例如：
Public static <T> void doxx(T t);
package cn.generic;
//自定義帶反省的方法
public class Demo2<T> {
public void testa(){
//a("aaa");
}
public T a(T t){
return null;
}
public <E,K> void b(T t,E e,K k){
}
//靜態方法需要宣告型別
public static <T> void c(T t){
}
}
package cn.generic;
public class Demo3 {
//編寫一個泛型方法，實現指定位置上的陣列元素的交換。
public <T> void swap(T arr[],int pos1,int pos2){
T temp =arr[pos1];
arr[pos1] = arr[pos2];
arr[pos2] = temp;
}
//編寫一個泛型方法，接收任意一個數組，並且顛倒陣列中的所有元素
public <T> void reverse(T arr[]){
int start = 0;
int end = arr.length-1;
while (true){
if (start>=end){
break;
}
T temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
start++;
end--;
}
}
}