Java基础（六）集合

￡神魔★判官ぃ 2022-07-12 08:33 227阅读 0赞

# Java基础（五） 集合 #

*  集合概述
 *  Set 类
 *  List 类
 *  Map 类

# 1. 集合概述 #

## 1.1 集合概述 ##

> 数组的长度是固定的。在很多场合中，我们需要一组长度变化的数组。比如：一个单位当中，有老员工跳槽，也有新的员工进来。一个单位的客户是变化的，有老的客户流失，也有新的客户进来。对于这样的需求，数组可以满足我们的需求。但是，这并不太合适。因为数组的删除，前面必然会有空间空出，后面的数据需要向前移位，这必然导致很大的时间开销。所以，集合的思想应运而生。

为了能够存放和操纵数目不固定的一组数据，JDK类库提供了Java集合，所有的Java集合都被存放在java.util的包内。

和Java数组不同的是，Java集合内不能存放基础数据，而只能存放对象的引用。出于表达上的便利，我们通常把”集合内变量的引用”，称为”集合中的对象”。

Java中的集合主要分为三种类型:

*  Set: 无序，并且集合内的数据不能重复;
 *  List: 有序(放入的先后顺序)，并且集合内的数据可以重复;
 *  Map: (AbstractMap和HashMap无序)，TreeMap有序。集合内的每一对元素包含一对键值对对象，键不可以重复，值可以重复。（Key不能重复，Value可以重复）

## 1.2 Collection接口和Iterator接口 ##

Set类和List类继承了Collection的接口，在Collection接口内声明了Set类和List类的通用方法,具体方法如下(CURD):

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>boolean add(Object o)</td> 
   <td>向集合中加入一个对象的引用</td> 
  </tr> 
  <tr> 
   <td>void clear()</td> 
   <td>删除集合内所有对象的引用</td> 
  </tr> 
  <tr> 
   <td>boolean contains(Object o)</td> 
   <td>判断集合内是否持有集合中对象的引用</td> 
  </tr> 
  <tr> 
   <td>boolean isEmpty()</td> 
   <td>判断集合内的元素是否为空</td> 
  </tr> 
  <tr> 
   <td>Iterator iterator()</td> 
   <td>返回一个Iterator对象，可以用它来便利集合内的元素</td> 
  </tr> 
  <tr> 
   <td>boolean remove(Object o)</td> 
   <td>删除集合内对象的引用</td> 
  </tr> 
  <tr> 
   <td>int size()</td> 
   <td>返回集合内元素的个数</td> 
  </tr> 
  <tr> 
   <td>Object[] toArray()</td> 
   <td>返回一个数组，数组内包含所有的元素</td> 
  </tr> 
 </tbody> 
</table>

Iterator接口可以帮助我们便利集合内的元素。Iterator接口隐藏了底层集合的数据结构，向用户提供了便利各种数据类型的统一方法。Iterator接口内声明了方法:

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>hasNext()</td> 
   <td>判断集合是否便利结束，如果没有，则返还true</td> 
  </tr> 
  <tr> 
   <td>next()</td> 
   <td>返回下一个元素，指针指向下一个</td> 
  </tr> 
  <tr> 
   <td>remove()</td> 
   <td>从集合内删除上一个由next()方法返还的元素</td> 
  </tr> 
 </tbody> 
</table>

实例方法：

import java.util.*;
     public class Visitor {
       public static void print(Collection c) {
        Iterator it = c.iterator();
        while(it.hasNext()) {
             Object element = it.next();
             System.out.println(element);
         }
       }
       public static void main(String args[]) {
         Set set = new HashSet();
         set.add("Tom");
         set.add("Mary");
         set.add("Jack");
         print(set);
         List list = new ArrayList();
         list.add("Linda");
         list.add("Mary");
         list.add("Rose");
         print(list);
         Map map = new HashMap();
         map.put("M","男");
         map.put("F","女");
         print(map.entrySet());
        }
      }

# 2. 集合实现类型详述 #

## 2.1 Set类型 ##

集合的最简单的一种实现类型，Set类型内的元素无序、且不可重复。相当于实现了Collection接口，其中的实现类类型包括:

*  HashSet:按照HashSet的哈希算法存储集合内的对象，读取的速度较快；
 *  LinkedHashSet:HashSet的子类，不仅实现了HashSet，而且以链表的形式展现，链表的结构可以提高添加和删除集合对象的性能；
 *  TreeSet:实现SortSet接口，具有排序功能。(SortSet?)

一般的用法:Set存放的是对象的引用，没油重复的对象。

package com.us.demo.set;
    
    import java.util.HashSet;
    import java.util.Set;
    
    // 集合 Set类型
    public class SimpleSet {
        public static void main(String []args){
            Set set =new HashSet();
            String s1=new String ("s1");
            String s2=s1;
            String s3=new String("s3");
            // Add
            set.add(s1);
            set.add(s2);
            set.add(s3);
            System.out.println(set.size());// 输出为2
        }
    
    }
    // 问题一：为什么Set s =new HashSet()而不是Set s = new Set()
    // 问题二：还有List的时候也是List list = new ArrayList();为什么不写成ArrayList list = new ArrayList
    // http://bbs.csdn.net/topics/391049065?page=1

