数组与集合的区别（内含集合的分类以及相关方法的使用）

关于数组与集合的区别：
一、不同点：
1） 存储的数据类型方面：
数组：可以存储基本类型的数据，也可以存储引用类型的数据：

   例如：int[] a = {1,2,3};//存储基本类型的数据；
              String[] str = {"123","chen"};//存储引用类型的数据。

集合：只能存储引用类型的数据，想要存储基本类型的数据，就得用到基本类型的包装类。（基本类 型与包装类的转换在上篇文章！）
2）长度方面：
数组：数组的长度固定；
集合：集合的长度可以改变。
二、相同点：
1）数组和集合都是引用类型；
2）数组和集合都可以存储多个元素。

接下来我们分别讨论数组和集合：

数组：
数组的两种常见的创建方式：
1）动态创建：
int[] arr = new int[10];//创建一个长度为10的数组，默认初始值为0（String 默认为 null…）；
2)静态创建：
int[] arr = {1,2,3,4,5};//给定初始值，初始长度。
数组的求长度的方法：
int[] arr = new int[10];//定义一个数组
int longarr = arr.length();//将数组长度赋值给一个int变量；int 变量名 = 数组名.length;

集合（Collection）：
Collection常用的方法：

                           1）public boolean add(E e)把给定的对象添加到当前的集合中；
                           2）public boolean remover(E e)把给定的对象在集合中删除
                           3）public boolean contains(Object obj)判断当前集合中是否包含给定的对象。
                           4）public boolean isEmpty()判断当前集合是否为空
                           5）public int size()返回当前集合中的元素个数；
                           6）public Object[] toArray()把集合中的元素存储到数组中
                           7）public void clear()清空集合中的所有元素。

常见的集合有set集合和list集合和map集合：
list集合：

    特点：1）有序；2）可以存储重复的元素；3）有索引的方法；
    set集合其中的两种（ArrayList和LinkedList）：
               相同点：1）有序；2）可以存储重复的元素；3）有索引的方法；
               不同点：
                   ArrayList：是一个单向链表；（存储快，查询慢）
                    底层：数组
                      常用方法：
                            1）public boolean(E e)将指定泛型的元素追加到此集合的末尾，存储成功返回true，反之，返回false；
                            2）public void add(int index,E element)在此集合的指定位置插入指定元素；
                            3）public boolean remove(Object o)删除指定元素，删除成功返回true，反之，返回false；（只删除第一个）
                            4）public E remove(int index)删除指定位置的元素，删除成功返回被删除的元素。
                            5）public E set(int index,E element)修改指定索引处的元素，返回被修改的元素；
                            6）public E get(int index)返回指定索引处的元素；
                            7）public int size()返回集合中元素的个数；
                            
                   LinkedList：是一个双向链表；（查询块，存储慢）
                     底层：双向链表
                      常用方法：
                            LinkedList特有的方法（不建议使用多态）：
                            1）public void push(E e)将元素推入此列表所表示的堆栈；（在集合开始添加一个元素）
                            2）public void addLast(E e)将指定元素添加到此列表的结尾；
                            3）public E getFirst()返回此列表的第一个元素；
                            4）public E getLast()返回此列表的最后一个元素；
                            5）public E removeFirst()删除并返回此列表的第一个元素；
                            6）public E removeLast()删除并返回此列表的最后一个元素；
                            7）public E pop()从此列表所表示的堆栈中弹出一个元素。（删除第一个元素）
                            8）public E removeLast()移除并返回此列表最后的一个元素；
                            9）public boolean isEmpty()如果列表不包含元素，返回true.

set集合：

      特点：1）没有索引的方法；2）不可存储重复元素。
     set集合其中的两种：
        HashSet：1）是一个无序的集合；2）不允许存储重复元素；3）不含带索引的方法；
                     底层（哈希表）：
                            JDK1.8之前： 数组 + 单向链表 
                            JDK1.8之后： 数组 + 单向链表 或者 数组 + 红黑树
         LinkedHashSet：1）是一个有序的集合；2）不允许存储重复元素；3）不包含带索引的方法；
                     底层（Linked哈希表）：
                             JDK1.8之前： 数组 + 单向链表 + 单向链表
                            JDK1.8之后： 数组 + 单向链表 + 单向链表 或者 数组 + 红黑树 + 单向链表

