List集合類方法的使用

Java代碼  收藏代碼
import java.util.ArrayList;  
import java.util.Iterator;  
import java.util.LinkedList;  
//import java.awt.List;  
import java.util.List;     //當出現下面的錯誤時，是由於少了這句，多了上面註釋的一句，請看仔細  
    //The type List is not generic; it cannot be parameterized with arguments <String>  
  
  
public class TestList {  
      
  
  public static void  main(String args[]){  
        
        
      List<String> l = new ArrayList<String>();// 利用ArrayList類實例化List集合  
      List<String> l2 = new LinkedList<String>();// 利用LinkedList類實例化List集合  
  
      //add(int index, Object obj)方法和set(int index, Object obj)方法的區別  
      String a = "A", b = "B", c = "C", d = "D", e = "E";  
      List<String> list = new LinkedList<String>();       //LinkedList  鏈式 至關於下表從0開始的  
      list.add(a);                                   //add()方法  
      list.add(e);  
      list.add(d);  
      list.set(1, b);      // 將索引位置爲1的對象e修改成對象b  
      list.add(2, c);      // 將對象c添加到索引位置爲2的位置  
      Iterator<String> it = list.iterator();    //遍歷時的方式*****方法1  
      while (it.hasNext()) {  
      System.out.println(it.next());  
      }  
        
      for(int i = 0; i < list.size(); i++) {  //遍歷時的方式*****方法2  
          System.out.println(list.get(i));    // 利用get(int index)方法得到指定索引位置的對象  
         }  
  
        
      //indexOf(Object obj)方法和lastIndexOf(Object obj)方法的區別  
      System.out.println("開始：");  
      String aa = "A", bb = "B", cc = "C", dd = "D", repeat = "Repeat";  
      List<String> list2 = new ArrayList<String>();  
      list2.add(aa); // 索引位置爲 0  
      list2.add(repeat); // 索引位置爲 1  
      list2.add(bb); // 索引位置爲 2  
      list2.add(repeat); // 索引位置爲 3  
      list2.add(cc); // 索引位置爲 4  
      list2.add(repeat); // 索引位置爲 5  
      list2.add(dd); // 索引位置爲 6  
      System.out.println(list2.indexOf(repeat));  
      System.out.println(list2.lastIndexOf(repeat));  
      System.out.println(list2.indexOf(bb));  
      System.out.println(list2.lastIndexOf(bb));  
      System.out.println("結束！");  
  
//subList(int fromIndex, int toIndex)方法  
//在使用subList(int fromIndex, int toIndex)方法截取現有List集合中的部分對象生成新的List集合時，  
//須要注意的是，新生成的集合中包含起始索引位置表明的對象，可是不包含終止索引位置表明的對象  
      // list a b c d e  
      list = list.subList(1, 3);// 利用從索引位置 1 到 3 的對象從新生成一個List集合  
      for (int i = 0; i < list.size(); i++) {  
      System.out.println(list.get(i));  
      }  
      
      List list22 = new LinkedList();  
      list22 = list.subList(0,1);  //b  
  
      list22.add(aa);  
      list22.add("zhang");  
      list22.add("guang");   //此時 list22 爲  B A zhang guang  
      list22.set(0, a);  
      list22.set(1, b);      //此時 list22 爲  A B zhang guang  
      for (int i = 0; i < list22.size(); i++) {  
      System.out.println(list22.get(i));  
      }  
      System.out.println("*********************************");  
      List list33 = new LinkedList();  
      list33=list22.subList(1, 3);  
      list22.addAll(list33);                 //總體加list時要用addAll()方法  
      for (int i = 0; i < list22.size(); i++) {  
          System.out.print(list22.get(i)+"\t.");  //get()方法  
          }  
        
//    list33.clear();  
//    for (int i = 0; i < list33.size(); i++) {  
//        System.out.println(list33.get(i));  
//        }  
      System.out.println(list22.contains(a));          // contains()方法  
      //System.out.println(list22.containsAll(list33));  // containsAll()方法  
        
      list22.remove(0);  
      for (int i = 0; i < list22.size(); i++) {  
          System.out.print(list22.get(i)+"\t.");  //get()方法  
          }  
        
      System.out.println("\n"+list22.size());  //size()  
        
      Object[] str = list22.toArray();      //toArray()方法 爲Object類型  
      for(int i=0;i<str.length;i++){  
          System.out.print(str[i]+"\t");  
      }  
       System.out.println("\n"+list22+"\t");  //請看直接輸出的格式！！！！  
      //run：[B, zhang, guang, B, zhang]   
      //System.out.println(list33+"\t");  
        
  }  
}
遍歷List集合的三種方法
List<String> list = new ArrayList<String>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
方法一：
超級for循環遍歷
for(String attribute : list) {
  System.out.println(attribute);
}
方法二：
對於ArrayList來講速度比較快, 用for循環, 以size爲條件遍歷:
for(int i = 0 ; i < list.size() ; i++) {
  system.out.println(list.get(i));
}
方法三：
集合類的通用遍歷方式, 從很早的版本就有, 用迭代器迭代
Iterator it = list.iterator();
while(it.hasNext()) {
  System.ou.println(it.next);
}
例子：
package package1;

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;


