Collection集合

java中的集合

1.什么是集合，为什么要使用集合?

集合是一个容器，是用来装数据的,还可以操作数据。

使用集合的目的是为了对这些数据进行共同的操作或管理 

2.集合与数组的差异

相同点: 它们都是用来装数据的.

不同点: 
数组的特点:1 定长   2.类型单一   3.有顺序
集合的特点:1.不是定长的，它会随着元素的添加而自动加长.
       
  2.集合可以装任何对象. 
  3.即有顺序也无顺序.

对不应用场景，我们会使用不同的集合对象来完成操作，为什么要使用不同的集合对象。
因为集合类它有好多，在不现地方，我们可以选择不同的集合来完我们要的操作，这样提高
效率。我们将这些集合的功能向上抽取，形成了一个集合的根接口   Collection
这个接口定义在java.util包下.

学习集合的途径 查看根接口可以知道系列中公共的行为，在使用时使用底层类，它们具有独特的特性。

Collection 表示一组对象，这些对象也称为 collection 的元素。
一些 collection 允许有重复的元素，而另一些则不允许。
一些 collection 是有序的，而另一些则是无序的。


Collection下有一个子接口  List   List接口下有一个实现类叫  ArrayList
也可以说ArrayList类实现了Collection接口，ArrayList类中具有Collection接口
中的所有方法。

在使用时有一个警告  这个不影响程序运行，只是现在写的程序不符合jdk1.5的验证.
注意：Demo1.java 使用了未经检查或不安全的操作。
注意：要了解详细信息，请使用 -Xlint:unchecked 重新编译。

Collection中方法

1.add方法
定义  public boolean add(Object obj);

作用: 是向集合中添加一个元素obj。如果添加成功返回true,添加失败返回false;

2.clear方法
定义 public void clear();

作用  移除Collection中的所有元素

3.contains方法
定义  public boolean contains(Object obj)

作用  如果集合中包含obj元素返回true,否则返回false
     注意 所谓的包含是指元素与obj做equals返回true。

   4.isEmpty方法
定义  public boolean  isEmpty()

作用  如果集合中没有元素返回true，否则返回false;

5.remove方法
定义  public boolean remove(Object obj);

作用  移除集合中指定的一个元素obj。如果移除成功，返回true,否则返回false;

6.size方法
定义  public int size();

作用  得到集合中的元素的个数

7.toArray方法
定义 public Object[] toArray()

作用 返回一个包含Collection所有元素的数组。

import java.util.Collection;
import java.util.ArrayList;
class Demo1
{
	public static void main(String[] args){
		
		new CollectionDemo().method7();
	}
}

class CollectionDemo
{
	//add 添加元素
	public void method1(){
		
		Collection c=new ArrayList();

		boolean f=c.add("abc");

		c.add(123);//在jdk1.5后如果向集合中添加一个基本类型元素，那么会自动装箱.
		//c.add(new Integer(123));

		System.out.println(f);

		System.out.println(c); //打印c时发现出现[元素1, 元素2,..] 说明ArrayList类重写了toString方法
	}

	//clear方法
	public void method2(){
	
		Collection c=new ArrayList();

		c.add("abc");

		c.add(123);

		System.out.println(c);
		c.clear();//移除集合中所有元素

		System.out.println(c);
	}
	//contains方法
	public void method3(){
		
		Collection c=new ArrayList();

		c.add("abc");

		c.add("def");

		c.add("kkk");

		System.out.println(c.contains("abcd"));
	}

	//isEmpty方法
	public void method4(){
		
		Collection c=new ArrayList();

		c.add("abc");

		c.add("def");

		c.add("kkk");

		c.clear();

		System.out.println(c.isEmpty());

	}

	//remove方法

	public void method5(){
		
		Collection c=new ArrayList();

		c.add("abc");

		c.add("def");

		c.add("kkk");

		c.add("abc");

		System.out.println(c.remove("abcd"));

		System.out.println(c);

	}

	//size方法
	public void method6(){
		
		Collection c=new ArrayList();

		c.add("abc");

		c.add("def");

		c.add("kkk");

		c.add("abc");	

		System.out.println(c.size());

	}

	//toArray()
	public void method7(){
		
		Collection c=new ArrayList();

		c.add("abc");

		c.add("def");

		c.add("kkk");

		c.add("abc");	

		Object[] arr=c.toArray();

		for(int i=0;i<arr.length;i++){
			
			System.out.println(arr[i]);
		}
	}
}

