集合框架拓展（增强for循环、可变参数、静态导入）

增强for循环——可变参数——静态导入

一、增强for循环

（1）JDK5增加的新特性：自动拆装箱，泛型，增强for，静态导入，可变参数，枚举等。

（2）增强for循环：是for循环的一种。

（3）格式：

    ArrayList<String>list = new ArrayList<>();

     for(集合里面存储的数据类型     变量名      :  集合/数组变量名){

     }
    for(Stringstr : list){

    }

（4）增强for循环的特点：

    1).没有循环变量；一般用于不需要循环变量的循环操作；如果在循环中需要循环变量，还是使用普通for循环；

     2).可以遍历集合，数组；

     3).增强for循环底层就是使用的"迭代器"。因为仍然会产生并发修改异常；

（5）好处：简化了数组和集合的遍历。

（6）弊端： 增强for的目标不能为null。一旦为null，就会出现问题，那该如何解决呢？对增强for的目标先进行不为null的判断，然后再使用。

（7）代码演示

package com.caoguangli.Map;

/*
 * ArrayList存储字符串并遍历。要求加入泛型，并用增强for遍历。
 * A:迭代器
 * B:普通for
 * C:增强for
 */

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
	 
	public class ForDemo {
		public static void main(String[] args) {
			ArrayList<Students> array = new ArrayList<Students>(); 
			// 创建学生对象
			array.add(new Students("哈哈", 27));
			array.add(new Students("小黑", 22));
			array.add(new Students("小样", 24));
			array.add(new Students("ajsh", 21));
			array.add(new Students("小丑", 23));
			// 迭代器
			System.out.println("----迭代器--------");
			Iterator<Students> it = array.iterator();
			while (it.hasNext()) {
				Students s = it.next();
				System.out.println(s.getSname() + "---" + s.getSage());
			}
			System.out.println("-----普通for------");
			// 普通for
			for (int x = 0; x < array.size(); x++) {
				Students s = array.get(x);
				System.out.println(s.getSname()+ "---" + s.getSage());
			}
           System.out.println("---增强for----");
			// 增强for
			for (Students s : array) {
				System.out.println(s.getSname() + "---" + s.getSage());
			}
		}
	}		 
class Students {
	// 成员变量
	private String sname;
	private int sage;
	public String getSname() {
		return sname;
	}
	public void setSname(String sname) {
		this.sname = sname;
	}
	public int getSage() {
		return sage;
	}
	public void setSage(int sage) {
		this.sage = sage;
	}
	@Override
	public String toString() {
		return "Student [sname=" + sname + ", sage=" + sage + "]";
	}
	public Students(String sname, int sage) {
		super();
		this.sname = sname;
		this.sage = sage;
	}
	public Students() {
		super();
	}
}

结果如下：

二、静态导入

（1）格式： import static 包名….类名.方法名 ;可以直接导入到方法的级别。

（2）静态导入的注意事项：

    A:  方法必须是静态的
        例：
              import static java.lang.Math.abs;
              import static java.lang.Math.max;

    B:  如果有多个同名的静态方法，容易不知道使用谁?这个时候要使用，必须加前缀。由此可见，意义不大，所以一般不用，但是要能看懂。

（3）代码演示

package com.caoguangli.Map;

	import static java.lang.Math.abs;
	import static java.lang.Math.pow;
	import static java.lang.Math.max;
	 
	
	public class StaticImportDemo {
		public static void main(String[] args) {
//			 System.out.println(java.lang.Math.abs(-100));
//			 System.out.println(java.lang.Math.pow(2, 3));
//			 System.out.println(java.lang.Math.max(20, 30));
			// 太复杂，我们就引入到import
	 
//			 System.out.println(Math.abs(-100));
//			 System.out.println(Math.pow(2, 3));
//			 System.out.println(Math.max(20, 30));
			// 太复杂，有更简单
	 
//			System.out.println(abs(-100));
			System.out.println(java.lang.Math.abs(-100));
			System.out.println(pow(2, 3));
			System.out.println(max(20, 30));
		}
		
		public static void abs(String s){
			System.out.println(s);
		}
	}
	

结果如下：

三、可变参数

1.定义一个方法，这个方法可以接收0-- 无限多的某类型实参。这种形参就是：可变参数；

2.格式：

    public int getMax(int ... nums){

    }

    注意：数据类型：可以是任何的Java类型(基本数据类型和引用数据类型)；

3.调用getMax()方法时，可以传递：0 – 无限多；

    getMax();//不传参数可以。

    getMax(1432,432,43,25,432,432,43,25,325,2,432,4532);//传多个参数也可以；

4.注意：

    1).可变参数可以同其它形参共存，但可变参数一定要位于参数列表的末尾；

5.可变参数，在方法内部，是按照"数组"的方式工作的。

通过反编译后，我们也看出，可变形参也被编译为数组的形式；

6.因为可变参数就是数组的形式，所以不能跟数组的形参构成"重载"

7.代码演示如下：

package com.caoguangli.Map;

/*
 * 可变参数：定义方法的时候不知道该定义多少个参数。
 * 格式：
 * 		修饰符 返回值类型 方法名(数据类型…  变量名){
 * 
 * 		}
 * 		注意：
 * 			这里的变量其实是一个数组
 * 			如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个。
 */				
public class ArgsDemo {
	public static void main(String[] args) {
		
		System.out.println("----2个数据求和---");
		// 2个数据求和
		int a = 20;
		int b = 30;
		int result = sum(a, b);
		System.out.println("result:" + result);
 
		System.out.println("---3个数据的求和---");
		// 3个数据的求和
		int c = 10;
		result = sum(a, b, c);
		System.out.println("result:" + result);
 
		System.out.println("---4个数据的求和---");
		// 4个数据的求和
		int d = 50;
		result = sum(a, b, c, d);
		System.out.println("result:" + result);
 
		// 需求：写一个求和的功能，到底是几个数据求和呢，不太清楚，但是知道在调用的时候就知道了。
		// 为了解决这个问题，Java就提供了一个东西：可变参数！
		System.out.println("---5个数据的求和---");
		result = sum(a, b, c, d, 40);
		System.out.println("result:" + result);
 
		System.out.println("---6个数据的求和---");
		result = sum(a, b, c, d, 40, 50);
		System.out.println("result:" + result);
	}
 
	//最终的结果为：
	
	public static int sum(int... a) {
		// System.out.println(a);
		int s = 0;
		for(int x : a){
			s +=x;
		}
		return s;
	}
}

结果如下：