爪哇2博客
爪哇2博客

爪哇中的竞彩篮球分析

哈希图是基于哈希表的实现 地图 接口。它将条目存储在键值对中。它将键映射到值。它是最常用的之一 采集.

爪哇 哈希图

哈希图

  1. 哈希图 实施 地图 an 接口 将键映射到值。
  2. 它不同步,也不是线程安全的。
  3. 不允许重复的密钥
  4. One 空值 key and multiple 空值 价值观 are allowed
  5. 它是无序集合,不能保证元素的任何特定顺序。

哈希图

您是否注意到竞彩篮球分析实现了Map接口,即使AbstractMap已经实现了它也是如此?
是的,为了使事情变得更明显,竞彩篮球分析实现了Map 接口 再次,再次实现接口没有错。’不必经过类层次结构即可发现竞彩篮球分析实现了Map接口。

哈希图构造函数

爪哇 哈希图类有四个 构造函数
上市 哈希图():这是 默认构造函数 并主要用于它会创建一个空的竞彩篮球分析,默认初始容量为16,负载系数为0.75。
上市 哈希图(int initialCapacity):此构造函数用于指定竞彩篮球分析的初始容量和默认负载系数0.75。
上市 哈希图(int initialCapacity,float loadFactor):此构造函数用于指定竞彩篮球分析的初始容量和负载因子。在大多数情况下,除非您对此有把握,否则应避免使用此构造函数,因为负载系数0.75在时间和空间之间提供了很好的折衷。
上市 哈希图(Map<? extends K,? extends V> m):当您要从其他一些Map创建竞彩篮球分析时使用此构造函数,例如 树状图 要么 Linked竞彩篮球分析.

将键值对添加到竞彩篮球分析

We can use 放() method to add entries to 哈希图.
例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
组织.Arpit.爪哇2blog;
组织.Arpit.爪哇2blog;
进口 爪哇.实用程序.哈希图;
 
上市 哈希图BuiltMain {
 
    上市 静态的 虚空 主要([] args) {
        哈希图<整数, > 员工哈希图 = 哈希图<整数, >();
        //将键值对放入竞彩篮球分析
        员工哈希图.(1, “阿尔伯特”);
        员工哈希图.(2, “约翰”);
        员工哈希图.(3, "马丁");
        员工哈希图.(4, “ Vaibhav”);
 
        系统..打印(员工哈希图);
    }
}
 

当您在程序上方运行时,将获得以下输出

{1 = Arpit,2 = John,3 = 马丁,4 = Vaibhav}

如果仅当竞彩篮球分析中不存在条目时才想添加条目怎么办?
You can use 放IfAbsent() the method in 这个 scenario.

从竞彩篮球分析中删除条目

有两种方法可以删除竞彩篮球分析中的条目。

  1. 去掉(Object key):从竞彩篮球分析中删除密钥
  2. 去掉(Object key,Object 值):如果值与传递的参数值相同,则删除键。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
组织.Arpit.爪哇2blog.哈希图;
 
进口 爪哇.实用程序.哈希图;
 
上市 哈希图RemoveMain {
 
    上市 静态的 虚空 主要([] args) {
        哈希图<, 整数> vehicleMaxSpeedMap = 哈希图<, 整数>();
        //将键值对放入竞彩篮球分析
 
        vehicleMaxSpeedMap.(“自行车”, 120);
        vehicleMaxSpeedMap.(“汽车”, 220);
        vehicleMaxSpeedMap.(“卡车”, 160);
        vehicleMaxSpeedMap.(“ Activa”, 140);
        系统..打印(vehicleMaxSpeedMap);
 
        //拔出卡车钥匙
        整数 速度 = vehicleMaxSpeedMap.去掉(“卡车”);
        系统..打印(“ ==============================”);
        系统..打印(“最大速度的车辆卡车”+速度+“已从竞彩篮球分析中删除”);
        系统..打印(vehicleMaxSpeedMap);
        系统..打印(“ ==============================”);
 
        //如果值为200,则删除Car
        布尔值 isCarRemoved = vehicleMaxSpeedMap.去掉(“汽车”,200);
        //由于相关值为220,因此不会删除车钥匙
        系统..打印(“已从竞彩篮球分析中移除汽车:”+isCarRemoved);
        系统..打印(vehicleMaxSpeedMap);
        系统..打印(“ ==============================”);
 
        //如果值为200,则删除Car
        布尔值 isActiva已移除 = vehicleMaxSpeedMap.去掉(“ Activa”,140);
        //由于关联值为140,因此将删除Activa键
        系统..打印(“已从竞彩篮球分析中删除活动:”+isActiva已移除);
        系统..打印(vehicleMaxSpeedMap);
        系统..打印(“ ==============================”);
 
    }
}
 

