Java——集合

1、ArrayList 、LinkedList 、Vector

• ArrayList:    底层数组实现；方法不同步，非线程安全；查询快、增删慢
• LinkedList    底层双向链表实现；方法不同步，非线程安全；查询慢、增删快
• Vector        底层数组实现；方法同步，线程安全；
  
  总结：需要线程同步使用Vector，经常查询使用ArrayList，经常插入删除使用LinkedList
  
  

  import java.util.ArrayList;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Vector;
  
  public class ListDemo {
  
      public static void main(String[] args) {
          // ArrayList非线程安全
          List<String> list1;
          list1 = new ArrayList<String>();
          list1.add("a");
          list1.add("b");
          list1.add("c");
          list1.remove(0);
          for (int i = 0; i < list1.size(); i++) {
              System.out.println(list1.get(i));
          }
          System.out.println("集合是否为空：" + list1.isEmpty());
  
          // Vector是线程安全的
          List<String> list2;
          list2 = new Vector<String>();
          list2.add("f");
          list2.add("g");
          list2.add("h");
          list2.remove(0);
          for (int i = 0; i < list2.size(); i++) {
              System.out.println(list2.get(i));
          }
          System.out.println("集合是否为空：" + list2.isEmpty());
  
          // LinkedList 线程不安全
          List<String> list3;
          list3 = new LinkedList<String>();
          list3.add("c");
          list3.add("v");
          list3.add("b");
          list3.remove(0);
          for (int i = 0; i < list3.size(); i++) {
              System.out.println(list3.get(i));
          }
          System.out.println("集合是否为空：" + list3.isEmpty());
      }
  
  }

  

2、Set 的HashSet和TreeSet

import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;

public class SetDemo {

    public static void main(String[] args) {
        // HashSet是无序、不重复
        Set<String> set1;
        set1 = new HashSet<String>();
        set1.add("a");
        set1.add("b");
        set1.add("c");
        set1.add("a");// 重复了，不会放进去
        System.out.println(set1);
        System.out.println(set1.size());

        // TreeSet是有序、不重复
        Set<String> set2;
        set2 = new TreeSet<String>();
        set2.add("a");
        set2.add("b");
        set2.add("c");
        set2.add("a");// 重复了，不会放进去
        System.out.println(set2);
        System.out.println(set2.size());
    }
}

3、Iterator

有三个方法：

hasNext()、next()、remove()

当对集合进行迭代操作时，不能使用集合的remove()方法

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class IteratorDemo {

    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");

        Iterator<String> iter = list.iterator();
        while (iter.hasNext()) {
            String str = iter.next();
            if ("a".equals(str)) {
                iter.remove();//这里不可以用list.remove()
            } else {
                System.out.println(str);
            }
        }
    }

}

4、hashcode和equal

• 如果两个对象的hashcode值不相等——>必定是两个不同的对象

• 如果两个对象的hashcode值相等，是同一个对象，但是内容可能相同，也不能不同，就还要进行equals()判断，如果为true 表示两个对象相同，如果为false 则表示是两个不同对象

当使用hashmap时，首先调用加入对象的hashCode方法得到hashCode值，判断已经存在的对象的hashCode值是否与加入对象的HashCode值相等，如果不相等，说明是不同的对象，直接加进去，如果hashcode值相等，再进行equals判断，如果为true ，说明对象已经加进去，就不会在增加新的对象，如果为false 则直接加进去。

String类已经重写了Object类的hashcode()和equals(),所以两个不同的字符串对象，内容相同，那么hashcode值就相同

5、Map

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class MapDemo {

    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        // put()添加
        map.put("key1", "value1");
        map.put("key2", "value2");
        map.put("key3", "value3");

        System.out.println(map.get("key1"));// get()方法取值

        System.out.println("key1是否存在:" + map.containsKey("key1"));
        System.out.println("value1是否存在:" + map.containsValue("value1"));

        Set<String> set = map.keySet();// 把key保存在一个set集合中
        // 便利set集合
        Iterator<String> iter1 = set.iterator();
        while (iter1.hasNext()) {
            System.out.println(iter1.next());
        }

        Collection<String> set2 = map.values();// 把value保存在一个Collection集合中
        // 便利set集合
        Iterator<String> iter2 = set2.iterator();
        while (iter2.hasNext()) {
            System.out.println(iter2.next());
        }
    }
}

6、HashMap、LinkedHashMap、CurrentHashMap

• HashMap   基于hash算法的Map接口的非同步实现，非线程安全；通过put(key ,value)和get(key)存取对象，put时，对key的hashcode值进行hash计算（可以理解为得到一个index）得到这个元素在数组中的位置，并将元素存储到该位置上，get时，通过对key的hashcode值的hash计算得到在数组中的位置，然后将该位置的元素取出。HashMap是无序的，内部维护的是单链表
  
  
• LinkedHashMap   底层使用哈希表与双向链表保存元素，非线程安全，LinkedHashMap是有序的，有插入顺序和访问顺序，内部维护的是一个双向链表
  
  
• CurrentHashMap   基于双数组和链表的Map接口的同步实现，线程安全
  

  HashMap是非线程安全的，当只有一个线程使用HashMap时没有问题，如果涉及到多个线程，就不能使用HashMap了，这时可以使用currentHashMap

7、HashMap和HashTable

• HashMap    方法是非同步的，非线程安全；基于AbstractMap类，而AbstractMap类是Map接口的实现；key value都可以为null
• HashTable    方法同步，线程安全，基于Dictionary类，key value都不能为null