(10)Java泛型-Map集合-集合框架工具类-可变参数-静态导入

--

部分1.5新特性Java泛型-Map集合-集合框架工具类

泛型

概述：

JDK1.5版本以后出现的新特性，用于解决安全问题，是一个类型安全机制。

对于泛型可以这样理解：

没有使用泛型时，只要是对象，不管是什么类型的对象，都可以存储进同一个集合中。使用泛型集合，可以将一个集合中的元素限定为一个特定类型，集合中只能存储同一个类型的对象，这样更安全；并且当从集合获取一个对象时，编译器也可以知道这个对象的类型，不需要对对象进行强制类型转换，这样更方便。

好处：

1， 将运行时期出现的问题ClassCastException。转移到编译时期。方便程序员解决问题，让运行运行时异常减少，较安全。

2， 避免了强制转换的麻烦。

泛型格式：

通过<>来定义要操作的引用数据类型。

放到返回类型的前面，修饰符的后面不然会报错

示例：ArrayList<String> al = new ArrayList<String>();

泛型类

什么是泛型类，简单的说就是带泛型的类。

在泛型出现之前，比如对于定义工具类，接收的类型不一样，比较通用的方法是采用多态的形式来实现。因为要让任意类的实例都可以使用所以设置所有类的父类Object。

示例：

class Student
{}
class Worker
{}
class Tool{
	private Object obj;
	public void setObject(Object obj){
		this.obj = obj;
	}
	public Object getObject(){
		return obj
	}
}
class  {
	public static void main(String[] args) {
		Tool t = new Tool();
		t.setObject(new Student());
		Student s = (Student)t.getObject()//需要对其向下转型object转student
		//t.setObject(new worker());
		//Student s = (Student)t.getObject()就会报类型转换错误异常
	}
}

因为早期使用Object来完成扩展，后面还需要对其转型使用，若不注意容易导致编译时期JVM看不出来问题但是用户运行时会报错。

所以在JDK1.5升级后我们就可以定义泛型类实现，原理一样。

示例：

class Student
{}
class Worker
{}
class Tool<W>{
	private W w;
	public void setW(W w){
		this.w = w;
	}
	public W getW(){
		return w;
	}
}
class  {
	public static void main(String[] args) {
		Tool<Student> t = new Tool Student> ()<;
　　//加上泛型由我们指定哪个类型来使用工具类
		t.setW(new Student());
		Student s = t.getW();
		//不用再强转。
	}
}

那什么时候定义泛型类？

当类中要操作的引用数据类型不确定时候。

泛型除了定义在类上还可以定义在方法上

泛型方法：

因为泛型类定义的泛型，在整个类中有效，如果被对方使用，那么泛型类的对象明确要操作的具体类型后，所要操作的类型就已经固定了。

为了让不同方法可以操作不用类型，而且类型还不确定，那么可以将泛型定义在方法上。

示例：

lass Demo{
	public <T> void show(T t)//泛型定义在方法上{
		System.out.println("Hello show!"+t);
	}
	public <T> void run(T t)//泛型定义在方法上{
		System.out.println("Hello run!"+t);
	}
}
class FanXingDemo {
	public static void main(String[] args) 
	{
		Demo d = new Demo();
		d.show("kj");
		d.show(3);
		d.run(3);
	}
}

使用泛型方法，你传什么类型他就是什么类型了

注意：静态方法不可以访问类上定义的泛型。

为什么？因为Demo<T>类上的T是new对象后才能明确，静态方法使用时，对象还没有建立所以就不能使用。

如果静态方法操作的引用数据类型不确定，可以将泛型定义在方法上。

泛型接口代码示例：

Interface Iner<T>{
	Void show(T t);
}
Class InerImp<T> implements Iner<t>{
	Public void show(T t){
	System.out.println(“show:”+t);
　　}
}
Class FanXingDemo2{
	Public static void main(Sting[] args){
		InerImp<String> in = new InerImp<String> ();
		In.show(“rtyu”);
　　}
}

