Java集合框架之四大接口、常用實現類

Java集合框架

<Java集合框架的四大接口>

Collection：存儲無序的、不唯一的數據；其下有List和Set兩大接口。

List：存儲有序的、不唯一的數據；

Set：存儲無序的、唯一的數據；

Map：以鍵值對的形式存儲數據，以鍵取值。鍵不能重復，但值可以重復。

接口的常用實現類：ArrayList、LinkedList、Vector、HashSet、LinkedHashSet、TreeSet、HashMap、LinkedHashMap、TreeMap、HashTable

一、List接口

是一個有序集合，繼承自Collection接口。現已知常用實現類有：ArrayList、LinkedList、Vector。

1. 常用方法：

add（）：在列表的最后添加元素；

add（index，obj）：在列表的指定位置添加元素；

size（）：返回當前列表的元素個數

get（int index）：返回下標為index的元素；

clear（）：清除列表中所有元素；

isEmpty（）：檢測列表是否為空；返回true/false；

contains（）：傳入一個對象，檢測列表中是否含有該對象；

indexOf（）：傳入一個對象，返回該對象在列表中首次出現的地址；

lastInsevOf（）：傳入一個對象，返回該對象在列表中最后一次出現的地址；

remove（）：傳入一個下標，或者一個對象，刪除指定元素；如果刪除指定對象，需要重寫equals（）方法，比對傳入的對象是不是屬於原列表，如果屬於，結果返回true；

set（index，obj）：用新傳入的對象，將指定位置的元素替換掉，返回被替換前的元素對象；

subList（）：截取一個子列表返回List類型；

toArray（）：將列表轉為數組，返回一個Object[]類型；

iterator（）：使用迭代器遍歷。

2. 如何輸出List列表？

a. for循環；

b. foreach遍歷（比較常用）；

c. 使用迭代器遍歷列表；

3. List接口的常用實現類：

ArrayList和LinkedList實現類是繼承自List接口的，所以List的常用方法它們也是適用的。

a. ArrayList

ArrayList實現了一個長度可變的數組，在內存空間中開辟一串連續的空間。

b. LinkedList

LinkedList使用鏈表結構存儲數據，在插入和刪除元素是速度非常快。

//ArrayList實現類
ArrayList<String> list1=new ArrayList<String>();
list1.add("第一條數據");  
list1.add("第二條數據");
list1.add("第三條數據");
list1.add("第四條數據");
list1.add("第五條數據");
list1.add("第三條數據");
list1.add(2,"第六條數據");  //在第三條數據后添加“第六條數據”

System.out.println(list1.size()); //返回列表長度
System.out.println(list1.get(2));  //返回“第六條數據”
//list1.clear(); //清除所有數據
System.out.println(list1.isEmpty()); //返回false
System.out.println(list1.contains("第一條數據"));  //返回true
System.out.println(list1.indexOf("第三條數據"));  //返回3
System.out.println(list1.lastIndexOf("第三條數據"));   //返回6
System.out.println(list1.remove(1));  //刪除“第二條數據”
System.out.println(list1.set(0, "替換第一條數據"));  //替換第一條數據
List list=list1.subList(2, 5);  //截取第三到第五條數據，返回List
System.out.println(list1.toString());  //轉成數組
        
//LinkedList實現類
LinkedList<News> list2=new LinkedList<News>();
list2.add(new News(1,"xxxxxxx","趙"));
list2.add(new News(2,"sssssss","錢"));
list2.add(new News(3,"yyyyyyy","孫"));
list2.add(new News(4,"nnnnnnn","李"));
list2.add(new News(5,"rrrrrrr","周"));
System.out.println(list2.contains(new News(3,"yyyyyyy","孫")));  //返回為true；重寫equals()方法；如果不重寫equals()方法，返回為false；
System.out.println(list2.remove(new News(1,"xxxxxxx","趙")));  //返回為true
        
                /*
         * 使用for循環遍歷
         */
        for (int i = 0; i < list1.size(); i++) {
            if(list1.get(i) instanceof String){  //判斷傳入的數據屬不屬於String類型
                String str=list1.get(i);
                System.out.println(str);
            }
        }
        /*
         * foreach遍歷
         */
        for (News news : list2) {
            System.out.println(news.getId()+"   "+news.getTitle()+"\t"+news.getAuthor());
        }
        /*
         * 迭代器遍歷
         */
        Iterator<String> iter=list.iterator();
        while(iter.hasNext()){ //判斷list有沒有下一條
            String s=iter.next();  //字符串取到下一條
            System.out.println(s);
        }        
                    

