Java.集合框架及集合类

上一次给大家分享了一些数组和动态数组的概念，说到数组，不难想到容器，数组是一种最简单的容量固定的容器，后面我们又引出了可变容量容器-------动态数组，在今天这一讲里我们主要讲集合类和集合框架。集合框架是预定义在java.util包中的一类数据结构。

集合类与数组的不同之处是，数组的长度是固定的，集合的长度是可变的，数组用来存放基本类型的数据，而集合用来存放对象的引用。常用的集合有List集合（列表），Set集合和Map集合（映射），其中List与Set继承了Collection接口。

1.List：是有序的Collection，常用List实现类是：

ArrayList类
LinkedList类

Stack（栈）
Vector(向量)

1.1. ArrayList:数组序列：有序的，可重复的，长度可变的，有下标的数据结构。
优点：因为地址连续，一旦数据存储好了，查询操作效率比较高。
缺点：因为地址连续，插入和删除操作效率比较低。不是线程同步的。

例1：班上有20位同学，学号是从1001~1020，从班上抽出1个一等奖，2个二等奖，5个三等奖，8个安慰奖，
 所有获奖的人不能重复。

import java.util.*;
public class prize {
	public static void main(String []args){
	   ArrayList list1=new ArrayList();
	   for(int i=0;i<20;i++){
		   list1.add(2001+i);
		   
	   }
	   //创建随机数对象
	   Random rd=new Random();
		//抽取一等奖
		int index=rd.nextInt(list1.size());//随机一个下标
		Object obj=list1.remove(index);
		System.out.println("一等奖是："+obj);
		//将抽到的数据移除;
		
		
	  for(int i=0;i<2;i++){
		  int index1=rd.nextInt(list1.size());
		  Object obj1=list1.remove(index1);
		  System.out.println("二等奖是："+obj1);
		  
	  }
	  for(int i=0;i<5;i++){
		  int index2=rd.nextInt(list1.size());
		  Object obj2=list1.remove(index2);
		  System.out.println("三等奖是："+obj2);
		  
	  }
	  for(int i=0;i<8;i++){
		  int index3=rd.nextInt(list1.size());
		  Object obj3=list1.remove(index3);
		  System.out.println("安慰奖是："+obj3);
		  
	  }
	}

 运行结果：

 

一等奖是：2012
二等奖是：2010
二等奖是：2014
三等奖是：2002
三等奖是：2004
三等奖是：2020
三等奖是：2001
三等奖是：2006
安慰奖是：2016
安慰奖是：2003
安慰奖是：2017
安慰奖是：2018
安慰奖是：2007
安慰奖是：2015
安慰奖是：2005
安慰奖是：2009

 1.2. LinkedList:链表，链式序列， 有序的，可重复的，长度可变的，有下标，地址任意,各个数据之间通过引用关联
优势：由于地址是任意的，非常适合进行插入和删除的操作。
缺点：查询性能比较低。

例2.为LinkedList列表添加元素，并选择移除元素。

public class LinkedListDemo {