泛型高级应用

泛型限定：是用于泛型的扩展用的。

？通配符，也可以理解为占位符。

？ extends E：可以接收E类型或者E 的子类型，向上限定。

？ super E：可以接收E类型或者E的父类型，向下限定。

示例：

import java.util.*;
class Person{
	private String name;
	Person(String name){
		this.name = name;
	}
	public String getName(){
		return name;
	}
}
class Student extends Person{
	Student(String name){
		super(name);
	}
}
class FanXingDemo3{
	public static void main(String[] args) {
		ArrayList<Person> al = new ArrayList<Person>();
		al.add(new Person("lisi"));
		al.add(new Person("lisi"));
		al.add(new Person("lisi"));
		al.add(new Person("lisi"));
		getIt(al);
		ArrayList<Student> al1 = new ArrayList<Student>();
		al1.add(new Student("lisi1"));
		al1.add(new Student("lisi2"));
		al1.add(new Student("lisi3"));
		al1.add(new Student("lisi4"));
		getIt(al1);
		
	}
	public static void getIt(Collection< ?extends Person> al){
		for (Iterator<?extends Person> it = al.iterator();it.hasNext() ; ){
			System.out.println(it.next().getName());
		}
	}
}

泛型限定2

如：在TreeSet集合中，需要对其存储对象比较

若只是指定当前类型就只能比较当前对象，

但是指定他们的父类型，就都可以指定了，不用再多写比较器了

示例：

import java.util.*;
class Person{
	private String name;
	Person(String name){
		this.name = name;
	}
	public String getName(){
		return name;
	}
}
class Student extends Person{
	Student(String name){
		super(name);
	}
}
class Worker extends Person{
	Worker(String name){
		super(name);
	}
}
class Cmp implements Comparator<Person>
{//定义比较器，若只是指定当前类型就只能比较当前对象，
//但是指定他们的父类型，就都可以指定了，不用再多写比较器了
	public int compare(Person p1,Person p2){
		return p1.getName().compareTo(p2.getName());
	}
}
class Demo {
	public static void main(String[] args) {
		TreeSet<Person> al = new TreeSet<Person>(new Cmp());
		al.add(new Person("lisi2"));
		al.add(new Person("lisi3"));
		al.add(new Person("lisi4"));
		al.add(new Person("lisi2"));
		getIt(al);
		TreeSet<Student> al1 = new TreeSet<Student>(new Cmp());
		al1.add(new Student("lisi1"));
		al1.add(new Student("lisi23"));
		al1.add(new Student("lisi43"));
		al1.add(new Student("lisi64"));
		getIt(al1);
	}
	public static void getIt(Collection< ?extends Person> al){
		for (Iterator<?extends Person> it = al.iterator();it.hasNext() ; ){
			System.out.println(it.next().getName());
		}
	}
}打印结果：

Map集合

概述：

Map<K,V>，Map集合和Collection接口一样是顶层接口。

基本特点：

该集合是存储键值对，是一对一对忘集合里面存储，而且要保证键的唯一性。

常用方法：

添加：

1， put(K ket,Value) 添加元素，如果出现添加时，相同的键，那么后添加的值会覆盖原     有键对应值，并put方法会返回被覆盖的值。

2， putAll(Map<? Extends K,?extends V> m)添加一个集合

删除：

1， clear()清空

2， remove(Objet key) 删除集合里的指定元素

判断：

1， containsValue(Obect value)判断指定值是否存在

2， containsKey(Object key)判断指定键是否存在

3， isEmpty()判断是否为空

获取：

1， V get(Object obj)通过键获取值

2， size()获取集合长度

3， Collection<V>values()返回此集合中所有的值，返回类型是一个集合

Set<Map.entry<K,V>>entrySet()返回包含的映射关系视图

Set<K>keyset();返回映射中包含的键Set视图。

