您现在的位置是：首页 > Java

当前栏目

JAVA 映射表

JAVA 集合排序映射

2023-03-02 11:13:04 时间

## Map ##

映射表是一种依照键/值对存储元素的容器。它提供了通过键快速获取、删除和更新键/值对的功能。映射表将键与值一起保存，键可以是任意类型的对象，映射表中不能有重复的键，如果存储的键在映射表中已经存在则值会覆盖。  
Map是映射表的父接口，他的方法有  
V put (K key, V value):添加元素。  
V get(Object Key) 返回键对应的值  
int size() 返回映射表中的条目数  
void clear ():移除所有的键值对元素  
V remove (Object key)：根据键删除键值对元素，并把值返回  
boolean containsKey (Object key)：判断集合是否包含指定的键  
boolean containsValue (Object value):判断集合是否包含指定的值  
boolean isEmpty ()：判断集合是否为空  
Set keySet();//获取键的集合  
Collection values();//获取所有值的集合  
Set<Map<K,V>> entrySet()返回一个包含了该映射表中的条目的集合。

public class MapDemo { 
        public static void main(String[] args) { 
            Map<Integer, String> map = new HashMap<>();
            //put() 放入元素
            map.put(1,"aaa");
            map.put(2,"ccc");
            map.put(3,"eee");
            //get()返回键对应的值
            System.out.println(map.get(1));//aaa
            //size()
            System.out.println(map.size());//3
            System.out.println(map);//{1=aaa, 2=ccc, 3=eee}
            //remove()移除指定键
            System.out.println(map.remove(2));//ccc
            System.out.println(map);//{1=aaa, 3=eee}
            //clear()删除所有元素
            map.clear();
            System.out.println(map);//{}
            map.put(1,"aaa");
            map.put(2,"aaa");
            map.put(3,"eee");
            System.out.println( map.containsKey(1) );//true
            System.out.println(map.containsValue("ccc"));//true
            // keySet();//获取键的集合
            System.out.println(map.keySet());//[1, 2, 3]
            // values();//获取所有值的集合
            System.out.println(map.values());//[aaa, aaa, eee]
        }
    }

遍历Map的方法  
1通过可以通过键找值的方式来遍历  
2通过 Map.Entry<K, V> 方法返回的Set集合遍历

public class MapDemo { 
        public static void main(String[] args) { 
            Map<Integer, String> map = new HashMap<>();
            map.put(1,"aaa");
            map.put(2,"aaa");
            map.put(3,"eee");
            map.put(4,"fff");
            map.put(5,"iii");
            //1通过可以通过键找值的方式来遍历
            Set<Integer> k = map.keySet();
            for (int key:k) { 
                String v = map.get(key);
                System.out.println(key+" "+v);
            }
            //2通过 Map.Entry<K, V> 方法返回的Set集合遍历
            Set<Map.Entry<Integer, String>> entries = map.entrySet();
            for (Map.Entry<Integer, String> entry : entries) { 
                System.out.println(entry.getKey()+" "+entry.getValue());
            }
        }
    }

Map接口下有三个具体的类实现了Map接口，分别是HashMap、LinkedHashMap、TreeMap。  
演示使用Map存储自定义的类

public class Student { 
        private String name;
        private int age;
    
        public Student() { 
        }
    
        public Student(String name, int age) { 
            this.name = name;
            this.age = age;
        }
    
        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;
        }
    
        @Override
        public String toString() { 
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    
        @Override
        public boolean equals(Object o) { 
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Student student = (Student) o;
            return age == student.age &&
                    Objects.equals(name, student.name);
        }
    
        @Override
        public int hashCode() { 
    
            return Objects.hash(name, age);
        }
    }

## HashMap ##

HashMap与HashSet相同，底层都是通过哈希表来实现的。都是通过重写hashCode()与equals()方法来确保元素的唯一性。  
而HashSet的底层其实也是使用了HashMap。