输出:

{汽车= 220,Activa = 140,卡车= 160,自行车= 120}
==============================
从竞彩篮球分析中移除了最大速度为160的车辆卡车
{Car = 220,Activa = 140,Bike = 120}
==============================
汽车从竞彩篮球分析中移除了吗?
{Car = 220,Activa = 140,Bike = 120}
==============================
是否从竞彩篮球分析中删除了activa:true
{汽车= 220,自行车= 120}
==============================

重要的竞彩篮球分析方法

得到():从竞彩篮球分析检索值
放():将值放入竞彩篮球分析
是空的:检查竞彩篮球分析是否为空。
containsKey():检查当前密钥是否为竞彩篮球分析
containsValue():检查竞彩篮球分析中是否存在值
尺寸():检查竞彩篮球分析的大小
明确():要从Hashmap中删除所有元素
clone():创建竞彩篮球分析的浅表副本。

这是涵盖这些方法的示例。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
 
组织.Arpit.爪哇2blog.哈希图;
 
进口 爪哇.实用程序.哈希图;
 
上市 哈希图MethodsMain {
 
    上市 静态的 虚空 主要([] args) {
        哈希图<, > employeeDeptmap = 哈希图<>();
 
        //检查地图是否为空
        布尔值 空的 = employeeDeptmap.是空的();
        系统..打印(“ employeeDeptmap是否为空:”+空的);
 
        //将键值对放入竞彩篮球分析
        employeeDeptmap.(“阿尔伯特”,“技术”);
        employeeDeptmap.(“约翰”, “销售”);
        employeeDeptmap.("马丁", “ HR”);
        employeeDeptmap.(“ Vaibhav”,“技术”);
 
      系统..打印(employeeDeptmap);
        //检查地图大小
        系统..打印(“ employeeDeptmap的大小:”+employeeDeptmap.尺寸());
 
        //从竞彩篮球分析获取价值
        系统..打印("马丁's department: "+employeeDeptmap.得到("马丁"));
        // 罗宾的部门将为空,因为我们没有键为“ 罗宾”
        系统..打印("罗宾's department: "+employeeDeptmap.得到("罗宾"));
 
        如果(employeeDeptmap.containsKey(“约翰”))
        {
            系统..打印(“ employeeDeptmap以John为关键”);
        }
 
        如果(employeeDeptmap.containsValue(“销售”))
        {
            系统..打印(“ employeeDeptmap具有销售额作为价值”);
        }
 
        //从地图中删除所有条目
        employeeDeptmap.明确();
        系统..打印(employeeDeptmap);
    }
}
 

输出:

employeeDeptmap是否为空:true
{Arpit = Tech,John = Sales,Martin = HR,Vaibhav = Tech}
员工人数图:4
马丁’s department: HR
罗宾’s department: 空值
employeeDeptmap以John为关键
employeeDeptmap具有“销售”价值
{}

Write declarative style 码 with 哈希图

爪哇 8‘s 地图 接口 整型roduced 新 methods such as 计算(), 计算IfPresent () and 计算IfAbsent() which help you write 码 using Lambda表达式.

计算()

让’s说您有一个团队的竞彩篮球分析,否。目标如下。

1
2
3
4
5
 
哈希图<,整数> 球队GoalMap= 哈希图<>();
球队GoalMap.(“ 球队1”,1);
球队GoalMap.(“ 球队2”,1);
 

Now you want to add 1 目标 to 球队1 and generally, you do it as follow.

1
2
3
 
球队GoalMap.(“ 球队1”,球队GoalMap.得到(“ 球队1”)+1);
 

取而代之的是,您可以通过以下方式轻松地进行计算。

1
2
3
 
球队GoalMap.计算(“ 球队1”,(球队,目标) ->目标+1);
 

因此,每当您要基于键应用映射时,都应使用值对然后使用计算。

