JAVA常用集合框架用法详解基础篇一之Colletion接口

首先，在学习集合之前我们能够使用的可以存储多个元素的容器就是数组。

下面举几个例子主要是引出集合类的：

1、8,4,5,6,7,55,7,8  像这样的类型相同的可以使用数组来存储，本例可以用int[] arr来存储。

2、”zhnagsan”,true,68 像这样的可以使用StringBuilder或者StringBuffer来存储，但最终需要使用.toString()的方法转换成字符串才可以使用。即 变为：”zhnagsantrue68”。

3、”李四”,25  像这样的可以使用对象来存储，如: new Person(“李四”,25);

一、为什么要使用集合呢，那什么时候需要使用集合类呢？？？？？？

1.集合类的由来：

对象用来封装特有的数据，对象多了需要存储，或者对象的个数不确定，就使用集合容器进行存储。原来集合是用来存储个数不确定的对象的。这一点是数组做不到的。

2.集合的特点：

--是用于存储对象的容器；

--集合的长度是可变的；

--集合中不可以存储基本的数据类型（如:int、 char、 boolean之类的），一般我们可以将基本数据类型进行装箱处理，然后在存储在集合中。

 

接下来用一幅图表示集合的整体框架：

3、集合容器因内部的数据结构不同，有多种具体容器。不断向上抽取，就形成了集合框架。

我们先详细的说说框架的顶层Collection接口：

Collection的常见方法：

---添加。

boolean add(Object obj); //添加一个对象

boolean addAll(Collection  coll);//添加一个集合

</pre><pre name="code" class="html">代码如下：
package com.ll.list;

import java.util.ArrayList;
import java.util.List;

public class testAdd {
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		List<String> allList=new ArrayList<String>();//定义List对象
		List<String> list=new ArrayList<String>();//定义另一个List对象	
		allList.add("hello");//使用从Collection接口中继承的方法
		allList.add(0, "world");//此方法为List自己扩展的方法
		System.out.println(allList);
		list.add("LL");
		list.add("www.ll.com");
		allList.addAll(list);//增加一组对象，此方法是从父类继承的
		System.out.println(allList);
		allList.addAll(1, list);//在指定的位置上，进行增加一组对象。此方法是List接口自己扩展的方法
		System.out.println(allList);
	}

}

---删除

boolean remove(Object  obj);
boolean removeAll(Collection coll);
void  clear();//将集合中的元素清空

代码如下：

package com.ll.list;

import java.util.ArrayList;
import java.util.List;

public class testRemove {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		List<String> allList=new ArrayList<String>();//实例化一个List对象
		allList.add("kello");
		allList.add("joke");
		allList.add("www.ll.com");
		allList.add("world");
		System.out.println(allList);//输出List对象中的元素
		allList.remove(0);//删除指定位置的内容
		System.out.println(allList);
		allList.remove("joke");//删除指定的内容
		System.out.println(allList);
	}

}

---判断

boolean contains(Object obj);//是否包含
boolean  containsAll(Collection coll);
boolean  isEmpty();//判断集合中是否含有元素

代码如下：

package com.ll.list;

import java.util.ArrayList;
import java.util.List;

public class testSizeAndGet {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		List<String> allList=new ArrayList<String>();//定义并实例化List对象
		allList.add("world");
		allList.add("world");
		allList.add("kkorld");
		allList.add("pprld");
		allList.add("lllrld");
		allList.add("wqwld");
		System.out.println("从前向后输出：");
		for(int i=0;i<allList.size();i++){
			System.out.println(allList.get(i)+"..");
		}
		
		System.out.println("从后向前输出：");
		for(int i=allList.size()-1;i>=0;i--){
			System.out.println(allList.get(i)+"..");
		}
	}

}

---获取

int size();//获取集合中元素的个数
Iterator iterator();//取出元素的方式，使用的是迭代器
Object get(int i);

代码如下：

package com.ll.list;

import java.util.ArrayList;
import java.util.List;

public class testSizeAndGet {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		List<String> allList=new ArrayList<String>();//定义并实例化List对象
		allList.add("world");
		allList.add("world");
		allList.add("kkorld");
		allList.add("pprld");
		allList.add("lllrld");
		allList.add("wqwld");
		System.out.println("从前向后输出：");
		for(int i=0;i<allList.size();i++){
			System.out.println(allList.get(i)+"..");
		}
		
		System.out.println("从后向前输出：");
		for(int i=allList.size()-1;i>=0;i--){
			System.out.println(allList.get(i)+"..");
		}
	}

}

我们再来测试一下迭代器Iterator的用法。

代码如下：

package com.ll.list;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/*
 * 迭代输出：Iterator
 * 是最常用的的集合输出操作
 * 但是只能进行单向的从前向后输出
 */