public class MapDemo { 
        public static void main(String[] args) { 
            //存储键是 String 值是Student
            HashMap<String, Student> hashMap = new HashMap<>();
            hashMap.put("s001",new Student("钟楚红",23));
            hashMap.put("s002", new Student("梅艳芳", 27));
            hashMap.put("s003", new Student("李丽珍", 26));
            hashMap.put("s004", new Student("翁虹", 27));
            hashMap.put("s005", new Student("叶子楣", 29));
            hashMap.put("s005", new Student("叶子楣222", 29));
            //遍历
            for (String s : hashMap.keySet()) { 
                Student student = hashMap.get(s);
                System.out.println(s+"=="+student.getName()+"=="+student.getAge());
            }
        }
    }

## LinkedHashMap ##

LinkedHashMap在HashMap的基础上实现了元素的有序性。  
LinkedHashMap与LinkedHashSet相同，都是通过链表来实现元素的有序性。

public class LinkedHashMapDemo { 
        public static void main(String[] args) { 
           // LinkedHashMap 元素有序,且唯一
            LinkedHashMap<Integer, String> map = new LinkedHashMap<>();
            map.put(100, "abc");
            map.put(200, "ccc");
            map.put(300, "ddd");
            Set<Map.Entry<Integer, String>> entries = map.entrySet();
            for (Map.Entry<Integer, String> entry : entries) { 
                Integer key = entry.getKey();
                String value = entry.getValue();
                System.out.println(key+"==="+value);
            }
        }
    }

## TreeSet ##

TreeSet底层的数据结构是二叉树，与TreeSet相同可以通过自然排序（实现comparable接口重写compareTo()方法）或者比较排序（通过构造函数添加比较器—重写Comparator接口的compare方法）。  
自然排序

public class TreeMapDemo { 
        public static void main(String[] args) { 
            TreeMap<Student, Integer> map = new TreeMap<>();
            map.put(new Student("钟楚红", 23), 10);
            map.put(new Student("梅艳芳", 27), 9);
            map.put(new Student("李丽珍", 26), 1);
            map.put(new Student("翁虹", 27), 4);
            map.put(new Student("叶子楣", 29), 2);
            map.put(new Student("叶子楣222", 29), 3);
            System.out.println(map);
        }
    }
    
    //其中重写Student的compareTo方法按照年龄排序
    public int compareTo(Student s) { 
            int num=this.getAge()-s.getAge();
            int num2=num==0?this.name.compareTo(s.name):num;
            return num2;
        }

选择排序

public class TreeMapDemo2 { 
        public static void main(String[] args) { 
            //按照姓名排序
            TreeMap<Student, Integer> map = new TreeMap<>(new Comparator<Student>() { 
                @Override
                public int compare(Student o1, Student o2) { 
                    int num=o1.getName().compareTo(o2.getName());
                    int num2=num==0?o1.getAge()-o2.getAge():num;
                    return num2;
                }
            });
            map.put(new Student("钟楚红", 23), 10);
            map.put(new Student("梅艳芳", 27), 9);
            map.put(new Student("李丽珍", 26), 1);
            map.put(new Student("翁虹", 27), 4);
            map.put(new Student("叶子楣", 29), 2);
            map.put(new Student("叶子楣222", 29), 3);
            System.out.println(map);
        }
    }

猜你喜欢

最长无重复子串
写技术博客的一些心得分享
Java 多线程（七）：线程池
Java 多线程（五）：锁（三）
Java 多线程（四）：锁（二）
Java 多线程（三）：锁（一）
Java 多线程（二）：并发编程的三大特性
线性时间非比较类排序
Java 多线程（一）：基础
合并k个已排序的链表
HDFS 高可用分布式环境搭建
合并两个有序数组
连续子数组的最大和
HDFS 分布式环境搭建
容器盛水问题
大数加法
HDFS 伪分布式环境搭建
设计LRU缓存结构
两数之和
使用单调栈来解决的一些问题

zl程序教程

当前栏目

JAVA 映射表

相关文章