JAVA5新特性

最新推荐文章于 2021-02-27 05:06:22 发布
最新推荐文章于 2021-02-27 05:06:22 发布
阅读量1.6k 收藏 2
点赞数
分类专栏： JAVA 文章标签： java string integer features 编译器 deprecated
1.静态导入方法

Java代码 复制代码  收藏代码
  1. package com.java.new_features_jdk5;   
  2.   
  3. /**  
  4.  *   
  5.  * 一般我们导入一个类都用 import com.....ClassName;而静态导入是这样：import static com.....ClassName.*; 
  6.  * 这里的多了个static，还有就是类名ClassName后面多了个 .* ，意思是导入这个类里的静态方法。当然，也可以只导入某个静态方法，只要把 .* 换成静态方法名就行了。 
  7.  * 然后在这个类中，就可以直接用方法名调用静态方法，而不必用ClassName.方法名 的方式来调用。 
  8.  * 这种方法的好处就是可以简化一些操作，例如打印操作System.out.println(...);就可以将其写入一个静态方法print(...)，在使用时直接print(...)就可以了。 
  9.  * 但是这种方法建议在有很多重复调用的时候使用，如果仅有一到两次调用，不如直接写来的方便。  
  10.  
  11.  * @author yuahan  
  12.  *  
  13.  */  
  14. public class _Static_Import {   
  15.     public static void main(String[] args) {   
  16.   
  17.     }   
  18. }  
2.新增加的for循环

Java代码 复制代码  收藏代码
  1. package com.java.new_features_jdk5;   
  2.   
  3. import java.util.ArrayList;   
  4. import java.util.List;   
  5.   
  6. /**  
  7.  * 增强的for循环，可以使用在数组和容器中  
  8.  * @author yuahan  
  9.  *  
  10.  */  
  11. public class _For {   
  12.     @SuppressWarnings("serial")   
  13.     public static void main(String[] args) {   
  14.         int[] array = {1,2,3,4,5,6,7,8,9,10};   
  15.         for(int num : array){   
  16.             System.out.print(num + " ");   
  17.         }   
  18.            
  19.         System.out.println();   
  20.            
  21.         List<Integer> list = new ArrayList<Integer>(){{   
  22.             this.add(1);   
  23.             this.add(2);   
  24.             this.add(3);   
  25.             this.add(4);   
  26.             this.add(5);   
  27.             this.add(6);   
  28.             this.add(7);   
  29.             this.add(8);   
  30.             this.add(9);   
  31.             this.add(10);   
  32.         }};   
  33.            
  34.         for(int num : list){   
  35.             System.out.print(num + " ");   
  36.         }   
  37.     }   
  38. }  
package com.java.new_features_jdk5;

import java.util.ArrayList;
import java.util.List;

/**
 * 增强的for循环，可以使用在数组和容器中
 * @author yuahan
 *
 */
public class _For {
	@SuppressWarnings("serial")
	public static void main(String[] args) {
		int[] array = {1,2,3,4,5,6,7,8,9,10};
		for(int num : array){
			System.out.print(num + " ");
		}
		
		System.out.println();
		
		List<Integer> list = new ArrayList<Integer>(){{
			this.add(1);
			this.add(2);
			this.add(3);
			this.add(4);
			this.add(5);
			this.add(6);
			this.add(7);
			this.add(8);
			this.add(9);
			this.add(10);
		}};
		
		for(int num : list){
			System.out.print(num + " ");
		}
	}
}



3.枚举 Enum

Java代码 复制代码  收藏代码
  1. package com.java.new_features_jdk5;   
  2.   
  3. /**  
  4.  *   
  5.  * 你可以将枚举类型视为特殊的类，因此几乎可以像创建普通类那样创建枚举。  
  6.  * 枚举类型有附加的特性，有EnumMap和EnumSet两个类。实例化方法中都需要传入枚举类型的类类型，如： 
  7.  *  EnumSet<_Enum> set = EnumSet.noneOf(_Enum.class); 
  8.     EnumMap<_Enum,String> map = new EnumMap<_Enum,String>(_Enum.class); 
  9.       
  10.     枚举可以有自己的构造方法，不过构造方法只能私有，这样外部是不能构造出新的枚举中的实例，而只是调用其中的实例。 
  11.  * @author yuahan  
  12.  *  
  13.  */  
  14. public enum _Enum {   
  15.     Better(90),   
  16.     Good(80),   
  17.     Ok(70),   
  18.     Bad(60),   
  19.     Worse;   
  20.        
  21.     private int value;   
  22.   
  23.     private _Enum() {   
  24.         this.value = 30;   
  25.     }   
  26.        
  27.     private _Enum(int value) {   
  28.         this.value = value;   
  29.     }   
  30.        
  31.     public int getValue() {   
  32.         return value;   
  33.     }   
  34.   
  35.     public void setValue(int value) {   
  36.         this.value = value;   
  37.     }   
  38.   
  39.     public static _Enum[] getEnumValues(){   
  40.         return _Enum.values();   
  41.     }   
  42.        
  43.     public static void _ValuesOf(){   
  44. //      _Enum test = _Enum.valueOf("test");//error  
  45. //      System.out.println(test);   
  46.            
  47.         _Enum Better = _Enum.valueOf("Better");   
  48.         System.out.println(Better);   
  49.     }   
  50.        
  51.        
  52.     public static void main(String[] args) {   
  53.         for(_Enum mark : _Enum.getEnumValues()){   
  54.             switch(mark){   
  55.             case Better:   
  56.                 System.out.println(_Enum.Better);   
  57.                 break;   
  58.             case Good:   
  59.                 System.out.println(_Enum.Good);   
  60.                 break;   
  61.             case Ok:   
  62.                 System.out.println(_Enum.Ok);   
  63.                 break;   
  64.             case Bad:   
  65.                 System.out.println(_Enum.Bad);   
  66.                 break;   
  67.             case Worse:   
  68.                 System.out.println(_Enum.Worse);   
  69.                 break;     
  70.             }   
  71.         }   
  72.            
  73.         _Enum._ValuesOf();   
  74.            
  75.         System.out.println(_Enum.Better.getValue());   
  76.     }   
  77. }  
