java集合框架总结

[size=small][/size]
java中的集合框架都是线性的数据结构，它相当于一种容器，可以存储数据。集合框架总共可以分为四类：List，Map，Set以及Queue，其中前三种较为常用。
[color=blue]1、Set：[/color]Set是一个接口，它的实现类有java.util.HashSet以及java.util.TreeSet，Set的特点是无序存储，所以如果要打印出Set中的所有元素就必须要定义一个迭代器Iterator来进行遍历并且输出。用Set实现数据的删除重复元素并且排序如下：
public class SetTest {

public static void main(String [] args){
set = createSet(10);
printSet(set);
java.util.List<Integer> list = sort(set);
System.out.println("排序后的set为：=============================》");
printList(list);
}

//创建一个大小为count的Set
public static java.util.Set<Integer> createSet(int count){
java.util.Set<Integer> set = new java.util.HashSet<Integer>();
java.util.Random random = new java.util.Random();
for(int i=1;i<=count;i++){
int value = random.nextInt(20);
//System.out.println("I am random:"+value);
set.add(value);
//System.out.println("I m i:"+i);
//printSet(set);
//System.out.println("==========================================>");
}
return set;
}

//打印整个Set
public static void printSet(java.util.Set<Integer> set){
//迭代器
java.util.Iterator<Integer> it = set.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}

public static void printList(java.util.List<Integer> list){
for(int i=0;i<list.size();i++){
System.out.println(list.get(i));
}
}

//排序：由小到大，将Set中取出的最小值，次小值等依次放入一个list
public static java.util.List<Integer> sort(java.util.Set<Integer> set){
java.util.List<Integer> list = new java.util.ArrayList<Integer>();
int m=0;
//java.util.Set<Integer> newset = createSet(12);
for(int i=0;i<set.size()+m;i++){
java.util.Iterator<Integer> it = set.iterator();
int min = it.next();
System.out.println("I am the schedule min:"+min);
while(it.hasNext()){
int value = it.next();
if(min > value){
min = value;
System.out.println("I am min:"+min);
}
}
list.add(min);
set.remove(min);
m++;
System.out.println("this set has removed min:=================");
printSet(set);
}
return list;
}

private static java.util.Set<Integer> set = new java.util.HashSet<Integer>();

}
[color=blue]2、List：[/color]实现了依据某种特定顺序进行有序存储，List接口的常用实现类是java.util.Vector以及java.util.ArrayList。基本操作代码为：
public class ListTest {

public static void main(String [] args){
java.util.List<String> list = creatList();
printList(list);
System.out.println("删除重复元素后List为：==========================>");
dlRepeat(list);
printList(list);
System.out.println("此时长度变为"+list.size());
printList(sort(list));
}

//创建一个新的list
public static java.util.List<String> creatList(){
java.util.List<String> list = new java.util.ArrayList<String>();
//for(int i=0;i<5;i++){
//int m = i+10;
//list.add(m+" ");
//}
//随机赋值
java.util.Random random = new java.util.Random();
for(int i=0;i<15;i++){
int value = random.nextInt(10);
list.add(value+"");
}
return list;
}

//打印整个list
public static void printList(java.util.List<String> list){
for(int i=0;i<list.size();i++){
System.out.println(list.get(i));
}
}

//删除重复的元素
public static void dlRepeat(java.util.List<String> list){
for(int i=0;i<list.size();i++){
if(list.get(i) == null){

}else{
for(int j=i+1;j<list.size();j++){
//System.out.println("i is: "+list.get(i));
//System.out.println("j is: "+list.get(j));
String value = list.get(i);
if(value.equals(list.get(j))){
System.out.println("i appear is: "+list.get(i)
+" j remove is: "+list.get(j));
list.remove(j);
}
//System.out.println("I am the :"+j);
}
}
}
}

//排序
public static java.util.List<String> sort(java.util.List<String> list){
//java.util.List<Integer > newlist = new java.util.ArrayList<Integer>();
//System.out.println(max.charAt(0));
//System.out.println(list.get(1).charAt(0));
for(int i=0;i < list.size() ; i++){
int min = i;
for(int j=i+1;j<list.size();j++){
if(list.get(min).charAt(0) > list.get(j).charAt(0))
min = j;
}
String temp = list.get(min);
String temp1 = list.get(i);
list.set(min, temp1);
list.set(i, temp);
}
return list;
}
}
[color=blue]3、Map：[/color]Map实现了一种一对一的存储关系，也叫做映射，分为键值和值两个部分，其中键值不能重复，如果一个map中已经存在某一键值的对应值，如(5,11)再添加时，map.add(5.21)，21会覆盖之前的值，但是map中允许值的重复出现。
基本操作代码如下：
public class MapTest {

public static void main(String [] args){
java.util.Map<Integer, Integer> map = createMap(10);
printMap(map);
dlRepeat(map);
System.out.println("the map has deleted:========================");
printMap(map);
java.util.Map<Integer, Integer> newmap = sort(map);
System.out.println("the map has sorted:=========================");
printMap(newmap);
}

//创建一个Map，并进行随机赋值
public static java.util.Map<Integer, Integer> createMap(int count){
java.util.Map<Integer, Integer> map = new java.util.HashMap<Integer, Integer>();
java.util.Random random = new java.util.Random();
for(int i=0;i<count;i++){
int value = random.nextInt(10);
map.put(i, value);
}
return map;
}

//打印Map(需要用到map.KeySet将map中的key作为一个Set存储，进行遍历)
public static void printMap(java.util.Map<Integer, Integer> map){
java.util.Set<Integer> set = map.keySet();
java.util.Iterator<Integer> it = set.iterator();
while(it.hasNext()){
int value = it.next();
System.out.println("key is:"+value+" and the value is:"+map.get(value));
}
}



//删除赋初始值时的重复元素
public static java.util.Map<Integer,Integer> dlRepeat(java.util.Map<Integer, Integer> map){
int m = 0;
for(int i=0;i<map.size()+m;i++){
if(map.get(i) == null){

}else{
System.out.println("i is:"+map.get(i));
for(int j=i+1;j<map.size()+m;j++){
System.out.println("j is:"+map.get(j));
if(map.get(i).equals(map.get(j))){
System.out.println("they are same,delete!");
map.remove(j);
m++;
}
}
}
}
return map;
}

//对已删除重复元素的Map进行排序
public static java.util.Map<Integer, Integer> sort(java.util.Map<Integer, Integer> map){
java.util.Set<Integer> set = map.keySet();
java.util.Map<Integer, Integer> newmap = createMap(0);
int m = 0,n=0;
for(int i=0;i<set.size()+m;i++){
java.util.Iterator<Integer> it = set.iterator();
int min = it.next();
System.out.println("I am the schedule min:"+min);
while(it.hasNext()){
int value = it.next();
if(map.get(min) > map.get(value)){
min = value;
System.out.println("I am min:"+min);
}
}
newmap.put(n, map.get(min));
n++;
set.remove(min);
m++;
}
return newmap;
}

}