只讲干货！！苦点累点也是为了买下来自己喜欢的东西！今天拿下：map类容器！

向秃头努力

于 2024-07-16 14:09:20 发布

阅读量478

点赞数 12

分类专栏： java进阶基础提高文章标签： java 开发语言

本文链接：https://blog.csdn.net/2201_75777992/article/details/140464160

版权

java进阶基础提高专栏收录该内容

6 篇文章 0 订阅

订阅专栏

map类容器

map类容器输入双例集合

Map接口介绍

Map接口定义了双例集合的存储特征，它并不是 Collection 接口的子接口。双例集合的存储特征是以key 与 value 结构为单位进行存储。体现的是数学中的函数 y=f(x) 感念。

Map 与 Collecton 的区别：

Collection中的容器，元素是孤立存在的（理解为单身），向集合中存储元素采用一个个元素的方式存储。
Map中的容器，元素是成对存在的(理解为现代社会的夫妻)。每个元素由键与值两部分组成，通过键可以找对所对应的值。
Collection中的容器称为单列集合，Map中的容器称为双列集合。
Map中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。
Map中常用的容器为HashMap，TreeMap等。

Map接口中常用的方法表

HashMap容器的使用

HashMap采用哈希算法实现，是 Map 接口最常用的实现类。由于底层采用了哈希表存储数据，我们要求键不能重复，如果发生重复，新的键值对会替换旧的键值对。 HashMap 在查找、删除、修改方面都有非常高的效率。

public class HashMapTest {
    public static void main(String[] args) {
        //实例化HashMap容器
        Map<String,String> map = newHashMap<>();
        //添加元素
        map.put("a","A");
        map.put("b","B");
        map.put("c","C");
        map.put("a","D");
        //获取容器中元素数量
        int size = map.size();
        System.out.println(size);
        System.out.println("---------------");
       //获取元素
        //方式一
        String v = map.get("a");
        System.out.println(v);
        System.out.println("---------------");
        //方式二
        Set<String> keys = map.keySet();
        for(String key:keys){
            String v1 = map.get(key);
            System.out.println(key+" ----"+v1);
       }
        System.out.println("-------------------");
        //方式三
        Set<Map.Entry<String,String>>entrySet = map.entrySet();
        for(Map.Entry<String,String>entry:entrySet){
            String key = entry.getKey();
            String v2 = entry.getValue();
            System.out.println(key+" ---------- "+v2);
       }

        System.out.println("--------------------");
        //Map容器的并集操作

        Map<String,String> map2 = newHashMap<>();
        map2.put("f","F");
        map2.put("c","CC");
        map.putAll(map2);
        Set<String> keys2 = map.keySet();
        for(String key:keys2){
            System.out.println("key: "+key+"Value: "+map.get(key));
       }

        System.out.println("---------------");
        //删除元素
        String v3 = map.remove("a");
        System.out.println(v3);
        Set<String> keys3 = map.keySet();
        for(String key:keys3){
            System.out.println("key: "+key+"Value: "+map.get(key));
       }

        System.out.println("-------------------");
        //判断Key是否存在
        boolean b = map.containsKey("b");
        System.out.println(b);
        //判断Value是否存在
        boolean cc =map.containsValue("CC");
        System.out.println(cc);

HashTable类和 HashMap 用法几乎一样，底层实现几乎一样，只不过HashTable 的方法添加了 synchronized 关键字确保线程同步检查，效率较低

HashMap 与 HashTable 的区别

1 HashMap: 线程不安全，效率高。允许 key 或 value 为 null

2 HashTable: 线程安全，效率低。不允许 key 或 value 为 null

TreeMap容器的使用

TreeMap和 HashMap 同样实现了 Map 接口，所以，对于 API 的用法来说是没有区别的。HashMap 效率高于 TreeMap ； TreeMap 是可以对键进行排序的一种容器，在需要对键排序时可选用TreeMap 。 TreeMap底层是基于红黑树实现的。

在使用 TreeMap 时需要给定排序规则：

元素自身实现比较规则

通过比较器实现比较规则

元素自身实现比较规则

public class Users implements
Comparable<Users>{
    private String username;
    private int userage;
    public Users(String username, int userage) {
        this.username = username;
        this.userage = userage;
   }

    public Users() {
   }

    @Override
    public boolean equals(Object o) {
        System.out.println("equals...");
        if (this == o) return true;
        if (o == null || getClass() !=o.getClass()) return false;

       Users users = (Users) o;

        if (userage != users.userage) returnfalse;
        return username != null ?username.equals(users.username) :users.username == null;
   }

    @Override
    public int hashCode() {
        int result = username != null ?username.hashCode() : 0;
        result = 31 * result + userage;
        return result;

   }

    public String getUsername() {
        return username;
   }

    public void setUsername(String username){
        this.username = username;
   }
    public int getUserage() {
        return userage;
   }

    public void setUserage(int userage) {
        this.userage = userage;
   }

    @Override
    public String toString() {
        return "Users{" +
                "username='" + username +'\'' +
               ", userage=" + userage +
              '}';   }

    //定义比较规则
    //正数：大，负数：小，0：相等
    @Override
    public int compareTo(Users o) {

       if(this.userage < o.getUserage()){
            return 1;
      }
        if(this.userage == o.getUserage()){
           return this.username.compareTo(o.getUsername());
       }
        return -1;
   }
 }

 public class TreeMapTest {
    public static void main(String[] args) {
        //实例化TreeMap
        Map<Users,String> map = new TreeMap<>();
        Users u1 = new Users("秃头",18);
        Users u2 = new Users("小子",22);
        Users u3 = new Users("TUT",22);
        map.put(u1,"秃头");
        map.put(u2,"小子");
        map.put(u3,"TUT");
        Set<Users> keys = map.keySet();
        for(Users key :keys){
            System.out.println(key+" --------- "+map.get(key));
       }
   }
 }

通过比较器实现比较规则

public class Student {
   private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
   }

    public Student() {
   }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", 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 boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() !=o.getClass()) return false;

        Student student = (Student) o;

        if (age != student.age) return false;
        return name != null ?name.equals(student.name) : student.name ==null;
   }

