（java）Collection

Collection下所有的方法以及使用
Collection集合只能单个存储元素，并且只能存储引用类型

1.boolean add(Object element); 向集合中添加元素
2. int size();获取集合中元素的个数
3.void clear();清空集合
4.boolean isEmpty();判断及合中是否有元素
5.Object[] toArrary();将集合转换Object类型的数组

6.boolean contains(Object o);判断集合中是否包含某个元素
注意：集合内的元素，一定要重写equals方法，因为contains的底层是通过调用equals来判断是否包含，而equals在为重写前（即默认情况）是通过比较内存地址来判断是否相等的，但是不符合业务逻辑我们需要将其改为通过内容来判度是否相等
String类，equals方法是重写过的，是通过内容来判断是否相等
Integer类这种包装类，也是重写过equals方法的

7.boolean remove(Object o);删除集合中某个元素

import java.util.*;
public class CollectionTest{
	public static void main(String[] args){
		//Collection是一个接口，是无法实例化的，只能实例化他的实现类，实现接口也是一种继承，满足多态
		//ArrayList是Collection的一种实现类 
		Collection n1  = new ArrayList();//多态
		//2.添加元素
		n1.add(1);//不能将整型传进去，但是自动装箱，会把1转化为integer
		n1.add(new Integer(100));
		n1.add(new Object());//Collection集合只能单个存储元素，并且只能存储引用类型
		Object o1 = new Object();i1
		n1.add(o1);
		//获取输出元素个数
		System.out.println(o1.size());


		
	}
}

boolean contains(Object o);判断集合中是否包含某个元素
boolean remove(Object o);删除集合中某个元素

//6.boolean contains(Object o);判断集合中是否包含某个元素
		
		Collection c = new ArrayList();
		Integer i1  = new Integer(10);
		c.add(i1);

		System.out.println(c.contains(i1));  //true

		//再创建Integer对象
		Integer i2 = new Integer(10);

		//这里或许会有疑问，并没有加i2添加至集合内部，为何会返回true
		//这里揭示了一个本质，即contains方法底层调用的是equals方法去判断是否包含，未重写的equals方法比较的是内存的地址，又Integer内重写了equals方法，equals是通过比较内容是否相等来判断是否相等
		System.out.println(c.contains(i2));//true

	//7.boolean remove(Object o);删除集合中某个元素
	Integer i1 = 10;
	Integer i2 = 10;
	c.add(i1);
	c.remove(i2);
	System.out.println(c.size());//输出为0
	//remove方法与contains方法一样，都是需要重写equals方法的

以下是没有重写equals方法的Manager的类，两个内容相同的类，用contains会输出flase

Manager m1 = new Manager(20,"ab");
Manager m2 = new Manager(20,"ab");
n1.add(m1);
System.out.println(n1.contains(m2));//false，因为未重写equals方法，所以默认比较的是m1和m2的内存地址
class Manager{
int no;
String name;
Manager(int no,String name){
		this.no  = no;
		this.name = name;
}

重写Manager的equals方法

Manager m1 = new Manager(20,"ab");
Manager m2 = new Manager(20,"ab");
n1.add(m1);
System.out.println(n1.contains(m2));//true，重写了equals方法，contains调用equals时比较的是内部内容是否相同

class Manager{
int no;
String name;
Manager(int no,String name){
		this.no  = no;
		this.name = name;
}
//重写equals的标准流程

	public boolean equals(Object o1){
		if(this == o1) {
			return true;
		}else if(o1 instanceof Manager) {
			if(((Manager) o1).name.equals(this.name)  && ((Manager)o1).no == this.no)
			{
				return true;
			}
	}
	return false;
	}
	
}

迭代器
Iterator iterator(); 获取集合所依赖的迭代器对象
通过迭代器中方法完成集合的迭代（遍历）

注意：这种方式是所有集合通用的遍历方式

Iterator 内部定义的几个方法如下：

default void f orEachRemaining(Consumer<? super E> action)
对每个剩余元素执行给定的操作，直到所有元素都被处理或动作引发异常。

boolean hasNext()
如果迭代具有更多元素，则返回 true 。

E next()
返回迭代中的下一个元素。

default void remove()
从底层集合中删除此迭代器返回的最后一个元素（可选操作）。

import java.util.*;
public class CollectionTest{
	public static void main(String[] args){
		Collection n1 = new ArrayList();
		n1.add(new Object());
		n1.add(new Object());
		n1.add(new Object());
		n1.add(2);
		
		//迭代，遍历
		//1.获取迭代器对象
		//不需要关心底层集合的具体类型，所有集合依赖的迭代器都实现了java.util.Iterator;接口
		Iterator e =  n1.iterator();  //迭代器是面向接口编程
										//it是引用，保存了内存地址，指向堆中的“迭代器对象”
										
		System.out.println(e);//java.util.ArrayList$Itr 类是ArrayList集合所依赖的迭代器
							//java.util.LinkedList$ListItr是类LinkedList集合所依赖的迭代器

		/*
			Iterator 下的两个重要方法
			boolean hasNext() 判断是否有更多的元素，如果有返回true
			E next()	将迭代器向下移动，并且取出指向的元素(内部的元素为引用类型)
			原则：调用it.next()方法之前必须调用it.hasNext();
		*/
		//while的写法
		while(e.hasNext)//判断接下来是否还有元素可以取出
		{
			Object element  = e.next();
			System.out.println(element);
		}
		//for循环的写法
		for(Iterator e1 = n1.iterator();e1.hasNext();)  //取出迭代器，和判断接下来是否还有元素可以取出放在for循环里
		{
			Object element = e.next();//取出内部的Object元素
			System.out.println(element);
			
		}
	}
}

深入remove方法
1.迭代器的remove方法
2.集合自身带的remove方法

public class Test{
	public static void main(String[] args){
		Collection c = new ArrayList();
		c.add(1);
		c.add(2);
		c.add(3);
		//获取迭代器对象
		Iterator it = c.iterator();
		while(it.hasNext()){
			it.next();//通过这个来改变集合内游标的位置
			it.remove();//通过迭代器删除


			//使用集合自身所带的remove方法
			Object o = it.next();
			//删除
			c.remove(o);    //这种方式会出现问题，因为在用集合自身去删除的时候，迭代器就不是原来的迭代器了，所以报出异常
			
		}
			System.out.println(c.size());//输出为
	}
}