标签：

【JavaSE】day04_Collection_Iterator_新循环_泛型

1.Collection集合的批量操作

1）boolean addAll(Collection c)

         将给定的集合中的所有元素添加到当前集合中。

         当执行完毕后，当前集合中的元素发生改变则返回true。

2）boolean containsAll(Collection c)

       判断当前集合中是否包含给定集合里的所有元素，全部包含则返回true。

       这里判断的依据依然是依靠元素的equals比较的。

代码演示：

package day04;

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

/**
 * 集合的批量操作
 *
 */
public class CollectionDemo01 {
	public static void main(String[] args) {
		Collection c1 = new ArrayList();
		c1.add("java");
		c1.add("php");
		c1.add("c++");
		System.out.println(c1);
		
		Collection c2 = new HashSet();
		c2.add("vb");
		c2.add("oc");
		c2.add("c#");
		c2.add("java");
		System.out.println(c2); //[oc, java, c#, vb]
		
		/*
		 * 并集
		 * boolean addAll(Collection c)
		 * 将给定的集合中的所有元素添加到当前集合中
		 * 当执行完毕后，当前集合中的元素发生改变则返回true。
		 */
		//c1.addAll(c2);
		//System.out.println(c1); //[java, php, c++, oc, java, c#, vb]
		
		c2.addAll(c1);
		System.out.println(c2);   //[oc, c++, php, java, c#, vb]
		
		//c2.add(c1);
		//System.out.println(c2); //[oc, [java, php, c++], java, c#, vb]
		
		/*
		 * 判断当前集合中是否包含给定集合里的所有元素，
		 * 全部包含则返回true。这里判断的依据依然是依靠
		 * 元素的equals比较的。
		 * boolean containsAll(Collection c)
		 */
		Collection c3 = new ArrayList();
		c3.add("c++");
		c3.add("php");
//		c3.add("oc");
		boolean contains = c1.containsAll(c3);
		System.out.println("contains:"+contains);
		
	}

}

3）boolean remove(E e)

     将给定的元素从集合中删除，成功删除返回true。

     删除元素的判断依据是：删除当前集合中第一个与给定元素equals比较为true的。

代码演示：

package day04;

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

import day03.Aoo;

/**
 * 集合提供了一个方法可以删除集合中的现有元素
 * 
 * boolean remove(E e)
 * 将给定的元素从集合中删除，成功删除返回true
 *
 */
public class CollectionRemove {
	public static void main(String[] args) {
		Collection c = new ArrayList();
		Aoo o =new Aoo("zhangsan",21);
		c.add(new Aoo("zhangsan",23));
		c.add(o);
		c.add(new Aoo("lisi",26));
		c.add(new Aoo("wangwu",22));
		//c.add(o);
		//c.add(o);
		System.out.println(c);
		
		/*
		 * 删除元素的判断依据是：删除当前集合中第一个
		 * 与给定元素equals比较为true的。
		 */
		c.remove(o);
		
		System.out.println(c);
		System.out.println(o);
	}

}

2.Iterator --迭代器

    由于集合的具体实现类各不相同，Set集合大部分实现又是无序的，所以不能像数组那样根据下标位置获取具体的某一个元素。

    集合提供了统一的获取集合元素方法：遍历集合，而遍历是使用迭代器来完成的。

    java.util.Iterator是迭代器的接口，定义类用于遍历 集合的相关方法。不同的集合都实现了一个可以遍历自身的迭代器实现类。我们无需记住实现类的名字，只当是迭代器使用即可。

   迭代器迭代元素需要循环：问、取、删。这个步骤。其中删除不是必须的。

1）若要遍历集合，可以调用集合的方法：

         Iterator iterator()

     该方法会返回可以遍历当前集合的迭代器。

2）boolean hasNext()

     询问迭代器，其遍历的集合是否还有元素没有遍历过，有则返回true。

3）E next()

     取出集合中下一个元素。

具体注意事项见代码：

package day04;

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

/**
 * 由于集合的具体实现类各不相同，Set集合大部分实现
 * 又是无序的，所以不能像数组那样根据下标位置获取具体的某一个元素。
 * 集合提供了统一的获取集合元素方法：遍历集合，而
 * 遍历是使用迭代器来完成的。
 * java.util.Iterator是迭代器的接口，定义类用于遍历
 * 集合的相关方法。不同的集合都实现了一个可以遍历自身
 * 的迭代器实现类。我们无需记住实现类的名字，只当是迭代器使用即可。
 * 迭代器迭代元素需要循环：问、取、删。这个步骤。
 * 其中删除不是必须的。
 *
 */
public class IteratorDemo {
	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(1);
		System.out.println(c);
		