    @Override
    public int hashCode() {
        int result = name != null ?name.hashCode() : 0;
        result = 31 * result + age;
        return result;
   }
 }


 public class StudentComparator implementsComparator<Student> {
    //定义比较规则

    @Override
    public int compare(Student o1, Studento2) {
        if(o1.getAge() > o2.getAge()){
            return 1;
       }
        if(o1.getAge() == o2.getAge()){
            returno1.getName().compareTo(o2.getName());
       }
        return -1;
   }
 }

 public class TreeMapTest {
    public static void main(String[] args) {
          Map<Student,String> treeMap = new TreeMap<>(new StudentComparator());
    Student s1 = new Student("秃头",18);
    Student s2 = new Student("小子",22);
    Student s3 = new Student("TUT",22);
    treeMap.put(s1,"秃头");
    treeMap.put(s2,"小子");
    treeMap.put(s3,"TUT");
    Set<Student> keys1 = treeMap.keySet();
    for(Student key :keys1){
        System.out.println(key+" ----"+treeMap.get(key));
     }
   }
 }

Iterator接口

Iterator迭代器接口介绍

Collection接口继承了 Iterable 接口，在该接口中包含一个名为iterator的抽象方法，所有实现了 Collection 接口的容器类对该方法做了具体实现。iterator 方法会返回一个 Iterator 接口类型的迭代器

对象，在该对象中包含了三个方法用于实现对单例容器的迭代处理。

Iterator迭代器的使用

迭代List 接口类型容器

public class IteratorListTest {
    public static void main(String[] args) {
        //实例化容器
        List<String> list  = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        //获取元素
        //获取迭代器对象
        Iterator<String> iterator =list.iterator();
        //方式一:在迭代器中，通过while循环获取元素
        while(iterator.hasNext()){

           String value = iterator.next();
            System.out.println(value);
       }
       System.out.println("-------------------------------");
        //方法二：在迭代器中，通过for循环获取元素
        for(Iterator<String> it =list.iterator();it.hasNext();){
            String value = it.next();
            System.out.println(value);
       }

   }
 }

迭代 Set 接口类型容器

public class IteratorSetTest {
   public static void main(String[] args) {
       //实例化Set类型的容器
        Set<String> set  = new HashSet<>();
        set.add("a");
        set.add("b");
        set.add("c");
        //方式一：通过while循环
        //获取迭代器对象
       Iterator<String> iterator =set.iterator();
        while(iterator.hasNext()){
            String value = iterator.next();
            System.out.println(value);

       }
        System.out.println("-------------------------");
        //方式二：通过for循环
        for(Iterator<String> it =set.iterator();it.hasNext();){
            String value = it.next();
            System.out.println(value);
       }
   }
 }

迭代 Map 接口类型容器

public class IteratorMapTest {
    public static void main(String[] args) {
        //实例化HashMap容器
        Map<String, String> map = new HashMap<String, String>();

        //添加元素
        map.put("a", "A");
        map.put("b", "B");
        map.put("c", "C");

        //遍历Map容器方式一
        Set<String> keySet = map.keySet();

        for (Iterator<String> it =keySet.iterator(); it.hasNext();){
            String key = it.next();
           String value = map.get(key);
           System.out.println(key+" ------------- "+value);
      }
       System.out.println("------------------------");
       //遍历Map容器方式二
       Set<Map.Entry<String, String>> entrySet = map.entrySet();
       Iterator<Map.Entry<String, String>> iterator = entrySet.iterator();
       while(iterator.hasNext()){
           Map.Entry entry =iterator.next();
         System.out.println(entry.getKey()+" ------------ "+ entry.getValue());
      }
  }
}

