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


 

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

   ArrayList: 

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

   简单操作应用：

public static void main(String args[]) {

Java代码  收藏代码
  1. // 创建一个队列对象  
  2. java.util.ArrayList<String> list = new java.util.ArrayList<String>();  
  3.   
  4. // 装入10个数据  
  5. for (int i = 0; i < 10; i++) {  
  6.     String s = "元素" + i;  
  7.     //加元素  
  8.     list.add(s);  
  9. }  
  10.   
  11. // 遍历1  
  12. for (int i = 0; i < list.size(); i++) {  
  13.     // 根据下标取出一个元素  
  14.     String str = list.get(i);  
  15.     System.out.print(str+" ");  
  16. }  
  17.   
  18. System.out.println();  
  19.   
  20. //遍历2  
  21. //得到队列的迭代器对象  
  22. java.util.Iterator<String> iter = list.iterator();  
  23. //判断是否有数据可以迭代  
  24. while(iter.hasNext()){  
  25.     //取出一个元素  
  26.     String str = iter.next();  
  27.     System.out.print(str+" ");  
  28.       
  29. }  
  30.   
  31. System.out.println();  
  32.   
  33. //遍历3  
  34. for(String str:list){  
  35.     System.out.print(str+" ");  
  36. }  
   

 

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

 

   HashSet:

 

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

 

   简单的操作应用：

public static void main(String args[]) {

Java代码  收藏代码
  1. // 创建一个容器对象  
  2. java.util.HashSet<String> sets = new java.util.HashSet<String>();  
  3.   
  4. // 装入10个元素  
  5. for (int i = 0; i < 10; i++) {  
  6.     String s = "元素a" + i;  
  7.     sets.add(s);  
  8. }  
  9.   
  10. //检验若输入加入重复的元素，在集合中的是原来的还是新加入的（结果表明是原来的）  
  11. boolean b = sets.add("新来的");  
  12. boolean b1 = sets.add("新来的");  
  13. System.out.println(b + "<>" + b1);  
  14. // 遍历1  
  15. // 得到迭代器对象  
  16. java.util.Iterator<String> iter = sets.iterator();  
  17. while (iter.hasNext()) {  
  18.     String str = iter.next();  
  19.     System.out.print(str + " ");  
  20. }  
  21.   
  22. System.out.println();  
  23.   
  24. //遍历2  
  25. for(String str:sets){  
  26.       
  27.     System.out.print(str+" ");  
  28. }  

 

 

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

 

   HashMap:

 

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

 

   简单的操作应用：

public static void main(String args[]) {

Java代码  收藏代码
  1. // 创建一个映射对象  
  2. java.util.HashMap<Integer, String> maps = new java.util.HashMap<Integer, String>();  
  3.   
  4. // 装入键值对  
  5. for (int i = 0; i < 20; i++) {  
  6.   
  7.     int num = i * 1000;  
  8.     String name = "学生" + i;  
  9.   
  10.     // 装入一个键值对  
  11.     maps.put(num, name);  
  12.   
  13. }  
  14.   
  15. //增加一个键值对，加入K相同的键值对，则会替换已经存在的键值对  
  16. maps.put(30000, "新学生");  
  17. maps.put(40000, "新学生");  
  18.   
  19. maps.put(40000, "又来一个");  
  20.   
  21.   
  22. //遍历  
  23. //得到K的Set集合  
  24. java.util.Set<Integer> set = maps.keySet();  
  25. //遍历K的集合，得到set的迭代器  
  26. java.util.Iterator<Integer> iter = set.iterator();  
  27. while(iter.hasNext()){  
  28.     //取出一个key  
  29.     int num = iter.next();  
  30.     //根据key得到对应的Value  
  31.     String name = maps.get(num);  
  32.       
  33.     System.out.println(num+" "+name);  
  34. }  

 

 

 

两个应用：

1.package hpw.collection;

Java代码  收藏代码
  1. /** 
  2.  * 任意的一个数组，重复排序 
  3.  *  
  4.  * @author  
  5.  *  
  6.  */  
  7. public class Task1 {  
  8.   
  9.     public static void main(String args[]) {  
  10.   
  11.         // 创建一个数组  
  12.         int[] array = new int[] { 133, 345, 467, 45, 786, 133, 456, 89, 45,  
  13.                 299, 786, 467, 123, 456 };  
  14.   
  15.         int[] temp = RemoveRepeat(array);  
  16.         // 出去重复后，打印数组  
  17.         for (int i = 0; i < temp.length; i++) {  
  18.             System.out.print(temp[i] + " ");  
  19.         }  
  20.           
  21.         System.out.println();  
  22.           
  23.         int[] newarray = sort(temp);  
  24.         // 排序后，打印数组  
  25.         for (int i = 0; i < newarray.length; i++) {  
  26.             System.out.print(newarray[i] + " ");  
  27.         }  
  28.   
  29.     }  
  30.   
  31.     /** 
  32.      * 去除数组中重复的元素 
  33.      *  
  34.      * @param base 
  35.      *            ：要去除的数组 
  36.      * @return：去除重复后的数组 
  37.      */  
  38.     public static int[] RemoveRepeat(int[] base) {  
  39.   
  40.         // 创建一个集合  
  41.         java.util.HashSet<Integer> sets = new java.util.HashSet<Integer>();  
  42.   
  43.         // 遍历数组，将元素装入集合  
  44.         for (int i = 0; i < base.length; i++) {  
  45.   
  46.             int temp = base[i];  
  47.             // 将元素装入集合  
  48.             sets.add(temp);  
  49.         }  
  50.   
  51.   
  52.         //创建一个新的数组  
  53.         int[] newarry=new int[sets.size()];  
  54.           
  55.         // 得到迭代器  
  56.         java.util.Iterator<Integer> ite = sets.iterator();  
  57.           
  58.         // 遍历集合，将元素装入队列  
  59.         for (int i = 0; ite.hasNext(); i++) {  
  60.   
  61.             newarry[i] = ite.next();  
  62.         }  
  63.   
  64.         return newarry;  
  65.     }  
  66.   
  67.     /** 
  68.      * 将数组排序 
  69.      *  
  70.      * @param base 
  71.      *            ：原数组 
  72.      * @return:排序后的数组 
  73.      */  
  74.     //冒泡排序  
  75.     public static int[] sort(int[] base){  
  76.           
  77.         for(int i=0;i<base.length;i++){  
  78.               
  79.             for(int j=i+1;j<base.length;j++){  
  80.                   
  81.                 if(base[i]>base[j]){  
  82.                     int temp=base[i];  
  83.                     base[i]=base[j];  
  84.                     base[j]=temp;  
  85.                 }  
  86.             }  
  87.         }  
  88.           
  89.         return base;  
  90.     }  
  91. }  

 

    2.package hpw.collection;

Java代码  收藏代码
  1. import java.util.HashMap;  
  2.   
  3. /** 
  4.  * 统计重复 
  5.  * @author lenovo 
  6.  * 
  7.  */  
  8. public class Task2 {  
  9.       
  10.     public static void main(String args[]){  
  11.           
  12.         // 创建一个数组  
  13.         int[] array = new int[] { 133, 345, 467, 45, 786, 133, 456, 89, 45,  
  14.                 299, 786, 467, 123, 456,45 };  
  15.           
  16.         //创建一个映射  
  17.         java.util.HashMap<Integer, Integer> map=new java.util.HashMap<Integer, Integer>();  
  18.         //统计  
  19.         map=count(array);  
  20.         //打印  
  21.         print(map);  
  22.           
  23.     }  
  24.   
  25.     /** 
  26.      * 统计出现的次数 
  27.      * @param base：原数组 
  28.      * @return：java.util.HashMap<Integer：数组元素, Integer：出现的次数> 
  29.      */  
  30.     public static java.util.HashMap<Integer, Integer> count(int[] base){  
  31.         //创建一个映射  
  32.         java.util.HashMap<Integer, Integer> maps=new java.util.HashMap<Integer, Integer>();  
  33.           
  34.         //遍历数组，出现重复，value+1  
  35.         for(int i=0;i<base.length;i++){  
  36.             //判断是否出现重复  
  37.             if(maps.containsKey(base[i])){  
  38.                   
  39.                 int value=maps.get(base[i])+1;  
  40.                 maps.put(base[i], value);  
  41.             }else{  
  42.                   
  43.                 maps.put(base[i], 1);  
  44.             }  
  45.         }  
  46.           
  47.         return maps;  
  48.     }  
  49.       
  50.     /** 
  51.      * 打印队列 
  52.      * @param map 
  53.      */  
  54.     public static void print(HashMap<Integer, Integer> map){  
  55.         //创建一个集合，得到K的元素  
  56.         java.util.Set<Integer> set=map.keySet();  
  57.           
  58.         //遍历集合，获得迭代器  
  59.         java.util.Iterator<Integer> ite=set.iterator();  
  60.         while(ite.hasNext()){  
  61.             //去除key  
  62.             int key=ite.next();  
  63.             //得到相应的value  
  64.             int value=map.get(key);  
  65.               
  66.             System.out.println(key+" "+value);  
  67.         }  
  68.           
  69.           
  70.     }  
  71. }  

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/baiduligang/p/4247675.html