【java】集合Map和Map遍历(两种方法)

集合Map常用方法：

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;

/**
 * 关于Mao接口中常用的方法：
 *  1、Map集合以key和value的方式存储数据：键值对
 *      key和value都是引用数据类型
 *      key和value都是存储对象的内存地址
 *      key起到主导地位，value是key的一个附属品
 *  2、Map接口中常用方法：
 *      V put(K key, V value) 向Map集合中添加键值对
 *      V get(Object key) 通过key获取value
 *      void clear() 清空Map集合
 *      boolean containsKey(Object key) 判断Map中是否包含某个key
 *      boolean containsKey(Object value) 判断Map中是否包含某个value
 *      boolean isEmpty() 判断Map集合中元素个数是否为0
 *      Set<K> keySet() 获取Map集合所有的key(所有的键是一个set集合)
 *      V remove(Object key) 通过key删除键值对
 *      int size() 获取Map集合中键值对的个数
 *      Collection<V> values() 获取Map集合中所有的value，返回一个Collection
 *
 *      Set<Map.Entry<K,V>> entrySet() 将Map集合转换成Set集合
 *      例：将Map集合转换成Set集合
 *          假设现在有一个Map集合，如下：
 *          map1集合对象
 *          key          value
 *          ------------------
 *          1             haha
 *          2             hehe
 *          3             xixi
 *
 *          Set set = map1.entrySet();
 *          set集合对象
 *            1=haha
 *            2=hehe
 *            3=xixi
 *            (注意：Map集合通过entrySet()方法转换成的这个Set集合，Set集合中元素的类型是Map.Entry<K,V>,Map.Entry是一个静态内部类)
 *
 */
public class MapTest01 {
    public static void main(String[] args) {
        //创建Map对象
        Map<Integer,String> map = new HashMap<>();
        //添加键值对
        map.put(1,"haha");
        map.put(2,"hehe");
        map.put(3,"xixi");
        //通过key获取value
        String s = map.get(2);
        System.out.println(s);//输出hehe
        //获取键值对的数量
        System.out.println(map.size());//输出3
        //通过key删除sey--value
        map.remove(2);//删除 呵呵
        //判断是否包含某个key
        //contains方法底层调用的都是equals进行比对，在自定义类型时需要重写equals方法
        System.out.println(map.containsKey(1));//输出true
        //判断是否包含某个value
        System.out.println(map.containsValue("haha"));//输出true
        //获取所有的value
        Collection<String> cl = map.values();
        for(String s1 : cl){
            System.out.println(s1);
        }
    }
}

集合Map的遍历：

/**
 * Map集合的遍历【******】
 *
 */
public class MapTest02 {
    public static void main(String[] args) {
        //第一种方式，获取所有的key，通过遍历key，来遍历value
        Map<Integer,String> map = new HashMap<>();
        map.put(1,"haha");
        map.put(2,"hehe");
        map.put(3,"xixi");
        map.put(4,"heihei");
        //获取所有的key，所有的key是一个set集合
        Set<Integer> keys = map.keySet();
        //遍历,通过key获取value
        //迭代器
        Iterator<Integer> it = keys.iterator();
        while(it.hasNext()){
            //取出其中一个key
            Integer key = it.next();
            //通过key获取value
            String value = map.get(key);
            System.out.println(value);
        }
        //foreach
        for(Integer key : keys){
            System.out.println(key +"="+ map.get(key));
        }

        //第二种遍历方式：Set<Map.Entry<K,V>> entrySet()  (效率高)
        //将Map集合转换为Set集合
        Set<Map.Entry<Integer,String>> set = map.entrySet();
        //迭代器
        Iterator<Map.Entry<Integer, String>> it2 = set.iterator();
        while(it2.hasNext()){
            Map.Entry<Integer,String> node = it2.next();
            Integer key = node.getKey();
            String value = node.getValue();
            System.out.println(key + "=" + value);
        }
        //foreach
        for(Map.Entry<Integer,String> nood : set){
            System.out.println(nood.getKey() +""+ nood.getValue());
        }

    }
}

foreach：

/**
 * 增强for(foreach)：
 * for(元素类型 变量名 : 数组或集合){
 *     System.out.println(变量名);
 * }
 * 缺点：没有下标
 */
public class ForEachTest01 {
    public static void main(String[] args) {
        //数组使用增强for
        int[] arr = {12,32,421,53,21,4};
        for(int data : arr){
            //data就是数组中的元素（数组中的每一个元素）
            System.out.println(data);//遍历输出arr数组中的元素
        }

        //集合使用增强for
        List<String> strList = new ArrayList<>();
        strList.add("faze");
        strList.add("up");
        strList.add("upp");
        //foreach
        for(String s : strList){
            System.out.println(s);
        }
        //迭代器循环
        Iterator<String> it = strList.iterator();
        while(it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
        //for循环遍历
        for (int i = 0; i < strList.size(); i++) {
            System.out.println(strList.get(i));
        }
    }
}

静态内部类：

public class In {
    public static class innerClass{
        public static void m1(){
            System.out.println("静态内部类的m1方法执行");
        }
        public void m2(){
            System.out.println("静态内部类实例方法执行");
        }
    }

    public static void main(String[] args) {
        //调用m1方法
        //In.innerClass是类名
        In.innerClass.m1();
        //创建静态内部类对象
        In.innerClass mi = new innerClass();
        mi.m2();
    }
}