java集合类--以及遍历方法

java集合类

Collection的子接口

• List

  • 可以允许重复的对象。
    • 可以插入多个null元素。
  • 是一个有序容器，保持了每个元素的插入顺序，输出的顺序就是插入的顺序。
  • 常用的实现类有 ArrayList、LinkedList 和 Vector。ArrayList 最为流行，它提供了使用索引的随意访问，而 LinkedList 则对于经常需要从 List 中添加或删除元素的场合更为合适。

  遍历方式

  //foreach遍历List
  public void foreachList() {
  		List<String> list = new ArrayList();
  		 list.add("aa");
  		 list.add("bb");
  		 list.add("cc");
  		 
  		 for (String s : list) {
  			System.out.println(s);
  		}
  	}
  

  //迭代器遍历list
  	public void IteratorList() {
  		List<String> list = new ArrayList();
           list.add("aa");
           list.add("bb");
           list.add("cc");
  	 
           //迭代器用于while循环 
           Iterator iter = list.iterator();
           while(iter.hasNext()){
               String str = (String)iter.next();
               System.out.println(str);
           }
  	 
  	}
  

• Set

  • 不允许重复对象
    • 无序容器，你无法保证每个元素的存储顺序，TreeSet通过 Comparator 或者 Comparable 维护了一个排序顺序。
  • 只允许一个 null 元素
  • 4.Set 接口最流行的几个实现类是 HashSet、LinkedHashSet 以及 TreeSet。最流行的是基于 HashMap 实现的 HashSet；TreeSet 还实现了 SortedSet 接口，因此 TreeSet 是一个根据其 compare() 和 compareTo() 的定义进行排序的有序容器。

  遍历方式

  //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);  
  }  
    
    
  //遍历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  
               }  
  } 
  

Map接口

• Map 的 每个 Entry 都持有两个对象，也就是一个键一个值，Map 可能会持有相同的值对象但键对象必须是唯一的。
• Map 里你可以拥有随意个 null 值但最多只能有一个 null 键。
• Map 接口最常用的几个实现类是 HashMap、LinkedHashMap 和 TreeMap。（HashMap、TreeMap最常用）

遍历方式

//使用key遍历
	public static void keySet() {
		
		Map<Integer, String> map = new HashMap<Integer, String>();
		map.put(1, "a");
		map.put(2, "b");
		map.put(3, "c");
		
		Set<Integer> set = map.keySet();//set里存入map的key集合
		Iterator<Integer> iterator = set.iterator();
		
		while(iterator.hasNext()) {
			Integer key = iterator.next();
			String value = map.get(key);
			
			System.out.println(key + " : " + value);
		}	
	}

//使用entrySet遍历
	//map有多个entrySet（键值对）一个键值对分为一个key和一个vaule
	public void entrySet() {
		
		Map<Integer, String> map = new HashMap<Integer, String>();
		map.put(1, "a");
		map.put(2, "b");
		map.put(3, "c");
		
		
		Set<Map.Entry<Integer, String>> entrySet = map.entrySet();//set里存入map的key集合
		Iterator<Map.Entry<Integer, String>> iterator = entrySet.iterator();
		
		while(iterator.hasNext()) {
			Map.Entry<Integer, String> entry = iterator.next();
			Integer key = entry.getKey();
			String value = entry.getValue();
			System.out.println(key + " : " + value);
		}
	}

各遍历方式的适用于什么场合？

​ 这里转自https://www.cnblogs.com/leskang/p/6031282.html

1. 传统的for循环遍历，基于计数器的：

   ​        顺序存储：读取性能比较高。适用于遍历顺序存储集合。

   ​        链式存储：时间复杂度太大，不适用于遍历链式存储的集合。

2. 迭代器遍历，Iterator：

   ​        顺序存储：如果不是太在意时间，推荐选择此方式，毕竟代码更加简洁，也防止了Off-By-One的问题。
   
   ​        链式存储：意义就重大了，平均时间复杂度降O(n)，还是挺诱人的，所以推荐此种遍历方式。

3. foreach循环遍历：

   ​         foreach只是让代码更加简洁了，但是他有一些缺点，就是遍历过程中不能操作数据集合（删除等），
   			所以有些场合不使用。而且它本身就是基于Iterator实现的，但是由于类型转换的问题，
  			所以会比直接使用Iterator慢一点，但是还好，时间复杂度都是一样的。所以怎么选择，
   			参考上面两种方式，做一个折中的选择。