java集合框架--List、Set、Map

1.List：有序的 collection（也称为序列）。此接口可以对列表中每个元素的插入位置进行精确地控制。可以根据元素的在列表中的位置访问元素，并搜索列表中的元素。列表允许重复的元素。

   ArrayList:

   特点：有序的、线性的、无固定大小的、有下标的、先进先出

   简单操作应用：

public static void main(String args[]) {

		// 创建一个队列对象
		java.util.ArrayList<String> list = new java.util.ArrayList<String>();

		// 装入10个数据
		for (int i = 0; i < 10; i++) {
			String s = "元素" + i;
			//加元素
			list.add(s);
		}

		// 遍历1
		for (int i = 0; i < list.size(); i++) {
			// 根据下标取出一个元素
			String str = list.get(i);
			System.out.print(str+"\t");
		}
		
		System.out.println();
		
		//遍历2
		//得到队列的迭代器对象
		java.util.Iterator<String> iter = list.iterator();
		//判断是否有数据可以迭代
		while(iter.hasNext()){
			//取出一个元素
			String str = iter.next();
			System.out.print(str+"\t");
			
		}
		
		System.out.println();
		
		//遍历3
		for(String str:list){
			System.out.print(str+"\t");
		}

	}

   

 

2.Set:是简单的集合，它的对象不按特定方式排序，只是简单的把对象加入集合中。不能有重复对象。

 

   HashSet:

 

   特点：无序的，长度可变的，不可重复的

 

   简单的操作应用：

public static void main(String args[]) {

		// 创建一个容器对象
		java.util.HashSet<String> sets = new java.util.HashSet<String>();

		// 装入10个元素
		for (int i = 0; i < 10; i++) {
			String s = "元素a" + i;
			sets.add(s);
		}

		//检验若输入加入重复的元素，在集合中的是原来的还是新加入的（结果表明是原来的）
		boolean b = sets.add("新来的");
		boolean b1 = sets.add("新来的");
		System.out.println(b + "<>" + b1);
		// 遍历1
		// 得到迭代器对象
		java.util.Iterator<String> iter = sets.iterator();
		while (iter.hasNext()) {
			String str = iter.next();
			System.out.print(str + "\t");
		}
		
		System.out.println();
		
		//遍历2
		for(String str:sets){
			
			System.out.print(str+"\t");
		}

	}

 

 

3.Map:Map中存入的对象是一对一对的，即每个对象和它的一个名字（键：key）关联在一起，一个键（key）只能对应一个值（value）,反则不然。

 

   HashMap:

 

   特点：无序的、不可重复的

 

   简单的操作应用：

public static void main(String args[]) {

		// 创建一个映射对象
		java.util.HashMap<Integer, String> maps = new java.util.HashMap<Integer, String>();

		// 装入键值对
		for (int i = 0; i < 20; i++) {

			int num = i * 1000;
			String name = "学生" + i;

			// 装入一个键值对
			maps.put(num, name);

		}
		
		//增加一个键值对，加入K相同的键值对，则会替换已经存在的键值对
		maps.put(30000, "新学生");
		maps.put(40000, "新学生");
		
		maps.put(40000, "又来一个");
		
		
		//遍历
		//得到K的Set集合
		java.util.Set<Integer> set = maps.keySet();
		//遍历K的集合，得到set的迭代器
		java.util.Iterator<Integer> iter = set.iterator();
		while(iter.hasNext()){
			//取出一个key
			int num = iter.next();
			//根据key得到对应的Value
			String name = maps.get(num);
			
			System.out.println(num+"\t"+name);
		}

 

 

 

两个应用：

1.package hpw.collection;

/**
 * 任意的一个数组，重复排序
 * 
 * @author 
 * 
 */
public class Task1 {

	public static void main(String args[]) {

		// 创建一个数组
		int[] array = new int[] { 133, 345, 467, 45, 786, 133, 456, 89, 45,
				299, 786, 467, 123, 456 };

		int[] temp = RemoveRepeat(array);
		// 出去重复后，打印数组
		for (int i = 0; i < temp.length; i++) {
			System.out.print(temp[i] + "\t");
		}
		
		System.out.println();
		
		int[] newarray = sort(temp);
		// 排序后，打印数组
		for (int i = 0; i < newarray.length; i++) {
			System.out.print(newarray[i] + "\t");
		}

	}

	/**
	 * 去除数组中重复的元素
	 * 
	 * @param base
	 *            ：要去除的数组
	 * @return：去除重复后的数组
	 */
	public static int[] RemoveRepeat(int[] base) {

		// 创建一个集合
		java.util.HashSet<Integer> sets = new java.util.HashSet<Integer>();

		// 遍历数组，将元素装入集合
		for (int i = 0; i < base.length; i++) {

			int temp = base[i];
			// 将元素装入集合
			sets.add(temp);
		}


		//创建一个新的数组
		int[] newarry=new int[sets.size()];
		
		// 得到迭代器
		java.util.Iterator<Integer> ite = sets.iterator();
		
		// 遍历集合，将元素装入队列
		for (int i = 0; ite.hasNext(); i++) {

			newarry[i] = ite.next();
		}

		return newarry;
	}

	/**
	 * 将数组排序
	 * 
	 * @param base
	 *            ：原数组
	 * @return:排序后的数组
	 */
	//冒泡排序
	public static int[] sort(int[] base){
		
		for(int i=0;i<base.length;i++){
			
			for(int j=i+1;j<base.length;j++){
				
				if(base[i]>base[j]){
					int temp=base[i];
					base[i]=base[j];
					base[j]=temp;
				}
			}
		}
		
		return base;
	}
}

 

    2.package hpw.collection;

import java.util.HashMap;

/**
 * 统计重复
 * @author lenovo
 *
 */
public class Task2 {
	
	public static void main(String args[]){
		
		// 创建一个数组
		int[] array = new int[] { 133, 345, 467, 45, 786, 133, 456, 89, 45,
				299, 786, 467, 123, 456,45 };
		
		//创建一个映射
		java.util.HashMap<Integer, Integer> map=new java.util.HashMap<Integer, Integer>();
		//统计
		map=count(array);
		//打印
		print(map);
		
	}

	/**
	 * 统计出现的次数
	 * @param base：原数组
	 * @return：java.util.HashMap<Integer：数组元素, Integer：出现的次数>
	 */
	public static java.util.HashMap<Integer, Integer> count(int[] base){
		//创建一个映射
		java.util.HashMap<Integer, Integer> maps=new java.util.HashMap<Integer, Integer>();
		
		//遍历数组，出现重复，value+1
		for(int i=0;i<base.length;i++){
			//判断是否出现重复
			if(maps.containsKey(base[i])){
				
				int value=maps.get(base[i])+1;
				maps.put(base[i], value);
			}else{
				
				maps.put(base[i], 1);
			}
		}
		
		return maps;
	}
	
	/**
	 * 打印队列
	 * @param map
	 */
	public static void print(HashMap<Integer, Integer> map){
		//创建一个集合，得到K的元素
		java.util.Set<Integer> set=map.keySet();
		
		//遍历集合，获得迭代器
		java.util.Iterator<Integer> ite=set.iterator();
		while(ite.hasNext()){
			//去除key
			int key=ite.next();
			//得到相应的value
			int value=map.get(key);
			
			System.out.println(key+"\t"+value);
		}
		
		
	}
}