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

         */



    }



}