package com.java.new_features_jdk5;

/**
 * 
 * 你可以将枚举类型视为特殊的类，因此几乎可以像创建普通类那样创建枚举。
 * 枚举类型有附加的特性，有EnumMap和EnumSet两个类。实例化方法中都需要传入枚举类型的类类型，如：
 * 	EnumSet<_Enum> set = EnumSet.noneOf(_Enum.class);
	EnumMap<_Enum,String> map = new EnumMap<_Enum,String>(_Enum.class);
	
	枚举可以有自己的构造方法，不过构造方法只能私有，这样外部是不能构造出新的枚举中的实例，而只是调用其中的实例。
 * @author yuahan
 *
 */
public enum _Enum {
	Better(90),
	Good(80),
	Ok(70),
	Bad(60),
	Worse;
	
	private int value;

	private _Enum() {
		this.value = 30;
	}
	
	private _Enum(int value) {
		this.value = value;
	}
	
	public int getValue() {
		return value;
	}

	public void setValue(int value) {
		this.value = value;
	}

	public static _Enum[] getEnumValues(){
		return _Enum.values();
	}
	
	public static void _ValuesOf(){
//		_Enum test = _Enum.valueOf("test");//error
//		System.out.println(test);
		
		_Enum Better = _Enum.valueOf("Better");
		System.out.println(Better);
	}
	
	
	public static void main(String[] args) {
		for(_Enum mark : _Enum.getEnumValues()){
			switch(mark){
			case Better:
				System.out.println(_Enum.Better);
				break;
			case Good:
				System.out.println(_Enum.Good);
				break;
			case Ok:
				System.out.println(_Enum.Ok);
				break;
			case Bad:
				System.out.println(_Enum.Bad);
				break;
			case Worse:
				System.out.println(_Enum.Worse);
				break;	
			}
		}
		
		_Enum._ValuesOf();
		
		System.out.println(_Enum.Better.getValue());
	}
}



4.反射 Reflect