/**
 *News類
 */
class News{
    private int id;
    private String title;
    private String author;

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        News other = (News) obj;
        if (author == null) {
            if (other.author != null)
                return false;
        } else if (!author.equals(other.author))
            return false;
        if (id != other.id)
            return false;
        if (title == null) {
            if (other.title != null)
                return false;
        } else if (!title.equals(other.title))
            return false;
        return true;
    }
    public News() {
        super();
    }
    public News(int id, String title, String author) {
        super();
        this.id = id;
        this.title = title;
        this.author = author;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getTitle() {
        return title;
    }
    public void setTitle(String title) {
        this.title = title;
    }
    public String getAuthor() {
        return author;
    }
    public void setAuthor(String author) {
        this.author = author;
    }
    
    
}

 

二、Set接口

1. 常用方法：

與List接口基本相同。但是Set接口中的元素是無序的，因此沒有與下標有關的方法。例如：get（index）、remove（index）、add（index，obj）

2. Set接口的現已知常用實現類有：

HashSet、LinkedHashSet、TreeSet

3. HashSet

底層是HashMap的相關方法，傳入數據后，根據數據的hashCode進行散列運算，得到一個散列值后再進行運算，確定元素在序列中存儲的位置。

所以，使用HashSet存數據必須在實體類中重寫hashCode和equals方法！！

    //HashSet無序的
    Set<String> set1=new HashSet<String>();
    set1.add("set1");
    set1.add("set2");
    set1.add("set3");
    set1.add("set4");
    set1.add("set5");

    //foreach遍歷
    for (String set : set1) {
        System.out.println(set);
    }
      

4. LinkedHashSet

在HashSet的基礎上，新增了一個鏈表。用鏈表來記錄HashSet種元素放入的順序；HashSet依然是無序的，但鏈表會按照存入的順序存儲。

    //LinkedHashSet按照放入的順序輸出
    Set<Person> set2=new LinkedHashSet<Person>();
//  set2.addAll(set1);  //追加set1的所有數據
    set2.add(new Person(1,"紅"));
    set2.add(new Person(2,"黃"));
    set2.add(new Person(3,"藍"));
    set2.add(new Person(4,"綠"));
    set2.add(new Person(4,"綠"));    

    //迭代器遍歷
    Iterator<Person> iter=set2.iterator();
    while(iter.hasNext()){
        Person p=iter.next();
        System.out.println(p.getId()+"\t"+p.getName());
    }

class Person{
    private int id;
    private String name;
    
    /*
     * 如果不重寫hashCode和equals方法，存入相同數據時將無法比對
     *
     */
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + id;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Person other = (Person) obj;
        if (id != other.id)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
    public Person() {
        super();
    }
    public Person(int id, String name) {
        super();
        this.id = id;
        this.name = name;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    
}

5. TreeSet

將存入的數據，進行排序，然后輸出。

如果傳入的是一個實體對象，那么需要傳入比較器：實體類實現Comparable接口，並重寫CompareTo方法；

    //TreeSet從小到大輸出。存入元素，默認升序排序；存入實體對象，需要傳入比較器
    Set<Person> set3=new TreeSet<Person>();
    set3.add(new Person(11,"a"));
    set3.add(new Person(22,"b"));
    set3.add(new Person(33,"c"));
    set3.add(new Person(44,"d"));