Map集合的子类

Map

|--Hashtable:底层是哈希表数据结构，不可以存入null键，集合是线程同步的。JDK1.0效率第。

|--HashMap:底层是哈希表数据结构，允许使用null值和null键，该集合是不同步的。JDK1.2效率高

|--TreeMap;底层是二叉树数据结构，线程不同步，可以用于给map集合中的键进行排序

注意：

1， 在添加元素，如果出现添加时相同的键，那么后添加的值会覆盖原有键对应的值。并put方法会返回被覆盖的值。

2， 在通过get方法的返回值来判断一个键是否存在，通过返回null来判断。

Map集合的两种取出方式：

方式一：

Set<v> keySet：将map中所有的键存入到Set集合中，因为set具备迭代器，所有的键可以迭代方式取出所有的键，根据get方法，获取每一个键对应的值。

Map集合的取出原理：将map集合转成set集合，再通过迭代器取出。

示例：

import java.util.*;
class  MapDemo1{
	public static void main(String[] args) {
		HashMap<String,String>map = new HashMap<String,String>();
		map.put("lisi","22");
		map.put("zhangsan","34");
		map.put("wangwu","56");
		map.put("xiaoba","11");
		Set<String>keyset = map.keySet();//把map集合里的所有键取出。
		Iterator<String>it = keyset.iterator();
		while (it.hasNext()){
			String key = it.next();//获取每一个键
			String value = map.get(key);//根据键获取值。
			System.out.println("key:"+key+"value:"+value);
		}
	}
}

方式二：

Set<Map.Entry<k,v>> entrySet()：将map集合的映射关系存入到了set集合中，而这个关系的数据类型就是Map.Entry，我们可以根据这个关系来获取键和对应的值。

简单说：关系是结婚证，可以根据结婚证来获取丈夫和妻子。

示例：

import java.util.*;
class  MapDemo2{
	public static void main(String[] args) {
		HashMap<String,String>map = new HashMap<String,String>();
		map.put("lisi","22");
		map.put("zhangsan","34");
		map.put("wangwu","56");
		map.put("xiaoba","11");
	//通过entrySet()方法，获取器映射关系即Map.Entry,同时还要知道键值的泛型是String类型
		Set<Map.Entry<String,String>> sme = map.entrySet();
	//迭代取出关系，返回类型一样
		Iterator<Map.Entry<String,String>> it = sme.iterator();
		while (it.hasNext()){
			Map.Entry<String,String> me = it.next();
			String key = me.getKey();取出键
			String value = me.getValue();取出值
			System.out.println("key:"+key+"value:"+value);
		}
	}
}

深入分析：

为什么映射关系的类型是Map.Entry?

其实Entry也是接口，他是Map接口中的一个内部接口。

interface Map{
	public static interface Entry{
		public abstract Object getKey();
		public abstract Object getValue();

	}
}

为什么把Entry定义成Map的内部接口？

因为Entry代表一种关系，但是现有Map才有关系，是属于Map的内部事物，所以才定义成内部规则。比如，心脏是人体内的事物，必须要定义内部规则，一样道理。

Map练习：

