(集合操作)商品的匹配问题

古城微笑少年丶 2022-05-28 23:54 175阅读 0赞

参照链接 : [链接][Link 1] [链接2][2]

一、list与Set、Map 区别及适用场景

Collection  
    --List：将以特定次序存储元素。所以取出来的顺序可能和放入顺序不同。

--**ArrayList / LinkedList / Vector**

--Set ： 不能含有重复的元素

--**HashSet / TreeSet/** **LinkedHashSet**

#####              HashSet:打印结果与插入顺序无关            #####

#####              TreeSet:按升序/降序排列         #####

#####              LinkedHashSet:打印结果与插入顺序一致 #####

Map

--HashMap

--HashTable

--TreeMap

1、List,Set都是继承自Collection接口，Map则不是

2、List特点：元素有放入顺序，元素可重复 ，Set特点：元素无放入顺序，元素不可重复，重复元素会覆盖掉，（注意：元素虽然无放入顺序，但是元素在set中的位置是有该元素的HashCode决定的，其位置其实是固定的，加入Set 的Object必须定义equals()方法 ，另外list支持for循环，也就是通过下标来遍历，也可以用迭代器，但是set只能用迭代，因为他无序，无法用下标来取得想要的值。）

3.Set和List对比：   
Set：检索元素效率低下，删除和插入效率高，插入和删除不会引起元素位置改变。   
List：和数组类似，List可以动态增长，查找元素效率高，插入删除元素效率低，因为会引起其他元素位置改变。

4.Map适合储存键值对的数据

5.线程安全集合类与非线程安全集合类

LinkedList、ArrayList、HashSet是非线程安全的，Vector是线程安全的;  
HashMap是非线程安全的，HashTable是线程安全的;  
StringBuilder是非线程安全的，StringBuffer是线程安全的。

二、list与Map遍历

import java.util.*;
    //商品的匹配问题(涉及List和map遍历问题)
    public class List_Map{
    	
     
    	public static void main(String[]args)
    	{
            List<Integer>order=new ArrayList<Integer>();
            order.add(1);
            order.add(2);
            order.add(3);
             
            //第一种方式 foreach
            for(Integer in:order)
            {
            	System.out.print(in);
            }
            System.out.println();
            //第二种方式 for循环
            for(int i=0;i<order.size();i++)
            {
         
            	System.out.print(order.get(i));
            }
            System.out.println();
            //第三种方式 采取迭代器的方式
            Iterator <Integer>iterator=order.iterator();
            while(iterator.hasNext())
            {
            	System.out.print(iterator.next());
            }
             //第四种遍历，把链表变为数组相关的内容进行遍历
           // String[] strArray=new String[order.size()];
           //  order.toArray(strArray);
           // for(int i=0;i<strArray.length;i++) //这里也可以改写为  foreach(String str:strArray)这种形式
           // {
           //  System.out.println(strArray[i]);
           // }
           
            System.out.println();
            Map <String,Integer>map=new HashMap<String,Integer>();
            map.put("bom1",2);
            map.put("bom2",3);
            map.put("bom3",1);
            map.put("bom4",4);
            //第一种遍历方式(二次遍历)
            for(String key:map.keySet())
            {
            	System.out.println(key+" "+map.get(key));
            }
    
            //第二种方式("通过Map.entrySet遍历key和value",推荐，尤其是容量大时)
            for(Map.Entry <String,Integer>m:map.entrySet())
            {
            	System.out.println(m.getKey()+"  "+m.getValue());
            }
    
           //第三种("通过Map.entrySet使用iterator遍历key和value：")
           Iterator<Map.Entry<String, Integer>> it = map.entrySet().iterator();
            while (it.hasNext()) {
            Map.Entry<String, Integer> entry = it.next();
             System.out.println(entry.getKey() +" "+ entry.getValue());
           }
    
           //第四种 (只能获得values的值)
           for(Integer in:map.values())
           {
           	   System.out.println(in);
           }
           //第四种 (只能获得key的值)
           for(String keys:map.keySet())
           {
           	   System.out.println(keys);
           }
    
    
    
    
    	}
    }

** 三、Set 遍历**

1.迭代遍历：
    Set<String> set = new HashSet<String>();
    Iterator<String> it = set.iterator();
    while (it.hasNext()) {
      String str = it.next();
      System.out.println(str);
    }
    
    2.for循环遍历：
    for (String str : set) {
          System.out.println(str);
    }
    
    
    优点还体现在泛型 假如 set中存放的是Object
    
    Set<Object> set = new HashSet<Object>();
    for循环遍历：
    for (Object obj: set) {
          if(obj instanceof Integer){
                    int aa= (Integer)obj;
                 }else if(obj instanceof String){
                   String aa = (String)obj
                 }
                  ........
    }

[Link 1]: http://blog.csdn.net/qq_22118507/article/details/51576319
[2]: http://blog.csdn.net/SpeedMe/article/details/22398395