Java代码 复制代码  收藏代码
  1. package com.java.new_features_jdk5;   
  2.   
  3. import java.lang.reflect.Array;   
  4. import java.lang.reflect.Constructor;   
  5. import java.lang.reflect.Field;   
  6. import java.lang.reflect.Method;   
  7. import java.lang.reflect.Modifier;   
  8. import java.util.Arrays;   
  9.   
  10. /**  
  11.  * Reflection 是 Java 程序开发语言的特征之一，它允许运行中的 Java 程序对自身进行检查，或者说“自审”，并能直接操作程序的内部属性。 
  12.  * Java 的这一能力在实际应用中也许用得不是很多，但是在其它的程序设计语言中根本就不存在这一特性 
  13.  * JavaDoc 中对每个类和其中的方法有非常详细介绍。主要有：  
  14.    
  15.  * Class   ------- java.lang  
  16.  * Package ------- java.lang  
  17.  *   
  18.  * Array  
  19.  * Field  
  20.  * Method  
  21.  * Modifier  
  22.  * Constructor  
  23.  * @author yuahan  
  24.  *  
  25.  */  
  26. public class _Reflect {   
  27.     private int id;   
  28.     private String name;   
  29.     private String[] hobbies;   
  30.        
  31.     public _Reflect(){}   
  32.        
  33.     public _Reflect(int id){   
  34.         this.id = id;   
  35.     }   
  36.        
  37.     public _Reflect(int id, String name, String[] hobbies) {   
  38.         super();   
  39.         this.id = id;   
  40.         this.name = name;   
  41.         this.hobbies = hobbies;   
  42.     }   
  43.   
  44.     public int getId() {   
  45.         return id;   
  46.     }   
  47.   
  48.     public void setId(int id) {   
  49.         this.id = id;   
  50.     }   
  51.   
  52.     public String getName() {   
  53.         return name;   
  54.     }   
  55.   
  56.     public void setName(String name) {   
  57.         this.name = name;   
  58.     }   
  59.   
  60.     public String[] getHobbies() {   
  61.         return hobbies;   
  62.     }   
  63.   
  64.     public void setHobbies(String[] hobbies) {   
  65.         this.hobbies = hobbies;   
  66.     }   
  67.        
  68.     public static void main(String[] args) throws Exception{   
  69.         //---------------------------------basic---------------------------------  
  70.         System.out.println(_Reflect.class.getSimpleName());   
  71.         System.out.println(_Reflect.class.getName());   
  72.         System.out.println(_Reflect.class.getPackage());    
  73.         System.out.println(_Reflect.class.getSuperclass().getName());   
  74.         System.out.println(int[].class.getName());    
  75.         System.out.println(_Reflect[].class.getName());         
  76.            
  77.            
  78. //      //--------------------------------- Method ---------------------------------  
  79.         Method[] methods = _Reflect.class.getMethods();   
  80.         for(Method method : methods){   
  81.             System.out.println(method + ": " +method.getDeclaringClass().getName());   
  82.         }   
  83.            
  84.            
  85.            
  86. //      //--------------------------------- isXXX ---------------------------------   
  87.         System.out.println(Comparable.class.isInterface());   
  88.         System.out.println(int.class.isPrimitive());   
  89.         System.out.println(int[].class.isArray());   
  90.            
  91.            
  92.            
  93. //      //--------------------------------- Modifier 修饰符 ---------------------------------  
  94.         System.out.println(Modifier.isPublic(_Reflect.class.getModifiers()));   
  95.            
  96.         Class<?>[] classes = null;   
  97.         System.out.println(Modifier.isPublic(_Reflect.class.getMethod("getId",classes).getModifiers()));   
  98.            
  99.            
  100.         //isAssignableFrom    isInstance   
  101.         System.out.println(Number.class.isAssignableFrom(Integer.class));   
  102.         System.out.println(Number.class.isInstance(1));   
  103.            
  104.            
  105.         //---------------------------------Field---------------------------------  
  106.         _Reflect _Reflect = new _Reflect();   
  107.         System.out.println(_Reflect.getId());   
  108.         System.out.println(_Reflect.getName());   
  109.         System.out.println(Arrays.toString(_Reflect.getHobbies()));   
  110.            
  111.         Field[] fields = _Reflect.class.getDeclaredFields();   
  112.         for(Field field : fields){   
  113.             if(field.getType() == int.class){   
  114.                 field.setAccessible(true);   
  115.                 field.setInt(_Reflect, 1);   
  116.             }else if(field.getType() == String.class){   
  117.                 field.setAccessible(true);   
  118.                 field.set(_Reflect, "1");   
  119.             }else if(field.getType() == String[].class){   
  120.                 field.setAccessible(true);   
  121.                 field.set(_Reflect, new String[]{"1","1"});   
  122.             }   
  123.         }   
  124.            
  125.         System.out.println(_Reflect.getId());   
  126.         System.out.println(_Reflect.getName());   
  127.         System.out.println(Arrays.toString(_Reflect.getHobbies()));   
  128.            
  129.            
  130. //      //---------------------------------new instance---------------------------------  
  131.         Constructor<_Reflect> constructor = _Reflect.class.getConstructor(new Class[]{int.class,String.class,String[].class});   
  132.         _Reflect _reflect = constructor.newInstance(new Object[]{1,"1",new String[]{"1","1"}});   
  133.         System.out.println(_reflect.getId());   
  134.         System.out.println(_reflect.getName());   
  135.         System.out.println(Arrays.toString(_Reflect.getHobbies()));   
  136.   
  137.            
  138.         Class<?> clazz = Class.forName("com.java.new_features_jdk5._Reflect");   
  139.         _Reflect clazzes = (_Reflect)clazz.newInstance();   
  140.         System.out.println(clazzes.getId());   
  141.         System.out.println(clazzes.getName());   
  142.         System.out.println(Arrays.toString(clazzes.getHobbies()));   
  143.            
  144.            
  145.            
  146.            
  147.         //---------------------------------Array---------------------------------  
  148.         //---------------------------------0---------------------------------  
  149.         int[] ints0 = (int[])Array.newInstance(int.class, 3);   
  150.         Array.setInt(ints0, 0, 0);   
  151.         Array.setInt(ints0, 1, 1);   
  152.         Array.setInt(ints0, 2, 2);   
  153. //    //Array.setInt(ints, 3, 3); //java.lang.ArrayIndexOutOfBoundsException  
  154.         System.out.println(Arrays.toString(ints0));   
  155.            
  156.            
  157.         //---------------------------------1---------------------------------  
  158.         int[][][] ints3 = (int[][][])Array.newInstance(int.class,2,3,4);   
  159.            
  160.         System.out.println(ints3.length);   
  161.         System.out.println(ints3[0].length);   
  162.         System.out.println(ints3[0][0].length);   
  163.            
  164.         int[][] ints3_1_row0_content = new int[][]{{1,2,3,4},{1,2,3,4},{1,2,3,4}};   
  165.         int[][] ints3_1_row1_content = new int[][]{{11,22,33,44},{11,22,33,44},{11,22,33,44}};   
  166.         Array.set(ints3, 0, ints3_1_row0_content);   
  167.         Array.set(ints3, 1, ints3_1_row1_content);   
  168.         System.out.println(Arrays.deepToString(ints3));   
  169.            
  170.            
  171.         //---------------------------------2---------------------------------  
  172.         int[][] ints2 = (int[][])Array.newInstance(int.class, 4,4);   
  173.         for (int i=0; i<4; i++) {   
  174.             ints2[i] = (int[]) Array.newInstance(int.class, i + 1);//重新创建每个第一位数组的长度  
  175.         }   
  176.         for(int[] array : ints2){   
  177.             for(int content : array){   
  178.                 System.out.print(content + ",");   
  179.             }   
  180.             System.out.println();   
  181.         }   
  182.   
  183.            
  184.         //---------------------------------4---------------------------------  
  185.         int[][][] ints4 = new int[1][2][3];   
  186.         Class<?> clazzz = ints4.getClass();   
  187.         int dim = 0;   
  188.         while(clazzz.isArray()){   
  189.             dim ++;   
  190.             clazzz = clazzz.getComponentType();   
  191.         }   
  192.         System.out.println(dim);   
  193.            
  194.         System.out.println(ints4.getClass().isArray());   
  195.         System.out.println(ints4.getClass().getComponentType().getName());   
  196.         System.out.println(ints4.getClass().getComponentType().getComponentType().getName());   
  197.         System.out.println(ints4.getClass().getComponentType().getComponentType().getComponentType().getName());   
  198. //      System.out.println(ints2.getClass().getComponentType().getComponentType().getComponentType().getComponentType().getName());//java.lang.NullPointerException  
  199.            
  200.     }   
  201. }  