*
需求：每一个学生都有一个对应的归属地，学生Student，地址String
学生属性：姓名，年龄
注意姓名和年龄相同的视为同一个学生，保证唯一性
*/
import java.util.*;
class Student implements Comparable<Student>{//实现Comparable接口并定义泛型
	private String name;
	private int age;
	Student(String name,int age){
		this.name = name;
		this.age = age;
	}
	public int compareTo(Student s){//复写compareTo方法
		int num = new Integer(this.age).compareTo(new Integer(s.age));
		if(num==0)
			return this.name.compareTo(s.name);
		return num;
	}
	public int hashCode(){
		return name.hashCode()+age*77;
	}
	public boolean equals(Object obj){
		if(obj instanceof Student)
			throw new ClassCastException("类型转换异常");
		Student s = (Student)obj;
		return this.name.equals(s.name)&&this.age==s.age;
	}
	public String getName(){
		return name;
	}
	public int getAge(){
		return age;	
	}
	public String toString(){
		return name+""+age;
	}
}
class HashMapDemo3{
	public static void main(String[] args) {
		HashMap<Student,String> hm = new HashMap<Student,String>();
		hm.put(new Student("lisi1",33),"beijing");
		hm.put(new Student("lisi2",23),"shanghai");
		hm.put(new Student("lisi3",11),"wuhan");
		hm.put(new Student("lisi4",44),"sichuan");
		hm.put(new Student("lisi5",22),"beijing");
		//第一种取出方式
		Set<Student>ss1 = hm.keySet();//将学生键存储进集合
		Iterator<Student> it1 = ss1.iterator();
		while (it1.hasNext()){
			Student key = it1.next();
			String value = hm.get(key);
			System.out.println(key+"地址是："+value);
		}
		//第二种取出方式
		Set<Map.Entry<Student,String>> ss2 = hm.entrySet();
		Iterator<Map.Entry<Student,String>> it2 = ss2.iterator();
		while (it2.hasNext()){
			Map.Entry<Student,String> myentry = it2.next();
			Student stu = myentry.getKey();
			String str = myentry.getValue();
			System.out.println(stu+"地址是      ："+str);
		}
	}
}

打印结果如图：

如果需要对学生对象进行年龄进行升序排序。我们可以加入比较器，因为数据是以键值对形式存在的，所以要使用可以排序的Map集合，TreeMap

练习：

/*

需求：获取字符串中字母出现的次数，“qwertyuiasdfghjqwertyusdfghjsdf”

希望打印结果是a(1)c(2).....

通过结果发现每一个字母都对应相应的次数，说明字母和次数键存在映射关系

这时需要使用Map集合

思路：

1，因为要对每一个字母操作，所以需要字符串转成字符数组

2，对应map集合，因为打印结果的字母有顺序，所以使用trremap集合

3，遍历数组，将每一个字母作为键去map集合中查找

若返回null就将字母和1存入map集合

若返回！null说明该字母在集合中有对应的次数那么就将该次数自增一次，

再存入map集合覆盖原有次数

4，将map集合中的数据转变成指定字符串输出。

*/

import java.util.*;
class MapDemo4{
	public static void main(String[] args) {
		String s = Demo_1("qwertyuqwertyusdfsgdsdsfsdf");
		System.out.println(s);
	}
	public static String Demo_1(String str){
		//将传进来的字符串转成字符数组
		char[] ch = str.toCharArray();
		//建立TreeMap集合，因为不能接受基本数据类型，所以使用数据包装类。
		TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>();
		int count = 0;//计数器记录次数
		for (int x=0;x<ch.length ;x++ )
		{//遍历到的数据不是字母时，就继续循环
			if(!(ch[x]>='a'&&ch[x]<='z')||((ch[x]>='A'&&ch[x]<='Z')))
				continue;
			//根据键获取值
			Integer value = tm.get(ch[x]);
			//若值不为null将自增后的次数赋值
			if (value!=null)
				count = value;
			//如果值为null
			count++;
			tm.put(ch[x],count);
			count=0;//清零
		}//定义缓冲区存储键和值
		StringBuilder sb = new StringBuilder();
		//将键值映射关系存储进集合
		Set<Map.Entry<Character,Integer>> s = tm.entrySet();
		Iterator<Map.Entry<Character,Integer>> it = s.iterator();
		//取出映射关系
		while (it.hasNext())
		{
			Map.Entry<Character,Integer> ss = it.next();
			Character key = ss.getKey();
			Integer value = ss.getValue();
			sb.append(key+"("+value+")");//添加进缓冲区
		}
		return sb.toString();
	}
}打印结果如图：

Map集合的扩展知识