public class testIterator {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		List<String> allList=new ArrayList<String>();
		allList.add("hello");
		allList.add("world");
		allList.add("__ll__");
		//直接实例化一个Iterator接口
		System.out.println("删除前的集合"+allList.toString());
		Iterator<String> it=allList.iterator();
		while(it.hasNext()){//判断是否还有元素
			String str=it.next();
			if("__ll__".equals(str)){
				it.remove();//使用remove方法删除指定的元素
			}
			else{
				System.out.print(str+"、");//next()方法用来取出当前元素
			}
		}
		System.out.println("\n删除后的集合"+allList.toString());
	}

}

----其他

boolean retainAll(Collection coll);//取与coll集合的交集
Object[]  toArray();将集合转成对象数组<span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);"> </span>

4、Collection是接口，所以只能通过子类来实例化。如：Collection coll=new ArrayList();

注意：这里会稍微提一下之前的迭代输出的代码。迭代输出有两种写法，如下：

法一：

       Iterator it=coll.iterator();

       while(it.hasnext){

       system.out.println(it.next());

       }

法二：

       for(Iterator it=coll.iterator;it.hasnext();){

       system.out.println(it.next());

       }

比较两种方法，我们会注意到while()循环结束后，it会一直占着内存不放，而for循环不会出现这种情况。

5、迭代器的原理

迭代器，取出元素的对象，该对象必须依赖具体的容器。因为每一个容器的数据结构是不同的。所以该迭代器是在容器中进行内部的实现。对于使用容器而言，具体的实现不重要，只要通过容器获取到该实现的迭代器的对象即可。也就是iterator方法。Iterator接口就是对所有Collection容器进行元素取出的公共接口。

补充：接下来补充一个Collection.Sort()方法的实例：可以看看代码：

//collection.sort()方法的测试类，这个类还需要Students类和一个自定义比较器//Studentscomparator类

package com.wq.list;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;

import javax.swing.text.html.ListView;

/**
 * 将要完成
 * 1.通过Collections.sort(),对Integer泛型的List集合进行排序
 * @author LULEI
 *
 */

public class CollectionsTest {
	
	/**
	 * 通过Collections.sort(),对Integer泛型的List集合进行排序
	 * 使用Random类来生成不相等的随机数10个
	 */
	public void testListSort1(){
	List<Integer> integer=new ArrayList<Integer>();
		Random random=new Random();  //产生一个随机种子对象
		int k=0;
		//生成10个随机数
		for(int i=0;i<10;i++){
			do{
				k=random.nextInt(100);//生成100以内的一个随机数
			}while(integer.contains(k));//判断随机数是否重复，如果不重复就跳出while循环
			integer.add(k);		//向list集合中添加元素
			System.out.println(k+"已经成功添加");
		}
		System.out.println("-----排序前------");
		for(Integer it:integer){
			System.out.println("元素："+it);
		}
		
		//调用sort()方法来进行排序
		Collections.sort(integer);	//直接调用父方法的sort()进行排序
		System.out.println("--------排序后--------");
		for(Integer it:integer){
			System.out.println("元素："+it);
		}
	}
	/**
	 * 通过Collections.sort(),对String泛型的List集合进行排序
	 * 向List集合中添加3个字符串
	 */
	public void testListSort2()
	{
		List<String> str=new ArrayList<String>();
		str.add("microsoft");
		str.add("baidu");
		str.add("google");
		System.out.println("----排序前----");
		for(String ss:str){
			System.out.println(ss);
		}
		Collections.sort(str);
		System.out.println("----排序后----");
		for(String ss:str){
			System.out.println(ss);
		}
	}
	
