java基础学习19（Map Collections Arrays）

于 2019-08-30 17:01:34 发布
阅读量195 收藏
点赞数
分类专栏： java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MyNote1994/article/details/100155586
版权

-------------| Map 如果是实现了Map接口的集合类，具备的特点： 存储的数据都是以键值对的形式存在的，键不可重复，值可以重复。
----------------| HashMap 底层也是基于哈希表实现 的。
----------------| TreeMap TreeMap也是基于红黑树（二叉树）数据结构实现 的， 特点：会对元素的键进行排序存储。
----------------| Hashtable 底层也是依赖了哈希表实现的，也就是实现方式与HashMap是一样的，但是Hashtable是线程安全的，操作效率低。

Map

Map的常用函数

在这里插入图片描述

public class Test {
    public static void main(String[] args) {

        Map<String,Object> m = new HashMap<String,Object>();
        m.put("1","阿伟");
        m.put("2","errorCode");

        Map<String,Object> map = new HashMap<String,Object>();
        map.put("1","阿建");
        map.putAll(m);
//        map.remove("2");
//        map.clear();

        System.out.println(map.containsKey("1"));
        System.out.println(map.containsValue("阿伟"));

        Set<Map.Entry<String, Object>> entries = map.entrySet();
        Iterator<Map.Entry<String, Object>> iterator = entries.iterator();
        while (iterator.hasNext()){
            Map.Entry<String, Object> next = iterator.next();
            System.out.println(next.getKey()+"---"+next.getValue());
        }

    }
}

Map的遍历方式

这里不过多描述，可以看代码，常说Map有多少多少遍历方式个人觉得了解就行，遍历的方式太多会用就行全部记住干嘛呢。

public class Test {
    public static void main(String[] args) {

        Map<String,Object> m = new HashMap<String,Object>();
        m.put("1","阿伟");
        m.put("2","errorCode");

        //keySet
        Set<String> keySet = m.keySet();
        Iterator<String> iterator1 = keySet.iterator();
        while (iterator1.hasNext()){
            String next = iterator1.next();
            System.out.println(next);
        }

        for (String s:keySet) {
            System.out.println(s);
        }

        Iterator<String> iterator2 = keySet.iterator();
        while (iterator2.hasNext()){
            System.out.println(m.get(iterator2.next()));
        }
        System.out.println("=======================");

        //values
        Collection<Object> values = m.values();
        Iterator<Object> iterator3 = values.iterator();
        while (iterator3.hasNext()){
            System.out.println(iterator3.next());
        }

        for (Object obj :values) {
            System.out.println(obj);
        }
        System.out.println("=======================");


        //entrySet
        Set<Map.Entry<String, Object>> entries = m.entrySet();
        Iterator<Map.Entry<String, Object>> iterator4 = entries.iterator();
        while (iterator4.hasNext()){
            Map.Entry<String, Object> next = iterator4.next();
            System.out.println(next.getKey()+"---"+next.getValue());
        }

        for (Map.Entry<String, Object> map :entries) {
            System.out.println(map.getKey()+"---"+map.getValue());
        }

    }

HashMap

实现原理

首先看下两种情况；
情况一：

class Person{
    private int id;

    private String name;

    public Person(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public void setId(int id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "id:"+this.id+"---name"+this.name;
    }
}

public class Test {
    public static void main(String[] args) {
        Person p1 = new Person(1, "张三");
        Map<Person, String> map = new HashMap<>();
        map.put(p1, "张三");
        map.put(p1, "李四");

        Set<Map.Entry<Person, String>> entries = map.entrySet();
        for (Map.Entry<Person, String> entry : entries) {
            System.out.println(entry.getKey() + "====" + entry.getValue());
        }
		//结果 id:1---name张三====李四
    }
}

情况二：

class Person{
    private int id;

    private String name;