计算IfPresent ()

如果存在指定的键且value不为null,则computeIfPresent将重新计算该值。
You might have written 码 like below before:

1
2
3
4
5
6
 
如果(球队GoalMap.containsKey(“ 球队1”))
{
   球队GoalMap.(“ 球队1”,球队GoalMap.得到(“ 球队1”)+1);
}
 

You can rewrite 这个 with 计算IfPresent as below

1
2
3
 
球队GoalMap.计算IfPresent (“ 球队1”,(球队,目标) ->目标+1);
 

如果函数返回null,则将从竞彩篮球分析中删除键。

计算IfAbsent()

如果指定的键不存在并且函数不返回null,则ifIfIfAbsent将重新计算值。
You might have written 码 like below before:

1
2
3
4
5
6
 
如果(!球队GoalMap.containsKey(“ 球队3”))
{
   球队GoalMap.(“ 球队3”,0);
}
 

You can rewrite 这个 with 计算IfAbsent as below

1
2
3
 
球队GoalMap.计算IfAbsent(“ 球队3”, -> 0);
 

如果密钥已经存在于地图中,那么什么都不会改变。

让’s see another to rewrite 哈希图 码 in a declarative style.

问题: 你想要 查找字符串中每个字符的频率.
您可能会以下面的简单方式编写程序。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
组织.Arpit.爪哇2blog.哈希图;
进口 爪哇.实用程序.哈希图;
上市 每个词的频率 {
   上市 静态的 虚空 主要([] args) {
       力量 = “ 这个isjavablog”;
 
      哈希图<字符,整数> 地图 = 哈希图<>();
      对于(整型 i= 0 ; i< 力量.长度() ; i++) {
          字符 c=力量.字符(i);
         如果(地图.containsKey(c)) {
            整型 计数 = 地图.得到(c);
            地图.(c,计数+1);
         } 其他 {
            地图.(c,1);
         }
      }
      系统..打印(地图);
   }
}
 

输出:

{a = 2,b = 1,s = 2,t = 1,v = 1,g = 1,h = 1,i = 2,j = 1,l = 1,o = 1}

上面的程序使用简单的逻辑来计算String中每个字符的频率。

  1. 创建一个竞彩篮球分析,它将包含要计数的字符映射。
  2. 逐字符遍历String
  3. 如果地图中不存在角色,则计数应为1
  4. 如果角色已经存在于地图中,则将其计数加1

让’s rewrite 这个 logic using 计算IfPresent and 计算IfAbesent methods.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
组织.Arpit.爪哇2blog.哈希图;
进口 爪哇.实用程序.哈希图;
上市 每个词的频率 {
   上市 静态的 虚空 主要([] args) {
       力量 = “ 这个isjavablog”;
 
      哈希图<字符,整数> 地图 = 哈希图<>();
      对于(整型 i= 0 ; i< 力量.长度() ; i++) {
          字符 c=力量.字符(i);
        地图.计算IfPresent (c, (字符,计数)-> 计数+1);
         地图.计算IfAbsent(c, (字符)-> 1);
      }
      系统..打印(地图);
   }
}
 

输出:

{a = 2,b = 1,s = 2,t = 1,v = 1,g = 1,h = 1,i = 2,j = 1,l = 1,o = 1}

As you can see, logic looks quite readable in case of 计算IfPresent and 计算IfAbesent methods.

从竞彩篮球分析获取entrySet(),keySet()和values()

条目Set()

条目Set(): As 哈希图 stores key 值 pair in 对于m of 条目, we can retrieve 条目Set() by calling map.entrySet()

键集()

键集():提供一组键。

价值观()

价值观():提供值的集合。

这是相同的示例。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
组织.Arpit.爪哇2blog;
 
进口 爪哇.实用程序.采集;
进口 爪哇.实用程序.哈希图;
进口 爪哇.实用程序.地图.条目;
进口 爪哇.实用程序.;
 