因为map集合具备映射关系，而在实际中许多都是一对多的关系，比如一个学校对应多个班级，一个班级对应多个学生对象，一个学生对象对应其多个属性。这样的映射关系，就形成了一个映射体系。相当于大集合套小集合，把小集合作为映射的对象

示例：

班级对应学生

"yureban" student("01","wangwu")

"yureban" student("01","zhouqi")

 

"jiuyeban" student("12","lisi")

"jiuyeban" student("13","zhangsan")

学校对应班级

"czbk" "yureban"

"czbk" "jiuyeban"

打印全校学生的信息：

import java.util.*; 
class Demo5{
	public static void main(String[] args) {

		//预热班学生集合
		HashMap<String,String>yureban = new HashMap<String,String>();
		//就业班学生集合
		HashMap<String,String>jiuyeban = new HashMap<String,String>();
		//学校班级集合
		HashMap<String,HashMap<String,String>>czbk = new HashMap<String,HashMap<String,String>>();
		//添加班级进学校班级集合
		czbk.put("yureban",yureban);
		czbk.put("jiuyeban",jiuyeban);		
		//添加预热班学生进集合
		yureban.put("01","wangwu");
		yureban.put("02","zhouqi");
		//添加就业班学生进集合
		jiuyeban.put("12","lisi");
		jiuyeban.put("13","zhangsan");

		getAllStudent(czbk);
	}
	//定义一个获取全部学生信息的集合,
	public static void getAllStudent(HashMap<String,HashMap<String,String>> hm){
		Iterator<String> it1 = hm.keySet().iterator();
		while (it1.hasNext()){
			//返回班级名称
			String s = it1.next();
			System.out.println(s+"：");
			//返回班级学生集合
			HashMap<String,String> hs = hm.get(s);
			getStudent(hs);				
		}
	}
	public static void getStudent(HashMap<String,String> hm){
		Iterator<String> it2 = hm.keySet().iterator();
		while (it2.hasNext()){
			//返回学生姓名
			String name = it2.next();
			//返回学生id
			String id = hm.get(name);
			System.out.println(name+":"+id);					
		}
	}
}打印结果：

集合框架工具类之Conllections

概述：

Conllections是集合框架中的一个工具类，该工具内的方法都是静态方法，不需要创建对象，没有封装特有数据。

在Conllections工具类中，大部分方法是用于对List集合进行操作。

常见特有操作

查找：

1，T max(Conllectin<? extends T>coll);根据coll集合里面的自然顺序查找集合里的最大元素。

2，T max(Conllection<? extends T>coll,Comparator<? Super T>comp);根据指定的comp比较器查找coll集合里的最大元素。

替换：

1， void fill(List<? Super T>list,T obj);将list集合里的全部元素替换成指定对象obj。

2， boolean replaceAll(List<T>list,T oldvalue,T newvalue);把list集合中的旧值用新值替换

3， void swap(List list,int I,int b);指定列表集的指定两个位置进行置换。

排序：

1， void shuffle(List<T> list);对指定list集合中的元素进行默认随机排序。

2， void sort(List<T> list);对指定list集合中的元素进行自然顺序的排序。

3， void sort(List<T> list,Comparator<?super T>comp);根据指定比较器的排序方式来对指定list集合进行排序。

反转：

1， reverse(List<?> list);对指定list集合进行反转。

2， Comparator reverseOrder();返回一个比较器，强行逆转了实现Comparable接口的对象的自然顺序

3， Comparator reverseOrder(Comparator<T> comp)；返回一个比较器，强行逆转了指定比较器的顺序

集合同步：

通常常用的集合都是不安全的，因为高效，如果多线程要操作这些集合，可以通过Collections提供的同步方法，将线程不安全的集合转换成安全的。

1， List<T>synchronizedList(List<T> list);返回支持的同步（线程安全的）List集合。

2， Map<K,V>synchronizedList(Map<K,V> m);返回支持的同步（线程安全的）Map集合。

示例练习：

