java复习：Map接口、Collections接口

最新推荐文章于 2022-08-20 06:09:23 发布
最新推荐文章于 2022-08-20 06:09:23 发布
阅读量591 收藏 2
点赞数
分类专栏： JAVA 文章标签： android java
本文为博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/YI_LI_A_E/article/details/49498025
版权

一、Map接口

1、Map概述

（1）public interface Map
将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射一个值。
格式如下：

Map<Key,Value>接口

将键映射到值得对象，一个映射不能包含重复的键。每一个键最多只能映射一个值。
（2）Map集合的分类：
这里写图片描述

2、 Map集合的共性方法

（添加）：
put(K key,V value)
将指定的值与此映射中的指定键相关联。add是返回的Boolean值。Put添加元素若出现添加相同键，后添加的会覆盖原来的值，然后put方法返回的是原来的值。
void putAll(Map t)
从指定映射中将所有映射关系复制到此映射中。
（删除）：
void clear()
从此映射中移除所有映射关系。
void remove(Object key)
如果存在此键的映射关系，则将其从映射中移除。
（判断）：
boolean containsValue(Object value)
如果此映射为指定值映射一个或多个键，则返回 true。
boolean containsKey(Object key)
如果此映射包含指定键的映射关系，则返回 true。
boolean isEmpty()
如果此映射未包含键-值映射关系，则返回 true。
（获取）：
get(Object key)
返回此映射中映射到指定键的值。如果此映射中没有该键的映射关系，则返回 null。
Collection values()
返回此映射中包含的值的 collection 视图。Collection是单列集合，Map为双列集合。

import java.util.*;
class Demo
{
    public static void main(String[] args)
    {
        Map<String,String>map=new HashMap<String,String>();
        Sop("/***********************添加***************************/");
        map.put("01","zhangsan");
        map.put("02","lisi");
        map.put("03","wangwu");
        Sop(map);
        Collection<String>coll=map.values();
        Sop(coll);
        Sop("/***********************判断***************************/");
        Sop(map.containsKey("01"));
        Sop(map.containsValue("zhangsan"));
        Sop(map.isEmpty());
        Sop("/***********************删除***************************/");
        Sop(map.remove("01"));
        Sop(map);
        Sop("/***********************获取***************************/");
        Sop(map.get("02"));
        map.put(null,"空值");
        Sop(map.get(null));
    }
    public static void Sop(Object obj)
    {
        System.out.println(obj);
    }
}

这里写图片描述

3、Map的取出方法

  • 3.1 方法一：
    Set keySet()
    返回此映射中包含的键的 set 视图。因为Set具备迭代器，所以可用迭代方法取出所有的键，再根据get方法获取每一个键对应的值。
import java.util.*;
class Demo
{
    public static void main(String[] args)
    {
  Map<String,String>map=new HashMap<String,String>();
        map.put("01","zhangsan");
        map.put("02","shenjing");
        map.put("03","haha");
        map.put("04","lisi");
        Set<String>keySet=map.keySet();
        Iterator<String>it=keySet.iterator();
        while (it.hasNext())
        {
            String key=it.next();
            String value=map.get(key);
            System.out.println(key+">>>"+value);
        }
    }
}
  • 3.2 方法二：
    Set entrySet()
    返回此映射中包含的映射关系的 set 视图。返回的 set 中的每个元素都是一个 Map.Entry。
    public static interface Map.Entry
    映射项（键-值对）。Map.entrySet 方法返回映射的 collection 视图，其中的元素属于此类。获得映射项引用的惟一 方法是通过此 collection 视图的迭代器来实现。
    K getKey()
    返回与此项对应的键。
    V getValue()
    返回与此项对应的值。