对于一个新的对象加入到Set内时？Set的Add方法时如何辨别这个对象内是否已经存在于集合中的呢？它遍历了Set对象，通过equals方法比较新的对象和旧的对象是否相等。具体做法如下所示：

public boolean myAdd(Set set,Object object){
            boolean isExit=false;
            Iterator iterator= set.iterator();
            while(iterator.hasNext()){
                Object tmp=iterator.next();
                if(tmp.equals(object)){
                    isExit=true;
                    break;
                }
            }
            return isExit;
        }

举例:

Set set = new HashSet();
     String s1 = new String("hello");
     String s2 = new String("hello");
     set.add(s1);
     set.add(s2);
     System.out.println(set.size());                 //集合中对象数目为1;

*  HashSet
    
    按照哈希算法来存储集合中的对象，存储集合内的对象的时候。HashSet会自动调用hashcode()方法来获取哈希码，然后根据哈希码进一步计算对象在内存内的位置。具体的什么是哈希算法情况算法章节。
    
    在Object类内定义了两个方法，hashCode()方法和equals(）方法。Object类的equals()方法是用来比较两个对象是否相等的。因此，如果`obj1.equals(obj2)=true`,那么obj1和obj2的内存地址相等，也就是引用了同样的一个对象，那么obj1和obj2的哈希值也肯定相等。
    
    当子类的没有覆盖equals()方法的时候，若`obj1.equals(obj2)=true`,那么这两者就是同一对象。另外，若子类覆盖了equals()方法，就比较obj1和obj2,进行equals()方法。

> 为了保证HashSet能正常工作， 要求当两个对象用equals()方法比较的结果为true时，它们的哈希码也相等。如果用户定义的Customer类覆盖了Object类的equals()方法，但是没有覆盖Object类的hashCode()方法，就会导致当customer1.equals(customer2)为true时，而customer1和customer2的哈希码不一定一样，这会使HashSet无法正常工作。(先调用对象的hashCode()方法比较,如果是true再调用equals方法比较,如果还是true再认为俩个对象是同一个)。

package com.us.demo.set;
    
    public class Customer { 
        public String name;
        public int size;
        public Customer(String name,int size){
            this.name=name;
            this.size=size;
        }
    
        public int getSize(){
            return this.size;
        }
    
        public String getName(){
            return this.name;
        }
        public boolean equals(Object o){
            if(this==o){
       return true;}
            if(! (o instanceof Customer)){
                return false;}
            else{
                Customer other=(Customer) o;
                if((other.name==this.name)&&(other.size==this.size)){
                    return true;
                }else{
                    return false;
                }
            }
        }
    
    }

示例程序:

package com.us.demo.set;
    
    import java.util.HashSet;
    import java.util.Set;
    
    public class SetTest {
        public static void main(String []args){
            Set set=new HashSet();
            set.add(new Customer("hello", 1));
            set.add(new Customer("hello", 1));
            System.out.println(set.size());//2
            // 说明除了 equals()方法外 还需要重写hashcode方法
        }
    }

出现以上原因在于customer1和customer2的哈希码不一样，因此为两为customer对象出不同的位置，于是把它们放到集中中的不同的地方。

我们还需要重写的hashcode()方法如下：

public int hashCode(){
        return this.age;
        }

*  TreeSet  
    TreeSet方法实现了SortSet方法，能够对于对象进行排序。当向TreeSet插入一个对象时，会把它插入到有序的对象队列内。那么TreeSethi如何将对象进行排序的呢？TreeSet支持两种排序的方式:自然排序和客户段化排序。默认情况下TreeSet采用的是自然排序。
    
    a. 自然排序
    
    在JDK类库中，有一部分实现了Compareable接口，如Integer、Double和String等。Compareable接口有一个compare()方法，返回整数类型。对于x.compare(y),如果

即想表示x比y大，即返回一个x比y大的值即可，猜测返回(x-y)的值。

TreeSet调用对象的compareTo()方法比较集合对象的大小，然后进行`升序`排序，这样的排序叫做自然排序。

JDK类库中实现了Comparable接口类的一些实现方式:

<table> 
 <thead> 
  <tr> 
   <th>类型</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Byte、Short、Integer、Long</td> 
   <td>按照数字大小排序</td> 
  </tr> 
  <tr> 
   <td>Float、Double</td> 
   <td>按照数字大小排序</td> 
  </tr> 
  <tr> 
   <td>Character</td> 
   <td>按照字符的Unicode字符的大小排序</td> 
  </tr> 
  <tr> 
   <td>string</td> 
   <td>按照字符串的字符的Unicode字符的大小排序</td> 
  </tr> 
 </tbody> 
</table>

使用自然排序，TreeSet类中只能加入相同的对象，这些对象必须实现了Comparable接口，否者就会报出ClassCastException异常。

需要特别注意的是:当改变了对象的属性后，TreeSet类不会重新排序。最适合TreeSet的是不可变对象(其属性不可变化)。

b. 客户化排序

除了自然排序外，TreeSet还支持客户化排序。java.util.Comparator接口提供了具体的排序方法，他有一个compare(Object x,Object y)方法，用于比较两个对象的大小。

当compare（x,y）方法，如果

如果希望TreeSet按照Customer对象的name属性进行排序，那么可以新建一个实现Comparator接口的CustomerComparator，参考如下代码:

package com.us.demo.set;
    import java.util.Comparator;
    import java.util.HashSet;
    import java.util.Iterator;
    import java.util.Set;
    import java.util.TreeSet;
    public class SetTest { 
        public class CustomerComparator implements Comparator{ 
            public int compare(Object o1,Object o2){
                Customer customer1=(Customer)o1;
                Customer customer2=(Customer)o2;
                if((customer1.name).compareTo(customer2.name)>0){
       return 1;}         
                else if((customer1.name).compareTo(customer2.name)<0){
       return -1;}
                else{ return 0;}
            }
        }
        public static void main(String []args){
    // Set set=new HashSet();
    // set.add(new Customer("hello", 1));
    // set.add(new Customer("hello", 1));
    // System.out.println(set.size());
    // // 说明除了 equals()方法外 还需要重写hashcode方法
            // http://stackoverflow.com/questions/16857925/no-enclosing-instance-of-type-mprogram-is-accessible-must-qualify-the-allocatio
            // No enclosing instance of type SetTest is accessible. 
            // Must qualify the allocation with an enclosing instance of type SetTest 
            // (e.g. x.new A() where x is an instance of SetTest).
            // 注意内部类的使用方法
            SetTest test1=new SetTest();
            Set set=new TreeSet(test1.new CustomerComparator());
            Customer customer1=new Customer("Abel", 10);
            Customer customer2=new Customer("Kitty", 10);
            Customer customer3=new Customer("Jett", 10);
            set.add(customer1);
            set.add(customer2);
            set.add(customer3);
    
            Iterator iterator=set.iterator();
            while(iterator.hasNext()){
                Customer customer=(Customer) iterator.next();
                System.out.println("name: "+(customer.name)+" size: "+(customer.size));
            }       
        }
    ｝

“\`  
打印输出

`name: Abel size: 10 name: Jett size: 10 name: Kitty size: 10`

## 2.2 List类型 ##

List类的主要特征是以线性的方式进行存储，集合中允许重复对象对象。主要的实现类包括：

*  ArrayList: 代表可变长度的数组，允许对元素进行快速的随机访问。但是向ArrayList中插入和删除元素的速度较慢；
 *  LinkedList: 在实现中采用链表的数据结构。使其有了链表的优势，那便是删除和插入的速度较快，而随机访问的速度较慢。
 *  Vector类 安全的集合
 *  （遍历的方式） a. `list.get(i) //通过索引检索对象`
 *  （遍历的方式） b. `Iterator it = list.iterator(); it.next();`

## 2.3 Map类型 ##

HashMap 是线程不安全的集合，HashTable 是线程安全的集合。TreeMap可以进行排序，对于其中的Key进行排序。  
Map是一种把键对象和值对象进行映射的集合。它的每一个对象包含了一对键值对。向Map内添加元素的时候，必须提供一对键值对。取元素的时候，只要给出键对象，就能返回对应的值对象。

map.put("2","Tuesday");
    map.put("3","Wedesday");
    map.put("4","Thursday");
    
    String day=map.get("2");

Map集合中的键对象不允许重复，如果以相同的键对象加入多个值对象，第一次加入的值对象会被覆盖。对于值对象则没有唯一性的要求，可以多个值对象，映射到同一个键对象。

map.put("1", "Mon");
     map.put("1", "Monday");      //"1"此时对应"Monday"
     map.put("one", "Monday");    //"one"此时对应"Monday"

Map有两种比较常见的实现：

*  HashMap
    
    按哈希算法来存取键对象，有很好的存取性能，为了保证HashMap能正常工作，和HashSet一样，要求当两个键对象通过equals()方法比较为true时，这两个键对象的hashCode()方法返回的哈希码也一样。
 *  TreeMap

Map map = new TreeMap();
      map.put("1", "Monday");
      map.put("3", "Wednsday");
      map.put("4", "Thursday");
      map.put("2", "Tuesday");
    
      Set keys = map.keySet();
      Iterator it = keys.iterator();
      while(it.hasNext()) {
         String key = (String)it.next();
         String value= (String)map.get(key);
         System.out.println(key + " " + value);
       }
    
      打印输出：
    
      1 Monday
      2 Tuesday
      3 Wednsday
      4 Thursday

注意，这边有一个需要注意的点。那就是，HashMap和HashTable有什么区别。