JDK 5.0特性

1，静态导入

import static java.lang.Math.*;
//静态导入的是静态方法和静态类，或者是静态成员变量
class StaticImport 
{
	public static void main(String[] args) 
	{
		 int a=Math.max(10,20);
		 int b=Math.min(10,20);
		 System.out.println(a);
		 System.out.println(b);
	}
}

　2，装箱和拆箱

//装箱和拆箱
//值类型转换为引用类型---装箱
//引用类型转换为值类型---拆箱
class BoxAndUnBox 
{
	public static void main(String[] args) 
	{
		//5.0之后才可以这样写
		// Integer i=new Integer(0);
		// int j=i;   //将值类型转换为封装类型，即装箱
		 //4.0版本 需要进行封箱，和拆箱
          Integer i=new Integer(10);
		  int j=i.intValue();
           System.out.println(j);

		  Double dou=new Double(20.0);
		  double d=dou.doubleValue();
		  System.out.println(d);
		  //反之
		  int int1=1;
		  Integer int2=new Integer(int1);
           System.out.println(int2);


         System.out.println(i+"...."+j);


		 int x= 0;
		 Integer y=x;
		 System.out.println(x+"..."+y);
         
           /*
		   *0....0
           *0...0
		   

		   //在基本数据类型中，会出现int-- short--long--float--double之间的转换
		    //例如：
			*/
			int z=10;
			print(10);  //此时调用 print(int i)，若将 print(int i)注释掉，则会调用 print(short i)。。。。一次类推

            

			
	}

	public static void print(int i)
	{
		 System.out.println(i);
	}
	public static void print(short i)
	{
		 System.out.println(i);
	}
	public static void print(long i)
	{
		 System.out.println(i);
	}
	public static void print(float i)
	{
		 System.out.println(i);
	}
	public static void print(double i)
	{
		 System.out.println(i);
	}
	
}

3，可变类型

class Variable 
{
	public static void main(String[] args) 
	{
		Integer[] numsInteger={1,2,3,4,5,6,7};
		print(numsInteger);
		/*
		1
		2
		3
		4
		5
		6
		7
		This is print[]
		*/

		//int[] numsInt={1,2,3,4,5,6,7};
		//print(numsInt);//这样写将报错
		/*
		    需要: Integer[]
			找到: int[]
			原因: 无法通过方法调用转换将实际参数int[]转换为Integer[]
		*/


		printVar(1,2,3,4,5,6);//调用可变类型参数方法

        printVar(numsInteger);


		

	}
	public static void print(Integer[] num)  
	{
		for (int i=0;i<num.length ; i++)
		{
         	System.out.println(num[i]);
		}
		System.out.println("This is print[]");
	}
	public static void printVar(Integer... num)  //这里使用可变类型，可变类型默认为数组，
	{
		for (int i=0;i<num.length ; i++)
		{
         	System.out.println(num[i]);
		}
		System.out.println("This is printVar[]");
	}

                   //public static void printVar(Integer[] num)
                   //此方法不能与可变参数 public static void printVar(Integer... num) 同时存在，因为可变参数最终被当做数组使用

                  //实际参数是组数，数组将被打散最终以printVar（1,2，3,4,5,6,7）进行传入

                  //可变参数只能放在方法参数列表的最后一位：一个方法只能有一个可变参数

                  // public static void printVar(Integer... num,int a)错误

　　　　　　　// public static void printVar(Integer... num，String... str) 错误

}

4，泛型

package cn.itcast.base;

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 java.util.Map.Entry;

public class GenericTest {
	