import java.util.*;
class Demo
{
    public static void main(String[] args)
    {
  Map<String,String>map=new HashMap<String,String>();
        map.put("01","zhangsan");
        map.put("02","shenjing");
        map.put("03","haha");
        map.put("04","lisi");
Set<Map.Entry<String,String>>entrySet=map.entrySet();
        Iterator<Map.Entry<String,String>>it=entrySet.iterator();
        while (it.hasNext())
        {
            Map.Entry<String,String>me=it.next();
            String key=me.getKey();
            String value=me.getValue();
            System.out.println(key+"....."+value);
        }
    }
}
  • 3.3 练习
    （1）
/*
需求：将学生作为对象，将其按照名字和年龄排序，使用Map存储和取出。
*/
import java.util.*;
class Student implements Comparable<Student>
{
    private String name;
    private int age;
    Student(String name,int age)
    {
        this.name=name;
        this.age=age;
    }
    public String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }
    public String toString()//使用它后面才可以直接打印System.out.println(stu+"~~~~"+addr);
    {
        return name+"····"+age;
    }
    public int hashCode()
    {
        return name.hashCode()+age*39;
    }
    public boolean equals(Object obj)
    {
        if(!(obj instanceof Student))
            throw new ClassCastException("类型转换异常");
        Student s=(Student)obj;
        return this.name.equals(s.name)&&this.age==s.age;
    }
    public int compareTo(Student s)
    {
        int num=new Integer(s.age).compareTo(new Integer(this.age));
        if(num==0)
            return s.name.compareTo(this.name);
        return num;
    }
}
class HashMapDemo
{
    public static void main(String[] args)
    {
        HashMap<Student,String> hm=new HashMap<Student,String>();
        hm.put(new Student("Lisi7",10),"Beijing");
        hm.put(new Student("Lisi5",14),"Hangzhou");
        hm.put(new Student("Lisi9",14),"Shanghai");
        hm.put(new Student("Lisi2",13),"Nanjing");
/****************************************************///方法一：
        Set<Student> keySet=hm.keySet();
        Iterator<Student> it=keySet.iterator();
        while(it.hasNext())
        {
            Student stu=it.next();
            String addr=hm.get(stu);
            System.out.println(stu+"······"+addr);
        }
/***************************************************///方法二：
        Set<Map.Entry<Student,String>>entrySet=hm.entrySet();
        Iterator<Map.Entry<Student,String>>it=entrySet.iterator();
        while(it.hasNext())
        {
            Map.Entry<Student,String>me=it.next();
            Student stu=me.getKey();
            String addr=me.getValue();
            System.out.println(stu+"·····"+addr);
/***************************************************/
        }
    }
}

这里写图片描述
（2）

    /*****************************************************************************
    字母出现的次数，例如“asddgdfdghhcvgr”希望打印结果是a（1）s（1）

    思路：
    1、将字符串转换为字符数组，要对每个字母操作
    2、使用treeMap集合进行排序
    3.遍历数组
    4、将map集合中的数据变成指定字符串形式返回
    ******************************************************************************/
    import java.util.*;
    class TreeMapDemo
    {
        public static void main(String[] args)
        {
            String s=charCount("adhfudfddsfjdjf");
            System.out.println(s);
        }
        public static String charCount(String str)
        {
            char[] chs=str.toCharArray();
            TreeMap<Character,Integer>tm=new TreeMap<Character,Integer>();
            for(int i=0;i<str.length();i++)
            {
                Integer value=tm.get(chs[i]);
                if(value==null)
                {
                    tm.put(chs[i],1);
                }
                else
                {
                    value=value+1;
                    tm.put(chs[i],value);
                }
            }
                StringBuilder sb=new StringBuilder();
                Set<Map.Entry<Character,Integer>>entrySet=tm.entrySet();
                Iterator <Map.Entry<Character,Integer>> it=entrySet.iterator();
                while(it.hasNext())
                {
                    Map.Entry<Character,Integer>me=it.next();
                    Character ch=me.getKey();
                    Integer ve=me.getValue();
                    sb.append(ch+"("+ve+")");
                }

            return sb.toString();
        }
    }

这里写图片描述

二、Collections接口

