java中的集合總結

知識點：

    集合框架和List、set、Map相關集合特色的描述

    Collection接口經常使用方法，List中相對Collection新增的方法，Collection的遍歷（通常for循環，加強for循環，Iterator迭代器循環），TreeSet的天然排序和定製排序

    Map接口經常使用的方法，Map的遍歷（key集遍歷，value集遍歷，key-value鍵值對entry集遍歷）

    Collections工具類中的經常使用方法（集合處理線程安全的方法）

      一：集合框架

相對與數組來講，集合存儲數據避免了長度初始化後，不可改變的弊端

 

注：實線箭頭表明繼承，虛線箭頭表明實現接口，虛線框表明抽象類

 

集合大體分爲：

   List接口：存儲有序的，能夠重複的數據

   Set接口：存儲無序的，不可重複的數據（其中不可重複性是指向Set添加相同的元素時，後面的元素不能添加進去，當向Set中添加類的對象時，所在類須要重寫equals()和hashCode()方法，而且hashCode方法要與equals()方法一致，這樣保證了存儲的類的對象元素不可重複性，由於當咱們向Set中，添加元素時會先算出元素的hashCode值，每個hashCode表明元素存儲的位置，若是內存中hashCode的位置沒有值的話，存入元素，有值的話，則調用equals()方法比較兩個元素是否相等，若是相等則不存，不相等則存）

           HashSet:主要實現類

           LinkedHashSet:是HashSet的子類，遍歷集合元素時，是按照添加進去的順序遍歷的，適用於頻繁遍歷，較少的添加

           TreeSet:添加進去的元素必須是同一類

                         添加進集合的元素按照必定規則排序，String，Integer等按照默認的順序排序

                         若是元素是自定義的類的對象，須要自定義按照類的屬性進行排序 ，兩種排序 天然排序和定製排序

                          a.天然排序：要求添加進TreeSet中的元素所在的類implements Comparable接口

                                                重寫compareTo(Object o)方法，在該方法內部指明元素是按照類的那個屬性進行排序的

                                                向TreeSet中添加元素便可，若是不實現Comparable接口，會報運行時異常

                          b.定製排序：建立一個實現Comparator接口的實現類的對象，在實現類中重寫compare(Object o1,Object o2 )方法

                                               在compare方法中指明元素是按照類的哪一個屬性進行排序的

                                               將實現Comparator接口的實現類的對象做爲參數傳遞給TreeSet的構造器中

                                               向TreeSet中添加元素便可，若不實現此接口，會報運行時異常

                            重寫compareTo()或者compare()方法須要與equals和hashCode()方法保持一致                 

   Map:存儲「鍵—值」對的數據，key是不可重複的，使用Set存放，value能夠重複的，使用Collection存放，一個key-value對構成一個entry(Map.Entry),entry是使用Set存放的

           HashMap:主要的實現類

           LinkedHashMap:是HashMap的子類，使用鏈表維護添加進Map中的順序，能夠按照添加進Map的順序實現遍歷

           TreeMap:須要按照key所在類的指定屬性進行排序，要求key是同一類的對象，對key使用天然排序和定製排序

           Hashtable：古老的實現類，線程安全的，不建議使用

                      子類：Properties：經常使用來處理屬性文件，key和value都是String類型的

    二：Collection、List、Set