上市 哈希图EntrySetMain {
 
    上市 静态的 虚空 主要([] args) {
        哈希图<整数, > studentIDNameMap = 哈希图<>();
 
        //将键值对放入竞彩篮球分析
        studentIDNameMap.(101,“安迪”);
        studentIDNameMap.(102, “玛丽”);
        studentIDNameMap.(103, “山姆”);
        studentIDNameMap.(104,“沙”);
 
        //获取entrySet
        <条目<整数, >> 条目Set = studentIDNameMap.条目Set();
        系统..打印(“ 条目Set:”+条目Set);
 
        //获取keySet
        <整数> 键集 = studentIDNameMap.键集();
        系统..打印(“ 键集:”+键集);
 
        //获取值
        采集<> 价值观 = studentIDNameMap.价值观();
        系统..打印(“值:”+价值观);
    }
}
 

输出:

条目Set:[101 =安迪,102 =玛丽,103 =山姆,104 =桑迪]
键集:[101、102、103、104]
值:[安迪,玛丽,山姆,桑迪]

遍历竞彩篮球分析

有很多方法可以 遍历竞彩篮球分析

  1. 遍历竞彩篮球分析 using keyset()
  2. 遍历竞彩篮球分析 using keyset() with 前言()和 lambda表达式[ 爪哇 8]
  3. 遍历竞彩篮球分析 using 前言()和lambda表达式[java 8]
  4. 遍历竞彩篮球分析’s 条目Set() using 迭代器
  5. 遍历竞彩篮球分析’s 条目Set() using 前言() and lambda表达式 [爪哇 8]
  6. 遍历竞彩篮球分析’s 条目Set() using 前言 loop

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
 
组织.Arpit.爪哇2blog.哈希图;
 
进口 爪哇.实用程序.哈希图;
进口 爪哇.实用程序.迭代器;
进口 爪哇.实用程序.地图;
进口 爪哇.实用程序.地图.条目;
 