/*

需求：对指定list集合中的指定部分元素进行替换，

  要求使用Collections中的fill方法。

分析：

1，需要对集合指定的部分元素取出，存储进新的集合

2，使用fill方法对新集合的元素进行替换

3，新集合的元素添加进list集合。

*/

import java.util.*;
class  FillDemo{
	public static void main(String[] args) {
		ArrayList<String>list = new ArrayList<String>();
		list.add("rytuy");
		list.add("fdsd");
		list.add("yrt");
		list.add("cv");
		//替换前集合
		System.out.println(list);
		//对集合指定部分替换
		fillSome(list,0,2,"java");
		//替换后集合
		System.out.println(list);
	}
	public static void fillSome(List<String>list,int start,int end,String str){
		if(start>end)
			throw new RuntimeException("插入位置非法");
		//定义临时集合
		List<String> list1 = new ArrayList<String>();
		//获取list集合中指定的要置换的元素
		//因为在start取一个，后面的一个就变成了start，而让y控制次数
		for (int x=start,y=start;y<=end ;y++)
		{//获取一个就往临时集合存储一个
			list1.add(list.get(x));
			//移除list集合需要替换的元素
			list.remove(x);
		}
		//将临时集合的元素替换
		Collections.fill(list1,str);
		//从start位置开始把临时集合里的元素插入进原集合
		list.addAll(start,list1);
	}
}打印结果如图：

集合框架工具类之Arrays

概述

此类包含用来操作数组（比如排序和搜索）的各种方法。此类还包含一个允许将数组作为列表来查看的静态工厂。

Arrays是集合框架中的一个工具类，该工具内的方法都是静态方法，不需要创建对象，没有封装特有数据。

常见方法：具体查看API文档java.util.Arrats类的方法

binarySearch():使用二分查找

copyOf():

copyOfRange():

deepToString():如果两个指定数组彼此是深层相等 的，则返回 true。

equals()判断某类型数组彼此是否相等

fill()将指定的某类型值分配给某类型数组

hashCode():对指定数组内容返回哈希码值

sort():对指定的数组进行排序

toString();将指定数组内容以字符串形式返回

数组变集合

static<T> List<T> asList(T…a);将指定数组转变为集合

注意：

1， 将谁转换成集合，不可以使用集合的增删方法，因为数组的长度是固定了。如果进行了增删操作，会发生不可以操作异常UnsupportedOperationException

2， 如果数组中的元素都是对象，那么变成集合时，数组中的元素转为集合中的元素。

3， 如果数组中的元素是基本数据类型，那么变成集合时，数组将作为集合元素存在。

示例：

import java.util.*;
class ArraysDemo {
	public static void sop(Object obj){
		System.out.println(obj);
	}
	public static void main(String[] args) {
		asListDemo();
	}
	public static void asListDemo()
	{//字符串数组转集合
		String[] str = {"wer","sdg","java","array","nihao"};
		List list = Arrays.asList(str);
		sop(list);
		/*基本数据类型不能转集合
		int[] in = {1,2,3,4,5};
		List list = Arrays.asList(in);
		sop(list);*/
	}
}

集合变数组

Collection接口中的toArray方法

<T> T[] toArray(T[] a);返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。

注意：

1， 指定类型的数组到底要定义多长呢？

当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组。长度为集合的size。

当指定类型的数组长度大于了集合的size，就不会新创建了数组。而是使用传递进来的数组。所以创建一个刚刚好的数组最优。

2， 为什么将集合变数组？

为了限定对元素的操作。不需要进行增删了。和数组变集合道理一样。

示例：