package com.java.new_features_jdk5;

import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Arrays;

/**
 * Reflection 是 Java 程序开发语言的特征之一，它允许运行中的 Java 程序对自身进行检查，或者说“自审”，并能直接操作程序的内部属性。
 * Java 的这一能力在实际应用中也许用得不是很多，但是在其它的程序设计语言中根本就不存在这一特性
 * JavaDoc 中对每个类和其中的方法有非常详细介绍。主要有：
 
 * Class   ------- java.lang
 * Package ------- java.lang
 * 
 * Array
 * Field
 * Method
 * Modifier
 * Constructor
 * @author yuahan
 *
 */
public class _Reflect {
	private int id;
	private String name;
	private String[] hobbies;
	
	public _Reflect(){}
	
	public _Reflect(int id){
		this.id = id;
	}
	
	public _Reflect(int id, String name, String[] hobbies) {
		super();
		this.id = id;
		this.name = name;
		this.hobbies = hobbies;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String[] getHobbies() {
		return hobbies;
	}

	public void setHobbies(String[] hobbies) {
		this.hobbies = hobbies;
	}
	
	public static void main(String[] args) throws Exception{
		//---------------------------------basic---------------------------------
		System.out.println(_Reflect.class.getSimpleName());
		System.out.println(_Reflect.class.getName());
		System.out.println(_Reflect.class.getPackage()); 
		System.out.println(_Reflect.class.getSuperclass().getName());
        System.out.println(int[].class.getName()); 
        System.out.println(_Reflect[].class.getName());      
        
        
//		//--------------------------------- Method ---------------------------------
		Method[] methods = _Reflect.class.getMethods();
        for(Method method : methods){
        	System.out.println(method + ": " +method.getDeclaringClass().getName());
        }
		
		
		
//		//--------------------------------- isXXX ---------------------------------	
		System.out.println(Comparable.class.isInterface());
		System.out.println(int.class.isPrimitive());
		System.out.println(int[].class.isArray());
		
		
		
//		//--------------------------------- Modifier 修饰符 ---------------------------------
		System.out.println(Modifier.isPublic(_Reflect.class.getModifiers()));
		
		Class<?>[] classes = null;
		System.out.println(Modifier.isPublic(_Reflect.class.getMethod("getId",classes).getModifiers()));
        
		
		//isAssignableFrom    isInstance
		System.out.println(Number.class.isAssignableFrom(Integer.class));
		System.out.println(Number.class.isInstance(1));
		
		
		//---------------------------------Field---------------------------------
		_Reflect _Reflect = new _Reflect();
		System.out.println(_Reflect.getId());
		System.out.println(_Reflect.getName());
		System.out.println(Arrays.toString(_Reflect.getHobbies()));
		
		Field[] fields = _Reflect.class.getDeclaredFields();
		for(Field field : fields){
			if(field.getType() == int.class){
				field.setAccessible(true);
				field.setInt(_Reflect, 1);
			}else if(field.getType() == String.class){
				field.setAccessible(true);
				field.set(_Reflect, "1");
			}else if(field.getType() == String[].class){
				field.setAccessible(true);
				field.set(_Reflect, new String[]{"1","1"});
			}
		}
		
		System.out.println(_Reflect.getId());
		System.out.println(_Reflect.getName());
		System.out.println(Arrays.toString(_Reflect.getHobbies()));
		
		
//		//---------------------------------new instance---------------------------------
		Constructor<_Reflect> constructor = _Reflect.class.getConstructor(new Class[]{int.class,String.class,String[].class});
		_Reflect _reflect = constructor.newInstance(new Object[]{1,"1",new String[]{"1","1"}});
		System.out.println(_reflect.getId());
		System.out.println(_reflect.getName());
		System.out.println(Arrays.toString(_Reflect.getHobbies()));

		
		Class<?> clazz = Class.forName("com.java.new_features_jdk5._Reflect");
		_Reflect clazzes = (_Reflect)clazz.newInstance();
		System.out.println(clazzes.getId());
		System.out.println(clazzes.getName());
		System.out.println(Arrays.toString(clazzes.getHobbies()));
		
		
		
		
		//---------------------------------Array---------------------------------
		//---------------------------------0---------------------------------
		int[] ints0 = (int[])Array.newInstance(int.class, 3);
		Array.setInt(ints0, 0, 0);
		Array.setInt(ints0, 1, 1);
		Array.setInt(ints0, 2, 2);
//	  //Array.setInt(ints, 3, 3); //java.lang.ArrayIndexOutOfBoundsException
		System.out.println(Arrays.toString(ints0));
		
		
		//---------------------------------1---------------------------------
		int[][][] ints3 = (int[][][])Array.newInstance(int.class,2,3,4);
		
		System.out.println(ints3.length);
		System.out.println(ints3[0].length);
		System.out.println(ints3[0][0].length);
		
		int[][] ints3_1_row0_content = new int[][]{{1,2,3,4},{1,2,3,4},{1,2,3,4}};
		int[][] ints3_1_row1_content = new int[][]{{11,22,33,44},{11,22,33,44},{11,22,33,44}};
		Array.set(ints3, 0, ints3_1_row0_content);
		Array.set(ints3, 1, ints3_1_row1_content);
		System.out.println(Arrays.deepToString(ints3));
		
		
		//---------------------------------2---------------------------------
		int[][] ints2 = (int[][])Array.newInstance(int.class, 4,4);
		for (int i=0; i<4; i++) {
			ints2[i] = (int[]) Array.newInstance(int.class, i + 1);//重新创建每个第一位数组的长度
		}
		for(int[] array : ints2){
			for(int content : array){
				System.out.print(content + ",");
			}
			System.out.println();
		}

		
		//---------------------------------4---------------------------------
		int[][][] ints4 = new int[1][2][3];
		Class<?> clazzz = ints4.getClass();
		int dim = 0;
		while(clazzz.isArray()){
			dim ++;
			clazzz = clazzz.getComponentType();
		}
		System.out.println(dim);
		
		System.out.println(ints4.getClass().isArray());
		System.out.println(ints4.getClass().getComponentType().getName());
		System.out.println(ints4.getClass().getComponentType().getComponentType().getName());
		System.out.println(ints4.getClass().getComponentType().getComponentType().getComponentType().getName());
//		System.out.println(ints2.getClass().getComponentType().getComponentType().getComponentType().getComponentType().getName());//java.lang.NullPointerException
		
	}
}



5.注解 Annotation

Java代码 复制代码  收藏代码
  1. package com.java.new_features_jdk5;   
  2.   
  3. /**  
  4.  * 比较常用的注释：  
  5.  *  SuppressWarnings    指示应该在注释元素（以及包含在该注释元素中的所有程序元素）中取消显示指定的编译器警告。 
  6.     Deprecated          用"@Deprecated" 注释的程序元素，不鼓励程序员使用这样的元素，通常是因为它很危险或存在更好的选择。在使用不被赞成的程序元素或在不被赞成的代码中执行重写时，编译器会发出警告。  
  7.     Override            表示一个方法声明打算重写超类中的另一个方法声明。如果方法利用此注释类型进行注解但没有重写超类方法，则编译器会生成一条错误消息。 
  8.  * @author yuahan  
  9.  *  
  10.  */  
  11. public class _Annotation {   
  12.     public static void main(String[] args) {   
  13.            
  14.     }   
  15. }  
package com.java.new_features_jdk5;

/**
 * 比较常用的注释：
 * 	SuppressWarnings	指示应该在注释元素（以及包含在该注释元素中的所有程序元素）中取消显示指定的编译器警告。
	Deprecated			用"@Deprecated" 注释的程序元素，不鼓励程序员使用这样的元素，通常是因为它很危险或存在更好的选择。在使用不被赞成的程序元素或在不被赞成的代码中执行重写时，编译器会发出警告。 
	Override			表示一个方法声明打算重写超类中的另一个方法声明。如果方法利用此注释类型进行注解但没有重写超类方法，则编译器会生成一条错误消息。
 * @author yuahan
 *
 */
public class _Annotation {
	public static void main(String[] args) {
		
	}
}



6.泛型

Java代码 复制代码  收藏代码
  1. package com.java.new_features_jdk5;   
  2.   
  3. import java.util.ArrayList;   
  4. import java.util.Collection;   
  5. import java.util.List;   
  6.   
  7. /**  
  8.  * Java语言的泛型类似于C++中的模板. 但是这仅仅是基于表面的现象。Java语言的泛型基本上完全在编译器中实现的，由编译器执行类型检查和类型推断，然后生成普通的非泛型的字节码。 这种实现称为"擦除"（编译器使用泛型类型信息保证类型安全，然后在生成字节码之前将其清除） 
  9.     需要注意的地方：  
  10.  *  1. 泛型不是协变的  
  11.         协变:Java 语言中的数组是协变的（covariant），也就是说， 如果 Integer 扩展了 Number，那么不仅 Integer 是 Number，而且 Integer[] 也是 Number[]，在要求Number[] 的地方完全可以传递或者赋予 Integer[]。 
  12.         但是，泛型并不是协变的。  如果Number是Integer的超类型，但是，如果需要List<Integer>的时候， 并不容许传递List<Number>，它们并不等价。 
  13.         不允许的理由很简单，这样会破坏要提供的类型安全泛型。  
  14.         如：  
  15.         public static void main(String[] args) {  
  16.             List<Integer> list=new ArrayList<Integer>(); 
  17.             List<Number> list2=list;//编译错误.  
  18.             list2.add(new Float(19.0f));  
  19.         }  
  20.       
  21.     2. 延迟构造  
  22.         因为可以擦除功能，所以List<Integer>和List<String>是同一个类，编译器在编译List<V>的时候，只生成一个类。所以，运行时，不能区分List<Integer>和List<String>(实际上，运行时都是List,类型被擦除了), 
  23.         用泛型类型参数标识类型的变量的构造就成了问题。运行时缺乏类型信息，这给泛型容器类和希望创建保护性副本的泛型类提出了难题。 
  24.       
  25.     3. 不能用通配符来帮助构造一个类（容器，数组等），因为根本不知道类型，不能确定该构造函数是否存在 
  26.         class Foo{  
  27.             public void doSomething(Set<?> set){  
  28.                 Set<?> copy = new HashSet<?>(set);//编译出错，不能用通配符类型的参数调用泛型构造函数 
  29.             }  
  30.         }  
  31.           
  32.         或者  
  33.           
  34.         class ArrayList<V>{  
  35.             V[] content;  
  36.             public ArrayList() {  
  37.                 content = new V[10];//编译出错，不能实例化用类型参数表示的类型数组 
  38.             }  
  39.         }  
  40.           
  41.         不过可以用Object类帮助实现，不过看上去很不舒服。  
  42.         class Foo{  
  43.             public void doSomething(Set<?> set){  
  44.                 Set<?> copy = new HashSet<Object>(set); 
  45.             }  
  46.         }  
  47.           
  48.         或者  
  49.           
  50.         class ArrayList<V>{  
  51.             V[] content;  
  52.             public ArrayList() {  
  53.                 content = (V[])new Object[10];  
  54.             }  
  55.         }  
  56.     4. 擦除  
  57.          因为泛型基本上都是在JAVA编译器中而不是运行库中实现的，所以在生成字节码的时候，差不多所有关于泛型类型的类型信息都被“擦除”了， 换句话说，编译器生成的代码与手工编写的不用泛型、检查程序类型安全后进行强制类型转换所得到的代码基本相同。 
  58.          擦除意味着，一个类不能同时实现 Comparable<String>和Comparable<Number>,因为事实上，两者都在同一个接口中，指定同一个compareTo()方法。 
  59.     5.  泛型的规则和限制  
  60.         (1  泛型的参数类型只能是类（ class ）类型，而不能是简单类型。  
  61.               比如， <int> 是不可使用的。  
  62.         (2 可以声明多个泛型参数类型，比如 <T, P,Q…> ，同时还可以嵌套泛型，例如： <List<String>>. 
  63.         (3  泛型 的参数 类 型可以使用 extends 语 句，例如 <T extends superclass> 。 
  64.         (4  泛型的参数类型可以使用 super 语句，例如 < T super childclass> 。 
  65.         (5 泛型还可以使用通配符，例如 <? e xtends ArrayList>  
  66.  * @author yuahan  
  67.  *  
  68.  */  
  69. public class _Generic <T> {   
  70.     public void array2Collection(T[] array, Collection<T> collection){   
  71.         if(array != null && collection != null){   
  72.             for(T content : array ){   
  73.                 collection.add(content);   
  74.             }   
  75.         }   
  76.     }   
  77.     public static void main(String[] args) {   
  78.         _Generic<Integer> generic = new _Generic<Integer>();   
  79.         Integer[] array = new Integer[]{1,2,3,4};   
  80.         List<Integer> list = new ArrayList<Integer>();   
  81.         generic.array2Collection(array, list);   
  82.         System.out.println(list);   
  83.     }   
  84. }  
package com.java.new_features_jdk5;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

/**
 * Java语言的泛型类似于C++中的模板. 但是这仅仅是基于表面的现象。Java语言的泛型基本上完全在编译器中实现的，由编译器执行类型检查和类型推断，然后生成普通的非泛型的字节码。 这种实现称为"擦除"（编译器使用泛型类型信息保证类型安全，然后在生成字节码之前将其清除）
 	需要注意的地方：
 * 	1. 泛型不是协变的
		协变:Java 语言中的数组是协变的（covariant），也就是说， 如果 Integer 扩展了 Number，那么不仅 Integer 是 Number，而且 Integer[] 也是 Number[]，在要求Number[] 的地方完全可以传递或者赋予 Integer[]。
		但是，泛型并不是协变的。  如果Number是Integer的超类型，但是，如果需要List<Integer>的时候， 并不容许传递List<Number>，它们并不等价。
		不允许的理由很简单，这样会破坏要提供的类型安全泛型。
		如：
		public static void main(String[] args) {
		    List<Integer> list=new ArrayList<Integer>();
		    List<Number> list2=list;//编译错误.
		    list2.add(new Float(19.0f));
		}
	
	2. 延迟构造
		因为可以擦除功能，所以List<Integer>和List<String>是同一个类，编译器在编译List<V>的时候，只生成一个类。所以，运行时，不能区分List<Integer>和List<String>(实际上，运行时都是List,类型被擦除了),
		用泛型类型参数标识类型的变量的构造就成了问题。运行时缺乏类型信息，这给泛型容器类和希望创建保护性副本的泛型类提出了难题。
	
	3. 不能用通配符来帮助构造一个类（容器，数组等），因为根本不知道类型，不能确定该构造函数是否存在
		class Foo{
			public void doSomething(Set<?> set){
			    Set<?> copy = new HashSet<?>(set);//编译出错，不能用通配符类型的参数调用泛型构造函数
			}
		}
		
		或者
		
		class ArrayList<V>{
			V[] content;
			public ArrayList() {
				content = new V[10];//编译出错，不能实例化用类型参数表示的类型数组
			}
		}
		
		不过可以用Object类帮助实现，不过看上去很不舒服。
		class Foo{
			public void doSomething(Set<?> set){
			    Set<?> copy = new HashSet<Object>(set);
			}
		}
		
		或者
		
		class ArrayList<V>{
			V[] content;
			public ArrayList() {
				content = (V[])new Object[10];
			}
		}
	4. 擦除
		 因为泛型基本上都是在JAVA编译器中而不是运行库中实现的，所以在生成字节码的时候，差不多所有关于泛型类型的类型信息都被“擦除”了， 换句话说，编译器生成的代码与手工编写的不用泛型、检查程序类型安全后进行强制类型转换所得到的代码基本相同。
		 擦除意味着，一个类不能同时实现 Comparable<String>和Comparable<Number>,因为事实上，两者都在同一个接口中，指定同一个compareTo()方法。
	5.  泛型的规则和限制
		(1  泛型的参数类型只能是类（ class ）类型，而不能是简单类型。
		      比如， <int> 是不可使用的。
		(2 可以声明多个泛型参数类型，比如 <T, P,Q…> ，同时还可以嵌套泛型，例如： <List<String>>.
		(3  泛型 的参数 类 型可以使用 extends 语 句，例如 <T extends superclass> 。
		(4  泛型的参数类型可以使用 super 语句，例如 < T super childclass> 。
		(5 泛型还可以使用通配符，例如 <? e xtends ArrayList>
 * @author yuahan
 *
 */
public class _Generic <T> {
	public void array2Collection(T[] array, Collection<T> collection){
		if(array != null && collection != null){
			for(T content : array ){
				collection.add(content);
			}
		}
	}
	public static void main(String[] args) {
		_Generic<Integer> generic = new _Generic<Integer>();
		Integer[] array = new Integer[]{1,2,3,4};
		List<Integer> list = new ArrayList<Integer>();
		generic.array2Collection(array, list);
		System.out.println(list);
	}
}



7.可变参数(Vararg)

Java代码 复制代码  收藏代码
  1. package com.java.new_features_jdk5;   
  2.   
  3. /**  
  4.  *   
  5.  * 可变参数可以解决代码冗余的问题。  
  6.  * 如：  
  7.  * public int max(int i, int j);  
  8.  * public int max(int i, int j, int k);  
  9.  * 可以简化成  
  10.  * public int max(int... num);  
  11.  *   
  12.  * 可以将可变参数视为长度可变的数组。不过需要注意以下问题 ：  
  13.  *  1. 变长参数一定要放在最后面  
  14.     max(int ... nums, int temp)// error  
  15.  *  2. 可变参数不能与数组参数并存  
  16.     max(int[] nums)//error  
  17.  
  18.  * @author yuahan  
  19.  *  
  20.  */  
  21. public class _Var_Arg {   
  22.        
  23.     public static int max(int ... nums){   
  24.         int max = Integer.MIN_VALUE;   
  25.         for(int num : nums){   
  26.             if(num >= max){   
  27.                 max = num;   
  28.             }   
  29.         }   
  30.         return max;   
  31.     }   
  32.        
  33.        
  34.     public static void main(String[] args) {   
  35.         int max1 = _Var_Arg.max(1,2,3,4,5);   
  36.         int max2 = _Var_Arg.max(new int[]{1,2,3,4,5});   
  37.         System.out.println(max1);   
  38.         System.out.println(max2);   
  39.     }   
  40. }  
package com.java.new_features_jdk5;

/**
 * 
 * 可变参数可以解决代码冗余的问题。
 * 如：
 * public int max(int i, int j);
 * public int max(int i, int j, int k);
 * 可以简化成
 * public int max(int... num);
 * 
 * 可以将可变参数视为长度可变的数组。不过需要注意以下问题 ：
 *	1. 变长参数一定要放在最后面
	max(int ... nums, int temp)// error
 *	2. 可变参数不能与数组参数并存
	max(int[] nums)//error

 * @author yuahan
 *
 */
public class _Var_Arg {
	