上市 哈希图IterationMain {
 
    上市 静态的 虚空 主要([] args) {
 
        哈希图<, > 用户CountryMap = 哈希图<>();
 
        //将键值对放入竞彩篮球分析
        用户CountryMap.(“ Anchit”,“印度”);
        用户CountryMap.(“安迪”, “美国”);
        用户CountryMap.(“罗伊”, “杰瑞”);
        用户CountryMap.(“玛丽”,“法国”);
 
        系统..打印(“ =============================================== ========“);
        系统..打印("遍历竞彩篮球分析 with 前言 and lambda:");
        用户CountryMap.每次((用户,国家) -> {
            系统..打印(用户+“-> "+国家);
            }
        );
 
        系统..打印(“ =============================================== ========“);
        系统..打印("遍历竞彩篮球分析 using keyset() with 前言 loop:");
        对于( 用户:用户CountryMap.键集())
        {
            系统..打印(用户+“-> "+用户CountryMap.得到(用户));
        }
        系统..打印(“ =============================================== ========“);
        系统..打印("遍历竞彩篮球分析'带foreach和lambda的keyset():");
        用户CountryMap.键集().每次((用户) -> {
            系统..打印(用户+“-> "+用户CountryMap.得到(用户));
            }
        );
 
        系统..打印(“ =============================================== ========“);
        系统..打印("遍历竞彩篮球分析'带迭代器的entrySet");
        迭代器<条目<, >> 迭代器 = 用户CountryMap.条目Set().迭代器();
        (迭代器.hasNext())
        {
            条目<, > 下一页 = 迭代器.下一页();
            系统..打印(下一页.得到Key()+“-> "+下一页.得到Value());
        }
 
        系统..打印(“ =============================================== ========“);
        系统..打印("遍历竞彩篮球分析'带foreach和lambda的entrySet");
        用户CountryMap.条目Set().每次((条目) -> {
            系统..打印(条目.得到Key()+“-> "+条目.得到Value());
            }
        );
 
        系统..打印(“ =============================================== ========“);
        系统..打印("遍历竞彩篮球分析'带foreach循环的s 条目Set");
        对于(地图.条目<, > 条目:用户CountryMap.条目Set())
        {
            系统..打印(条目.得到Key()+“-> "+条目.得到Value());
        }
 
    }
}
 

输出:

================================================ =======
遍历竞彩篮球分析 with 前言 and lambda:
安奇特–> India
安迪–> USA
罗伊–> Germary
玛丽–> France
================================================ =======
遍历竞彩篮球分析 using keyset() with 前言 loop:
安奇特–> India
安迪–> USA
罗伊–> Germary
玛丽–> France
================================================ =======
遍历竞彩篮球分析’带foreach和lambda的keyset():
安奇特–> India
安迪–> USA
罗伊–> Germary
玛丽–> France
================================================ =======
遍历竞彩篮球分析’带迭代器的entrySet
安奇特–> India
安迪–> USA
罗伊–> Germary
玛丽–> France
================================================ =======
遍历竞彩篮球分析’带foreach和lambda的entrySet
安奇特–> India
安迪–> USA
罗伊–> Germary
玛丽–> France
================================================ =======
遍历竞彩篮球分析’带foreach循环的s 条目Set
安奇特–> India
安迪–> USA
罗伊–> Germary
玛丽–> France

将自定义对象存储为键

您可以将自定义对象存储为竞彩篮球分析中的Key,但是您应该实现 哈希码和等于 方法,否则可能无法按预期工作。

创建一个名为 国家.java

国家.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
 
组织.Arpit.爪哇2blog;  
上市 国家  {  
 
     名称;  
     人口;  
 
    上市 国家( 名称, 人口) {  
        ();  
        这个.名称 = 名称;  
        这个.人口 = 人口;  
    }  
    上市 得到Name() {  
        返回 名称;  
    }  
    上市 虚空 setName( 名称) {  
        这个.名称 = 名称;  
    }  
    上市 得到Population() {  
        返回 人口;  
    }  
    上市 虚空 setPopulation( 人口) {  
        这个.人口 = 人口;  
    }
 
    @覆写
    上市 整型 hashCode() {
        最后 整型 主要 = 31;
        整型 结果 = 1;
        结果 = 主要 * 结果 + ((名称 == 空值) ? 0 : 名称.hashCode());
        结果 = 主要 * 结果 + (整型) (人口 ^ (人口 >>> 32));
        返回 结果;
    }
    @覆写
    上市 布尔值 等于(目的 对象) {
        如果 (这个 == 对象)
            返回 真正;
        如果 (对象 == 空值)
            返回 ;
        如果 (得到Class() != 对象.得到Class())
            返回 ;
        国家 其他 = (国家) 对象;
        如果 (名称 == 空值) {
            如果 (其他.名称 != 空值)
                返回 ;
        } 其他 如果 (!名称.等于(其他.名称))
            返回 ;
        返回 真正;
    }
 
   @覆写
    上市 toString() {
 
        返回 “国家:”+名称+“ |人口:”+人口;
    }
}  
 

创建另一个班级 哈希图Main.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 
组织.Arpit.爪哇2blog;
 
进口 爪哇.实用程序.哈希图;
 
上市 哈希图Main {
 
    上市 静态的 虚空 主要( args[])
    {
        国家 印度= 国家(“印度”,10000);
        国家 日本= 国家(“日本”,3000);
        国家 法国= 国家(“法国”,5000);
        国家 俄国= 国家(“俄国”,4000);
 
        //以国家/地区名称为键,以资本为值的竞彩篮球分析
        // 哈希图将元素存储在键值对中
        哈希图<国家,> 国家CapitalMap= 哈希图<>();
        国家CapitalMap.(印度,“德里”);
        国家CapitalMap.(日本,“东京”);
        国家CapitalMap.(法国,“巴黎”);
        国家CapitalMap.(俄国,“莫斯科”);
 
        系统..打印(“ -----------------------------”);
        //使用keySet()并针对每个循环迭代竞彩篮球分析
        系统..打印(“使用keySet()并针对每个循环迭代竞彩篮球分析”);
        对于 (国家 国家Key:国家CapitalMap.键集()) {
            系统..打印(国家Key +“和  Capital:"+国家CapitalMap.得到(国家Key));
 
        }
        系统..打印(“ -----------------------------”);
    }
 
}
 

当您在程序上方运行时,将获得以下输出

—————————–
使用keySet()并针对每个循环迭代竞彩篮球分析
国家:日本|人口:3000,首都:东京
国家:印度|人口:10000,首都:德里
国家:俄罗斯|人口:4000,首都:莫斯科
国家:法国|人口:5000,首都:巴黎
—————————–

在Java中对竞彩篮球分析进行排序

按键

我们可以使用以下命令对竞彩篮球分析中的键进行排序 树状图。我们只需要将竞彩篮球分析传递给TreeMap的构造函数即可。

按值

我们需要按照以下步骤对竞彩篮球分析进行排序。

  1. Get 条目Set() from 哈希图
  2. 将entrySet转换为 清单
  3. 借助排序列表 比较器
  4. 遍历列表并将Entry对象放入 Linked竞彩篮球分析

让’s写了一个用键和值对竞彩篮球分析进行排序的示例。我们将创建一个名为Vehicle的类,并将其用作竞彩篮球分析中的Key,value将是Vehicle的所有者。

创建一个名为的类 车辆.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
组织.Arpit.爪哇2blog;
 
上市 车辆 实施 可比<车辆>{
 
     名称;
     最大速度;
 
    上市 车辆( 名称, 最大速度) {
        ();
        这个.名称 = 名称;
        这个.最大速度 = 最大速度;
    }
 
    上市 得到Name() {
        返回 名称;
    }
    上市 虚空 setName( 名称) {
        这个.名称 = 名称;
    }
    上市 得到MaxSpeed() {
        返回 最大速度;
    }
    上市 虚空 setMaxSpeed( 最大速度) {
        这个.最大速度 = 最大速度;
    }
 
    @覆写
    上市 toString() {
        返回 “车辆名称:”+名称+“ |最大速度:”+最大速度;
    }
 
    @覆写
    上市 整型 相比于(车辆 v) {
        返回 这个.得到Name().相比于(v.得到Name());
    }
}
 

请注意,我们已实施 可比 接口 here which compares two vehicle by its 名称. This 可比 will be used to 分类 it by Keys 而 constructing 树状图.
创建一个名为的类 哈希图SortMain.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
 
组织.Arpit.爪哇2blog;
 
进口 爪哇.实用程序.数组列表;
进口 爪哇.实用程序.馆藏;
进口 爪哇.实用程序.哈希图;
进口 爪哇.实用程序.Linked竞彩篮球分析;
进口 爪哇.实用程序.清单;
进口 爪哇.实用程序.地图.条目;
进口 爪哇.实用程序.;
进口 爪哇.实用程序.树状图;
 
上市 哈希图SortMain {
 
    上市 静态的 虚空 主要([] args) {
 
        车辆 v1= 车辆(“汽车”, 150);
        车辆 v2= 车辆(“卡车”, 130);
        车辆 v3= 车辆(“自行车”, 150);
        车辆 v4= 车辆(“吉普车”, 180);
 
        // 哈希图将元素存储在键值对中
        哈希图<车辆,> vehicleOwnerMap= 哈希图<>();
        vehicleOwnerMap.(v1,“约翰”);
        vehicleOwnerMap.(v2,“克里斯”);
        vehicleOwnerMap.(v3,“玛丽”);
        vehicleOwnerMap.(v4,哈里);
 
        //按键排序
        //当Vehicle类实现Comparable时,该类按车辆名称定义排序
        树状图<车辆,> treeMap= 树状图<车辆,>(vehicleOwnerMap);
        系统..打印(“按车辆名称排序的TreeMap:”+treeMap);
 
        //按值排序
        <条目<车辆, >> 条目Set = vehicleOwnerMap.条目Set();
        清单<条目<车辆, >> vehicleEntryList= 数组列表<>(条目Set);
        馆藏.分类(vehicleEntryList,(e1,e2) ->
                         e1.得到Value().相比于(e2.得到Value()));
 
        Linked竞彩篮球分析<车辆, > lmp= Linked竞彩篮球分析<车辆, >();
        vehicleEntryList.每次((条目)-> {
            lmp.(条目.得到Key(), 条目.得到Value());
        });
        系统..打印(“按所有者名称排序的地图:”+lmp);
    }
}
 

输出:

按车辆名称对TreeMap进行排序:{车辆名称:自行车|最大速度:150 =玛丽,车辆名称:汽车|最大速度:150 =约翰,车辆名称:吉普|最大速度:180 =哈里,车辆名称:卡车|最大速度:130 = Chris}按所有者名称排序的地图:{车辆名称:卡车|最大速度:130 =克里斯,车辆名称:吉普|最大速度:180 =哈里,车辆名称:汽车|最大速度:150 =约翰,车辆名称:自行车|最大速度:150 =玛丽}

如果你不这样做’了解上面我们用来对Entry 目的的List进行排序的lambda表达式的语法,那么您需要检查一下 爪哇 8中的Lambda表达式.

是竞彩篮球分析线程安全的吗?

哈希图默认情况下不是线程安全的,并且在多线程环境中,它可以给出不确定的结果。
让’借助示例演示了这一点:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
 
组织.Arpit.爪哇2blog;
 
进口 爪哇.实用程序.馆藏;
进口 爪哇.实用程序.哈希图;
进口 爪哇.实用程序.地图;
进口 爪哇.实用程序.同时.执行器服务;
进口 爪哇.实用程序.同时.执行者;
进口 爪哇.实用程序.同时.时间单位;
 
上市 计数器 {
 
    上市 静态的 虚空 主要([] args) 抛出 InterruptedException {
 
        地图<, 整数> 计数器Map= 哈希图<>();
 
        计数器Map.(“ 计数器1”,0);
        计数器Map.(“ 计数器2”,100);
 
        执行器服务 新FixedThreadPool = 执行者.新FixedThreadPool(10);
 
        可运行 计数器Task = () ->
        {
            增量时间(计数器Map,“ 计数器1”);
            增量时间(计数器Map,“ 计数器2”);
 
        };
 
        对于 (整型 i = 1; i <= 100; i++) {
            新FixedThreadPool.提交(计数器Task);
        }
 
        新FixedThreadPool.关掉();
        新FixedThreadPool.awaitTermination(30, 时间单位.);
 
        系统..打印(“ 计数器1的时间:”+计数器Map.得到(“ 计数器1”));
        系统..打印(“ 计数器2的时间:”+计数器Map.得到(“ 计数器2”));
    }
 
    上市 静态的 虚空 增量时间(地图<,整数> 计数器Map, 计数器)
    {
        整数 计数 = 计数器Map.得到(计数器)
        计数++;
        计数器Map.(计数器,计数);
    }
}
 

我在映射中放置了两个条目,键分别为counter1和counter2,值分别为time 0和100.我们创建了一个任务,将两个counter的时间都增加了1,我们正在使用 ExecuterService 提交100次。

让’s运行程序并检查输出:

计数器1的时间:95
计数器2的时间:195

但是我们的预期输出应该是

计数器1的时间:100
计数器2的时间:200

因为我们已经提交了100次任务,并且在每次执行任务时,它都会调用 增量时间()  并将时间增加1。
让’再次运行程序。

计数器1的时间:98
计数器2的时间:197

它与上次执行不同,这是由于竞彩篮球分析中的线程安全性问题。

我们可以通过两种方式解决此线程安全问题:

  1. 馆藏.synchronizedMap
  2. 并发哈希图

馆藏.synchronizedMap

We can use 馆藏.synchronizedMap() to make all operations of 哈希图 thread safe and make 增量时间()  方法同步解决了上述问题。 增量时间()  还应该同步,否则会出现原子性问题。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
 
组织.Arpit.爪哇2blog.哈希图;
 
进口 爪哇.实用程序.馆藏;
进口 爪哇.实用程序.哈希图;
进口 爪哇.实用程序.地图;
进口 爪哇.实用程序.同时.执行器服务;
进口 爪哇.实用程序.同时.执行者;
进口 爪哇.实用程序.同时.时间单位;
 
上市 计数器 {
 
    上市 静态的 虚空 主要([] args) 抛出 InterruptedException {
 
        地图<, 整数> 计数器Map=馆藏.syncedMap( 哈希图<>());
 
        计数器Map.(“ 计数器1”,0);
        计数器Map.(“ 计数器2”,100);
 
        执行器服务 新FixedThreadPool = 执行者.新FixedThreadPool(10);
 
        可运行 计数器Task = () ->
        {
            增量时间(计数器Map,“ 计数器1”);
            增量时间(计数器Map,“ 计数器2”);
 
        };
 
        对于 (整型 i = 1; i <= 100; i++) {
            新FixedThreadPool.提交(计数器Task);
        }
 
        新FixedThreadPool.关掉();
        新FixedThreadPool.awaitTermination(30, 时间单位.);
 
        系统..打印(“ 计数器1的时间:”+计数器Map.得到(“ 计数器1”));
        系统..打印(“ 计数器2的时间:”+计数器Map.得到(“ 计数器2”));
    }
 
    上市 静态的 已同步 虚空 增量时间(地图<,整数> 计数器Map, 计数器)
    {
        整数 计数 = 计数器Map.得到(计数器);
        计数++;
        计数器Map.(计数器,计数);
    }
 
}
 

输出:

计数器1的时间:100
计数器2的时间:200

As you can see, we are 得到ting correct 出put after using 馆藏.synchronizedMap() and making 增量时间 已同步.

并发哈希图

使用Collections.synchronizedMap()的缺点是它会锁定整个hashmap对象,这可能会导致性能问题,但是 并发哈希图 仅锁定部分映射,并在多线程环境中表现良好。

哈希图如何在内部工作

这个主题值得一提,因此我在 哈希图如何在Java中工作.

爪哇 8 哈希图更新

要了解此更改,您需要了解竞彩篮球分析在内部如何工作。爪哇 8 在哈希冲突过多的情况下,已引入了良好的性能改进。

在Java 7之前
If two 对象ects have the same hashcode and are not equal, then both will be stored at the same bucket with the help of the 单链表. In case, there are too many hash collisions, then the performance of 得到() and 放() may suffer.
In the worst case, 如果 all keys have same hashcode then 得到() operation in 哈希图 may take 准时.

爪哇 8更新
在Java 8中,竞彩篮球分析将链接列表更改为 二叉树 如果元素数量达到某个阈值。借助此更改,竞彩篮球分析中的get()操作可能会占用 O(log(n))时间 在最坏的情况下。

爪哇 哈希图教程

结论

You have learned about basics of 哈希图, how to create a 哈希图 and add key-value pairs to it, 进口ant 哈希图 methods, how to write declarative style 码 with 哈希图, how to 遍历竞彩篮球分析 and thread safety issues with 哈希图 and how to 已同步 a 哈希图.

那’关于Java中的竞彩篮球分析的全部内容。

导入联系人

您可能还喜欢:

分享这个

作者

关注作者

相关文章

  • 10月02

    用Java中的值初始化ArrayList

    在本文中,我们将学习使用Java中的值初始化ArrayList。 数组列表是Java中List接口的实现类。它用于存储元素。它基于动态增长的阵列概念。我们可以通过几种方式用值初始化ArrayList。让’我们看到了其中一些…]

  • 3月17日

    爪哇 8中的PriorityQueue

    在本文中,我们将介绍Java 8 PriorityQueue。当应该根据对象的优先级处理对象时,在这种情况下,我们使用PriorityQueue。这是一种特殊的队列(也称为非绑定队列),可以根据元素的自然顺序或基于[…]

  • 10月06日

    2d Arraylist 爪哇示例

    在本文中,我们将看到如何在Java中创建2d Arraylist。创建2d Arraylist的最佳方法是在Java中创建列表的列表。 [crayon-601c01ad071ef278593411 /]让’s创建一个程序来实现2d Arraylist 爪哇。 [crayon-601c01ad071f2574451254 /]输出:list3中的第二个元素:List3_Str2 list1中的第三个元素:List1_Str3 list2中的第一个元素[…]

  • 04 May

    哈希图如何在Java中工作

    最常见的面试问题是<code>竞彩篮球分析如何在Java中工作</code>, “竞彩篮球分析的获取和放置方法如何在内部工作”。在这里,我试图通过一个简单的示例来解释内部功能。 [crayon-601c01ad70861428064242-i /]是Java中使用最广泛的Collections之一。与其深入研究,不如从理论上入手,因此您将[…]

  • 10月21日

    如何在Java中对HashSet进行排序

    在本文中,我们将看到如何在Java中对HashSet进行排序。 哈希集是一个不按任何顺序存储元素的集合。您可能会遇到需要对HashSet进行排序的情况。排序HashSet的方法有很多种,我们将在这里看到两种方法。使用TreeSet可以使用[…]

  • 10月20日

    要设置的Java数组

    在本文中,我们将学习Java数组设置转换。有很多方法可以将数组转换为set。 1.使用Java 8’s Stream如果您使用的是Java 8,建议您使用此方法。 [crayon-601c01ad70dd9159285938 /]输出[John,Martin,Mary] 2.使用HashSet构造函数()我们可以直接调用HashSet‘s的java构造函数set […]

发表评论

您的电子邮件地址不会被公开。 必需的地方已做标记 *

订阅我们的新闻

获取质量教程到您的收件箱。现在订阅。


让’s be Friends

©2020 爪哇2博客