1、Collections方法

  • 1.1 一般方法
    public static void sort(List list)
    *根据指定比较器产生的顺序对指定列表进行排序。
    public static T max(Collection coll)
    根据元素的自然顺序，返回给定 collection 的最大元素。collection 中的所有元素都必须实现 Comparable 接口。此外，collection 中的所有元素都必须是可相互比较的（也就是说，对于 collection 中的任何 e1 和 e2 元素，e1.compareTo(e2) 不得抛出 ClassCastException）。
    public static void fill(List list,T obj)
    使用指定元素替换指定列表中的所有元素。
    public static boolean replaceAll(Listlist, T oldVal,T newVal)
    使用某一值替换列表中出现的所有某一指定值
    public static void reverse(List list)
    反转指定列表中元素的顺序。
import java.util.*;
class CollectionsDemo8
{
    public static void main(String[] args)
    {
        List<String>list=new ArrayList<String>();
        list.add("absdf");
        list.add("fgfg");
        list.add("sxxg");
        list.add("ggf");
        System.out.println(list);
        /**************排序*********************/
        Collections.sort(list);
        System.out.println("sort后："+list);
        /**************取最值*********************/
        String max=Collections.max(list);
        System.out.println(max);
        /**************二分查找*********************/
        int index=Collections.binarySearch(list,"fgfg");
        System.out.println("fgfg位置:"+index);
        /***************替换*****************************/
        Collections.replaceAll(list,"fgfg","哈哈");
        System.out.println("replaceAll后"+list);
        /***************反转*************************/
        Collections.reverse(list);
        System.out.println("reverse后数组："+list);
        /***************添加*************************/
        Collections.fill(list,"pp");
        System.out.println("fill后数组："+list);

    }
}

这里写图片描述

public static void sort(List list, Comparator c)
根据指定比较器产生的顺序对指定列表进行排序。此列表内的所有元素都必须是使用指定比较器可相互比较的（也就是说，对于列表中的任何 e1 和 e2 元素，c.compare(e1, e2) 不得抛出 ClassCastException）。
public static T max(Collection coll,Comparator comp)
根据指定比较器产生的顺序，返回给定 collection 的最大元素。collection 中的所有元素都必须是通过指定比较器可相互比较的（也就是说，对于 collection 中的任何 e1 和 e2 元素，comp.compare(e1, e2) 不得抛出 ClassCastException）。

/*
需求：自定义比较方法，按照字符串的长度进行排序。
*/
import java.util.*;
class CollectionDemo
{
    public static void main(String[] args)
    {
        List <String> list=new ArrayList<String>();
        list.add("abcd");
        list.add("bcd");
        list.add("qq");
        list.add("kkk");
        Collections.sort(list,new StrLenComparator());
        System.out.println(list);
        String max=Collections.max(list,new StrLenStringDemo());
        System.out.println(max);
    }
}
class StrLenComparator implements Comparator<String>
{
    public int compare(String s1,String s2)
    {
        if(s1.length()>s2.length())
        return 1;
        else if(s1.length()<s2.length())
        return -1;
        return s1.compareTo(s2);
    }
}
  • 1.2 查找方式
    public static int binarySearch(List list,T key)
    使用二进制搜索算法来搜索指定列表，以获得指定对象。