在迭代器中删除元素

public class IteratorRemoveTest {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        Iterator<String> iterator =list.iterator();
        while(iterator.hasNext()){
            //不要在一次循环中多次调用next方法。
            String value = iterator.next();
            iterator.remove();
       }
        System.out.println("----------------");
        for(Iterator<String> it =list.iterator();it.hasNext();){
            System.out.println(it.next());
            list.add("dddd");
       }
   }
}

遍历集合的方法总结

遍历 List 方法一：普通 for 循环

for ( int i = 0 ; i < list . size (); i ++ ){ //list 为集合的对象名

String temp = ( String ) list . get ( i );

System . out . println ( temp );

}

遍历 List 方法二：增强 for 循环 ( 使用泛型！ )

for ( String temp : list ) {

System . out . println ( temp );

}

遍历 List 方法三：使用 Iterator 迭代器 (1)

for ( Iterator iter = list . iterator (); iter . hasNext ();){

String temp = ( String ) iter . next ();

System . out . println ( temp );

}

遍历 List 方法四：使用 Iterator 迭代器 (2)

Iterator iter = list . iterator ();

          while ( iter . hasNext ()){

          Object obj = iter . next ();

          iter . remove (); // 如果要遍历时，删除集合中的元素，建议使用这种方式！

          System . out . println ( obj );

}

遍历 Set 方法一：增强 for 循环

for ( String temp : set ){

System . out . println ( temp );

}

遍历 Set 方法二：使用 Iterator 迭代器

for ( Iterator iter = set . iterator (); iter . hasNext ();){

String temp = ( String ) iter . next ();

System . out . println ( temp );

}

遍历 Map 方法一：根据 key 获取 value

Map < Integer , Man > maps = new HashMap < Integer , Man > ();

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

for ( Integer id : keySet ){

System . out . println ( maps . get ( id ). name );

}

遍历 Map 方法二：使用 entrySet

Set < Map . Entry < Integer , Man >> ss = maps . entrySet ();

for ( Iterator < Map . Entry < Integer , Man >>

                iterator = ss . iterator ();

                iterator . hasNext ();) {

                Map . Entry e = iterator . next ();

                 System . out . println ( e . getKey () + "-- " + e . getValue ());

}

Collections工具类

类 java.util.Collections 提供了对 Set 、 List 、 Map 进行排序、填充、查找元素的辅助方法

Collections 工具类的常用方法

public class CollectionsTest {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("c");
        list.add("b");
        list.add("a");
        //对元素排序
        Collections.sort(list);
       for(String str:list){
            System.out.println(str);
       }
        System.out.println("-------------------");

        List<Users> list2 = new ArrayList<>();
        Users u = new Users("oldlu",18);
        Users u2 = new Users("sxt",22);
        Users u3 = new Users("admin",22);
        list2.add(u);
        list2.add(u2);
        list2.add(u3);
        //对元素排序
        Collections.sort(list2);
       for(Users user:list2){
            System.out.println(user);
       }
        System.out.println("-------------------");

        List<Student> list3 = new ArrayList<>();
        Student s = new Student("oldlu",18);
        Student s1 = new Student("sxt",20);

        Student s2 = newStudent("admin",20);
        
        list3.add(s);
        list3.add(s1);
        list3.add(s2);
        
        Collections.sort(list3,new StudentComparator());
        for(Student student:list3){
            System.out.println(student);
       }
        System.out.println("-------------------");

        List<String> list4 = new ArrayList<>();
        list4.add("a");
        list4.add("b");
        list4.add("c");
        list4.add("d");

        //洗牌
        Collections.shuffle(list4);
        for(String str:list4){
            System.out.println(str);
       }
  }
 }

只讲干货

#有什么错误的地方大家多多担待，欢迎大家留下意见共同努力。

#需要什么技术的内容大家也可以积极留言。

#有升本的伙伴也可留言，后序也可更新升本内容C 和数据结构。

#有需要的伙伴或有什么问题直接联留下wx或联系邮箱2821835676qq.com

向秃头努力

关注

12
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
只讲干货！！苦点累点也是为了买下来自己喜欢的东西！今天拿下：map类容器！

接口最常用的实现类。由于底层采用了哈希表存储数据，我们要求键不能重复，如果发生重复，新的键值对会替换旧的键值对。中的容器，元素是孤立存在的（理解为单身），向集合中存储元素采用一个个元素的方式存储。接口，在该接口中包含一个名为iterator的抽象方法，所有实现了。中的集合不能包含重复的键，值可以重复；对象，在该对象中包含了三个方法用于实现对单例容器的迭代处理。每个元素由键与值两部分组成，通过键可以找对所对应的值。如果要遍历时，删除集合中的元素，建议使用这种方式！接口的容器类对该方法做了具体实现。
复制链接

扫一扫