2017.02.28 list，set，map关系，区别细分析

来源：互联网发布：工业设计软件分类编辑：程序博客网时间：2024/06/11 00:22

今天看到String[] 数组的并集，交集，差集，顺便说一下这个的思路吧，其实最简单的

就是并集了，因为我们可以用set的特性（不保存重复的特性），直接保存

交集：思路：就是先把一个数组的所有数据放到一个map中，然后把value变成false，然后在是另外一个数组的如果遇到contians（key）有了，就把value变成true，这样true的就是交集了。

其实我第一种方法是把a数组放到一个set中，然后b数组去和这个比较，重复的就是交集

差集：先比较数组的长度，分出大小两个数组（这里大的叫a，小的叫b数组），然后让a数组判断是否在LinkedList c中，如果不在就加进去。然后看b数组，遍历元素，如果在c中存在，就说明是交集数据，从c中去掉，然后加到交集数据中。如果不在c中存在，这时候要判断是不是在交集中，如果还没有，就真的是差集了。这样出来的就是交集和差集的了。

好了，同志们，如果你们看到这，我希望您能给我回一个信，评论一下这篇文章，给我更多动力，谢谢。

因为他在这里面都是HashMap，LinkedList，所有我就想到为什么用这个了，我一直没细想这些东西，所以今天我要总结一下。

首先先说list，set，map的关系和区别：

List按对象进入的顺序保存对象，不做排序或编辑操作。Set对每个对象只接受一次，并使用自己内部的排序法(你只关心某个元素是否属于Set,而不关心它的顺序--否则应该使用List)。Map同样对每个元素保存一份，但这是基于"键"的，

Map也有内置的排序，因而不关心元素添加的顺序。如果添加元素的顺序对你很重要，应该使用 LinkedHashSet或者

LinkedHashMap.

详细介绍：
List特点：元素有放入顺序，元素可重复
Map特点：元素按键值对存储，无放入顺序
Set特点：元素无放入顺序，元素不可重复（注意：元素虽然无放入顺序，但是元素在set中的位置是有该元素的HashCode决定的，其位置其实是固定的）

下面说一下list

List接口有三个实现类：LinkedList，ArrayList，Vector

Arraylist和Vector是采用数组方式存储数据，LinkedList使用双向链表实现存储，按序号索引数据需要进行向前或向后遍历，
但是插入数据时只需要记录本项前后项即可，插入数据较快。
list接口：除了具有Collection接口必备的iterator()方法外，List还提供一个listIterator()方法，返回一个ListIterator接口，
和标准的Iterator接口相比，ListIterator多了一些add()之类的方法，允许添加，删除，设定元素，还能向前或向后遍历。

和LinkedList一样，ArrayList也是非同步的（unsynchronized）。

Vector类
　　Vector非常类似ArrayList，但是Vector是同步的。由Vector创建的Iterator，虽然和ArrayList创建的Iterator是同一接口，

但是，因为Vector是同步的，当一个Iterator被创建而且正在被使用，另一个线程改变了Vector的状态（例如，添加或删除了一些元素），

这时调用Iterator的方法时将抛出ConcurrentModificationException，因此必须捕获该异常。

set接口：HashSet，LinkedHashSet，TreeeSet

Set接口
Set不允许包含相同的元素，如果试图把两个相同元素加入同一个集合中，add方法返回false。
Set判断两个对象相同不是使用==运算符，而是根据equals方法。也就是说，只要两个对象用equals方法比较返回true，Set就不会接受这两个对象。

HashSet
HashSet有以下特点
 不能保证元素的排列顺序，顺序有可能发生变化
 不是同步的
 集合元素可以是null,但只能放入一个null
当向HashSet结合中存入一个元素时，HashSet会调用该对象的hashCode()方法来得到该对象的hashCode值，然后根据 hashCode值来决定该对象在HashSet中存储位置。
简单的说，HashSet集合判断两个元素相等的标准是两个对象通过equals方法比较相等，并且两个对象的hashCode()方法返回值相等
注意，如果要把一个对象放入HashSet中，重写该对象对应类的equals方法，也应该重写其hashCode()方法。其规则是如果两个对象通过equals方法比较返回true时，其hashCode也应该相同。另外，对象中用作equals比较标准的属性，都应该用来计算 hashCode的值。

LinkedHashSet
LinkedHashSet集合同样是根据元素的hashCode值来决定元素的存储位置，但是它同时使用链表维护元素的次序。这样使得元素看起来像是以插入顺序保存的，也就是说，当遍历该集合时候，LinkedHashSet将会以元素的添加顺序访问集合的元素。
LinkedHashSet在迭代访问Set中的全部元素时，性能比HashSet好，但是插入时性能稍微逊色于HashSet。

