JAVA Class17

学习内容：

Map接口：

特点：数据以键值对的形式储存，键不可以重复，值可以重复。

1.常用方法：

（1）put，返回String

（2）remove，返回String

（3）replace，返回String

public class Test {

    public static void main(String[] args) {
        Map<Integer,String> m= new HashMap<Integer,String>();
        String m1=m.put(1, "世界");//如果集合之前未存储该元素，返回null
        String m2=m.put(2, "隐士");
        String m3=m.put(3, "皇帝");
        String m4=m.put(3, "女教皇");//值被取代，返回这个键之前对应的值，即皇帝
        System.out.println(m4);
        System.out.println(m);
        System.out.println(m.get(3));
        String s = m.get(1);
        System.out.println(s);
        String r = m.remove(2);//返回被删除的值
        System.out.println(r);
        System.out.println(m);
        String re = m.replace(1, "诡诈师");//返回被修改之前的值
        System.out.println(re);
        System.out.println(m);
   }
}

2.遍历方式：

因为键值对的储存方式，无法直接遍历，间接的遍历方法：

（1）keySet方法返回包含所有键的Set，利用键找到值

public class Test {

    public static void main(String[] args) {
        Map<Integer,String> m= new HashMap<Integer,String>();
        String m1=m.put(1, "世界");//如果集合之前未存储该元素，返回null
        String m2=m.put(2, "隐士");
        String m3=m.put(3, "皇帝");
        for(Integer i:m.keySet()) {//返回一个set 包含所有键
            int key = i;
            System.out.println(i+"="+m.get(key));
        }
        Set<Integer> set = m.keySet();
        for(Iterator<Integer> it=set.iterator();it.hasNext();) {
            int i = it.next();
            String value = m.get(i);
            System.out.println(i+"="+value);
        }
    }
}

（2）entrySet返回一个包含Entry类的Set，Entry类是Map接口的内部接口，把键值对储存为Entry对象，可以通过getKey和getValue的方法来分别获取键值。

public class Test {

    public static void main(String[] args) {
        Map<Integer,String> m= new HashMap<Integer,String>();
        String m1=m.put(1, "世界");//如果集合之前未存储该元素，返回null
        String m2=m.put(2, "隐士");
        String m3=m.put(3, "皇帝");
        Set<Entry<Integer, String>> e = m.entrySet();
        for(Iterator<Entry<Integer, String>> it =e.iterator();it.hasNext();) {
            Entry<Integer, String> entry = it.next();
            int key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key+"="+value);
        }
        for(Entry<Integer, String> entry:e ) {
            System.out.println(entry.getKey()+"="+entry.getValue());
        }
   }
}

3.实现类：

（1）HashMap（2）LinkedHashMap（存取有序）

public class Test {

    public static void main(String[] args) {
        LinkedHashMap<Integer,String> lhm = new LinkedHashMap<Integer,String>();
        lhm.put(1, "英伟达");
        lhm.put(2, "超微半导体");
        lhm.put(3, "英特尔");
        lhm.put(4, "RXVega");
        System.out.println(lhm);
        HashMap<Integer,String> hm = new HashMap<Integer,String>();
        hm.put(1, "GTXTITAN V");
        hm.put(2, "ThreadRipper");
        hm.put(3, "I9 7980XE");
        hm.put(4, "Vega56");
        hm.put(5, "X399");
        System.out.println(hm);
    }
}

 4.Map嵌套：

把一个Map的实现类当做另一个Map的值：

public Test{
  public static void main(String[] args){
    HashMap<Integer,String> student = new HashMap<Integer,String>();
        student.put(1,"POTER");
        student.put(2,"JIM");
        student.put(3,"WINSTON");
        HashMap<String,HashMap<Integer,String>> classroom = new HashMap<String,HashMap<Integer,String>>();
        classroom.put("JAVA01",student);
        Set<String> sc = classroom.keySet();
        Set<Integer> ss = student.keySet();
        for(String s:sc) {
            System.out.println(s+"班有"+"学生：");
            for(Integer i:ss) {
                System.out.println("学号："+i+"姓名："+classroom.get(s).get(i));
            }
        }
        Set<Entry<String,HashMap<Integer,String>>> ec= classroom.entrySet();
        Set<Entry<Integer, String>> es = student.entrySet();
        for(Entry<String,HashMap<Integer,String>>entry:ec) {
            System.out.println(entry.getKey()+"班有"+"学生：");
            for(Entry<Integer, String>entry2:es) {
                System.out.println("学号："+entry2.getKey()+"姓名："+entry2.getValue());
            }
        }
  }  
}

5.Collections工具类：

常用方法：

 reverse 反转
 shuffle  混淆
 sort  降序排序
 swap  交换位置

public class TestCollections {

    public static void main(String[] args) {
        ArrayList<Integer> a = new ArrayList<Integer>();
        a.add(1);
        a.add(2);
        a.add(3);
        Collections.reverse(a);//反转
        Collections.shuffle(a);//混淆
        Collections.sort(a);//降序排序
        Collections.swap(a,0,2);//交换位置
    }
}    

 6.可变参数：

JDK1.5特性，方法可传入多个同类型的参数

public class TestAlter {
    public static int add(String str,int...a) {//可变参数，类型相同，个数不同，本质上是个数组，jdk1.5
        //如果有其他参数，可变参数必须放在最后，而且同一个方法只能有一个可变参数
        int sum = 0;
        for(int i=0;i<a.length;i++) {
            sum+=a[i];
        }
        return sum;
    }
    public static void main(String[] args) {
        System.out.println(add("a",1,2,3,4,5,6,7,8,9,10));
    }

}

7.静态导入

导入包的静态成员变量，可以直接使用，节省代码

import static java.lang.System.out;//静态成员直接导入，JDK1,5
import static java.util.Arrays.sort;
public class TestStatic {

    public static void main(String[] args) {
        out.println("静态导入");
        int[] a = {2,6,9,5,4};
        sort(a);
        for(int i=0;i<a.length;i++) {
            out.print(a[i]);
        }
    }

}