Java基础学习（二）---集合

+#+##集合的基础知识总结–

为啥会有集合?

第一个原因：在我们编程的时候，常常会需要存放多个数据元素，这时候我们没办法用数组来存，因为数组的长度不可变。如果需要存放数量变化的数据，数组就没办法来处理了。
第二个原因：数组没办法存放具有映射关系的数据，比如成绩表，语文–77，数学–99，英语–66，这个可以看成两个数组，但这两个数组的映射关系无法表示。

数组和集合的区别

1.数组的长度不变，集合长度可变。
2.数组可以存放基本类型的值，也可以是对象（实际上存放的是对象的引用变量），集合里只能存放对象。

集合的分类

集合之所以有很多分类，是根据数据结构不同，底层的存储方式不同，所以有多种集合类。
java的集合主要是由两个接口派生的：Collection(单列集合)和Map(双列集合)，在这两大接口下，又有许多子接口或实现类。

个个集合的简述特点

1Collection(单列集合)
        1.1List(有序,可重复)
            1.1.1ArrayList
                底层数据结构是数组,查询快,增删慢
                线程不安全,效率高
            1.1.2Vector
                底层数据结构是数组,查询快,增删慢
                线程安全,效率低
            1.1.3LinkedList
                底层数据结构是链表,查询慢,增删快
                线程不安全,效率高
        1.2Set(无序,唯一)
            1.2.1HashSet
                底层数据结构是哈希表。
                哈希表依赖两个方法：hashCode()和equals()
                执行顺序：
                    首先判断hashCode()值是否相同
                        是：继续执行equals(),看其返回值
                            是true:说明元素重复，不添加
                            是false:就直接添加到集合
                        否：就直接添加到集合
                最终：
                    自动生成hashCode()和equals()即可

                    LinkedHashSet
                    底层数据结构由链表和哈希表组成。
                    由链表保证元素有序。
                    由哈希表保证元素唯一。
            1.3.1TreeSet
                底层数据结构是红黑树。(是一种自平衡的二叉树)
                如何保证元素唯一性呢?
                    根据比较的返回值是否是0来决定
                如何保证元素的排序呢?
                    两种方式
                        自然排序(元素具备比较性)
                            让元素所属的类实现Comparable接口
                        比较器排序(集合具备比较性)
                            让集合接收一个Comparator的实现类对象

2.Map(双列集合)
    A:Map集合的数据结构仅仅针对键有效，与值无关。
    B:存储的是键值对形式的元素，键唯一，值可重复。

    2.1HashMap
        底层数据结构是哈希表。线程不安全，效率高
            哈希表依赖两个方法：hashCode()和equals()
            执行顺序：
                首先判断hashCode()值是否相同
                    是：继续执行equals(),看其返回值
                        是true:说明元素重复，不添加
                        是false:就直接添加到集合
                    否：就直接添加到集合
            最终：
                自动生成hashCode()和equals()即可
        2.1.1LinkedHashMap
            底层数据结构由链表和哈希表组成。
                由链表保证元素有序。
                由哈希表保证元素唯一。
    2.2Hashtable
        底层数据结构是哈希表。线程安全，效率低
            哈希表依赖两个方法：hashCode()和equals()
            执行顺序：
                首先判断hashCode()值是否相同
                    是：继续执行equals(),看其返回值
                        是true:说明元素重复，不添加
                        是false:就直接添加到集合
                    否：就直接添加到集合
            最终：
                自动生成hashCode()和equals()即可
    2.3TreeMap
        底层数据结构是红黑树。(是一种自平衡的二叉树)
            如何保证元素唯一性呢?
                根据比较的返回值是否是0来决定
            如何保证元素的排序呢?
                两种方式
                    自然排序(元素具备比较性)
                        让元素所属的类实现Com储arable接口
                    比较器排序(集合具备比较性)
                        让集合接收一个Comparator的实现类对象

如何挑选哪种存储方式

是否是键值对象形式:
        是：Map
            键是否需要排序:
                是：TreeMap
                否：HashMap
            不知道，就使用HashMap。

        否：Collection
            元素是否唯一:
                是：Set
                    元素是否需要排序:
                        是：TreeSet
                        否：HashSet
                    不知道，就使用HashSet

                否：List
                    要安全吗:
                        是：Vector
                        否：ArrayList或者LinkedList
                            增删多：LinkedList
                            查询多：ArrayList
                        不知道，就使用ArrayList
            不知道，就使用ArrayList

集合的几种遍历方式

集合类的通用遍历方式, 用迭代器迭代:
1.创建迭代器对象
2.创建元素对象
3.把元素添加到集合中
4.通过集合对象获取迭代器对象
5.通过迭代器对象的hasNext()方法来判断是否有元素
6.通过迭代器对象的next（）方法来获取下一个位置

Iterator it = list.iterator();//通过集合对象获取迭代器对象

while(it.hasNext()) {
　　Object obj = it.next();
}

Map遍历方式：

1、通过获取所有的key按照key来遍历

//Set<Integer> set = map.keySet(); //得到所有key的集合
for (Integer in : map.keySet()) {
    String str = map.get(in);//得到每个key多对用value的值
}

2、通过Map.entrySet使用iterator遍历key和value

Iterator<Map.Entry<Integer, String>> it = map.entrySet().iterator();
while (it.hasNext()) {
     Map.Entry<Integer, String> entry = it.next();
       System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
}

3、通过Map.entrySet遍历key和value，推荐，尤其是容量大时

for (Map.Entry<Integer, String> entry : map.entrySet()) {
    //Map.entry<Integer,String> 映射项（键-值对）  有几个方法：用上面的名字entry
    //entry.getKey() ;entry.getValue(); entry.setValue();
    //map.entrySet()  返回此映射中包含的映射关系的 Set视图。
    System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
}

4、通过Map.values()遍历所有的value，但不能遍历key

for (String v : map.values()) {
    System.out.println("value= " + v);
}

List遍历方式：

第一种：

for(Iterator iterator = list.iterator();iterator.hasNext();){                    
    int i = (Integer) iterator.next();                   
    System.out.println(i);               
}

第二种

Iterator iterator = list.iterator();
while(iterator.hasNext()){
    int i = (Integer) iterator.next();
    System.out.println(i);
}

第三种：

for (Object object : list) { 
    System.out.println(object); 
}

第四种：

for(int i = 0 ;i<list.size();i++) {  
    int j= (Integer) list.get(i);
    System.out.println(j);  
}

Collections 操作集合的工具类（都是静态的方法）

//几种常见的方法

 * public static<T> void sort(List<T> list) 排序，默认是自然排序
 * public static<T> int binarySearch(List<> List,t Key);二分查找
 * public static<T> T max(Collection <> coll): 最大值
 * public static void reverse(List<?> List):反转
 * public static void shuffle(List<> List):随机置换
 * 
 */
public class CollectionsDome {

    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        List<Integer> list = new ArrayList<Integer>();
        list.add(30);
        list.add(50);
        list.add(30);
        list.add(40);
        list.add(10);
        list.add(20);
        System.out.println("list" + list);
        System.out.println("-------------");
        Collections.sort(list);
        System.out.println("list"+list);
    }
    //结果
    //list[30, 50, 30, 40, 10, 20]
    //-------------
    //list[10, 20, 30, 30, 40, 50]


}