33Java集合------集合的遍历、泛型机制

遍历集合

Intrator

• 迭代器用于遍历集合元素。获取迭代器可以使用Collection定义的方法 -----Iterator Iterator()
• 迭代器Iterator是一个接口，集合在重写Collection的Iterator()方法时利用内部类提供了迭代器的实现
• Iterator提供了统一的遍历集合元素的方式，其提供了用于遍历集合的两个方法
  ——boolean haasNext():判断集合是否还有元素可以遍历
  ——E next():返回迭代的下一个元素

package day04;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/**
 * 遍历集合
 * Collection提供了统一的遍历集合元素的
 * 方式：迭代器模式
 * 
 * 
 * Iterator iterator()
 * 获取用于遍历当前集合的迭代器
 * 
 * 
 * Java.util.Iterator是一个接口，规定了用于遍历
 * 集合元素的相关方法，不同集合提供了相应的实现类。
 * 无需记住那些实现类的名字，只将他们当做Iterator即可
 * 
 * 遍历集合遵循：问，取，删的步骤，其中删除不是必须操作
 * @author 
 *
 */
public class CollectionDemo3 {

	public static void main(String[] args) {
		Collection c = new ArrayList();
		c.add("one");
		c.add("#");
		c.add("two");
		c.add("#");
		c.add("three");
		c.add("#");
		c.add("four");
		
		//获取用于遍历当前集合的迭代器
		Iterator it = c.iterator();
		/**
		 * boolean hasNext()问的过程
		 * 该方法是判断集合中是否还有元素可以取出
		 * 
		 * E next() 取的过程
		 * 获取集合中下一个元素
		 */
		while(it.hasNext()) {
			String str = (String) it.next();
			if ("#".equals(str)) {
				/**
				 * 在使用迭代器遍历集合是，不要
				 * 使用集合的方法增删元素，否则
				 * 会引发异常
				 */
				//c.remove(str);
				/**
				 * 迭代器提供了remove方法，用来删除
				 * 通过next方法中取出来的元素
				 */
				it.remove();
			}
			System.out.println(str);
		}
		System.out.println(c);
		

	}

}

for each循环

package day04;
/**
 * JDK5.0之后推出了一个新的特性
 * 增强for循环，又叫新循环，for each
 * 
 * 新循环不能代替传统循环。作用仅仅是用来遍历集合或
 * 数组的
 * @author 
 *
 */
public class NewForDemo1 {

	public static void main(String[] args) {
		String[] array = {"one","two","three","four"};
		for (int i = 0; i < array.length; i++) {
			String string = array[i];
			System.out.println(string);
		}
		for(String str:array) {
			System.out.println(str);
		}

	}

}

package day04;

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

/**
 * 新循环遍历集合
 * @author 
 *
 */
public class NewForDemo2 {

	public static void main(String[] args) {
		Collection c = new ArrayList();
		c.add("one");
		c.add("two");
		c.add("three");
		c.add("four");
		System.out.println(c);
		/**
		 * 新循环并非新的语法，新循环是编译器认可，
		 * 而不是虚拟机认可。
		 * 使用新循环遍历集合时，编译器会将它改为
		 * 迭代器方式遍历。所以在使用新循环遍历集合
		 * 时，不能通过集合的方法增删元素。
		 */
		for(Object o:c) {
			//Iterator it =c.Iterator();
			//while(it.hasNext()){
			//Object o = it.next();
			String str = (String)o;
			System.out.println(str);
			if ("#".equals(str)) {
				c.remove(str);//会报错
			}
		}

	}

}

泛型机制

package day04;
/**
 * 泛型
 * 泛型又称参数化类型，是当前类的属性的类型，
 * 方法参数的类型以及方法返回值的类型的定义权移交给使用者。
 * 使用者在创建当前类的同时将泛型的实际类型传入
 * @author 
 *
 * @param <X>
 * @param <Y>
 */
public class Point<X,Y> {
	private X x;
	private Y y;
	
	public String toString(){
		return "x="+x+",y="+y;
	}
	
	public Point(X x, Y y) {
		super();
		this.x = x;
		this.y = y;
	}
	public X getX() {
		//隐式的强制类型转换
		return x;
	}
	public void setX(X x) {
		this.x = x;
	}
	public Y getY() {
		return y;
	}
	public void setY(Y y) {
		this.y = y;
	}
	
}

package day04;
public class TestPoint {

	public static void main(String[] args) {
		Point<Integer,Double> p 
				= new Point<Integer,Double>(1,2.2);
		
		p.setX(1);
		int x = p.getX();
		Point p2 = p;
		
		p2.setX("1");
		int x2 = p.getX();
	}

}

package day04;
/**
 * 泛型的原型是Object
 * 定义了泛型只是编译器在做一些验证工作。
 * 当我们对泛型类型设置值时，会检查是否满足类型要求。
 * 当我们获取一个泛型类型的值时，会自动进行类型转换
 * @author 
 *
 */
public class TestPoint2 {

	public static void main(String[] args) {
		/**
		 * 这里指定泛型的类型为Integer
		 * 但实际上，创建的Point对象中，x，y属性是
		 * Object类型，这里只是应当将它当做Integer
		 * 看待
		 */
		Point<Integer,Integer> p1 = new Point<Integer,Integer>(1,2);
		/**
		 * 由于参数是X，Y，这里会验证实参是否为Integer，
		 * 若不是，则编译失败
		 * 可以传入基本类型，因为还会自动装箱
		 */
		p1.setX(1);
		/**
		 * 获取时，也会自动进行造型。
		 * 这里无需显示的进行类型转换
		 */
		int x1 = p1.getX();
		/**
		 * 若不指定泛型则使用默认的Object类型
		 */
		Point p2 = p1;
		p2.setX("一");
		String x2= (String)p2.getX();
		System.out.println("x2=: "+x2);
		
		//类造型异常
		x1 = p1.getX();
		System.out.println("x1: "+x1);
		
	}

}

package day04;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/**
 * 集合支持泛型，而泛型是约束集合中元素的类型
 * @author 
 *
 */
public class CollectionDemo4 {

	public static void main(String[] args) {
		Collection<String> c = new ArrayList<String>();
		//只能添加String类型的元素了
		c.add("one");
		c.add("two");
		c.add("three");
		
		//遍历集合元素
		for(String str : c) {
			System.out.println(str);
		}
		/**
		 * 迭代器也应当指定泛型，而泛型的实际类型
		 * 应当与它便利的集合的泛型类型一致。
		 */
		Iterator<String> it = c.iterator();
		while(it.hasNext()) {
			//获取元素时不需要再造型了
			String str = it.next();
			System.out.println(str);
		}
		
		
		Collection c2 = c;
		c2.add(1);
		c2.add(2);
		System.out.println(c2.size());
		
		
		for(String str : c){
			System.out.println(str);
		}

	}

}