	/**
	 *  通过Collections.sort(),对String泛型的List集合进行排序
	 *  向List里添加十条随机字符串
	 *  字符串的长度要不大于10
	 *  每个字符串的每个字符都是随机生成的，但可以重复
	 *  每个字符串是不可以重复的
	 * @param args
	 */
	public void testListOfString(){
		List<String> newStr=new ArrayList<String>();//用于存储字符串的
		Random randomLength=new Random();//随机生成字符串的长度
		
		//所有字符查询表
		String table="qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM1234567890";
		
		//生成10个字符串
		for(int i=0;i<10;i++){
			StringBuilder sb=new StringBuilder();//用来存储随机产生的字符串
			do{
				//确定当前字符串的长度
				
				int length=randomLength.nextInt(11);//注意每个字符串不能大于10个字符
				
				while(length==0){//避免length的值为0，否则这样就会产生空字符串
					length=randomLength.nextInt(11);
				}
				
				for(int m=0;m<length;m++){
					int pos=randomLength.nextInt(table.length());//获取字符查询表中任意一个随机的位置
					sb.append(table.charAt(pos));//将该位置上的字符添加到sb中
				}
			}while(newStr.contains(sb.toString()));//判断是否有重复的字符串，如果集合中不含有该字符串则退出while循环
			newStr.add(sb.toString());//使用toString方法转化为String类型
		}
		
		System.out.println("====排序前=====");
		for(String stBd:newStr){
			System.out.println(stBd);
		}
		//调用sort()方法进行排序
		Collections.sort(newStr);
		
		System.out.println("====排序后=====");
		for(String stBd2:newStr){
			System.out.println(stBd2);
		}
		Collections.sort(newStr);
	}
	/**
	 * 如何给Students类型的List集合元素进行排序
	 * 直接使用Collections.sort()方法是不行的，必须先让Students类继承comparable接口
	 * 并且覆写comparable接口的compareTo()方法。然后确定新的比较规则：此处我们设置如下
	 * this.id.compareTo(o.id);通过比较id号的字符大小顺序来进行排序
	 * @param args
	 */
	public void testStudentsList(){
		List<Students> liStu=new ArrayList<Students>();//实例化一个集合，用来存储Students对象
		Random random=new Random();//生成随机种子用于随机生成几个不相等的id号
		//添加3个Students的对象
		liStu.add(new Students(Integer.toString(random.nextInt(1000)), "tim"));
		liStu.add(new Students(Integer.toString(random.nextInt(1000)), "jack"));
		liStu.add(new Students(Integer.toString(random.nextInt(1000)), "lucy"));
		liStu.add(new Students(Integer.toString(100000), "lily"));
		/*
		 * 直接使用Collections.sort()方法是不行的，必须先让Students类继承comparable接口
		 * 并且覆写comparable接口的compareTo()方法。然后确定新的比较规则：此处我们设置如下
		 * this.id.compareTo(o.id);通过比较id号的字符大小顺序来进行排序
		 */
		System.out.println("=====排序前====");
		for(Students stu:liStu){
			System.out.println(stu.getId()+"."+stu.getName());
		}
		Collections.sort(liStu);
		
		System.out.println("=====排序后====");
		for(Students stu:liStu){
			System.out.println(stu.getId()+"."+stu.getName());
		}
		
		/**
		 * 接下来是用comparator接口来确定新的临时比较规则：使用姓名来排序
		 * 过程如下：1、定义一个StudentComparator类，然后
		 * 让这个类继承comparator接口，然后覆写该接口的compare()方法
		 * 2、然后调用Collections.sort()方法来进行排序
		 */
		Collections.sort(liStu,new StudentsComparator());
		System.out.println("-------按照名字进行排序---------");
		System.out.println("=====排序后====");
		for(Students stu:liStu){
			System.out.println(stu.getId()+"."+stu.getName());
		}
	}
	
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		CollectionsTest ct=new CollectionsTest();
		//排序Integer类型的List
		ct.testListSort1();
		//排序String类型的List
	//	ct.testListSort2();
		//排序随机生成的String类型的List
		ct.testListOfString();
		//排序Students类
		ct.testStudentsList();
	}

}

//Students类
package com.wq.list;

import java.util.HashSet;
import java.util.Set;
/**
 * 学生类
 * @author LULEI
 *
 */
public class Students implements Comparable<Students>{
	private String name;
	private String id;
	public Set<Courses> courses;//用于后面添加课程
	
	public Students(String id,String name){
		this.setId(id);
		this.setName(name);
		//Set是一个接口，不能直接实例化，通过HashSet()对courses进行实例化
		this.courses=new HashSet<Courses>();
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (!(obj instanceof Students))
			return false;
		Students other = (Students) obj;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
	@Override
	public int compareTo(Students o) {
		// TODO Auto-generated method stub
		//将比较规则设置为id号
		return this.id.compareTo(o.id);
	}
	
}

//StudentsComparator类
package com.wq.list;

import java.util.Comparator;

public class StudentsComparator implements Comparator<Students> {

	@Override
	public int compare(Students o1, Students o2) {
		// TODO Auto-generated method stub
		//将规则改成比较名字
		return o1.getName().compareTo(o2.getName());
	}

}

运行结果如下：
57已经成功添加
22已经成功添加
65已经成功添加
52已经成功添加
27已经成功添加
90已经成功添加
38已经成功添加
77已经成功添加
47已经成功添加
21已经成功添加
-----排序前------
元素：57
元素：22
元素：65
元素：52
元素：27
元素：90
元素：38
元素：77
元素：47
元素：21
--------排序后--------
元素：21
元素：22
元素：27
元素：38
元素：47
元素：52
元素：57
元素：65
元素：77
元素：90
====排序前=====
Zj
gkjvUfLB
WgPiL3VX
Xj2DtAtL9
kyrkT9ILYa
G
s0FfBD
bZR
eDA
pVihS
====排序后=====
G
WgPiL3VX
Xj2DtAtL9
Zj
bZR
eDA
gkjvUfLB
kyrkT9ILYa
pVihS
s0FfBD
=====排序前====
319.tim
606.jack
464.lucy
100000.lily
=====排序后====
100000.lily
319.tim
464.lucy
606.jack
-------按照名字进行排序---------
=====排序后====
606.jack
100000.lily
464.lucy
319.tim

这一篇先写到这，下一篇我将说说Collection的子类。