第十八天笔记

黑马程序员 <a href="http://www.itheima.com" target="blank">java培训</a>

第十八天笔记

1.Map集合概述和特点

Collection集合---set list 它们都是单列集合

Map-----它是一个双列结合，它在存储是是以key-value存在的,它的key值是唯一的。

Map是一个接口，它和collection无关，它们是并列结构。

2.Map集合的功能概述

主要学习：hashmap treemap

Map中的方法：

3.添加操作 put

Public object put（Object key，Object value）

参数：key value 表示要存储的键值对

返回值：如果为null，代表key不重复，key-value存储了，如果不为null，代表key重复了，返回的是被替换的元素。

获取操作 get

Public object get（Object key）

作用：根据key获取相应的value值。

获取操作 keySet

Public Set keySet（）

作用：获取map集合中所有key的一个Set集合。

获取操作 vslues

Public Collection vslues（）

作用：获取map中的value的一个Collection集合

获取操作 entrySet

Public set<Entry> entrySet（）

作用：获取所有的key-value映射的一个set集合。

删除操作 clear

Public void clear（）

Public Object remove(Object key)

作用：根据key解除映射关系，返回的就是value值。

得到集合的长度

Public int size（）；

判断操作

Public boolan isEmpty（）

Public Boolean containsKey( Object key) 判断是否包含指定的key值

Public Boolean containsValue(Object value) 判断是否包含指定的value值

public class MapDemo2 {

    public static void main(String[] args) {

        // putTest();
        // clearTest();

        // removeTest();
        checkTest();
    }

    // 1.存储 put
    public static void putTest() {
        Map<String, Integer> map = new HashMap<String, Integer>();
        System.out.println(map.put("张三", 10));
        map.put("李四", 20);
        map.put("王五", 30);
        System.out.println(map.put("张三", 100));
        System.out.println(map);
    }

    // 2.删除
    public static void clearTest() {
        Map<String, Integer> map = new HashMap<String, Integer>();
        map.put("李四", 20);
        map.put("王五", 30);

        map.clear();// 清空map

        System.out.println(map);
    }

    // 3.remove
    public static void removeTest() {
        Map<String, Integer> map = new HashMap<String, Integer>();
        map.put("李四", 20);
        map.put("王五", 30);

        System.out.println(map.remove("李四"));

        System.out.println(map);
    }

    // 4.判断
    public static void checkTest() {
        Map<String, Integer> map = new HashMap<String, Integer>();
        map.put("李四", 20);
        map.put("王五", 30);

        // 判断是否为空
        System.out.println(map.isEmpty());
        //判断是否包含指定的key
        System.out.println(map.containsKey("李四"));
        //判断是否包含指定的value
        System.out.println(map.containsValue(20));

        System.out.println(map);
    }
}

4.Map集合获取功能测试

get
keyset

value

public class MapDemo3 {

    public static void main(String[] args) {
        // getTest();
        // keySetTest();
        valuesTest();
    }

    // 1.get
    public static void getTest() {
        Map<String, String> map = new HashMap<String, String>();
        map.put("one", "aaa");
        map.put("two", "bbb");
        map.put("3", "ccc");

        String v1 = map.get("one1");
        System.out.println(v1);

        String v3 = map.get(3);
        System.out.println(v3);
    }

    // 2.keySet
    public static void keySetTest() {
        Map<String, String> map = new HashMap<String, String>();
        map.put("one", "aaa");
        map.put("two", "bbb");
        map.put("3", "ccc");

        Set<String> set = map.keySet();
        System.out.println(set);
    }

    // 3. values
    public static void valuesTest() {
        Map<String, String> map = new HashMap<String, String>();
        map.put("one", "aaa");
        map.put("two", "bbb");
        map.put("3", "ccc");
        Collection<String> c = map.values();
        System.out.println(c);
    }
}

5. Map集合的遍历值键找值

使用map.KeySet方法得到所有的Set

遍历Set，就得到了每一个key，在根据map.get（key），对应的value。

public class MapDemo4 {

    public static void main(String[] args) {
        //1.定义Map集合，装入数据
        Map<String, String> map = new HashMap<String, String>();
        map.put("one", "aaa");
        map.put("two", "bbb");
        map.put("3", "ccc");
        //2.得到所有的key
        Set<String> keys=map.keySet();
        
        //3.遍历keys这个Set集合，就得到了Map集合中所有的key
        for(String key:keys){
            //4.根据key获取对应的value.
            System.out.println("key:"+key+"  value:"+map.get(key));
        }
    }
}

6. Map集合的遍历值键值对对象找键和值

entrySet方法返回的是一个Set集合，而集合中的对象是Map.Entry类型，对于Entry,我们可以使用泛型来规范它，它的泛型就是Map集合的泛型。

Set<Map.Entry<K, V>> entrySet(); entrySet方法的返回值是Set集合，集合中的元素是 Map.Entry ，通过查找源代码发现 Entry是一个接口，而这个接口是定义在Map接口中。

public class MapDemo5 {

