黑马程序员_基础学习笔记（12）

黑马程序员---比向东---第十六天  

Map

    Map集合：该集合存储键值对，一对一对往里存。而且要保证键的唯一性。

        添加

        put(K key,V value);put(Map<? extendsK,? extends V>);

        删除

        remove(Object key);clear();

        判断

        isEmpty();containsValue(Objectvalue);containsKey(Object key);

        获取

        get(Object key);size();values();  entrySet();keySet();

    Map的子类

        Hashtable:底层是哈希表数据结构，不可以存null键null值。线程同步

        HashMap:  底层是哈希表数据结构，允许存null键null值，线程不同步

        TreeMap: 底层是二叉树数据结构，线程不同步，可以给Map中的键排序

                 其实Set底层就是使用了Map集合。 

Map集合的两种取出方式

    Set<k>keySet:将Map中所有的键存入到Set集合，因为Set集合具备迭代器

                 所以可以迭代取出所有的键，在根据get(key)获取值。

                 Map集合的取出原理：将Map集合转成Set集合，再迭代取出。

   

    Set<Map.Entry<k,v>>entrySet:将Map集合中的映射关系存入到Set集合中，

                            而这个关系的数据类型就是：Map.Entry

publicstatic void main(String[] args)

    {

        Map<String,String> map = newHashMap<String,String>();

        map.put("1","xiaoming---1");

        map.put("2","xiaoming---2");

        map.put("3","xiaoming---3");

        map.put("4","xiaoming---4");

 

        sop("第一种方式");

        Set<String> keyset = map.keySet();

        for (Iterator<String> it =keyset.iterator();it.hasNext() ; )

        {

            String key = it.next();

            String value = map.get(key);

            sop("key="+key+",value="+value);

        }

        sop("第二种方式");

        Set<Map.Entry<String,String>>entryset = map.entrySet();

 

        for(Iterator<Map.Entry<String,String>> it =entryset.iterator();it.hasNext() ; )

        {

            Map.Entry<String,String> me =it.next();

            String key = me.getKey();

            Stringvalue = me.getValue();

            sop("key="+key+",value="+value);

        }

    }

    Map.Entry 其实Entry也是一个就扣，它是Map接口中的一个内部接口。

    interface Map

    {

        public static interface Entry

        {   定义内部接口是因为取出Map中的成员属性方便

            public abstract Object getKey();

            public abstract Object getValue();

        }

 

    }

    class HashMap implements Map

    { //HashMap 取出元素的原理

        class Haha implements Map.Entry

        { 

            public abstract ObjectgetKey(){  }

            public abstract ObjectgetValue(){  }

        }

    }

集合的嵌套使用

    定义一个czbk学校(外层集合)，存放教室(内层集合),遍历的时和for的嵌套循环类似

       方法一通过keySet遍历

      

Set<String> keySet = czbk.keySet();

        for (Iterator<String> it =keySet.iterator();it.hasNext() ; )

        { //roomName表示学校里的班级变量，存放在Map中的  键  位置上

            //内循环 控制班级中的学生遍历

            String roomName = it.next(); 

            List<Student> room =czbk.get(roomName);

 

            System.out.println(roomName);

           

            //遍历内层循环(输出教室集合中存放的学生对象)

            //内循环 控制班级中的学生遍历

            for (Iterator<Student> it = room.iterator();it.hasNext() ; )

            {

                Student s = it.next();

                System.out.println(s);

            }

        }

        方法二通过entrySet遍历

        Set<Map.Entry<String,List<Student>>>entrySet=czbk.entrySet();

        for(Iterator<Map.Entry<String,List<Student>>>it=entrySet.iterator();

             it.hasNext();  ) //外循换 控制班级遍历

        {

            Map.Entry<String,List<Student>>me = it.next();

            String ss = me.getKey();

            List<Student> stu= me.getValue();

            sop(ss);      //内循环 控制班级中的学生遍历

            for (Iterator<Student> it_1 = stu.iterator();it_1.hasNext() ; )

            {

                Student student = it_1.next();

                sop(student);

            }

        }

黑马程序员---比向东---第十七天

集合变数组

1 指定类型的数组的长度定义

            当指定类型的数组长度小于了集合的size，那么该方法内部会创建

            一个新的数组。长度为集合size的数组

            当指定类型的数组长度大于了集合的size，那么就不会创建新数组

            而是使用传递进来的数组。

        2集合变数组的好处。

            为了限定对元素的操作。不需要进行增删操作了

数组变集合

1 如果数组中的元素都是对象，变成集合时，数组中的元素就直接

          转成集合中的元素。

        2如果数组中的元素都是基本数据类型，那么集合会将该数组作为集合中的元素存在。

          也就是说这个数组集合中的一个元素。且仅仅这一个

高级for循环

 

格式：

    for (数据类型 变量名：被遍历的集合(Collection)或者数组)

    {

    }

    对集合进行遍历时，只能获取集合中的元素，不能对集合进行过多的操作

 而迭代器除了遍历，还可以进行remove集合中元素的动作。

 如果使用ListIterator，还可以在遍历过程中对集合进行增删改查的动作

 

 传统for循环和高级for循环的区别

    高级for有一个局限性，必须有被遍历的目标。

    建议在遍历数组的时候，还是希望使用传统for，因为传统for可以定义角标。

    HashMap<Integer,String>hm = new HashMap<Integer,String>();

 

        hm.put(1,"a");

        hm.put(2,"c");

        hm.put(3,"c");

 

       

        Set<Integer> keySet = hm.keySet();

        for(Integer i : keySet )

        {

            sop(i+"::"+hm.get(i));

        }

 

        //简写格式

        for(Map.Entry<Integer,String> me : hm.entrySet())

        {

            sop(me.getKey()+"----"+me.getValue());

        }

方法的可变参数

在使用时注意：可变参数一定要定义在参数的最后面。

可变参数，其实就是上一种数组参数的简写形式

不用每一次都手动的建立数组对象，只要将要操作的元素作为参数

传递即可，隐士的将这些参数封装成了数组。

staticImport 静态导入

当类名重名时，需要指定具体的包名当方法重名时，指定具备所属的对象或者类

当import 后面加static时导入的是类中的所有静态成方法和成员。而不加的时候则是导入包中的类