    public Person(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public void setId(int id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "id:"+this.id+"---name"+this.name;
    }
}

public class Test {
    public static void main(String[] args) {
        Person p1 = new Person(1, "张三");
        Map<Person, String> map = new HashMap<>();
        map.put(new Person(1, "张三") , "张三");
        map.put(new Person(1, "张三"), "李四");

        Set<Map.Entry<Person, String>> entries = map.entrySet();
        for (Map.Entry<Person, String> entry : entries) {
            System.out.println(entry.getKey() + "====" + entry.getValue());
        }
       //id:1---name张三====张三    id:1---name张三====李四
    }
}

问题分析
这两种情况我们发现第二种情况可以插入两条数据，第一种不行。前文也说了Map种key是不允许重复的，那么当key为引用类型的时候是如何判断key是否重复的呢。在这里插入图片描述
原来如此：
往HashMap添加元素的时候，首先会调用键的hashCode方法得到元素的哈希码值，然后经过运算就可以算出该元素在哈希表中的存储位置。 情况1： 如果算出的位置目前没有任何元素存储，那么该元素可以直接添加到哈希表中。情况2：如果算出的位置目前已经存在其他的元素，那么还会调用该元素的equals方法与这个位置上的元素进行比较，如果equals方法返回 的是false，那么该元素允许被存储，如果equals方法返回的是true，则替换原有数据。

修改代码如下让第二种情况下也只能插入一条数据

class Person{
    private int id;

    private String name;

    public Person(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public void setId(int id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "id:"+this.id+"---name"+this.name;
    }

    @Override
    public int hashCode() {
        return this.getId();
    }

    @Override
    public boolean equals(Object obj) {
        Person p = (Person)obj;
        return p.id == this.id;
    }
}

public class Test {
    public static void main(String[] args) {
        Map<Person, String> map = new HashMap<>();
        map.put(new Person(1, "张三") , "张三");
        map.put(new Person(1, "张三"), "李四");

        Set<Map.Entry<Person, String>> entries = map.entrySet();
        for (Map.Entry<Person, String> entry : entries) {
            System.out.println(entry.getKey() + "====" + entry.getValue());
        }
	 //id:1---name张三====李四
    }

TreeMap

TreeMap 要注意的事项：

  • 往TreeMap添加元素的时候，如果元素的键具备自然顺序，那么就会按照键的自然顺序特性进行排序存储。

  • 往TreeMap添加元素的时候，如果元素的键不具备自然顺序特性， 那么键所属的类必须要实现Comparable接口，把键的比较规则定义在CompareTo方法上，或者在创建TreeMap对象的时候传入比较器。

实现Comparable

class Person implements  Comparable{
    private int id;

    private String name;

    public Person(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public void setId(int id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "id:"+this.id+"---name"+this.name;
    }

    @Override
    public int compareTo(Object o) {
        Person p = (Person) o;
        return this.id-p.id;
    }
}

public class Test {
    public static void main(String[] args) {
        TreeMap<Person,String> treeMap = new TreeMap<Person,String>();
        treeMap.put(new Person(1,"张三"),"张三");
        treeMap.put(new Person(2,"李四"),"李四");

        Set<Map.Entry<Person, String>> entries = treeMap.entrySet();
        for (Map.Entry<Person, String> entry : entries) {
            System.out.println(entry.getKey() + "====" + entry.getValue());
        }
    }
}

传入比较器

class Person{
    private int id;

    private String name;

    public Person(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public void setId(int id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "id:"+this.id+"---name"+this.name;
    }

    @Override
    public int hashCode() {
        return this.id;
    }
}

class  MyComparator<T> implements Comparator<T>{
    @Override
    public int compare(T o1, T o2) {
        return o1.hashCode()-o2.hashCode();
    }
}
public class Test {
    public static void main(String[] args) {
        TreeMap<Person,String> treeMap = new TreeMap<Person,String>(new MyComparator<Person>());
        treeMap.put(new Person(1,"张三"),"张三");
        treeMap.put(new Person(2,"李四"),"李四");
        treeMap.put(new Person(2,"李四2"),"李四2");
        
        Set<Map.Entry<Person, String>> entries = treeMap.entrySet();
        for (Map.Entry<Person, String> entry : entries) {
            System.out.println("key:"+entry.getKey() + ",====value:" + entry.getValue());
        }
    }
}

Hashtable

底层也是依赖了哈希表实现的，也就是实现方式与HashMap是一样的，但是Hashtable是线程安全的，操作效率低。

Collections类

  • 对list进行二分查找：前提该集合一定要有序

    • int binarySearch(list,key);
    • binarySearch(list,key,Comparator)

  • 对list集合进行排序

    • sort(list);
    • sort(list,comaprator)

  • 对集合取最大值或者最小值

    • max(Collection)
    • max(Collection,comparator)
    • min(Collection)
    • min(Collection,comparator)

  • 对list集合进行反转

    • reverse(list)

  • 可以将不同步的集合变成同步的集合