TreeSet类
TreeSet是SortedSet接口的唯一实现类，TreeSet可以确保集合元素处于排序状态。TreeSet支持两种排序方式，自然排序和定制排序，其中自然排序为默认的排序方式。向TreeSet中加入的应该是同一个类的对象。
TreeSet判断两个对象不相等的方式是两个对象通过equals方法返回false，或者通过CompareTo方法比较没有返回0
自然排序
自然排序使用要排序元素的CompareTo（Object obj）方法来比较元素之间大小关系，然后将元素按照升序排列。
Java提供了一个Comparable接口，该接口里定义了一个compareTo(Object obj)方法，该方法返回一个整数值，实现了该接口的对象就可以比较大小。
obj1.compareTo(obj2)方法如果返回0，则说明被比较的两个对象相等，如果返回一个正数，则表明obj1大于obj2，如果是负数，则表明obj1小于obj2。
如果我们将两个对象的equals方法总是返回true，则这两个对象的compareTo方法返回应该返回0
定制排序
自然排序是根据集合元素的大小，以升序排列，如果要定制排序，应该使用Comparator接口，实现 int compare(T o1,T o2)方法

Map：HashMap HashTable Treemap LinkedHashMap

在JavaSE中,对Map的实现主要包括: HashMap, TreeMap, HashTable 和 LinkedHashMap.
如果每个类都用一句话来描述,则表述如下:

HashMap 使用哈希表(hash table)实现, 在 keys 和/或 values 之中,都是无序的.
TreeMap 基于红黑树(red-black tree)数据结构实现, 按 key 排序.
LinkedHashMap 保持者插入顺序.
Hashtable 与HashMap实现方式一样,但Hashtable属于同步(synchronized)的.

所以如果代码是线程安全的,那么应该使用HashMap,因为Hashtable的同步是有一定量的运行代价的。而现今对于需要同步的Map，使用 ConcurrentHashMap 也比 Hashtable 有更高的效率。

2. HashMap
如果HashMap中的key使用的是自定义的类对象,那么需要遵守 equals() 与 hashCode() 规范.

[java] view plain copy
 
class Dog {  
    String color;  
   
    Dog(String c) {  
        color = c;  
    }  
    public String toString(){     
        return color + " dog";  
    }  
}  
   
public class TestHashMap {  
    public static void main(String[] args) {  
        HashMap<Dog, Integer> hashMap = new HashMap<Dog, Integer>();  
        Dog d1 = new Dog("red");  
        Dog d2 = new Dog("black");  
        Dog d3 = new Dog("white");  
        Dog d4 = new Dog("white");  
   
        hashMap.put(d1, 10);  
        hashMap.put(d2, 15);  
        hashMap.put(d3, 5);  
        hashMap.put(d4, 20);  
   
        //print size  
        System.out.println(hashMap.size());  
   
        //loop HashMap  
        for (Entry<Dog, Integer> entry : hashMap.entrySet()) {  
            System.out.println(entry.getKey().toString() + " - " + entry.getValue());  
        }  
    }  
}  

输出为:

[plain] view plain copy
 
4  
white dog – 5  
black dog – 15  
red dog – 10  
white dog – 20  

注意看,我们错误地添加了两次"white dogs",但是HashMap 接受了,这严格来说是没意义的,因为现在对"white dogs"的数量产生了混淆.
修正后的 Dog 类如下所示:

[java] view plain copy
 
class Dog {  
    String color;  
   
    Dog(String c) {  
        color = c;  
    }  
   
    public boolean equals(Object o) {  
        return ((Dog) o).color == this.color;  
    }  
   
    public int hashCode() {  
        return color.length();  
    }  
   
    public String toString(){      
        return color + " dog";  
    }  
}  

再运行新的代码,结果如下所示:

[plain] view plain copy
 
3  
red dog – 10  
white dog – 20  
black dog – 15  

原因在于 HashMap 不运行两个相同的元素作为KEY.
如果没有重写,使用的就会是 Object 类实现的 hashCode() 和 equals() 方法
默认的 hashCode() 方法实现对每个不同的对象返回不同的整数.
默认的 equals() 方法只比较两个引用是否指向同一个实际对象.

3. TreeMap
TreeMap是根据key排序的.我们先看下面的示例来加深 "按key排序" 的印象.

[java] view plain copy
 
class Dog {  
    String color;  
   
    Dog(String c) {  
        color = c;  
    }  
    public boolean equals(Object o) {  
        return ((Dog) o).color == this.color;  
    }  
   
    public int hashCode() {  
        return color.length();  
    }  
    public String toString(){     
        return color + " dog";  
    }  
}  
   