public class demo2 {
public static void main(String[] args) {
	//定義數組
	String[] str= {"hello你好","喂，你好","哈哈哈哈"};
	//定義集合
	List<String> list=new ArrayList<String>();
	//把數組添加在集合中
	for(int i=0;i<str.length;i++) {
		list.add(str[i]);
	}
	//遍歷集合
	ListIterator<String> iterator=list.listIterator();
	while (iterator.hasNext()) {
		System.out.println(iterator.next());
	}
	System.out.println("-------反向迭代--------");
	while (iterator.hasPrevious()) {
		System.out.println(iterator.previous());
	}
}
}
結果：
hello你好
喂，你好
哈哈哈哈
-------反向迭代--------
哈哈哈哈
喂，你好
hello你好  
--------------------------------------經常使用方法--------------------------------------------
l 增長元素方法

l add(Object e)：向集合末尾處，添加指定的元素

l add(int index, Object e)：向集合指定索引處，添加指定的元素，原有元素依次後移

l 刪除元素刪除

l remove(Object e)：將指定元素對象，從集合中刪除，返回值爲被刪除的元素

l remove(int index)：將指定索引處的元素，從集合中刪除，返回值爲被刪除的元素

l 替換元素方法

l set(int index, Object e)：將指定索引處的元素，替換成指定的元素，返回值爲替換前的元素

l 查詢元素方法

l get(int index)：獲取指定索引處的元素，並返回該元素
--------------------Map集合：---------------------------------------------
Map<String,Object> hashMap = new HashMap<>();
        //添加元素到 Map 中
        hashMap.put("key1", "value1");
        hashMap.put("key2", "value2");
        hashMap.put("key3", "value3");
        hashMap.put("key4", "value4");
        hashMap.put("key5", "value5");
         
        //刪除 Map 中的元素,經過 key 的值
        hashMap.remove("key1");
         
        //經過 get(key) 獲得 Map 中的value
        Object str1 = hashMap.get("key1");
         
        //能夠經過 添加 方法來修改 Map 中的元素
        hashMap.put("key2", "修改 key2 的 Value");
         
        //經過 map.values() 方法獲得 Map 中的 value 集合
        Collection<Object> value = hashMap.values();
        for(Object obj : value){
            //System.out.println(obj);
        }
         
        //經過 map.keySet() 獲得 Map 的key 的集合，而後 經過 get(key) 獲得 Value
        Set<String> set = hashMap.keySet();
        for(String str : set){
            Object obj = hashMap.get(str);
            //System.out.println(str+"="+obj);
        }
         
        //經過 Map.entrySet() 獲得 Map 的 Entry集合，而後遍歷
        Set<Map.Entry<String, Object>> entrys = hashMap.entrySet();
        for(Map.Entry<String, Object> entry: entrys){
            String key = entry.getKey();
            Object value2 = entry.getValue();
            System.out.println(key+"="+value2);
        }
         
        System.out.println(hashMap);