    //迭代器遍歷
    Iterator<Person> iter=set3.iterator();
    while(iter.hasNext()){
        Person p=iter.next();
        System.out.println(p.getId()+"\t"+p.getName());
    }

class Person implements Comparable{  //實現
    private int id;
    private String name;
    
    //compareTo方法判斷傳入的對象和已有對象
    @Override
    public int compareTo(Object o) {
        Person p=null;
        if(o instanceof Person){
            p=(Person)o;
        }else{
            return 0;
        }
        return this.id -p.getId();  //為正數，升序；為負數，降序；等於0，位置不變
    }
    
    public Person() {
        super();
    }
    public Person(int id, String name) {
        super();
        this.id = id;
        this.name = name;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    
    
}

 

三、Map接口

1. Map接口的特點：

以鍵值對的形式存儲數據，以鍵取值。鍵不能重復，值可以重復。

2. Map接口的現已知常用實現類有：

HashMap、HashTable、LinkedHashMap、TreeMap

3. 常用方法：

put（key，value）：向Map的最后追加一個鍵值對；

get（key）：通過鍵，取到一個值；

clear（）：清除Map中的所有數據；

containsKey（key）：檢測是否包含指定的鍵；

containsValue（obj）：檢測是否包含指定的值；

replace（）：替換指定鍵的值；

4. 遍歷Map

a. keySet（）：返回Set，先取鍵，再取值；

b. values（）：返回Collection，直接取值；

c. 取代一個entry鍵值對，返回Set<Entry<>>；

        Map<String, String> map1=new HashMap<String, String>();
        map1.put("01", "aaaaaa");
        map1.put("02", "bbbbbb");
        map1.put("03", "cccccc");
        map1.put("04", "dddddd");
//        map1.clear();  //清除所有數據
        System.out.println(map1.containsKey("01"));  //返回true
        System.out.println(map1.containsValue("aaaa"));  //返回false
        System.out.println(map1.replace("03", "dddddd"));  //將cccccc替換為dddddd
        System.out.println(map1.get("02"));  //返回bbbbbb
        
        /**
         * 遍歷Map的方式一，先取鍵，再取值
         */
        Set<String> keys=map1.keySet();  //取到所有鍵
        Iterator<String> iter=keys.iterator();
        while(iter.hasNext()){ //迭代器遍歷取到每一個鍵
            String key=iter.next();
            System.out.println(key+"  "+map1.get(key)); //key:取到鍵    map1.get(key):取到每個鍵對應的值
        }
        
        /**
         * 遍歷Map的方式二，直接取值；只能取到值
         */
        Collection<String> values = map1.values();
        Iterator<String> iter1= values.iterator();
        while(iter1.hasNext()){
            System.out.println(iter1.next());
        }
        
        /**
         * 遍歷Map的方式三,取到一個entry鍵值對
         */
        Set<Entry<String,String>> set= map1.entrySet();
        Iterator<Entry<String,String>> iter2=set.iterator();
        while(iter2.hasNext()){
            Entry<String,String> entry=iter2.next();
            System.out.println(entry.getKey()+"  "+entry.getValue());
        }
        

5. LinkedHashMap

可以使用列表，記錄數據放入的次序，輸出的順序與放入的順序一致。與LinkEDHashSet一樣。

6. TreeMap

根據鍵的順序，進行排序后輸出。與TreeSet。

如果傳入的是實體對象，必須重寫比較函數。

7. HashMap和HashTable的區別？

a. HashTable是線程安全的，HashMap是線程不安全的；

b. HashTable的鍵不能為null，HashMap的鍵可以為null；

c. HashTable繼承自Dirctionary字典類，HashMap繼承自abstract類；

d. 擴容大小：HashTable兩倍，HashMap兩倍加一；

e. 初始容量：HashTable為11，HashMap為16；兩者的填充因子默認都是0.75；