JAVA第七章集合（四）

最新推荐文章于 2023-04-14 10:45:32 发布
最新推荐文章于 2023-04-14 10:45:32 发布
阅读量280 收藏
点赞数
分类专栏： java类型 文章标签： map
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39128354/article/details/76758332
版权

Map接口

Map与Collection 是并列在，用保存具有映射关系的数据：key-Value
Map中的key和value都可以是任何类型的数据
Map中的key用Set来存放，不允许重复，既同一个Map对象所对应的类。须重写hashCode()和equals（）方法
常用String类作为Map的“键”。
key和value之间存在单向的一对一关系。既通过指定的key总能找到唯一的确定的value

HashMap

1.key是用Set来存放的，不可重复，value是用Collection来存放的。可重复，一个key-value对是一个Entry所有的Entry是用Set存放的也是不可重复的。
2.向HashMap中添加元素时。会调用key所在类的equals（）方法，判断俩个key是否相同，若相同则只能添加进后加的那个元素
Map接口
|…HashMap(主要实现类）
|…LinkedHashMap；
|…TreeMap
|…Hashtable
|….Properties;
Map常用的方法
添加，删除操作
Object put(Object key,Object value)向Map中添加一个元素
Object remove(Object key)按照指定的key删除此key-value
void putAll(Map t)
void clear()：清空

元素查询的操作
Object get(Object key)获取指定key的value值 若无此key则返回null
boolean containsKey(Object key)
boolean containsValue(Object value)
int size()返回集合的长度
boolean isEmpty()
boolean equlas(Object obj)
元视图操作的方法
Set keySet()
Collection values()
Set entrySet()

package Collection;

public class Person implements Comparable {
    private String name;
    private Integer id;

    public Person() {
        super();
    }
    public Person(String name, Integer id) {
        super();
        this.name = name;
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((id == null) ? 0 : id.hashCode());
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Person other = (Person) obj;
        if (id == null) {
            if (other.id != null)
                return false;
        } else if (!id.equals(other.id))
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", id=" + id + "]";
    }
    @Override
    public int compareTo(Object o) {
        if(o instanceof Person){
            Person p=(Person)o;
            int i=this.id.compareTo(p.id);
            if(i==0){
                return this.name.compareTo(p.name);
            }else{
                return i;
            }
        }
        return 0;
    }

}

package Collection;

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

import org.junit.Test;

public class testHashMap {
    @Test
    public void testOne(){
        Map map= new HashMap();
        Map map1= new HashMap();
        map1.put("AA", 123);
        map1.put("BB", 235);
        map1.put("SS", 1235);
        map.put("AA", 123);
        map.put("BB", 235);
        map.put("SS", 1235);
        map.put("VV", 224);
        map.put("AA", 456);
        map.put(123, new Person("AA",123));
        map.put(new Person("BB",124), 124);
        map.put(new Person("BB",124), 125);
        System.out.println(map.size());
        //map.remove("AA");
        //System.out.println(map.size());
        //map.clear();
        //System.out.println(map.size());
        System.out.println(map.get("AA"));
        System.out.println(map.get(444));
        System.out.println(map.get("AA").equals(map.get("BB")));//比较俩个是否相等
        System.out.println(map.isEmpty());//判断是否为空
        boolean b1=map.containsValue(224);//判断map中是否包含该values值
        boolean b2=map.containsKey("AA");//判断改制中是否包含其key
        System.out.println(b1);
        System.out.println(b2);
        //进行遍历
        Set set=map.keySet();//遍历key
        for(Object obj:set){
        System.out.println(obj);
        }
        Collection com=map.values();

        Iterator i=com.iterator();//遍历values
        while(i.hasNext()){
            System.out.println(i.next());
        }
        Set set1=map.keySet();
        for(Object obj:set1){
            System.out.println(obj+"----------------->"+map.get(obj));
        }//entrySet方式一
        Set ste2=map.entrySet();
        for(Object obj:ste2){
            Map.Entry entry=(Map.Entry)obj;
            System.out.println(entry.getKey()+"--------->"+entry.getValue());
        }//方式二
        Set ste3=map.entrySet();
        for(Object obj:ste3){
            Map.Entry entry=(Map.Entry)obj;
            System.out.println(entry);
        }

    }
}
运行结果
6
456
null
false
false
true
true
AA
BB
SS
VV
Person [name=BB, id=124]
123
456
235
1235
224
125
Person [name=AA, id=123]
AA----------------->456
BB----------------->235
SS----------------->1235
VV----------------->224
Person [name=BB, id=124]----------------->125
123----------------->Person [name=AA, id=123]
AA--------->456
BB--------->235
SS--------->1235
VV--------->224
Person [name=BB, id=124]--------->125
123--------->Person [name=AA, id=123]
AA=456
BB=235
SS=1235
VV=224
Person [name=BB, id=124]=125
123=Person [name=AA, id=123]

LinkedHashMap

使用链表维护添加进Map中的顺序，故遍历Map是按照添加的顺序遍历的

    package Collection;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;

import org.junit.Test;

public class testHashMap {
    @Test
    public void tetsTwo(){
        Map map= new LinkedHashMap();
        map.put("BB", 235);
        map.put("SS", 1235);
        map.put("VV", 224);
        map.put("AA", 456);
        map.put(123, new Person("AA",123));
        map.put(new Person("BB",124), 124);
        map.put(new Person("BB",124), 125);
        Set ste2=map.entrySet();
        for(Object obj:ste2){
            Map.Entry entry=(Map.Entry)obj;
            System.out.println(entry.getKey()+"--------->"+entry.getValue());
        }
    }
    }
    运行结果
    BB--------->235
SS--------->1235
VV--------->224
AA--------->456
123--------->Person [name=AA, id=123]
Person [name=BB, id=124]--------->125

TreeMap方法

//自排序
@Test//自排序
    public void tetsOne(){
        Map map=new TreeMap();

        map.put(new Person("AA",124), 110);
        map.put(new Person("CC",125), 132);
        map.put(new Person("TT",126), 98);
        map.put(new Person("VV",123), 214);
        map.put(new Person("EE",152), 20);
        map.put(new Person("AA",142), 24);
        Set ste2=map.entrySet();
        for(Object obj:ste2){
            Map.Entry entry=(Map.Entry)obj;
            System.out.println(entry.getKey()+"--------->"+entry.getValue());
        }
    }
运行结果
Person [name=VV, id=123]--------->214
Person [name=AA, id=124]--------->110
Person [name=CC, id=125]--------->132
Person [name=TT, id=126]--------->98
Person [name=AA, id=142]--------->24
Person [name=EE, id=152]--------->20

//定制排序
ackage Collection;

public class Customer {
    private String name;
    private Integer id;
    public Customer() {
        super();
    }
    public Customer(String name, Integer id) {
        super();
        this.name = name;
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    @Override
    public String toString() {
        return "Customer [name=" + name + ", id=" + id + "]";
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((id == null) ? 0 : id.hashCode());
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Customer other = (Customer) obj;
        if (id == null) {
            if (other.id != null)
                return false;
        } else if (!id.equals(other.id))
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
}

package Collection;

import java.util.Comparator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

import org.junit.Test;

public class testTreeMaop {
    @Test
    public void testTwo(){
        Comparator com= new Comparator(){

            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof Customer && o2 instanceof Customer){
                    Customer c1=(Customer)o1;
                    Customer c2=(Customer)o2;
                    int i=c1.getId().compareTo(c2.getId());
                    if(i==0){
                        return c1.getName().compareTo(c2.getName());
                    }else{
                        return i;
                    }
                }
                return 0;
            }

        };
        Map map=new TreeMap(com);
        map.put( new Customer("AA",124),124);
        map.put( new Customer("SS",123),125);
        map.put( new Customer("GG",126),245);
        map.put( new Customer("mm",195),745);
        map.put( new Customer("ss",45),245);
        Set ste2=map.entrySet();
        for(Object obj:ste2){
            Map.Entry entry=(Map.Entry)obj;
            System.out.println(entry.getKey()+"--------->"+entry.getValue());
        }

    }
    //运行结果
    Customer [name=ss, id=45]--------->245
Customer [name=SS, id=123]--------->125
Customer [name=AA, id=124]--------->124
Customer [name=GG, id=126]--------->245
Customer [name=mm, id=195]--------->745

Hashtable

:古老的实现类，线程安全，不建议使用
Properties：常用来处理属性文件：键和值都是String类型的。

使用Properties处理属性文件
package Collection;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Comparator;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.TreeMap;

import org.junit.Test;

public class testTreeMaop {
    @Test
    public void Three() throws FileNotFoundException, IOException{
        Properties pros=new Properties();
        pros.load(new FileInputStream(new File("jdbc.properties")) );
        String user=pros.getProperty("user");
        String password=pros.getProperty("password");
        System.out.println("uesr"+"="+user+"\n"+"password"+password);


    }
    文件内容
user=root
password=123abc
运行结果
uesr=root
password123abc
自在强
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第七章面对对象核心技术
m0_64081081的博客
04-23 541
java第7章总结
java第七章
05-01
java第七章
第七章：Java_集合
Jaybo
02-12 461
集合概述 对象的存储：①数组（基本数据类型 & 引用数据类型） ②集合（引用数据类型） 数组存储数据的弊端：长度一旦初始化以后，就不可变；真正给数组元素赋值的个数没有现成的方法可用。 Collection接口Collection接口 ： 方法： ①add(Object obj),addAll(Collection coll),size(),clear(),isEmpty(
java 第六章集合代码所需
09-28
第六章的学习通常会深入探讨Java中的集合框架，这是一个强大的工具，包括多种数据结构，如列表、队列、堆栈、映射等。下面我们将详细讲解Java集合框架及其相关知识点。 1. **集合接口**： - `List`：表示有序的...
第16章：Java集合.zip_java 集合_java集合
09-24
本章内容主要围绕Java集合框架展开，包括ArrayList、LinkedList、HashSet、HashMap等常见数据结构的使用方法及其特点。 1. **集合接口**： - `Collection`：所有单值容器的根接口，包括List、Set等子接口。 - `...
Java程序设计与数据结构第七章习题答案
12-11
第七章习题主要会涵盖数组、链表、栈、队列、树以及图等基本数据结构，以及相关的算法应用。以下是这个章节可能涉及的一些核心知识点： 1. **数组**：数组是最基础的数据结构，它允许存储同一类型的元素序列。学习...
Java教学课件PPT第7章 泛型和集合框架.ppt
08-06
Java教学课件PPT
JAVA 面向对象程序设计第7章 集合.pptx
07-05
本章主要探讨了Java集合的三个核心类型：Set、List和Map，以及它们的特点和用途。 7.1 集合概述 Java集合框架位于`java.util`包中，它提供了一种灵活的方式来存储和操作数据。不同于数组，集合可以存储对象，并且...
java课件（第7章）
05-25
java课件（第7章）,学好java你绝对需要它！
Java第七章
m0_74224475的博客
04-05 105
第七章总结
Java-第7章
weichen_Hi的博客
09-13 500
7.0简介1．核心库Java.io包提供了全面的I/O接口2．Java中I/O是以流为基础进行串行化输入/输出7.1File类1．File类从java.lang.Object类继承而来的2．在创建File类对象时，必须制定文件或者目录的路径1) 路径可分为绝对路径和相对路径3．常用方法：canRead、canWrite、compareTo、createNewFile等4．目录也是一种文件7.2流1...
java：第七章
weixin_34409822的博客
06-06 128
第七章 循环的强化练习 public static void main(String[] args) { Scanner input = new Scanner(System.in); System.out.println("青鸟游戏平台>游戏币支付\n"); System.out.println("请选择您玩的游戏类型：\n"...
Java作业第7章
youshini的专栏
03-25 1031
Java——第七章（进程和多线程）
Li_peilun的博客
11-30 711
常常在任务管理器当中可以看到进程，系统进程什么的，但是究竟这个是什么东东？有仔细想过吗？进程是正在运行的程序，其实不然，正在运行的程序不一定有一个进程，还可以有多个进程支持，每个应用程序都需要一个或多个进程来支持运行，当应用程序运行时会伴随进程的启动。一个进程是一个应用程序的执行路径。多个进程间有什么关系？一个应用程序中，多个进程是在同一时间内一起执行，即并发执行。并行是表面上的同时执行，实际上达不
Java_第07章_面向对象编程(进阶)
最新发布
qq_52922453的博客
04-14 1361
编写Order类，有int型的orderId，String型的orderName，相应的getter()和setter()方法，两个参数的构造器，重写父类的equals()方法：public boolean equals(Object obj)，并判断测试类中创建的两个对象是否相等。调用这样的方法，就称为虚方法调用。③ 我们前面讲过，在构造器的首行可以使用"this(形参列表)"，调用本类中重载的构造器， 结合②，结论：在构造器的首行，"this(形参列表)" 和 "super(形参列表)"只能二选一。
Java 6 SCJP指南：第7章 - 泛型与集合
在Java编程中，第7章“Generics and Collections”是SCJP（Sun Certified Programmer for Java）证书考试中的关键部分。这个章节涵盖了设计使用集合、重写equals()和hashCode()方法、区分'=='和'equals()'、使用泛型...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值