(1）Collection中經常使用的方法

      add():想集合裏添加元素

      addAll()：向集合添加集合

      isEmpty():判斷集合是否爲空

      clear():清空集合

      contains(Object obj)是否包含某個元素,是返回true，否返回false (若是存入集合元素是自定義類的對象，自定義類要重寫equals()方法)

      containsAll(Collection<?> c) 集合中包含集合

      retainAll(Collection coll):取兩個集合的共有元素（交集），並返回給當前集合col

      remove(Object obj):刪除元素中的元素，刪除成功，返回true，失敗返回 false

      removeAll():刪除集合中一部分元素,返回刪除了部分元素後的集合col

      equals(Object o):判斷兩個集合是否相等

      hashCode():返回元素的hashCode值

      toArray():集合轉化爲數組  (Object[] objarr=col.toArray())

      iterator():返回一個Iterator接口實現類的對象，進而實現集合遍歷 (Iterator iterator=col.iterator();)

(2）List相對Collection,新增長的方法

     一、void add（int index,Object ele）:在指定的索引位置index添加元素ele
     二、boolean addAll(int index,Collection eles)
     三、Object remove(int index):刪除指定索引位置的元素
     四、Object set(int index,Object ele):設置指定索引位置的元素爲ele
     五、Object get(int index):獲取指定索引的元素
     六、int indexOf(Object obj):返回obj在集合中首次出現的位置，沒有的話，返回-1
     七、int lastIndexOf(Object obj):返回obj在集合中最後一次出現的位置，沒有的話，返回-1
     八、List subList(int fromIndex,index toIndex):返回從fromIndex到toIndex結束，左閉右開的集合

     List經常使用方法：增（add(Object obj)）刪(remove)改(set(int index,Object obj))查(get(int index)
            插(add(int index,Object obj))長度(size())

(3）TreeSet中添加自定義類的對象的，兩種排序方法（a.天然排序 和b.定製排序）

a.天然排序

public class TreeSetTest {
    /*
 * TreeSet
 * 1:向TreeSet中添加的元素必須是同一類
 * 2.能夠按照添加進集合中的元素指定順序遍歷，像String，包裝類等默認的按照從小到大排序遍歷
 * 3.當向TreeSet中添加自定義類的對象，有兩種排序方法（1）天然排序（2）定製排序
 * 4.天然排序：自定義類實現java.lang.Comparable接口，並重寫其compareTo(Object obj),方法內部，
 * 指明按照自定義類的哪個屬性排序
 * 5.向TreeSet中，添加元素時，先按照compareTo()進行比較，一旦返回 0，兩個對象的屬性相同
 * 程序會認爲兩個對象相同，進然後一個對象不能添加到集合中
 * 6.compareTo()、hashcode()、equals()三者保持一致
 * */

 //一、comparable 天然排序
 @Test
 public void treeSetTest1(){
 TreeSet set=new TreeSet();
 
 set.add(new Person("zhangsan",21));
 set.add(new Person("wangwu",22));
 set.add(new Person("lishi",22));
 Iterator iterator=set.iterator();
 while (iterator.hasNext()){
 System.out.println(iterator.next());
 }
 }

}

自定義類Person、implements Comparable接口，重寫compareTo(Object o)方法，根據類的屬性，定義排序規則

public class Person implements Comparable {
 private String name;
 private Integer age;
 public Person() {
 }
 public Person(String name, int age) {
 this.name = name;
 this.age = age;
 }
 @Override
 public int hashCode() {
 return Objects.hash(name, age);
 }
 @Override
 public boolean equals(Object o) {
 if (this == o) return true;
 if (!(o instanceof Person)) return false;
 Person person = (Person) o;
 return age == person.age &&
 name.equals(person.name);
 }
 @Override
 public String toString() {
 return "Person{" +
 "name='" + name + '\'' +
 ", age=" + age +
 '}';
 }

 //先根據age排序，當對象age屬性相等時，再根據name屬性排序
 @Override
 public int compareTo(Object o) {
 if(o instanceof Person){
 Person p=(Person)o;
 int i=age.compareTo(p.age);
 if (i==0){
 return name.compareTo(p.name);
 }
 return i;
 }
 return 0;
 }
}

運行結果：

b.定製排序

  建立一個實現Comparator接口的實現類的對象，在實現類中重寫compare(Object o1,Object o2 )方法

  在compare方法中指明元素是按照類的哪一個屬性進行排序的

  將實現Comparator接口的實現類的對象做爲參數傳遞給TreeSet的構造器中

//二、comparator 定製排序
@Test
public void treeSetTest2(){
 //1.建立一個實現了Comparator接口的類的對象
 Comparator comparator=new Comparator() {
 //2.向TreeSet中添加Man對象，在compare()方法中，指明Man按照那個屬性排序的
 @Override
 public int compare(Object o1, Object o2) {
 if (o1 instanceof Man && o2 instanceof Man) {
 Man m1 = (Man) o1;
 Man m2 = (Man) o2;
 int i = m1.getId().compareTo(m2.getId());
 if (i == 0) {
 return m1.getName().compareTo(m2.getName());
 }
 return i;
 }
 return 0;
 }
 };

 //3.將comparator對象做爲形參傳遞給TreeSet的構造器中
 TreeSet set=new TreeSet(comparator);
 //4.向TreeSet中添加Comparator接口，compare方法中涉及到的類的對象
 set.add(new Man(1001,"zhangsan"));
 set.add(new Man(1004,"wangwu"));
 set.add(new Man(1004,"lisi"));

 Iterator iterator=set.iterator();
 while (iterator.hasNext()){
 System.out.println(iterator.next());
 }
 System.out.println("---------------------");

 for (Object o:set){
 System.out.println(o);
 }
}

Man類重寫equals方法和hashCode()方法

public class Man {
    private Integer id;
 private String name;
 private Integer age;
 public Man() {
 }
 public Man(Integer id, String name) {
 this.id = id;
 this.name = name;
 }
 public Integer getId() {
 return id;
 }
 public void setId(Integer id) {
 this.id = id;
 }
 public String getName() {
 return name;
 }
 public void setName(String name) {
 this.name = name;
 }
 public Integer getAge() {
 return age;
 }
 public void setAge(Integer age) {
 this.age = age;
 }
 @Override
 public String toString() {
 return "Man{" +
 "id=" + id +
 ", name='" + name + '\'' +
 ", age=" + age +
 '}';
 }
 @Override
 public boolean equals(Object o) {
 if (this == o) return true;
 if (!(o instanceof Man)) return false;
 Man man = (Man) o;
 return name.equals(man.name) &&
 age.equals(man.age);
 }
 @Override
 public int hashCode() {
 return Objects.hash(name, age);
 }
}
運行結果：

(4）Collection的遍歷（List，Set）:迭代器和加強for循環Collection下集合類都適用，通常for循環適用於List，List中有get(i)方法

public class forcirculation {
    @Test
 public void forcirculationTest(){
 Collection col=new ArrayList();
 col.add("AA");
 col.add("BB");
 col.add("CC");
 col.add("DD");
 //1.通常for循環，適用於List,由於List中增長get(i)方法，而Set是都是Collection的方法沒有增長get()方法，沒法獲取遍歷時，沒法得到i位置的元素
 /*for (int i=0;i<col.size();i++){
 System.out.println(col.);
 }*/
 //2.迭代器遍歷集合(數組不能使用迭代器)
 Iterator iterator=col.iterator();
 while (iterator.hasNext()){
 System.out.println(iterator.next());
 }
 System.out.println("===========");
 //3.加強for循環（數組能夠）
 for(Object i:col){
 System.out.println(i);
 }
 System.out.println("===========");
 //數組
 Object[] objArr=new String[]{"AA","BB","CC"};
 for (Object i:objArr){
 System.out.println(i);
 }
 }
}
運行結果：


  三：Map key-value鍵值對
(1）Map中的主要方法

   Object put(Object key,Object value)
 Object get(Object key)
 Object remove(Object key)
 void putAll(Map t)
 void clear()
 boolean containsKey(Object key)
 boolean contaninsValue(Object value)
 int size()
 boolean isEmpty()
 boolean equals(Object obj)

(2）Map的遍歷

 public class circulateHashMap {
 //遍歷HashMap
 /*
 * Set keySet()
 * Collection values()
 * Set entrySet()
 * */
 @Test
 public void CirculateHashMapTest(){
 HashMap map=new HashMap();
 map.put("AA",12);
 map.put("BB",null);
 map.put(new Person("張三",21),11);

 //1.遍歷key集
 Set set=map.keySet();
 Iterator iterator=set.iterator();
 while (iterator.hasNext()){
 System.out.println(iterator.next());
 }
 System.out.println("------------------------------");
 //2.遍歷value集
 Collection cols=map.values();
 for (Object o:cols){
 System.out.println(o);
 }
 System.out.println("------------------------------");
 //遍歷key-value鍵值對
 //方法一 經過Map.entry
 Set entrySet=map.entrySet();
 for(Object o:entrySet){
 //System.out.println(o);
 Map.Entry entry=(Map.Entry)o;
 System.out.println(entry.getKey()+"===>"+entry.getValue());
 }
 System.out.println("------------------------------");
 //方法二 經過key值獲取
 Set set2=map.keySet();
 for (Object o:set2){
 System.out.println(o+"===>"+map.get(o));
 }
 }
}
運行結果：

   四：Collections工具類

  (1）Collections工具類中涉及到方法（Collections是操做Collection和Map的工具類）

 reverse(List):反轉List中元素的順序（Collections.reverse(list)）
 shuffle(List):對List集合元素進行隨機排序
 sort(List):根據元素的天然順序對指定List集合進行升序，從小到大排序
 sort(List,Comparator):根據指定的Comparator 產生的順序對List集合進行排序
 swap(List,int i,int j):將指定list集合中，i和j位置的元素進行交換

 Object max(Collection):根據天然順序，返回集合中最大元素
 Object max(Collection,Comparator):根據Comparator指定的順序，返回集合中最大的元素
 Object min(Collection)
 Object min(Collection,Comparator)
 int frequency(Collection,Object):返回集合中指定元素出現的次數
 void copy(List dest,List src):將src中的元素複製到dec中
 boolean replaceAll(List list,Object oldVal,Object newVal):使用newVal替換oldVal的值

其中：copy(List dest,List src)方法desc集合須要初始化長度，否則會報錯

List list=new ArrayList();
list.add(123);
list.add(342);
list.add(87);

//List list1=new ArrayList(); 集合長度爲0，報數組越界錯誤
List list1= Arrays.asList(new Object[list.size()]);
System.out.println(list);
System.out.println(list1);
Collections.copy(list1,list);
System.out.println(list1);

運行結果

若是List list1=new ArrayList()，報錯

(2）Collections工具類中保證集合安全方法
 List list=new ArrayList();
 list.add(123);
 list.add(342);
 list.add(87);

   //保證List集合線程安全
   List list2= Collections.synchronizedList(list);

補充：上面關於集合中存放的元素，在實際開發中須要加上泛型的，下一篇博客中有介紹