	public static int max(int ... nums){
		int max = Integer.MIN_VALUE;
		for(int num : nums){
			if(num >= max){
				max = num;
			}
		}
		return max;
	}
	
	
	public static void main(String[] args) {
		int max1 = _Var_Arg.max(1,2,3,4,5);
		int max2 = _Var_Arg.max(new int[]{1,2,3,4,5});
		System.out.println(max1);
		System.out.println(max2);
	}
}



8.格式化输入输出
不太喜欢c的输出格式，没有进行尝试。
我有一块大板砖
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA5新特性介绍
10-31
JAVA5新特性介绍,JAVA5新特性介绍
java5新特性
04-17
java5新特性
java5的特性_JAVA5 特性：可变参数
weixin_42300956的博客
02-27 93
JAVA5 特性可变参数1. 使用目的在 Java 中，类里面的方法如果不确定要传入某一个类型的参数的个数，可以使用可变参数传参。public static void main(String[] args) {printStr("1","2","3");}private static void printStr(String...strs){for (String str : strs) {Sys...
【Java5 特性】5.Java5其他特性
小确幸的博客
01-04 261
静态导入 可变参数（Varargs） 循环增强foreach
java 5新特性_Java5的新特性
weixin_36059505的博客
02-21 373
序这是Java语言特性系列的第一篇，从java5的新特性开始讲起。初衷就是可以方便的查看语言的演进历史。特性列表 泛型枚举装箱拆箱变长参数注解foreach循环静态导入格式化线程框架/数据结构Arrays工具类/StringBuilder/instrument1、泛型所谓类型擦除指的就是Java源码中的范型信息只允许停留在编译前期，而编译后的字节码文件中将不再保留任何的范型信息。也就是说，范型信息...
Java5、6、7、8、9的新特性
热门推荐
shengzhu1的博客
07-22 1万+
Java5java5是很重要的一个版本，有泛型、枚举、自动装箱/拆箱、可变参数、注解、foreach循环、静态导入、新的线程模型等等更新。具体参考 Java5的新特性Java6鸡肋的版本，有JDBC4.0更新、Complier API、WebSevice支持的加强等更新。 Java6的新特性Java7java7有一些比较重要的更新，如异常处理增加了被抑制的异常、捕获多异常、try-with-r
Java5新特性
03-20
总结了JAVA5的新特性。
java5、java6、java7、java8、java9新特性
隐居者
07-13 1万+
1. 介绍2. JAVA5新特性2.1 泛型 Generics2.2 枚举类型2.3 自动装箱拆箱（自动类型包装和解包）autoboxing &amp; unboxing2.4 可变参数varargs(varargs number of arguments)2.5 Annotations（重要） 它是java中的metadata（注释）2.6 新的迭代语句2.7 静态导入（import stati...
JAVA5新特性介绍.zip
09-16
JDK1.5新特性：自动拆装箱、泛型、增强for循环、静态方法导入、可变参数、枚举
【总结篇】Java5新特性总结
小异常的博客
04-09 421
文章目录一、自动装箱、拆箱1、自动装箱、拆箱概述2、自动装箱、拆箱好处3、使用方式1）自动装箱2）自动拆箱4、注意事项5、应用1）自动装箱2）自动拆箱二、增强For循环1、增强For循环概述2、增强For循环的好处3、使用方式（语法格式）4、注意事项5、应用场景三、可变参数1、可变参数概述2、可变参数好处3、使用方式（语法格式）4、注意事项5、应用场景四、静态导入1、静态导入概述2、静态导入好处3...
[转自互联网]体验Java 5.0的新增语言特性
learningjsp的专栏
01-09 1418
Java 5.0发布了，许多人都将开始使用这个JDK版本的一些新增特性。从增强的for循环到诸如泛型(generic)之类更复杂的特性，都将很快出现在您所编写的代码中。我们刚刚完成了一个基于Java 5.0的大型任务，而本文就是要介绍我们使用这些新特性的体验。本文不是一篇入门性的文章，而是对这些特性以及它们所产生的影响的深入介绍，同时还给出了一些在项目中更有效地使用这些特性的技巧。 　　简介　　在
java 5_Java 5.0的五个特性
weixin_34219634的博客
02-21 208
至今，毫无疑问你已经看过不止一篇网上文章列举了Java5.0的伟大的语言新特性:泛型，标注，枚举类型，自动装箱，可变参数， for/in循环，甚至静态引入。我也认为这些是伟大的特性，但是，你已经读过他们了。因此，在此我将集中于你可能没有听说过的Java5.0的新API特性。那么，在下面，是我喜欢的Java5.0的五个新API特性。那些看完本文后的细心的读者会发现额外的奖励—第六个特性:很少有人知道...
java 5 新特性 for_【小家java】java5新特性（简述十大新特性） 重要一跃
weixin_42500791的博客
02-21 72
相关阅读每篇一句我给你10快，他给你20。你以为他比我对你好，但你不知道的是他有1000快，我只有10快。珍惜对你好的人，友情也是，爱情也是。Java5开发代号为Tiger(老虎),于2004-09-30发行评价：很重要的一次更新特性列表泛型枚举自动装箱拆箱可变参数注解foreach循环(增强for、for/in)静态导入格式化(System.out.println 支持%s %d等格式化输出)线...
Java5-Java8新特性，这回全了
石竹的专栏
01-15 1920
Java5:泛型 Generics 引用泛型之后，允许指定集合里元素的类型，免去了强制类型转换，并且能在编译时刻进行类型检查的好处。Parameterized Type作为参数和返回值，Generic是vararg、annotation、enumeration、collection的基石。
Java 1.5新特性简介
Onlyarticle的专栏
10-10 6261
jdk 1.5新特性说明 “JDK1.5”的一个重要主题就是通过新增一些特性来简化开发，这些特性包括泛型，for-each　循环，自动装包/拆包，枚举，可变参数,　静态导入　。使用这些特性有助于我们编写更加清晰，精悍，安全的代码。 一． 首先简单介绍一下各种特性及其使用 1.泛型(Generic)C++通过模板技术可以指定集合的元素类型，而Ja
java5的特性_Java5，6，7，8的主要新特性归纳
weixin_39776239的博客
02-27 81
1.JAVA5新特性1.1泛型Generics//设置集合的传入传出类型，装入集合后会擦除类型，传入或传出不同类型会报错，保证数据类型的安全List nums = new ArrayList();1.2枚举类型1.3自动装箱拆箱例：Integer i = 1; //装箱，基本数据类型自动包装类型int j = i; //拆箱 ，包装类型自动转基本数据类型1.4可变参数例：public voi...
java17 新特性
最新发布
05-22
Java 17是Java SE 17的正式名称，是Java的最新版本，于2021年9月14日发布。以下是Java 17的新特性： 1. 预览特性的完全实现：Java 17中包含了之前预览的一些特性的完全实现，如Pattern Matching for switch语句、Records、Sealed Classes等。 2. 垃圾收集器变化：Java 17中引入了Epsilon垃圾收集器，它是一种不做任何实际工作的垃圾收集器，主要用于性能测试和调试。 3. 向量API：Java 17中引入了Vector API，它提供了一种基于向量的编程模型，可以有效地利用现代CPU的向量化指令。 4. 改进的安全性：Java 17中包含了一些改进的安全性功能，如强制生成RSA密钥对时指定密钥长度、禁用不安全的算法等。 5. Unicode 13.0：Java 17中更新了Unicode版本至13.0，这意味着Java现在支持最新的Unicode字符集，包括一些新的符号和表情符号。 6. 改进的性能：Java 17中还包含了一些改进的性能功能，如使用G1垃圾收集器时的堆分配、类数据共享等。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值