/*
关于Collection中的xxxAll方法
1.addAll方法

定义 public boolean addAll(Collection c)

作用: 将c集合中的所有元素添加到集合中.添加成功返回true,否则返回false;
2.containsAll方法
定义  public boolean ContainsAll(Collection c);


作用 判断集合中是否包含c中的所有元素.如果包含返回true,否则返回false;
3.removeAll方法
定义 public boolean removeAll(Collection c)


作用 移除集合中与c集合中相同的元素，如果没有移除任何元素返回false，
    否则返回true.
4.retainAll方法
定义 public boolean retainAll(Collection c)


作用 得到集合与c集合的一个交集。如果集合是c集合的一个子集，返回false,否则返回true。

import java.util.*;
class Demo2 
{
	public static void main(String[] args) 
	{
		new CollectionDemo().method4();
	}
}

class CollectionDemo
{
	//addAll方法
	public void method1(){
		
		Collection c1=new ArrayList();

		c1.add("a");
		c1.add("b");
		c1.add("c");

		Collection c2=new ArrayList();
		c2.add(1);
		c2.add(2);

		c2.addAll(c1); //将c1集合中的元素添加到c2中。

		System.out.println(c2);
	}
	//containsAll方法
	public void method2(){
			
		Collection c1=new ArrayList();

		c1.add("a");
		c1.add("b");
		c1.add("c");

		Collection c2=new ArrayList();

		c2.add("a");
		c2.add("b");
		c2.add("c");
		c2.add("d");

		System.out.println(c2.containsAll(c1)); //判断c2集合中是否包含c1集合中的所有元素.
		
	}

	//removeAll方法
	public void method3(){
			
		Collection c1=new ArrayList();

		c1.add("a");
		c1.add("b");
		c1.add("e");

		Collection c2=new ArrayList();

		c2.add("a");
		c2.add("b");
		c2.add("c");
		c2.add("d");

		System.out.println(c2.removeAll(c1)); 

		System.out.println(c2);	
		
	}

	//retainAll方法
	public void method4(){
			
		Collection c1=new ArrayList();

		c1.add("a");
		c1.add("b");
		c1.add("c");
		c1.add("e");

		Collection c2=new ArrayList();

		c2.add("a");
		c2.add("b");
		c2.add("c");
		c2.add("k");

		System.out.println(c2.retainAll(c1)); //将c2与c1中不同的元素移除，得到的是与c1集合包含的元素
											  //如果c2是c1集合的一个子集，那么返回false;		

		System.out.println(c2);		
		
	}
}

Collection中的iterator方法


定义  public Iterator iterator();

 iterator方法返回值是Iterator类型

 Iterator是一个接口

 iterator方法得到的对象的真实类型应该是一个实现了Iterator接口的类的对象.
 我们在使用时，不需要知道具体实现类中是怎样实现的，只需要知道Iterator接口中
 提供了什么样行为。

 在Iterator接口中有三个方法
 1.hasNext

定义  public boolean hasNext();
作用： 是用来判断当前集合是否有元素可以进行迭代，如果有返回true,否则返回false
 2.next
定义  public Object next();
作用  得到下一个要迭代的元素.
 3.remove
 迭代器的作用就是用来遍历集合,怎样遍历集合?
 1.得到一个集合的迭代器.  可以通过Collection中定义的iterator方法得到。

import java.util.Collection;
import java.util.ArrayList;
import java.util.Iterator;
class Demo3 
{
	public static void main(String[] args) 
	{
	
		Collection c=new ArrayList();
		
		c.add("tom");
		c.add(new Thread());
		c.add(123);
		
		//得到集合中的所有元素

		/*
		//1.得到集合迭代器

		Iterator it=c.iterator(); //当前it这个迭代器就可以操作c这个集合


		//2.判断是否有元素进行迭代

		while(it.hasNext()){
			

			//3.如果有元素进行迭代，那么得到这个要迭代的元素

			Object obj=it.next();

			System.out.println(obj);
			
		}*/

		for(Iterator it=c.iterator();it.hasNext(); ){
			
			Object obj=it.next();

			System.out.println(obj);
		}

		

		//System.out.println(c);
	}
}

/*

关于迭代器的详解

Collection中定义了iterator方法,这个方法的返回值类型是Iterator类型

Collection 与Iterator都是接口

我们真正使用时使用的具体的某个集合类，Collection有很多的实现类，这些实现类
在不同地方使用，这些类的底层实现有差异。那么对于这些集合类进行迭代，方式
也不样，将这些方式向上抽取就形成了Iterator接口。

针对于不同的实现的集合类，会有不同的Iterator实现类与其对应，这些实现Iterator接口的
类一般都定义在集合类内部，也就是一个内部类，为什么这么定义，是因为，Iterator的实现类
是针对于特定的集合进行操作的，定义在内部类会合适.


伪代码

interface Iterator{
	
	boolean hasNext();

	boolean next();
}

interface Collection{
	
	void add;

	Iterator iterator(); //迭代器
}


//这个类有自己的底层实现
class MyCollection1 implements Collection{
	
	public void add(){}

	
	//那么对所在的外部类元素进行迭代时也应该有自己的方式
	class MyIter implements Iterator{
		
		public boolean hasNext(){
			
		}

		public Object next(){
		
		}
	}

	public Iterator iterator(){

		return new MyIter();
	}

}



class MyCollection2 implements Collection{
	
	public void add(){}

	
	//那么对所在的外部类元素进行迭代时也应该有自己的方式
	class MyIter implements Iterator{
		
		public boolean hasNext(){
			
		}

		public Object next(){
		}
	}

	public Iterator iterator(){

		return new MyIter();
	}

}