JAVA基础学习之 Map集合、集合框架工具类Collections，Arrays、可变参数、List和Set集合框架什么时候使用等（4）

package com.itcast.test20140113;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class MainDemo {

    public static void main(String[] args) {
        // Map集合使用
        //MapUser();

        /*
         * 泛型 运行时，会将泛型去掉，生成的class文件中是不带泛型的，这个称为泛型的擦除 为什么擦除呢？是为了兼容运行的类加载器。 泛型限定 ?
         * extends E 接收E类型或者E的子类型对象。上限，存储元素的时候使用上限 ? super E
         * 接收E类型或者E的父类型。下限，获取元素的时候使用下限 public void printCollection(Collection<?
         * extends Person> collection) 通配符 public void
         * printCollection(Collection<?> collection)
         */

        // 集合框架工具类使用
        CollectionUtilUser();
        
        /*
         * Arrays.toString(array);//数组toString[2,3,4]
         */
        List<String> stooges = Arrays.asList("Larry", "Moe", "Curly");
        System.out.println(stooges);// [Larry, Moe, Curly]
        
        /*
         * 如果数组中的元素是对象，那么转成集合时，直接将    数组中的元素    作为集合中的元素存储
         * 如果数组中的元素是基本类型数组，那么会将该           数组                     作为集合中的元素进行存储
         */
        int[] array = { 1, 3, 4 };
        List<int[]> list = Arrays.asList(array);//将数组进行集合存储
        System.out.println(list);// [[I@4aa0b07b]
        Integer [] array1 = { 1, 3, 4 };
        List<Integer> integers = Arrays.asList(array1);//将数组中的元素进行集合存储
        System.out.println(integers);// [1, 3, 4]
        
        Integer [] integers2 = integers.toArray(new Integer[integers.size()]);//集合转换为数组
        System.out.println(Arrays.toString(integers2));
        
        //可变参数
//        public static String Params(int... params){
//            return  Arrays.toString(params);
//        }
//        System.out.println(Params(1,2,3));//int... 就是int[]
        
    }
    
    

    /**
     * 集合框架工具类使用
     */
    public static void CollectionUtilUser() {
        /*
         * Collections.sort(list);排序
         * Collections.sort(list,CompareByStringLength);自定义对象 实现Comparator接口进行比较
         * Collections.binarySearch(list, key)//折半查找，要先排序，然后再查询，查询list集合中值为key的索引，找不到返回负数
         * Collections.max(list);//集合中最大值
         * Collections.reverse(list);//反转集合
         * Collections.replaceAll(list, oldVal, newVal);
         * Collections.shuffle(list);//随机集合中的元素顺序
         * Collections.synchronizedCollection(collection);将非同步集合转为同步集合
         * Collections.synchronizedList(list);
         * Collections.synchronizedMap(m);
         * Collections.synchronizedSet(s);
         */
    }

    /**
     * Map集合使用
     */
    public static void MapUser() {
        /*
         * Map集合中存储的就是键值对 常用方法： value
         * put(key,value)存储value，返回前一个和key关联的值，如果没有相同的key，返回null void clear（）
         * value remove(key) boolean containsKey(key) boolean
         * containsValue(value) boolean isEmpty() value
         * get(key)通过键获取值，如果没有改键，返回null int size（）
         */

        /*
         * 根据键获取值
         */
        Map<Integer, String> map = new HashMap<Integer, String>();
        map.put(1, "a");
        map.put(2, "b");
        map.put(3, "c");
        // 第一种方式
        Set<Integer> set = map.keySet();
        // Collection<String> collection = map.values();
        for (Integer integer : set) {
            System.out.println(integer + ":" + map.get(integer));
        }
        // 第二种方式
        Set<Entry<Integer, String>> entrySet = map.entrySet();
        for (Entry<Integer, String> entry : entrySet) {
            System.out.println(entry.getKey() + ":" + entry.getValue());
        }

        /*
         * Map常用的子类： Hashtable：内部结构是哈希表，是同步的，不允许null作为键，null作为值
         * HashMap：内部结构是哈希表，不是同步的，允许null作为键，null作为值。
         * TreeMap：内部结构是二叉树，不是同步的，可以对Map集合中的键进行排序
         * HashMap的子类LinkedHashMap:存的时候和取得元素的位置顺序相同
         */

        /*
         * List和Set集合框架什么时候使用 
         * 如果需要唯一：Set 
         *                 需要指定顺序：TreeSet 
         *                  但是想要一个和存储一致的顺序:LinkedHashSet 
         *                     不需要: HashSet
         *              不需要： List 
         *                 需要频繁增删:LinkedList 
         *                     不需要:ArrayList
         */

    }

}