/**********************************************************************
需求：（1）使用binarySearch方法查找指定的元素
      （2）使用自定义的查找方式进行指定元素的查找
       (3)使用自定义的查找方式进行元素的查找，但是需要按照字符串长度进行排序
**********************************************************************/
import java.util.*;
class StrLenStringDemo implements Comparator<String>
{
    public int compare(String s1,String s2)
    {
        if(s1.length()>s2.length())
        return 1;
        else if(s1.length()<s2.length())
        return -1;
        return s1.compareTo(s2);
    }
}
class CollectionDemo
{
    public static void main(String[] args)
    {
        List <String> list=new ArrayList<String>();
        list.add("abcd");
        list.add("bcd");
        list.add("qq");
        list.add("kkk");
        Sop("原数组："+list);

        Collections.sort(list);//要排列有序的序列
        Sop("sort后数组："+list);

        int index1=Collections.binarySearch(list,"abcd");
        Sop("abcd位置："+index1);

        int index2=halfSearch1(list,"kkk");//查找
        Sop("kkk位置："+index2);

        Collections.sort(list,new StrLenStringDemo());
        Sop("按照长度排序后数组："+list);
        int index3=halfSearch2(list,"bcd",new StrLenStringDemo());
        Sop("bcd位置："+index3);
    }
    public static void Sop(Object obj)
    {
        System.out.println(obj);
    }
    public static int halfSearch1(List<String>list,String key)
    {
        int min=0;
        int max=list.size()-1;
        while(min<=max)
        {
            int mid=(min+max)>>1;
            String str=list.get(mid);
            int num=str.compareTo(key);
            if(num>0)
                max=mid-1;
            else if(num<0)
                min=mid+1;
            else
                return mid;
        }
        return -1;
    }
    public static int halfSearch2(List<String>list,String key,Comparator<String>cmp)
    {
        int min=0;
        int max=list.size()-1;
        while(min<=max)
        {
            int mid=(min+max)>>1;
            String str=list.get(mid);
            int num=cmp.compare(str,key);
            if(num>0)
                max=mid-1;
            else if(num<0)
                min=mid+1;
            else 
                return mid;
        }
        return -1;
    }
}

这里写图片描述
1.3

