Java学习第十五章 之 Map、可变参数、Collections

/*

Map:存储键值对

        键不能重复存储，值可以重复

        每一个键对应一个值

方法:

       v put(K key , V value)将指定的键和值添加到集合中

       v get(Object obj) 获取指定的键对应的值

       v remove(Object key)移除指定的键所对应的值

*/

public class MapDemo{

    public static void main(String[] args){

        //创建map对象

        Map<String , String> map = new HashMap<String , String>();

        //给Map中添加元素，会返回key所对应的value值，若key没有对应的值，则返回null

        map.put("张三" , "上海");

        map.put("李四" , "北京");

        System.out.println(map);

        //根据key获取value值

       String s =  map.get("张三");

       System.out.println(s);//上海
       //移除key，返回key对应的value值

        String st = map.remove("张三");

        System.out.println(st);//上海

        System.out.println(map);//{李四，北京}

    }

}

/*

Map集合键找值的方式 : 通过元素的键，获取键所对应的值

Set<K>  keySet() 遍历键的Set集合，得到每一个键，根据键，获取键对应的值

*/

public class MapDemo{

    public static void main(String[] args){

     //创建Map对象

    Map<String , Integer> map = new HashMap<String , Integer>();

    map.put("张三" , 20);

    map.put("李四" , 20);

    //获取Map中的key

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

   //遍历存放所有key的Set集合

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

   while(it.hasNext()){

          //获取key

          String key = it.next();

          //通过key找到对应的值

         int value = map.get(key);

          System.out.println(key+" "+ value);

    }

    }

}



/*

Entry嵌套接口 : static interface(Map.Entry(K , V))

                         K getKey() 返回与此项对应的键

                         V getValue() 返回与此项对应的值

                         Set<Map.Entry<K , V>> entrySet() 用于返回Map集合中所有的键值对对象，以Set集合形式返回 

*/

public class MapDemo{

     public static void main(String[] args){

         //创建Map对象

        Map<String , Integer>  map = new HashMap<String , Integer>();

       map.put("赵云" , 20);

       map.put("吕小布" , 20);

      //遍历Map中的所有的 key 和 value 的对应关系

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

    //遍历Set集合

     for(Map.Entry<String , Integer> entry : entrySet){

             //通过每一对对应关系获取对应的key

             String key = entry.getKey();

             //通过每一对对应关系获取对应的key
             int value = entry.getValue();

           System.out.println(key +"  "+ value);

       }

     }

}

/*

HashMap存储自定义类型

*/

public class Student {

    private String name;
    private int age;

158     public String getName() {
      return name;
    }
    public void setName(String name) {
       this.name = name;
    }
    public int getAge() {
       return age;
    }
    public void setAge(int age) {
       this.age = age;
    }
    public Student() {
       super();
 
    }
    public Student(String name, int age) {
       super();
     this.name = name;
     this.age = age;
    }
    @Override
     public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
     }
    @Override
     public boolean equals(Object obj) {
        if (this == obj)
        return true;
        if (obj == null)
        return false;
        if (getClass() != obj.getClass())
        return false;
        Student other = (Student) obj;
        if (age != other.age)
        return false;
        if (name == null) {
        if (other.name != null)
        return false;
201         } else if (!name.equals(other.name))
        return false;
        return true;
     }
    @Override
     public String toString() {
          return "Student [name=" + name + ", age=" + age + "]";
     }

    public static void main(String[] args) {

          //创建Map对象
          Map<Student, String> map = new HashMap<Student, String>();
          map.put(new Student("张三" , 20), "北京");
          map.put(new Student("李四" , 20), "上海");
          map.put(new Student("王五" , 20), "广州");


        //遍历存放所有key的Set集合
        Set<Student> keySet = map.keySet();


        Iterator<Student> it = keySet.iterator();
        while(it.hasNext()) {

        //获取key
        Student key= it.next();

        //通过key找到对应的值

        String value = map.get(key);
        System.out.println(key +".."+ value);
  }

/*

静态导入:

              在导包的过程中我们可以直接导入静态部分，这样某个类的静态成员就可以直接使用了。在源码中经常会出现静态导入

              格式；import static xxx.yyy;导入后yyy可直接使用

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

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

*/

/*

  可变参数:如果定义一个方法需要接受多个参数，并且多个参数类型一致，可以简化成如下格式:

                  修饰符  返回值类型  方法名(参数类型...形参名);直接传递数据

                   等价与

                  修饰符 返回值类型 方法名(参数类型[] 形参名);方法调用时必须传递数组  

                  如果在方法书写时，这个方法拥有多参数，参数中包含可变参数，可变参数一定要写在参数列表的末尾位置

*/

public class Demo{

    public static void main(String[] args){

        int sum = add(1,2,3);

       System.out.println(sum);

   }

   public static int add(int...arr){         

           int sum = 0; 
           for (int i = 0; i < arr.length; i++) {
           sum += arr[i];
          }

           return sum;

   }

}



/*

Collections集合工具类:

                                  static void shuffle(List<?> list)集合元素存储位置打乱

                                  static <T extends Comparable<? super T>> void  sort(List<?> list) 集合元素排序

*/

/*

集合嵌套:　Collection集合嵌套、Map集合嵌套、Collection和Map集合嵌套
                   ArrayList< ArrayList<String>>    Collection< ArrayList<String>>

                  HashMap<String , ArrayList<Person>>   ArrayList< Map<String , String>>

                  HashMap<String , HashMap<String , String>>    HashMap<String , HashMap<Person , Student>>

*/