    public static void main(String[] args) {
        // 1.定义Map集合，装入数据
        Map<String, String> map = new HashMap<String, String>();
        map.put("one", "aaa");
        map.put("two", "bbb");
        map.put("3", "ccc");

        // 2.调用map集合的entrySet方法
        // Set<Entry<String, String>> set = map.entrySet();
        // //
        // entrySet方法返回的是一个Set集合，而集合中的对象是Map.Entry类型，对于Entry,我们可以使用泛型来规范它，它的泛型就是Map集合的泛型
        // for (Entry<String, String> en : set) { // 从Set集合中遍历出来的就是Map.Entry类型对象
        // System.out.println(en.getKey() + "  " + en.getValue()); //
        // 可以通过Map.Entry的getKey,getValue,获取对应的key与value.
        //
        // }
        
        // for(Map.Entry<String, String> en:map.entrySet()){
        //
        // }
        //
        // for(String key:map.keySet()){
        //
        // }
    }
}

7.关于集合的选择

Collection

List

ArrayList LinkedList Vector

Set

HashSet TreeSet

Map

HashMap

TreeMap

关于集合选择:

存储时是直接存储值，还是以key-value存储。

Collection Map

如果选择了Map集合

在实际开发中，对于Map集合，我们就选择HashMap,不使用TreeMap。

虽然TreeMap集合可以排序，但是在实际操作中，排序也不使用它。

8.集合Collections工具类

Collections它是集合的工具类。这个类在java.util包下，它主要功能是对Collection这样的集合进行操作。它的方法全是静态的。

常用方法：

binarySearch 二分法查找

copy 集合的复制

fill 对集合中元素赋值

max min 得到集合中最大值与最小值

reverse 对集合元素进行反转

shuffle 对集合中元素进行乱序

sort

swap 对集合中指定位置上的两个元素进行交换

synchronizedXxx（List Set Collection Map）将非同步的集合转换成同步集合

public class CollectionsDemo1 {

    public static void main(String[] args) {
        // maxAndminTest();

        // sortTest();

        // reverseTest();

        // shuffleTest();

        // swapTest();

        // fillTest();

        // copyTest();

        binarySearchTest();
    }

    // binarySearch 二分法查找，要求首先有顺序
    public static void binarySearchTest() {
        List<Integer> list = new ArrayList<Integer>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(5);
        list.add(6);
        list.add(7);
        list.add(8);
        list.add(9);
        int index = Collections.binarySearch(list, 4);
        System.out.println(index);
    }

    // copy
    public static void copyTest() {
        List<Integer> list = new ArrayList<Integer>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        List<Integer> dest = new ArrayList<Integer>();
        dest.add(5);
        dest.add(6);
        dest.add(7);
        dest.add(8);

        Collections.copy(dest, list);
        System.out.println(dest);
    }

    // fill
    public static void fillTest() {
        List<Integer> list = new ArrayList<Integer>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);

        Collections.fill(list, 5); // 将集合中所有元素使用5替换.

        System.out.println(list);

    }

    // swap 将指定位置上的元素交换
    public static void swapTest() {
        List<Integer> list = new ArrayList<Integer>();

        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);

        System.out.println(list);
        Collections.swap(list, 1, 2); // 将集合中索引值为1,2的元素位置交换

        System.out.println(list);
    }

    // 1.max min
    public static void maxAndminTest() {
        List<Integer> list = new ArrayList<Integer>();

        list.add(10);
        list.add(300);
        list.add(110);
        list.add(1109);
        Integer max = Collections.max(list);
        System.out.println(max);
        Integer min = Collections.min(list);
        System.out.println(min);

        // 问题:如果集合中的元素象我们上面的是Integer,那么它们的比较可以按数字比较，如果集合中是Student对象哪，那么max,min获取的是什么?
        // 如果集合中元素是Student,如果Student类具有自然顺序，它们可以获取最大值，或最小值。
        // 如果没有自然顺序，就必须使用max,min重载的方法
        // max(Collection c,Comparator cc)

    }

    // 2.sort
    public static void sortTest() {

        List<Integer> list = new ArrayList<Integer>();

        list.add(10);
        list.add(300);
        list.add(110);
        list.add(1109);

        // 调用Collections中的sort方法
        System.out.println(list);

        Collections.sort(list);

        System.out.println(list); // 从小到大排序 根据元素自然顺序

        // 注意:使用sort排序，集合中元素要具有自然顺序，如果没有自然顺序，那么我们就需要使用 sort(List c,Comparator
        // cc);
    }

    // 3.要对集合排序，降序排
    public static void reverseTest() {
        List<Integer> list = new ArrayList<Integer>();

        list.add(10);
        list.add(300);
        list.add(110);
        list.add(1109);

        Collections.sort(list);// 从小到大
        Collections.reverse(list); // 反转

        System.out.println(list);
    }

    // 4.乱序
    public static void shuffleTest() {
        List<Integer> list = new ArrayList<Integer>();

        list.add(10);
        list.add(300);
        list.add(110);
        list.add(1109);

        Collections.sort(list);// 从小到大
        System.out.println(list);

        Collections.shuffle(list); // 乱序
        System.out.println(list);
    }

}