西红柿鸡蛋面U
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
浅谈Java中的Map
Adelagirl的博客
11-13 470
Map概述 将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。 Map接口和Collection接口有何不同： Map是双列的，Collection是单列的 Map的键唯一，Collection的子体系Set是唯一的 Map集合的数据结构针对键有效，跟值无关；Collection集合的数据结构是针对元素有效 Entry Map中还有一个嵌套接口Entry 成员方...
Map接口
m0_57727988的博客
07-16 1393
Map接口的概念,Map接口的常用方法,Map接口的实现类,以及底层结构和添加元素的具体过程
map.keySet()获取map全部的key值
weixin_30426957的博客
01-31 2006
public static String getUrlWithQueryString(String url, Map<String, String> params) { if (params == null) { return url; } StringBuilder builde...
知识单元六 泛型与集合
qq_64314976的博客
07-15 884
1. 下面说法不正确的是( )？ [单选题] * 列表(List)、集合(Set)和映射(Map)都是java.util包中的接口。 List接口是可以包含重复元素的有序集合。 Set接口是不包含重复元素的集合。 Map接口将键映射到值，键可以重复，但每个键最多只能映射一个值。(正确答案) 2. 下面哪些方法不是接口Collection中已声明的方法( )？ [单选题] * 添加元素的add(Object obj) 方法 删除元素的remove(Object obj)方法 得到元素个数的length()方
Map接口概述(HashMap,TreeMap)
qq_40935960的博客
07-07 305
Map集合概述： 将键值映射到值得对象 一个映射不能包括重合的键 每个键最多只能映射到一个值 Map接口和Collection接口的不同 Map是双列，collection是单列的 Map的键唯一，collectionde子体系Set是惟一的 Map集合的数据结构值针对键有效，跟值无关，Collection集合的数据结构是针对元素有效的 通过API,我们知道Map集合的最大特点就是...
Java期末复习-类集框架
08-06
类集框架的最大父接口是`Collection`，而`Map`接口则是处理键值对的双值操作接口。 1. **Collection接口** - `Collection`接口是所有单值存储集合的基础，它定义了一些基本操作，如添加、删除和检查元素。`...
Java 软件开发复习提纲.pdf
最新发布
05-08
Java集合框架包括接口（如List、Set、Map）和实现这些接口的类，如ArrayList、Vector、LinkedList、Stack、HashSet、TreeSet、LinkedHashSet、PriorityQueue、HashMap、TreeMap、LinkedHashMap、Hashtable、...
HappyJava:java学习代码
03-31
2. **集合框架**：深入讲解ArrayList、LinkedList、HashSet、HashMap等集合类的使用，以及List、Set、Map接口的理解和实现。 3. **异常处理**：学习如何正确捕获和处理异常，理解Checked异常和Unchecked异常的区别...
Java 复习试题 试题库
05-25
通过这个Java复习题库，你可以系统地练习和测试自己的Java知识水平。每个题目都对应一个或多个上述知识点，解答过程中不仅能检验理论知识，还能提升实际编程能力。希望这份题库能成为你学习Java道路上的得力助手，助...
Java中集合相关知识点复习
12-21
为了保证线程安全，可以使用`Collections.synchronizedMap`对HashMap进行包装，或者使用`ConcurrentHashMap`，后者提供了线程安全的同时性能更优的并发操作。 HashMap的内部结构是一个数组，每个数组元素关联一个...
java中map的使用实例
03-23
java中map简单实例，包含插入，读出，遍历代码。内含map使用实例及HashMap,LinkedHashMap,TreeMap的区别
Map获取其键和值
m0_67394006的博客
08-20 844
尽管您可能注意到，纵然假设忽略构建一个需要传递给 putAll() 的 Map 的开销，使用 putAll() 通常也并不比使用大量的 put() 调用更有效率，但 putAll() 的存在一点也不稀奇。但应注意，putAll() 在添加所有元素之前可以正确调整 Map 的大小，因此如果您未亲自调整 Map 的大小（我们将对此进行简单介绍），则 putAll() 可能比预期的更有效。表 3： 返回视图的 Map 方法： 使用这些方法返回的对象，您可以遍历 Map 的元素，还可以删除 Map 中的元素。
Java中的映射 Map接口
qq_41141896的博客
05-30 950
        Collection接口接口操作的时候，每次都会向集合中增加一个元素，但是如果增加的是一对元素，则使用Map接口来实现，Map是专门用来存储键---值对的对象，Map中存在的关键字和值都必须是对象，并要求关键字是唯一，而值可以重复。        Map集合 ,键值的映射关系的一种集合(接口) * 将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。     ...
Java中关于Map的几种遍历方式
程序猿小张的升级路
11-06 272
Java中关于Map的几种遍历方式欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入...
leetcode451. 根据字符出现频率排序(JAVA)(hashmap)
qq_35706707的博客
04-05 574
my solution: class Solution { public String frequencySort(String s) { Map<Character,Integer> map=new HashMap<>(); List<Character> ret=new ArrayList<C...
关于Map 接口的一些知识点
CSDN博客
06-20 554
Map: 1. map是键值对关系，它将键映射到值，一个映射不能包含重复的键，每个键最多只能映射到一个值， 意思是，键不能重复，值可以重复，键与之一一对应。 2.映射顺序 定义为迭代器在映射的 collection 视图上返回其元素的顺序。 某些映射实现可明确保证其顺序，如 TreeMap 类； 另一些映射实现则不保证顺序，如HashMap 类。 3.map接口里的一些方法： ...
Map集合 键值对 映射关系 Hashtable HashMap TreeMap keySet entrySet Map.Entry
逍遥单机君
10-16 1416
Map 将建映射到值得对象，一个映射不能包含重复的jian
java hashmap实例_java HashMap详解及实例代码
weixin_39549110的博客
02-16 195
java hashmap/** map集合的特点* 将键映射值的对象，一个映射不能包含重复的值；每个键最多只能映射到一个值** map集合和collection集合的区别？* map集合存储元素是成对出现的，map集合的键是唯一的，就是可重复的。可以把这个理解为：夫妻对* collection集合存储元素是单独出现的，collection的儿子set是唯一的，list是可重复的，可以把这个理解为：...
Java编程复习关键点：反射、IO流、控制结构
Java集合框架包括List（如ArrayList、LinkedList）、Set（如HashSet、TreeSet、LinkedHashSet）、Queue（如PriorityQueue）、Map（如HashMap、TreeMap、LinkedHashMap、Hashtable、IdentityHashMap、WeakHashMap）...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值