    • Set synchronizedSet(Set s)
    • Map synchronizedMap(Map<K,V> m)
    • List synchronizedList(List list)
public class Test {
    public static void main(String[] args) {
        //引用类型
        List<Person> list = new ArrayList<Person>();
        list.add(new Person(21,"张三"));
        list.add(new Person(7,"李四"));
        list.add(new Person(11,"李四"));

        List<String> stringList = new ArrayList<String>();
        stringList.add("7");
        stringList.add("3");
        stringList.add("2");
        stringList.add("12");


        //排序
        Collections.sort(stringList, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.hashCode()-o2.hashCode();
            }
        });

        Collections.sort(list,new MyComparator<Person>());

        for (String str:stringList) {
            System.out.println(str);
        }

        for (Person person:list) {
            System.out.println(person);
        }

        //二分查找
        System.out.println(Collections.binarySearch(list,new Person(21,"张三"),new MyComparator<Person>()));
        System.out.println(Collections.binarySearch(stringList, "7", new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.hashCode()-o2.hashCode();
            }
        }));

        //对集合取最大值或者最小值
        System.out.println(Collections.max(stringList, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.hashCode()-o2.hashCode();
            }
        }));

        System.out.println(Collections.min(stringList, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.hashCode()-o2.hashCode();
            }
        }));

        System.out.println(Collections.max(list,new MyComparator<Person>()));
        System.out.println(Collections.min(list,new MyComparator<Person>()));

        //对list集合进行反转
        Collections.reverse(list);
        for (Person person:list) {
            System.out.println(person);
        }

        //基本类型
        List<Integer> integers = new ArrayList<Integer>();
        integers.add(7);
        integers.add(3);
        integers.add(2);
        integers.add(12);

        Collections.sort(integers);
        for (Integer i:integers) {
            System.out.println(i);
        }
    }
}

Arrays类

  • 二分查找,数组需要有序
    • binarySearch(int[])
    • binarySearch(double[])
  • 数组排序
    • sort(int[])
    • sort(char[])……
  • 将数组变成字符串： toString(int[])
  • 复制数组： copyOf();
  • 复制部分数组：copyOfRange():
  • 比较两个数组是否相同：equals(int[],int[]);
  • 将数组变成集合：List asList(T[]);
    ① 如果数组中存入的基本数据类型，那么asList会将数组实体作为集合中的元素。
    ② 如果数组中的存入的引用数据类型，那么asList会将数组中的元素作为集合中的元素。
    这样可以通过集合的操作来操作数组中元素，但是不可以使用增删方法，add，remove。因为数组长度是固定的，会出现UnsupportOperationExcetion。
    可以使用的方法：contains，indexOf。
public class Test {
    public static void main(String[] args) {
        //引用类型数组转为集合
        Person peoples[] = new Person[]{new Person(1,"张三"),new Person(2,"李四"),new Person(3,"王二")};
        List<Person> list = Arrays.asList(peoples);
        for (Person p :list) {
            System.out.println(p);
        }

        //基本类型数组转为集合
        Integer is[] = new Integer[]{6,7,8};
        List<Integer> list2 = Arrays.asList(is);
        list2.add(9);
        for (Integer i :list2) {
            System.out.println(i);
        }
    }
}

附:
在这里插入图片描述