		/*
		 * 若要遍历集合，可以调用集合的方法：
		 * Iterator iterator()
		 * 该方法会返回可以遍历当前集合的迭代器。
		 */
		Iterator<String> it = c.iterator();
		/*
		 * boolean hasNext()
		 * 询问迭代器，其遍历的集合是否还有元素没有
		 * 遍历过，有则返回true。
		 */
		while(it.hasNext()){
			/*
			 * E next()
			 * 取出集合中下一个元素。
			 */
			String str = it.next();
			
			/*
			 * 删除"#"
			 */
			if("#".equals(str)){ //用字面量.equals(str),可以避免空指针异常
				/*
				 * 在使用迭代器遍历集合的过程中，不能通过
				 * 集合的方法改变集合的元素，否则可能抛异常。
				 * java.util.ConcurrentModificationException
				 */
				//c.remove(str);
				
				/*
				 * 删除的是刚通过next()方法取出来的元素。
				 */
				it.remove();
				//it.remove(); //遵循问一次、取一次、删一次，删多次会抛异常。
			}
			System.out.println(str);
			//System.out.println(it.next());
		}
		System.out.println(c);
		
	}

}

3.新循环

  java5.0以后推出的一个新特性：增强for循环

 又叫作：新循环、增强循环、for each

 新循环不能代替传统循环重复工作的需求。 新循环是用来遍历集合或数组的。

1）语法：

    for(元素类型 e : 集合或数组 ){

         //循环体

    }

2）新循环并不是JVM认可的新语法。而是编译器认可的。编译器在编译源程序时若发现我们使用新循环来遍历集合时，会将代码改变为使用迭代器的方式遍历集合。所以新循环遍历集合本质上就是迭代器遍历。所以新循环在遍历集合的过程中不允许通过集合的方法修改元素数量。

代码演示：

package day04;

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

/**
 * java5.0以后推出的一个新特性：增强for循环
 * 又叫作：新循环、增强循环、for each
 * 新循环不能代替传统循环重复工作的需求。
 * 新循环是用来遍历集合或数组的。
 *
 */
public class NewForDemo {
	public static void main(String[] args) {
		String[] array = new String[]{"one","two","three"};
		
		for(int i=0;i<array.length;i++){
			String str = array[i];
			System.out.println(str);
		}
		
		/*
		 * ":"左边是数组或集合中元素的类型，右边是数组或者集合名。
		 * 缺点：不知道循环的次数。
		 */
		for(String str : array){
			System.out.println(str);
		}
		
		/*
		 * 增强for循环遍历集合
		 */
		Collection c = new ArrayList();
		c.add("one");
		c.add("#");
		c.add("two");
		c.add("#");
		c.add("three");
		System.out.println(c);
		
		/*
		 * 新循环并不是JVM认可的新语法。而是编译器认可的。
		 * 编译器在编译源程序时若发现我们使用新循环来遍历集合时，
		 * 会将代码改变为使用迭代器的方式遍历集合。所以新循环遍历
		 * 集合本质上就是迭代器遍历。
		 * 所以新循环在遍历集合的过程中不允许通过集合的方法修改
		 * 元素数量。
		 */
		for(Object str : c){ 
			
//			 if("#".equals(str)){
//			 	c.remove(str);
//			 }
			 /*
			  * 上面这段代码报错
			  * java.util.ConcurrentModificationException
			  */
			 	 
			
			System.out.println(str);
		}
	}

}

4.泛型

1）JDK5.0开始支持的新特性

  泛型是参数化类型，可以对一个类中的属性，方法的参数，方法的返回值类型进行约束，在使用时指定类型。

2）泛型的注意事项

 当使用一个具有泛型的类时，若不指定，则就按照默认 的Object作为实际类型。

具体细节见代码：

package day04;
/**
 * 泛型的注意事项
 *
 */
public class PointTest {
	public static void main(String[] args) {
		/*
		 * 当使用一个具有泛型的类时，若不指定，则就按照默认
		 * 的Object作为实际类型。
		 */
		Point<Integer> p = new Point<Integer>();
		p.setX(1);
		int x = p.getX();
		System.out.println(x); //1
		
		//p2不指定类型则默认认为x、y是Object类型
		Point p2 = p; //指定类型的话只能是Integer
		p2.setX("1"); //这里可以传入任何类型的值。
		/*
		 * 这里会出现隐式的类型转换
		 * 只不过是将String强转为Integer！
		 * 会出现类造型异常！
		 * java.lang.ClassCastException
		 */
		x = p.getX();
		System.out.println(x); //异常	
		
		
	}

}

【JavaSE】day04_Collection_Iterator_新循环_泛型

标签：

原文地址：http://blog.csdn.net/u011637069/article/details/48010251