	public static void main(String[] args) {
		
		/*
		 * 格式：类型<类型[,类型...]>
		 * * 泛型使用必须前后相同
		 * * 泛型是在编译前进行类型约束，在字节码文件中不存在泛型信息
		 */
		
		List<String> list = new ArrayList<String>();
		list.add("abc");
//		list.add(123);
		
		
		Map map = new HashMap();
		map.put(123, 123);
		
		//没有泛型的map 的遍历
		Set s = map.entrySet();
		Iterator ite = s.iterator();
		while(ite.hasNext()){
			Map.Entry entry = (Entry) ite.next();
			Integer key = (Integer) entry.getKey();
			Integer value = (Integer) entry.getValue();
			System.out.println("*** " + key + ":" + value);
		}
		
		
		
		Map<String,Integer> map2 = new HashMap<String, Integer>();
		map2.put("123", 456);
		map2.put("abc", 789);
		
		
		//遍历map  [key,value][key,value]
//		map2.keySet()  获得所有的键值 key
		Set<Map.Entry<String,Integer>> set = map2.entrySet();  //获得每一组 Entry(key,value)
		//迭代器
		Iterator<Entry<String,Integer>> it = set.iterator();
		while(it.hasNext()){
			Map.Entry<String, Integer> entry = it.next();
			String key = entry.getKey();
			Integer value = entry.getValue();
			System.out.println(key + ":" + value);
		}
		
		
	}
	
/*	
 * 不能同时存在
 * public void demo(List<String> list){
		
	}
	

	public void demo(List<Integer> list){
		
	}*/

}

5,foreach

package cn.itcast.base;

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

public class ForEachTest {
	
	public static void main(String[] args) {
		
		List<String> list = new ArrayList<String>();
		list.add("abc");
		//list.add(123);
		
		//遍历list
		for(int i = 0 ; i < list.size(); i ++){
			String obj = list.get(i);
			System.out.println(obj);
		}
		
		for(String s:list){
			System.out.println("##" + s);
		}
		
		
		
		//没有泛型
		List l = new ArrayList();
		l.add("abc");
		l.add(123);
		
		for(Object o :l){
			System.out.println("---" + o);
		}
		
		
		String[] str = {"abc","edc"};
		for(String s:str){
			System.out.println("string " + s);
		}
		
		/* foreach
		 * for(类型   变量名 : 集合(Iterable)|数组){}
		 * 
		 *  * 需要实现Iterable接口的所有的集合。只要能够迭代的所有的集合
		 */
		
		
	}

}

　　

package cn.itcast.base;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

public class ForEachTestDemo {
	
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("abc");
		list.add("abcd");
		list.add("asf");
		list.add("ceg");
		list.add("daf");
		list.add("dfs");
		
		//迭代器
		Iterator<String> it = list.iterator();
		while(it.hasNext()){
			String str = it.next();
			if(str.contains("a")){
				//list.remove(str);  //java.util.ConcurrentModificationException
				it.remove();
			}
		}
		
		System.out.println(list);
		
		
		
	}
	
	public void demo3(){
		//java.util.Arrays.ArrayList  
		List<String> list = Arrays.asList("abc","bcd", "asf", "ceg", "daf", "dfs");  
		
		for(int i = 0 ; i < list.size() ; i ++){
			String str = list.get(i);
			if(str.contains("a")){
				//java.lang.UnsupportedOperationException
				list.remove(i);
			}
		}
		
		
		System.out.println(list);
	}
	
	public void demo2(){
		//不能删除
		List<String> list = new ArrayList<String>();
		list.add("abc");
		list.add("abcd");
		list.add("asf");
		list.add("ceg");
		list.add("daf");
		list.add("dfs");
		
		//java.util.ConcurrentModificationException
		for(String s:list){   //foreach不能删除
			if(s.contains("a")){
				list.remove(s);
			}
		}
		
		System.out.println(list);
	}
	
	
	public void demo(){
		
		List<String> list = new ArrayList<String>();
		list.add("abc");
		list.add("abcd");
		list.add("asf");
		list.add("ceg");
		list.add("daf");
		list.add("dfs");
		list.add("abc");
		
		for(int i = 0 ; i < list.size(); i++){
			String str = list.get(i);
			if(str.contains("a")){  //确定是否包含字符串a
				//移除
				list.remove(i);
//				list.remove(str);
				i --;
			}
			//System.out.println(str);
		}
		
		System.out.println(list);
		
	}

}