Dlwyz
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
集合框架2——Map系 & 集合工具类(Collections、Arrays)
180斤的专栏
06-20 4056
0. 集合框架按其所实现的接口, 大致能分成Collection系 和Map系.  1. Map集合: 存储键值对, 且要保证键的唯一性.  2. Map与Collection的区别:  Map与Co
java基础(Map集合及子类的遍历)
努力学习中
06-17 282
1：Collection集合与Map集合 Collection集合：元素是孤立存在的，向集合中存储元素采用一个个元素的方式存储。单例集合。 Map集合：每个元素是由健和值两部分组成，通过键可以找到对应的值，健不能重复。双例集合。 2：Map的子类 HashMap<K,V> 特点： 1：HashMap底层是哈希表，查询速度很快 2：HashMap是一个无序集合，存和取顺序不一致。 LinkedMap<K,V> 特点： 1：是有序的，存和取得顺序一致。 3：HashMap<k,v&
Binary XML file line #19: Error inflating class com.luminal.view.CustomVie
鲁迷那的专栏—坚持实践后再写出来！
02-15 436
com.luminal.view E/AndroidRuntime: FATAL EXCEPTION: main     Process: com.luminal.view, PID: 4456     java.lang.RuntimeException: Unable to start activity ComponentInfo{com.luminal.view/com.luminal.vi...
java使用数组实现Map集合
热门推荐
236004的博客
08-16 1万+
package collection; import java.util.Arrays; import java.util.Collection; /** * @ClassName: ArrayImplMap * @Description:采用二维数组实现简单的Map集合(ArrayImplMap) * 1、新建或扩充数组 * 2、判断是否有值： * Y:覆盖 * N:新增 *
java基础学习之集合-Map
Johunqig的博客
02-21 853
java中的Map集合是一个由键-值（key-value）组合而成的，Map作为一个接口，jdk解释为将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。 Map.entry是其内部的一个接口，由于Map没有实现Iterable接口，就不能使用iterator来遍历集合，所以通过entrySet方法转换为Set，这个Set里存放每个元素都是一个 Map.Entry< K ,
Java基础系列面试题（88个）.pdf
06-27
Java作为一款广泛应用的编程语言，其基础知识面试题涵盖了众多方面，包括JDK和JRE的区别、对象的比较、字符串操作、抽象类与接口、容器、多线程、反射以及Java Web相关知识等。下面将详细解释这些知识点： 1. JDK...
JAVA面试使用的笔试题目
01-15
这份Java面试笔试题目涵盖了多个Java基础、容器以及数据库相关的知识点，以下是这些知识点的详细解析： 1. **JDK和JRE的区别**： JDK（Java Development Kit）是Java开发工具包，包含了JRE（Java Runtime ...
Java开发详解.zip
09-02
000000_【课程介绍 —— 写在前面的话】_Java学习概述笔记.pdf 010101_【第1章：JAVA概述及开发环境搭建】_JAVA发展概述笔记.pdf 010102_【第1章：JAVA概述及开发环境搭建】_Java开发环境搭建笔记.pdf 010201_【第2...
最最常用的 100 个 Java类分享
09-03
11. `java.util.Collections`：Collections类提供了静态方法来操作集合，如排序、查找和转换。 12. `java.util.Date`：Date类表示特定的瞬间，精确到毫秒。 13. `java.util.HashSet`：HashSet是基于哈希表的Set...
文本(2024-06-23 161043).txt
06-23
文本(2024-06-23 161043).txt
PSO_VMD_MCKD 基于PSO_VMD_MCKD方法的风机轴承微弱函数.rar
06-23
PSO_VMD_MCKD 基于PSO_VMD_MCKD方法的风机轴承微弱故障诊断。为实现 VMD 和 MCKD 的参数自适应选择，采用粒子群优化算法对两种算法中的参数进行优化，确定适应度函数为包络谱峰值因子。该资源中包括了频谱函数和求包络谱函数
计算机软考高级真题2012年上半年 系统分析师 综合知识.docx
06-23
考试资料，计算机软考，系统分析师高级，历年真题资料，WORD版本，无水印，下载。
THE CACHE MEMORY BOOK
06-23
THE CACHE MEMORY BOOK
IMG_20240623_224516.jpg
最新发布
06-24
IMG_20240623_224516.jpg
sxs-win11.zip 是一个与 Windows 11 相关的压缩文件
06-23
bootstrap卡片排版这是Windows 11系统中sxs文件包的镜像，它适用于.NET 3.5的安装过程。。内容来源于网络分享，如有侵权请联系我删除。另外如果没有积分的同学需要下载，请私信我。
paramiko-3.2.0-py3-none-any.zip
06-23
paramiko-3.2.0-py3-none-any.zip
2000-2022年 中国各银行流动性比例数据
06-23
银行流动性比例是指银行的流动性资产期末余额与流动性负债期末余额之比，用于衡量银行流动性的总体水平。这个比例越高，表明银行偿还短期债务的能力越强，流动性风险越小。 本数据覆盖到城市商业银行、城镇银行、大型商业银行、股份制银行、民营银行、农村合作银行、农村商业银行、农村信用社等500多家银行。 数据名称：中国各银行流动性比例数据 数据年份：2000-2022年 相关数据 银行代码、股票代码、统计截止日期、银行中文简称、流动性比例(本币)%、流动性比例(外币)%、流动性比例(本外币)%。
collections和arrays区别
04-10
collections和arrays是两个不同的概念。collections通常指的是Python中的集合类，包括列表、元组、字典等。而arrays则是指一个连续的内存空间，用来存储同一类型的数据。通常在使用数组时，需要预先指定大小，而在...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值