	public static void main(String[] args) {
		// 创建链表对象
		LinkedList<String> list = new LinkedList<String>();

		// 加入元素
		list.add("元素一");
		list.offer("元素二");
		list.addLast("元素三");
		list.offerLast("元素四");
		list.addFirst("元素五");
		list.add(0, "元素六");
		
		list.remove(3);

		 for(int i=0;i<list.size();i++){
		 String str = list.get(i);
		 System.out.println(str);
		 }

 运行结果：

 

元素六
元素五
元素一
元素三
元素四

1.3. 向量Vector：Vector和ArraryList都是大小可变数组的实现,使用方法与ArraryList一样。
区别：ArraryList不是同步的
          Vector是同步的，在多线程中一般采用Vector。
栈 Stack : 后进先出，最先放入的数据在栈的底部，最后放的数据在栈的底部，  每次取数据只能取到栈顶的数据.其中Stack是Vector的子类。

 

例3.

public class StackDemo {

	public static void main(String[] args) {
		
		//创建一个栈对象
		Stack<String> stack = new Stack<String>();	
		//将数据压入栈
		stack.push("张三");
		stack.push("李四");
		stack.push("王五");	
		//查看栈顶的对象
		String str = stack.peek();
		System.out.println(str);
		//获取并移除栈顶对象  将数据弹出栈
		String str2 = stack.pop();
		System.out.println(str2);	
		String str3 = stack.pop();
		System.out.println(str3);
	}
	
	
} 运行结果：

 

王五
王五
李四

2. 集合  :Set:无重复的Collection.必须使用迭代器才能获取数据。
常用的Set实现类：
      HashSet：无序的，不可重复的，长度可变的
     TreeSet:根据的内容的自然顺序（阿斯克码）进行排序。

 

 例4. 创建一个HashSet集合，并获取数据。

  

import java.util.*;
public class Setdome {
   public static void main (String[]args){
	  HashSet set=new HashSet();
	  set.add("a张三");
	  set.add("a李四");
	  set.add("a王五");
	  //取出元素
	  //1.将set中的数据放入迭代器，并返回迭代器；
	  Iterator iter=set.iterator();
	  //2.开始迭代
	  while(iter.hasNext()){
		  Object obj=iter.next();
		  System.out.println(obj);
	  }
	  //加强版的迭代器
//	  for(Object obj:set){
//		  System.out.println(obj);
//	  }
	   
	   
   }

   运行结果：

a王五
a李四
a张三

 例5.     有一个数组，String [] tst={"小六子"，“小顺子”，“张三丰”，“小六子”，“周芷若”，“赵敏”，“张三丰”，“周芷若”，“谢逊”，“伯通”};去掉重复名字在进行排序。

 

package com.zjx.List;
import java.util.*;
public class SetDemo1 {
     public static void main(String[]args){
    	 //创建数组
    	TreeSet tst=new TreeSet();
    	//添加数据
    	tst.add("小六子");
    	tst.add("小顺子");
    	tst.add("张三丰");
    	tst.add("小六子");
    	tst.add("周芷若");
    	tst.add("赵敏");
    	tst.add("张三丰");
    	tst.add("周芷若");
    	tst.add("谢逊");
    	tst.add("伯通");
    	//方法一
    	Iterator iter=tst.iterator();
    	while(iter.hasNext()){
    		Object obj=iter.next();
    		System.out.println(obj);
    	}
    }
}

 运行结果：

伯通
周芷若
小六子
小顺子
张三丰
谢逊
赵敏

 3.映射:Map:将键映射到值得一种结构，键是一个Set,键不能重复，每个键都对应一个值。
 常用的Map实现类：
 HashMap：键是一个HashSet，k是一个HashSet
 TreeMap： 键是一个TreeSet, k是一个TreeSet
 所有的k不能重复，每个k都对应一个Value
 如果在加入额外数据的时候，出现相同的key，则替换掉原来的Value

例6.创建一个HashMap类，添加数据，并获取数据

import java.util.*;
public class HashMapDemo {
     public static void main(String[]args){
    	 
    	 //创建HashMap对象
    	 HashMap<Integer,String> map=new HashMap<Integer,String>();
    	 map.put(1011, "张三");
    	 map.put(1012, "李四");
    	 map.put(1013, "王五");
    	 map.put(1014, "赵六");
    	 //取出数据
    	 //1.取出的k
    	 Set set= map.keySet();
    	 Iterator iter=set.iterator();
    	 while( iter.hasNext()){
    		 Object key =iter.next();
    		String value=map.get(key);
    		System.out.println(key+""+value); 
    	 }
    	 
    	 
    	 
     }
}

 运行结果：

1011张三
1012李四
1013王五
1014赵六

 例7.String str =“abbbccccdddffffgg”，统计这个字符串中每个字符出现的次数，其中Map, K:字符，V：出现的次数

 

import java.util.*;
public class mapdemo {
  public static void main(String []args){
	  
	HashMap<Character,Integer> map= new HashMap<Character,Integer>();
	  String str="abbbccccdddffffgg";
	  for(int i=0;i<str.length();i++){
		  char c=str.charAt(i);
		boolean b=map.containsKey(c);
		if(b){
			int value =map.get(c);
			value++;
			map.put(c, value);
		}else   {
			map.put(c, 1);
		}	  
		  
	  }
	  	 
	 Set<Character> set=map.keySet();
	 Iterator<Character> iter=set.iterator();
	 while (iter.hasNext()){
		char key=iter.next();
		int value=map.get(key);
		System.out.println(key+"出现："+value+"次");
		 
	 }
	  	  
  }
}

 运行结果：

f出现：4次
g出现：2次
d出现：3次
b出现：3次
c出现：4次
a出现：1次