import java.util.*; 
class  CollectionToArray{ 
    public static void main(String[] args){ 
        ArrayList<String> al = new ArrayList<String>();{
        al.add("abc1");  
        al.add("abc2"); 
        al.add("abc3"); 
        //将集合变为String数组 
        String[] arr = al.toArray(new String[al.size()]); 
        //利用Arrays操作数组的方法 
        System.out.println(Arrays.toString(arr)); 
    } 
}

1.5版本新特性

增强for循环

用于对集合的遍历，和iterator功能类似，他的底层结构还是iterator，是为了简化书写。 

格式：

for (数据类型变量名：被遍历的集合(Collection)或者数组)

{执行语句}

注意：

高级for循环对集合进行遍历时，只能获取集合元素，但是不能对集合进行操作。

而迭代器除了遍历还可以进行remove集合中的元素的动作。

如果是用ListIterator，还可以在遍历过程中对集合进行增删改查的动作。

传统for和高级for有神马区别？

高级for有一个局限性，必须有被遍历的目标。

建议在遍历数组的时候，还是希望用传统for，因为传统for可以定义角标。

示例：

import java.util.*;
class  AdvForDemo{
	public static void sop(Object obj){
		System.out.println(obj);
	}
	public static void main(String[] args) {
		HashMap<Integer,String> hs = new HashMap<Integer,String>();
		hs.put(1,"java1");
		hs.put(2,"java2");
		hs.put(3,"java3");
		hs.put(4,"java4");
		getFor_1(hs);
		getFor_2(hs);
	}
	public static void getFor_1(HashMap<Integer,String> is){
		//用keySet方法取出键
		Set<Integer>keyset = is.keySet();
		for (Integer i: keyset)
		{
			String value = is.get(i);
			sop(i+":"+value);
		}
	}
	public static void getFor_2(HashMap<Integer,String> is2){
		//用entrySet方法取出键值
		for(Map.Entry<Integer,String> keyset2:is2.entrySet()){
			Integer in = keyset2.getKey();
			String str = keyset2.getValue();
			sop(in+":       "+str);
		}
	}
}

1.5版本新特性

可变参数

如果一个方法在参数列表中传入多个参数，当参数个数不确实时，每次都要重载其方法比较麻烦，这时可以用数组作为形式参数传入，但是每次还是要定义一个数组对象，所以在1.5版本后，java提供了一个新特性即可变参数。

其实可变参数就是数组参数的简写形式，不用每次都手动的建立数组对象。只要将要操作的元素作为参数传递即可。他是隐式的将这些参数封装成了数组。

注意：

可变参数一定要定义在参数列表的最后面。

示例：

class  ParamMethodDemo{    
    public static void main(String[] args){    
        show("haha",2,3,4,5,6);    
    }    
    public static void show(String str,int... arr)//...就表示可变参数{    
        System.out.println(arr.length);    
    }    
}  

1.5版本新特性

静态导入

静态导入类似于import导入java相关类，它导入的是静态成员，这样在编写程序时可以减少书写

格式：

import static java.util.Arrays.*;//导入了Arrays类中的所有静态成员。

Import static java.lang.System.*;//导入了System类中的所有静态成员。

注意：

1，当导入没有加上static时导入的是某一类  

当加上static时导入的是某一类中的静态成员。

2，当类名重名时，需要指定具体的包名

当方法重名时，指定具备所属的对象或者类。

示例：

import java.util.*;    
import static java.util.Arrays.*; //导入了Arrays类中的所有静态成员。   
import static java.lang.System.*; //导入了System类中的所有静态成员。      
class  StaticImport    
{    
    public static void main(String[] args){    
        out.println("haha");//省略书写System.    
        int[] arr = {3,1,5};        
        sort(arr);//使用Arrays工具类的方法sort时就可以省略书写Array.        
        int index = binarySearch(arr,1); 
        out.println("Index="+index);       
        //当没有指定继承时，所以类默认继承了Object，    
       //因为toString方法object都具备，所以为了区分，必须写上具体调用者    
       System.out.println(Arrays.toString(arr));    
    }    
}

---------------------- ASP.Net+Android+IOS开发、 .Net培训、期待与您交流！ ----------------------详细请查看： http://edu.csdn.net