3.关于集合遍历或迭代：（以下讲解的遍历方式或迭代方式是所有的Collection通用的一种方式，在所有的Collection及其子类中使用，在Map中不能用）

单独拿出来讲“ Collection 接口调用 iterator()方法来获取一个迭代器对象Iterator”

package 集合;

import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;

public class Jihe02 {

	public static void main(String[] args) {
	 //创建集合对象,用到多态
		Collection c = new HashSet();
	//添加元素
		c.add(200);
		c.add(3.14);
		c.add("加油");
		c.add(new Object());
//		对集合Collection进行迭代/遍历：
//		首先，获取集合对象的迭代器对象Iterator
//		第二步：通过迭代器对象Iterator中的方法完成对集合对象的遍历或迭代，
		/*迭代器Iterator（Iterator接口）共有三种方法：
		 * 1.  boolean hasNext(); 若仍有元素可以迭代，则返回true
		 * 2.  Object next(); 返回迭代的下一个元素(就是指这个方法让迭代器前进一位，并且将指向的元素返回)
		 * 迭代器最初并没有指向第一个元素对象，先hasNext()判断有元素可以迭代吗？有，则调用next()，让迭代器前进一位
		 * 依次将元素将集合中的元素取出
		 * boolean hasNext = it.hasNext();
		if(hasNext) {
			Object obj = it.next();
			System.out.println(obj);
		}
		应该使用循环来实现将集合中的元素依次取出*/
		Iterator it = c.iterator();
		while(it.hasNext()) {
			Object obj = it.next();
			System.out.println(obj);
		}
/*加油
3.14
200
java.lang.Object@7de26db8
*/	
	}
}

package 集合;

import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;

public class Jihe0202 {

	public static void main(String[] args) {
		//创建集合对象,用到多态
		Collection c = new HashSet();
		//添加元素
		c.add(1);//自动装箱，就是Integer x = new Integer(1); c.add(x);
		c.add(11);
		c.add(111);
		//获取迭代器，循环迭代
		Iterator it = c.iterator();
		while(it.hasNext()) {
			Object obj = it.next();
			if(obj instanceof Integer) {
				System.out.println("Integer型对象");
			}
			System.out.println(obj);
		}
/*想说明：
 * 在集合中传进去什么类型的数据，取出时仍然是什么类型的数据
 * 上面是传进去了Integer对象，取出仍是Integer对象
 * 只不过在输出时，有println(obj)方法：
 * 源码：
 *  public void println(Object x) {
        String s = String.valueOf(x);
        }
        将输出对象都转换为String类型的，同时，String类重写了toString()方法*/
	}
	/*
 Integer型对象
1
Integer型对象
11
Integer型对象
111*/

}

当集合结构发生改变时（例如 增添或删除个别元素时），没有重新获取迭代器

package 集合;

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

public class Jihe02020 {

	public static void main(String[] args) {
		 
				Collection c = new  ArrayList();
				
//				 如果在集合中是空时，就获取迭代器，添加元素后，
//				就是集合结构发生改变时，没有重新获取迭代器
//			出现异常：java.util.ConcurrentModificationException
//				Iterator it = c.iterator();	
				
				//添加元素
				c.add(1); 
				c.add(11);
				c.add(111);
				Iterator it = c.iterator();	
				while(it.hasNext()) {
					Object obj = it.next();
					System.out.println(obj);
				}
				
				//删除元素后，重新获取迭代器
				c.remove(11);
				Iterator i = c.iterator();	
				while(i.hasNext()) {
					Object obj = i.next();
					System.out.println(obj);
				}
				
				//迭代器Iterator接口中的第三个方法：
				/*default void remove() {
        throw new UnsupportedOperationException("remove");
    }
    就是remove()方法，删除的是迭代器当前指向的元素*/
				
				
				c.add(200); 	
				Iterator j = c.iterator();	
				while(j.hasNext()) {
					Object obj = j.next();
					System.out.println(obj);
					j.remove();
				}
				
				System.out.println(c.size());
	}
/*
1
11
111
1
111
1
111
200
0
*/
}

4. Collection 接口里面的：contains方法 中底层会调用调用了equals方法进行比对，来判断判断集合中是否包含某个元素，所以存放在一个集合中的类型，一定要重写equals方法；同时，记住：String类和Integer类都已经重写了equals方法；

package 集合;

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

public class Jihe03 {
//深入Collection 集合中的contains方法：
//	boolean contains(Object o); 判断集合中是否包含元素o,包含返回true
	public static void main(String[] args) {
		Collection c = new ArrayList();
		
		String s1 = new String("abc");
		c.add(s1);
		String s2 = new String("abcd");
		c.add(s2);
		
		String s3 = new String("abc");
//		s3并没有添加到集合c中
//		那c集合中是否包含元素s3呢？
		System.out.println(c.contains(s3));//true
		
		/*分析：
		 *关键看底层的源代码：
		 *在ArrayList中找到contains方法，
		 *public boolean contains(Object o) {
        return indexOf(o) >= 0;
    }
    然后在indexOf(o)中：
     if (o.equals(es[i])) {
                    return i;
                }
       调用了equals方法，
       其中的o是s3,es[i]是s1 
       就是 s3.equals(s1)
       分析：
      在堆中中new出了两个String对象s1 和 s3 ,
      s1 和 s3中都保存的是在方法区的常量池中的同一个字符串"abc"的内存地址，
       向右赋值，给了栈中的两个变量  s1 和 s3,
       此时的实例变量s1 和 s3 中保存的是 两个String对象s1 和 s3 在堆中的内存地址
       然后，s1的内存地址送到集合 c 的ArrayList数组中，s3并没有添加到集合c中，
       但因为底层的contains方法调用了equals方法，
       因为String类的equals方法是重写了，比较的是两个元素的内容，
       因为s1 和 s3保存的内容都是字符串"abc"
       所以c.contains(s3) 就是相当于 s3 也在集合c中
             
		 * */
	}

}

放在集合中的元素一定要重写equals方法

package 集合;

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

public class Jihe0303 {

	public static void main(String[] args) {
		// 创建集合对象,用到多态
		Collection c = new ArrayList();
		// 创建用户对象
		User u1 = new User("jack");
		User u2 = new User("jack");

		// 添加元素
		c.add(u1);

		// System.out.println(c.contains(u2));//false
		/*
		 * contains方法 中底层会调用调用了equals方法进行比对，因为User类没有重写equals方法
		 * 所以此处调用Object类中的equals方法，它是用“==”，就是比较两个元素对象的内存地址 就是 u1.equals(u2) 是 false
		 */

//		重写User类中的equals方法后
		System.out.println(c.contains(u2));// true
	}
}

class User {

	public String name;

	public User() {
	}

	public User(String name) {
		this.name = name;
	}

	// 重写equals方法,就是姓名一样，就可以认为同一个用户
	@Override
	public boolean equals(Object obj) {
		if (obj == null || !(obj instanceof User)) {
			return false;
		}
		if (obj == this) {
			return true;
		}
		User s = (User) obj;
		if (s.name.equals(this.name)) {
			return true;
		}
		return false;
	}

}

4. Collection 接口里面的：remove方法 ; 因为底层调用了equals方法

//创建集合对象
		Collection cc = new ArrayList(); 
		
		
		String s1 = new String("abc");
		cc.add(s1);
		
		String s2 = new String("abc");
		cc.remove(s2);
		
		System.out.println(cc.size());//0
		
		/*分析：因为contains方法在确认元素属于集合时，底层调用了equals方法，所以s1和s2认为是一样的，
		 * 删除其中一个，就认为同时删除了
		 * */