java [33] jdk5新特性

Jdk5新特性：

静态导入
自动装箱/拆箱
增强for循环
可变参数
枚举反射类型
泛型
元数据

一、静态导入

导入静态方法，使用起来更加简洁，不好用；

七、内省（xing）操作javabean的属性

八、泛型

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--;

           

        }

       

       

    }

}