復習java基礎第四天(集合:List、Map、Collections、Enumeration)

一、List:

List 代表一個元素有序、且可重復的集合，集合中的每個元素都有其對應的順序索引

List 允許使用重復元素，可以通過索引來訪問指定位置的集合元素。

List 默認按元素的添加順序設置元素的索引。

List 集合里添加了一些根據索引來操作集合元素的方法：

另外：

List 額外提供了一個 listIterator() 方法，該方法返回一個 ListIterator 對象，

ListIterator 接口繼承了 Iterator 接口，提供了專門操作 List 的方法：

boolean hasPrevious()
Object previous()
void add()

ArrayList 和 Vector 是 List 接口的兩個典型實現 區別：

1、Vector 是一個古老的集合，通常建議使用 ArrayList。

2、ArrayList 是線程不安全的，而 Vector 是線程安全的。

3、即使為保證 List 集合線程安全，也不推薦使用 Vector。

public class Person {
    
     private String name;
     private int age;
     
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public Person(){}
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }  
}

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

public class TestArrayList {
    public static void main(String []args){
        
        List list = new ArrayList();
        List list2 = new ArrayList();
        Person p1 = new Person("lisi007",15);
        list.add(new Person("lisi003",12));
        list.add(new Person("lisi003",12));
        list.add(p1);
        list.add(new Person("lisi005",10));
        list.add(new Person("lisi006",20));
        
        for(Object obj:list){
            System.out.println(obj);
        }
        
        System.out.println();
        list2.add(new Person("zhangsan",22));
        list2.add(new Person("zhangsan",23));
        list.addAll(2, list2);
        list.add(3, p1);
    //    list.remove(1);
        
        System.out.println(list.indexOf(p1));
        System.out.println(list.lastIndexOf(p1));
        
        for(Object obj:list){
            System.out.println(obj);
        }
                
/*        //遍歷List方法1：調用iterator()方法
        Iterator iterator = list.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
        
        //遍歷List方法2：增強for循環
        for(Object obj:list){
            System.out.println(obj);
        }
        
        //遍歷List方法3：for循環,利用get(int index)
        for(int i=0;i<list.size();i++){
            System.out.println(list.get(i));
        }
        //遍歷List方法4：
        ListIterator li = list.listIterator();
        while(li.hasNext()){
            System.out.println(li.next());
        }
*/                
    }     
}

 

二、Map:

——Map 用於保存具有映射關系的數據，因此 Map 集合里保存着兩組值， 一組值用於保存 Map 里的 Key，

      另外一組用於保存 Map 里的 Value。

——Map 中的 key 和 value 都可以是任何引用類型的數據。

——Map 中的 Key 不允許重復（值可以），即同一個 Map 對象的任何兩個 Key 通過 equals 方法比較中

      返回 false。

——Key 和 Value 之間存在單向一對一關系，即通過指定的 Key 總能找到唯一的，確定的 Value。

Map常用方法：

HashMap 和 Hashtable 是 Map 接口的兩個典型實現類，它們的區別：

——Hashtable 是一個古老的 Map 實現類，不建議使用。

——Hashtable 是一個線程安全的 Map 實現，但 HashMap 是線程不安全的。

——Hashtable 不允許使用 null 作為 key 和 value，而 HashMap 可以。

注意：

1、與 HashSet 集合不能保證元素的順序的順序一樣，Hashtable 、HashMap 也不能保證其中

     key-value 對的順序。

2、Hashtable 、HashMap 判斷兩個 Key 相等的標准是：兩個 Key 通過 equals 方法返回 true，

     hashCode 值也相等。

3、Hashtable 、HashMap 判斷兩個 Value相等的標准是：兩個 Value 通過 equals 方法返回 true。

另外：

——LinkedHashMap 是 HashMap 的子類。

——LinkedHashMap 可以維護 Map 的迭代順序：迭代順序與 Key-Value 對的插入順序一致。

Properties ：

——Properties 類是 Hashtable 的子類，該對象用於處理屬性文件。

——由於屬性文件里的 key、value 都是字符串類型，所以 properties 里的 Key 和 Value 都是字符串類型的。

TreeMap：

1、TreeMap 存儲 Key-Value 對時，需要根據 Key 對 key-value 對進行排序。

     TreeMap 可以保證所有的 Key-Value 對處於有序狀態。

2、TreeMap 的 Key 的排序：

——自然排序：TreeMap 的所有的 Key 必須實現 Comparable 接口，而且所有的 Key 應該是

      同一個類的對象，否則將會拋出 ClasssCastException。

——定制排序：創建 TreeMap 時，傳入一個 Comparator 對象，該對象負責對 TreeMap 中的

      所有 key 進行排序。此時不需要 Map 的 Key 實現 Comparable 接口。

練習代碼：