public class TestTreeMap {  
    public static void main(String[] args) {  
        Dog d1 = new Dog("red");  
        Dog d2 = new Dog("black");  
        Dog d3 = new Dog("white");  
        Dog d4 = new Dog("white");  
   
        TreeMap<Dog, Integer> treeMap = new TreeMap<Dog, Integer>();  
        treeMap.put(d1, 10);  
        treeMap.put(d2, 15);  
        treeMap.put(d3, 5);  
        treeMap.put(d4, 20);  
   
        for (Entry<Dog, Integer> entry : treeMap.entrySet()) {  
            System.out.println(entry.getKey() + " - " + entry.getValue());  
        }  
    }  
}  

执行后结果如下:

[plain] view plain copy
 
Exception in thread “main” java.lang.ClassCastException: collection.Dog cannot be cast to java.lang.Comparable  
at java.util.TreeMap.put(Unknown Source)  
at collection.TestHashMap.main(TestHashMap.java:35)  

既然 TreeMap 是按key排序的,那么key对象就必须可以和另一个对象作比较,因此必须实现 Comparable 接口。
当然，你也可以使用 String 对象作为key,因为 String 类已经实现了 Comparable 接口。
下面，我们修改 Dog 类的代码，使其实现Comparable：

[java] view plain copy
 
class Dog implements Comparable<Dog>{  
    String color;  
    int size;  
   
    Dog(String c, int s) {  
        color = c;  
        size = s;  
    }  
   
    public String toString(){     
        return color + " dog";  
    }  
   
    @Override  
    public int compareTo(Dog o) {  
        return  o.size - this.size;  
    }  
}  
   
public class TestTreeMap {  
    public static void main(String[] args) {  
        Dog d1 = new Dog("red", 30);  
        Dog d2 = new Dog("black", 20);  
        Dog d3 = new Dog("white", 10);  
        Dog d4 = new Dog("white", 10);  
   
        TreeMap<Dog, Integer> treeMap = new TreeMap<Dog, Integer>();  
        treeMap.put(d1, 10);  
        treeMap.put(d2, 15);  
        treeMap.put(d3, 5);  
        treeMap.put(d4, 20);  
   
        for (Entry<Dog, Integer> entry : treeMap.entrySet()) {  
            System.out.println(entry.getKey() + " - " + entry.getValue());  
        }  
    }  
}  

执行后输出的结果是:

[plain] view plain copy
 
red dog – 10  
black dog – 15  
white dog – 20  

这就是根据key对象排序的结果,此处我们使用了 size(尺寸)来比较 dog.
如果我们把
"Dog d4 = new Dog("white", 10);"
这一行代码替换为
"Dog d4 = new Dog("white", 40);"
那么，执行后的结果为:

[plain] view plain copy
 
white dog – 20  
red dog – 10  
black dog – 15  
white dog – 5  

原因是 TreeMap 使用 compareTo() 方法来比较 key对象,不同的 size 就被认为是不同的 dog.
4. Hashtable
根据Java文档, HashMap 类基本上等同于 Hashtable, 区别仅仅在于: HashMap 不是同步的,并且运行 null 值.
5. LinkedHashMap
LinkedHashMap 是 HashMap 的子类. 所以继承了所有 HashMap 的特性,另外, 链表保持了插入的顺序.
我们复制上面的 HashMap 的示例代码,并将HashMap替换为LinkedHashMap:

[java] view plain copy
 
class Dog {  
    String color;  
   
    Dog(String c) {  
        color = c;  
    }  
   
    public boolean equals(Object o) {  
        return ((Dog) o).color == this.color;  
    }  
   
    public int hashCode() {  
        return color.length();  
    }  
   
    public String toString(){     
        return color + " dog";  
    }  
}  
   
public class TestHashMap {  
    public static void main(String[] args) {  
   
        Dog d1 = new Dog("red");  
        Dog d2 = new Dog("black");  
        Dog d3 = new Dog("white");  
        Dog d4 = new Dog("white");  
   
        LinkedHashMap<Dog, Integer> linkedHashMap = new LinkedHashMap<Dog, Integer>();  
        linkedHashMap.put(d1, 10);  
        linkedHashMap.put(d2, 15);  
        linkedHashMap.put(d3, 5);  
        linkedHashMap.put(d4, 20);  
   
        for (Entry<Dog, Integer> entry : linkedHashMap.entrySet()) {  
            System.out.println(entry.getKey() + " - " + entry.getValue());  
        }         
    }  
}  

输出结果如下:

[plain] view plain copy
 
red dog – 10  
black dog – 15  
white dog – 20  

区别在于 HashMap输出的结果顺序与插入顺序是无关的.
下面再次列出使用 HashMap的输出结果以供对比:

[plain] view plain copy
 
red dog – 10  
white dog – 20  
black dog – 15  

别忘了留言！

0 0