map集合：

        特点：
        1）Map集合是一个双列集合，每个元素包含两个值（键值对），一个key；一个value。
        2）Map集合中的key不允许重复，value允许重复。
        3）Map集合中的key只能对应一个value
        4）Map集合种的key和value的类型可以是一样的，也可以是不一样的。
        5）不能存储null的key和null的value；
        常用方法：
        1）public V put(k key,V value):把指定的键与指定的值添加到Map集合中；
        2）public V remover(Object key)：把指定的键所对应的键值对元素在Map集合中删除，返回被删除的元素；
        3）public V get(Object key)：根据指定的键，在Map集合中获取对应的值。
        4）public boolean containKey(Object key)：判断集合中是否有此键；
        5）public Set<K> keySet()：获取Map集合中的所有键，存储到Set集合中。
        6）Set<Map.Entry<K,V>> entryset()：取出Map集合中所有的Entry对象，存储到Set集合中：
                 使用Entry集合中的方法：
                            A)、K getKey() 获取键
                            B)、V getValue() 获取值
       Map其中的两种：
          HashMap：1）是一个无序的集合；2）不允许存储重复元素；3）不含带索引的方法；
                 底层（哈希表）：
                        JDK1.8之前： 数组 + 单向链表 
                        JDK1.8之后： 数组 + 单向链表 或者 数组 + 红黑树
     LinkedHashMap：1）是一个有序的集合；2）不允许存储重复元素；3）不包含带索引的方法；
                 底层（Linked哈希表）：
                         JDK1.8之前： 数组 + 单向链表 + 单向链表
                        JDK1.8之后： 数组 + 单向链表 + 单向链表 或者 数组 + 红黑树 + 单向链表

HashMap两种遍历：
一、按键找值：

import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class Demo01HashMap {
    public static void main(String[] args) {
        Map<Integer,String> hashMap = new HashMap<>();
        hashMap.put(1,"张三");
        hashMap.put(2,"李四");
        hashMap.put(3,"王五");
        //方式一：键找值：
        Set<Integer> key = hashMap.keySet();
        for (Integer k : key) {
            String name = hashMap.get(k);
            System.out.println("key:" + k + "      value:" + name);
        }
    }
}

二、键值对：

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class Demo01HashMap {
    public static void main(String[] args) {
        Map<Integer,String> hashMap = new HashMap<>();
        hashMap.put(1,"张三");
        hashMap.put(2,"李四");
        hashMap.put(3,"王五");
        //方式二：键值对：
            //利用HashMap中的entrySet方法，将HashMap元素中的键值对存储到Set集合中；
        Set<HashMap.Entry<Integer,String>> entry = hashMap.entrySet();
            //创建一个迭代器
        Iterator<Map.Entry<Integer, String>> it = entry.iterator();
        //遍历：
        while(it.hasNext()){
            Map.Entry<Integer,String> map = it.next();
            int k = map.getKey();
            String v = map.getValue();
            System.out.println("key:" + k + "      value:" + v);
        }


    }
}

一些特殊的集合：
Vector（单列集合的“鼻祖”）

  Vector（最早期的集合，JDK1.0时期）：实现了List接口。采用了同步技术（悲观锁【后面会写】）;他也是数组结构：查询快，增删慢。因为
  采用的悲观锁，保证了他的多线程的安全性，但是降低了效率，JDK1.0之后被逐渐淘汰。

HashTable（JDk1.0版本就存在的双列集合）：

  采用了同步技术（悲观锁【后面会写】，因为采用的悲观锁，保证了他的多线程的安全性，但是降低了效率。
  底层：哈希表结构；
  特点：不能存储null键和null值；