url=jdbc:mysql:///test
driver=com.mysql.jdbc.Driver
user=root
password=123

public class Person {
    
     private String name;
     private int age;
     
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public Person(){}
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }  
}

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.TreeMap;

public class TestHashMap {
      public static void main(String []args) throws FileNotFoundException, IOException{
          Map map = new HashMap();
          
          //添加Map元素:key不可以重復，value可以重復
          map.put("AA", new Person("AAA",12));
          map.put("DD", new Person("AA",12));
          map.put("CC", new Person("CCC",13));
          map.put("MM", new Person("MMM",15));
          map.put("NN", new Person("AA",14));
          
          //遍歷Map中的元素:得到鍵的集合通過keySet()方法
          Set keySet = map.keySet();
          for(Object obj:keySet){
              Object value = map.get(obj);
              System.out.println("key= "+obj+"  value= "+value);
          }
          
          //直接得到值的集合
          Collection values = map.values(); //這里得到的值是可以重復的
          for(Object val:values){
              System.out.println(val);
          }
          
          //得到鍵值對的集合
/*        Map<String,Object> map = new HashMap<String,Object>();//此方法需要泛型
          for(Map.Entry<String, Object> kv:map.entrySet()){
              String key = kv.getKey();
              Object value = kv.getValue();
              System.out.println(key + " : " +value);
          }*/
          
          //移除元素的
          map.remove("DD");
          
          //操作Map的工具方法：
          System.out.println(map.size());
          System.out.println(map.isEmpty());
          System.out.println(map.containsKey("AA"));
          
          Comparator comparator = new Comparator(){
            @Override
            public int compare(Object o1, Object o2) {
                int result;
                 Person p1 = (Person) o1;
                 Person p2 = (Person) o2;
                 result = p1.getAge() - p2.getAge();
                if(result == 0){
                    return p1.getName().compareTo(p2.getName());
                }
                return result;
            }
          };
          
          TreeMap tm = new TreeMap(comparator);
          tm.put(new Person("ABC",12), "ABC");
          tm.put(new Person("ABCDF",17), "ABCD");
          tm.put(new Person("ABCDE",14), "ABCD");
          tm.put(new Person("ABCD",14), "ABCD");
          
          Set c = tm.keySet();
          for(Object keys:c){
              Object value = tm.get(keys);
              System.out.println(keys+"  :  "+value);
          }
          
          //properties文件在java中對應的是一個properties類的對象
          //1、創建一個properties類的對象
           Properties properties = new Properties();
           
          //2、使用IO流加載對應的properties文件
           properties.load(new FileInputStream("jdbc.properties"));
           
          //3、得到對應的屬性值
          String url = properties.getProperty("url");
          System.out.println(url);              
      }
}

 

三、操作集合的工具類：Collections：（注意不是Collection）

1、Collections 是一個操作 Set、List 和 Map 等集合的工具類

2、Collections 中提供了大量方法對集合元素進行排序、查詢和修改等操作，還提供了對集合對象設置不可變、

     對集合對象實現同步控制等方法。

排序操作：

—reverse(List)：反轉 List 中元素的順序。

—shuffle(List)：對 List 集合元素進行隨機排序。

—sort(List)：根據元素的自然順序對指定 List 集合元素按升序排序。

—sort(List，Comparator)：根據指定的 Comparator 產生的順序對 List 集合元素進行排序。

—swap(List，int， int)：將指定 list 集合中的 i 處元素和 j 處元素進行交換。

同步控制：

Collections 類中提供了多個 synchronizedXxx() 方法，該方法可使將指定集合包裝成線程同步的集合，

從而可以解決多線程並發訪問集合時的線程安全問題。

 

四、Enumeration：

Enumeration 接口是 Iterator 迭代器的 “古老版本”。

練習代碼：

public class Person {
    
     private String name;
     private int age;
     
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public Person(){}
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }  
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Enumeration;
import java.util.List;

public class TestCollections {
    public static void main(String []args){
        
     List list = new ArrayList();
     list.add(new Person("lisi003",22));
     list.add(new Person("lisi009",18));
     list.add(new Person("lisi005",20));
     list.add(new Person("lisi001",12));
     
     //使用Collection中的方法對list中和元素進行排序
     Collections.sort( list, new Comparator() {
        @Override
        public int compare(Object o1, Object o2) {
            Person p1 = (Person) o1;
            Person p2 = (Person) o2;
            return p1.getAge() - p2.getAge();
        }
    });
     
     for(Object obj:list){
         System.out.println(obj);
     }
     
     //獲取線程安全的list對象
     List list2 = Collections.synchronizedList(new ArrayList());
     
     //對Enumeration進行遍歷
     Enumeration names = Collections.enumeration(list);
     while(names.hasMoreElements()){
         System.out.println(names.nextElement());
     }
  }   
}