java 为什么用 hashmap缓存 java 为什么使用hashmap
大家好，感谢邀请，今天来为大家分享一下java 为什么用 hashmap缓存的问题，以及和java 为什么使用hashmap的一些困惑，大家要是还不太明白的话，也没有关系，因为接下来将为大家分享，希望可以帮助到大家，解决大家的问题，下面就开始吧！
java学习路线
目前在职Java开发，我给出的Java学习路线是：
JavaSE--数据库--jdbc----前端基础--Javaweb--Spring--Mybatis--Maven--Springboot---Reids--Springcloud--Linux--Git。
JavaSE：java基础，既然是基础，那肯定是最重要的，所以学习的时候也是需要重点学习的地方。
数据库：为什么要学数据库呢，因为我们的web数据需要持久化到磁盘上统一管理，而数据库无疑就是最好工具。目前主流的关系型数据库有mysql和oracle。我建议先学mysql。为什么呢mysql相比Oracle难度要低，而在国内应用场景又是最多的。
学会了mysql可以开发出一个完整的产品了，再学oracle都可以的。
前端基础：既然是做一个网站，那肯定不能是后台的数据，这样用户也是没办法看的，所以需要学习前端知识，把数据展示到页面上，而对于后台人员来说，学习阶段只需要学习前端基础就可以了。Html、js、css、jquery就可以了。当然到离开后期你也可以学学专门为后端人员定制的前端框架，比如，layui，easyui。如果还觉得不够可以学学前端专用框架。比如vue element，但是大前提是把自己的后台学到位了再学其他的。
Javaweb：jsp、servlet。为什么用了html还要学jsp呢。因为jsp和Java是无缝连接的。学了javaweb以后就可以自己做一个项目出来了，比如你想做一个个人网站。你可以给你们学校做一个教务管理系统都是可以的。
Spring：后台框架。为什么要用框架呢，可以快速开发，并且降低了耦合。Spring的AOP支持允许将一些通用任务如安全、事务、日志等进行集中式管理，从而提供了更好的复用，Spring的ORM和DAO提供了与第三方持久层框架的良好整合，并简化了底层的数据库访问。
Mybatis：持久层框架，当然持久层还有一个框架应用也很广的，那就是hibernate，一个是半自动的一个是全自动，而在国内应用最多的是mybatis，在国外用得最多的是hibernate，具体原因，大家可以百度查查。持久层框架有什么好处呢？如果你用原始的jdbc做开发，那你得自己来管理每一个连接，连接的打开和关闭，都是有开发人员来操作的，而且jdbc也没有实体的映射，需要我们写代码把值set进去，而用了框架这些都交给框架去做了。
Maven：mavne是一个工具，他的核心是pom.xml，这个配置文件，pom的全英文是project object model，意思是对象管理模型，也就是把项目也看成一个对象来操作了。给我们带来最直观的好处就是依赖问题，以前我们需要自己下载jar包，在构建到项目中，但是有了maven只需要写jar的依赖就可以自动给我们下载了。
Springboot：springboot是基于maven的，springboot最明显的特点就是开箱即用，也就是构建了一个springboot项目直接就可以做开发了，而不需要像我们自己配一个springmvc的框架一样的需要去配置大量的xml文件。让我们开发人员更着重于业务上的开发。
Redis：前面的mysql，oracle是关系型数据库，什么是关系型呢，就是一对一一对多多对多。有表与表之间有这些关系在，所以就叫关系型数据库，而redis就是非关系型数据库，也就是他存储数据之间是没有这些关系，他是以键值对 list set方式存储的。
对了，顺便在这里说一下，我目前是在职Java开发，如果你现在也在学习Java，了解Java，渴望成为一名合格的Java开发工程师，在入门学习Java的过程当中缺乏基础入门的视频教程，你都可以申请加入我的Java新手学习交流qun：前面输入是：前面输入是：七九八，中间输入是：八四四，最后输入是：六二零。里面聚集了很多正在学习Java技术的初学者，qun文件里面还有我做Java技术这段时间整理的一些学习手册，面试题，开发工具，PDF文档书籍教程，需要的话都可以来获取下载。
Springcloud：微服务框架，什么是微服务呢，就是把我们传统的单体服务拆分开了，就是将一个单体架构的应用按业务划分为一个个的独立运行的程序即服务，微服务架构其实就是一个分布式架构，具体的就不详细的讲了，因为这里面牵涉到的解决方案是灵活的。
Linux：linux的应用通常都是在底层，那我们上层开发人员为什么也要学它呢，其实我们的主要应用是在服务器上，也就是服务器的系统。当然系统也有Windows的，而Windows的和Linux的区别就是Windows服务器有问题是微软来解决，很方便：别人替你做，但也不方便：你遇到问题都得让他官方来解决漏洞，但是Linux就不一样，他是完全开源的，有问题自己马上就可以解决，只要开发人员能力够硬去改内核都是可以的。
Git：版本管理工具，与之对应的还有svn，最大的区别在于git是分布式系统，而svn不是分布式的，因为你们进企业以后都是协同开发也就是一个项目小组里面几个小伙伴一起开发一个项目，所以就要有一个代码的管理工具来保证你们做的不同模块可以整合，所以说git也是需要学的。
java 为什么使用hashmap
首先当我们需要存储数据的时候，动态数组虽然能够自动扩容，但是必须在初始时刻指定初始容量。而对于那些在编译时无法确定具体的数量即动态增长的数据，就需要用到Java集合类了。对于ArrayList和 LinkedList，还有 Vector它们都有一些缺点，要么插入删除速度慢、要么就是遍历速度慢。那么有没有一种插入、删除、遍历都比较不错的集合类呢？于是 HashMap就出现了。HashMap是一个散列表，它存储的是一组键值对(key-value)的集合，并实现快速的查找。
（1）为了实现快速查找，HashMap选择了数组而不是链表。以利用数组的索引实现 O(1)复杂度的查找效率。
（2）为了利用索引查找，HashMap引入 Hash算法,将 key映射成数组下标: key-> Index。
（3）引入 Hash算法又导致了 Hash冲突。为了解决 Hash冲突，HashMap采用链地址法，在冲突位置转为使用链表存储。
（4）链表存储过多的节点又导致了在链表上节点的查找性能的恶化。为了优化查找性能，HashMap在链表长度超过 8之后转而将链表转变成红黑树，以将 O(n)复杂度的查找效率提升至 O(log n)。
【综上】
HashMap存在的意义就是实现一种快速的查找并且插入、删除性能都不错的一种 K/V（key/value）数据结构。
附上一位博主的高见：网页链接
java google 的内存缓存为什么总调用cacheloader
首先，看一下使用范例：
Java代码
LoadingCache<Key,Graph> graphs=CacheBuilder.newBuilder()
.maximumSize(1000)
.expireAfterWrite(10,TimeUnit.MINUTES)
.removalListener(MY_LISTENER)
.build(
newCacheLoader<Key,Graph>(){
publicGraph load(Key key)throwsAnyException{
return createExpensiveGraph(key);
}
});
适用性
缓存在很多情况下都是非常有用的。比如，我们需要多次根据给定的输入获取值，而且该值计算或者获取的开销是非常昂贵的。
缓存和ConcurrentMap是非常相像的，但是它们也不完全一样。最根本的区别就是，ConcurrentMap会持有所有添加的对象，直到被显示的移除。而缓存为了限制其内存的使用，通常都会配置成可以自动的将对象移除。在某些情况下即使不自动移除对象也是非常有用的，如LoadingCache它会自动加载缓存对象。
一般，Guava缓存适用于以下几种情况：
你愿意花费一些内存来换取性能提升；
你预测到某些键会多次进行查询；
你的缓存数据不超过内存（Guava缓存是单个应用中的本地缓存。它不会将数据存储到文件中，或者外部服务器。如果不适合你，可以考虑一下 Memcached）。
如果你的需要符合上面所说的每一条，那么选择Guava缓存绝对没错。
使用CacheBuilder的构建模式可以获取一个Cache，如上面的范例所示。但是如何进行定制才是比较有趣的。
注意：如果你不需要缓存的这些特性，那么使用ConcurrentHashMap会有更好的内存效率，但是如果想基于旧有的ConcurrentMap复制实现Cache的一些特性，那么可能是非常困难或者根本不可能。
加载
对于缓存首先需要明确的是：有没有一个方法可以通过给定的键来计算/加载相应的值？如果有，那么可以使用CacheLoader。如果没有这样的方法，或者你想复写缓存的加载方式，但你仍想保留“get-if-absent-compute”语义，你可以在调用get方法时传入一个Callable实例，来达到目的。缓存的对象可以通过Cache.put直接插入，但是自动加载是首选，因为自动加载可以更加容易的判断所有缓存信息的一致性。
From a CacheLoader
LoadingCache缓存是通过一个CacheLoader来构建缓存。创建一个CacheLoader仅需要实现V load(K key) throws Exception方法即可。下面的范例就是如何创建一个LoadingCache：
Java代码
LoadingCache<Key,Graph> graphs=CacheBuilder.newBuilder()
.maximumSize(1000)
.build(
newCacheLoader<Key,Graph>(){
publicGraph load(Key key)throwsAnyException{
return createExpensiveGraph(key);
}
});
...
try{
return graphs.get(key);
}catch(ExecutionException e){
thrownewOtherException(e.getCause());
}
通过方法get(K)可以对LoadingCache进行查询。该方法要不返回已缓存的值，要不通过CacheLoader来自动加载相应的值到缓存中。这里需要注意的是：CacheLoader可能会抛出Exception，LoaderCache.get(K)则可能会抛出ExecutionException。假如你定义的CacheLoader没有声明检查型异常，那么可以通过调用getUnchecked(K)来获取缓存值；但是一旦当CacheLoader中声明了检查型异常，则不可以调用getUnchecked。
Java代码
LoadingCache<Key,Graph> graphs=CacheBuilder.newBuilder()
.expireAfterAccess(10,TimeUnit.MINUTES)
.build(
newCacheLoader<Key,Graph>(){
publicGraph load(Key key){// no checked exception
return createExpensiveGraph(key);
}
});
...
return graphs.getUnchecked(key);
批量查询可以使用getAll(Iterable<? extends K>)方法。缺省，getAll方法将循环每一个键调用CacheLoader.load方法获取缓存值。当缓存对象的批量获取比单独获取更有效时，可以通过复写CacheLoader.loadAll方法实现缓存对象的加载。此时当调用getAll(Iterable)方法时性能也会提升。
需要注意的是CacheLoader.loadAll的实现可以为没有明确要求的键加载缓存值。比如，当为某组中的一些键进行计算时，loadAll方法则可能会同时加载组中其余键的值。
From a Callable
所有Guava缓存，不论是否会自动加载，都支持get(K, Callable(V))方法。当给定键的缓存值已存在时则直接返回，否则通过指定的Callable方法进行计算并将值存放到缓存中。直到加载完成时，相应的缓存才会被更改。该方法简单实现了"if cached, return; otherwise create, cache and return"语义。
Java代码
Cache<Key,Value> cache=CacheBuilder.newBuilder()
.maximumSize(1000)
.build();// look Ma, no CacheLoader
...
try{
// If the key wasn't in the"easy to compute" group, we need to
// do things the hard way.
cache.get(key,newCallable<Value>(){
@Override
publicValue call()throwsAnyException{
return doThingsTheHardWay(key);
}
});
}catch(ExecutionException e){
thrownewOtherException(e.getCause());
}
直接插入
使用cache.put(key, value)方法可以将值直接插入到缓存中，但这将会覆盖缓存中已存在的值。通过使用Cache.asMap()所导出的ConcurrentMap对象中的方法也可以对缓存进行修改。但是，请注意asMap中的任何方法都不能自动的将数据加载到缓存中。也就是说，asMap中的各方法是在缓存自动加载范围之外来运作。所以，当你使用CacheLoader或Callable来加载缓存时，应该优先使用Cache.get(K, Callable<V>)，而不是Cache.asMap().putIfAbsent。
缓存回收
残酷的现实是我们可以肯定的说我们没有足够的内存来缓存一切。你必须来决定：什么时候缓存值不再值得保留？Guava提供了三种基本的缓存回收策略：基于容量回收策略，基于时间回收策略，基于引用回收策略。
基于容量回收策略
使用CacheBuilder.maximumSize(long)可以设置缓存的最大容量。缓存将会尝试回收最近没有使用，或者没有经常使用的缓存项。警告：缓存可能会在容量达到限制之前执行回收，通常是在缓存大小逼近限制大小时。
另外，如果不同的缓存项有不同的“权重”，如，缓存项有不同的内存占用，此时你需要使用CacheBuilder.weigher(Weigher)指定一个权重计算函数，并使用CacheBuilder.maxmumWeight(long)设定总权重。和maximumSize同样需要注意的是缓存也是在逼近总权重的时候进行回收处理。此外，缓存项的权重是在创建时进行计算，此后不再改变。
Java代码
LoadingCache<Key,Graph> graphs=CacheBuilder.newBuilder()
.maximumWeight(100000)
.weigher(
newWeigher<Key,Graph>(){
publicint weigh(Key k,Graph g){
return g.vertices().size();
}
})
.build(
newCacheLoader<Key,Graph>(){
publicGraph load(Key key){// no checked exception
return createExpensiveGraph(key);
}
});
基于时间回收策略
CacheBuilder为基于时间的回收提供了两种方式：
expireAfterAccess(long, TimeUnit)当缓存项在指定的时间段内没有被读或写就会被回收。这种回收策略类似于基于容量回收策略；
expireAfterWrite(long, TimeUnit)当缓存项在指定的时间段内没有更新就会被回收。如果我们认为缓存数据在一段时间后数据不再可用，那么可以使用该种策略。
就如下面的讨论，定时过期回收会在写的过程中周期执行，偶尔也会读的过程中执行。
测试定时回收
测试定时回收其实不需要那么痛苦的，我们不必非得花费2秒来测试一个2秒的过期。在构建缓存时使用Ticker接口，并通过CacheBuilder.ticker(Ticker)方法指定时间源，这样我们就不用傻乎乎等系统时钟慢慢的走了。
基于引用回收策略
通过键或缓存值的弱引用(weak references)，或者缓存值的软引用(soft references)，Guava可以将缓存设置为允许垃圾回收。
CacheBuilder.weakKeys()使用弱引用存储键。当没有(强或软)引用到该键时，相应的缓存项将可以被垃圾回收。由于垃圾回收是依赖==进行判断，因此这样会导致整个缓存也会使用==来比较键的相等性，而不是使用equals()；
CacheBuilder.weakValues()使用弱引用存储缓存值。当没有(强或软)引用到该缓存项时，将可以被垃圾回收。由于垃圾回收是依赖==进行判断，因此这样会导致整个缓存也会使用==来比较缓存值的相等性，而不是使用equals()；
CacheBuilder.softValues()使用软引用存储缓存值。当响应需要时，软引用才会被垃圾回收通过最少使用原则回收掉。由于使用软引用造成性能上的影响，我们强烈建议使用可被预言的maximum cache size的策略来代替。同样使用softValues()缓存值的比较也是使用==，而不是equals()。
显示移除
在任何时候，你都可以可以通过下面的方法显式将无效的缓存移除，而不是被动等待被回收：
使用Cache.invalidate(key)单个移除;
使用Cache.invalidteAll(keys)批量移除；
使用Cache.invalidateAll()移除全部。
文章分享结束，java 为什么用 hashmap缓存和java 为什么使用hashmap的答案你都知道了吗？欢迎再次光临本站哦！