javalru算法

㈠ java中LinkedHashMap的LRU算法,为什么多次访问其实并未改变元素的实际排序

要这样才行！！
Map hashMap = new LinkedHashMap<Integer, Integer>(16,(float) 0.75,true);

hashMap.get(2);是获取KEY为2的那一组，即（2，2）
二使用最多，所以排到最后 。
如果你要得到(3,3)就用hashMap.get(3). 这里面的3并不是map中的索引数值，而是你定义的KEY 。 你可以这样：
for (int i = 0; i < 6; i++) {
hashMap.put(i+"--", i);
}
即将KEY变为字符串，你获取数据的时候就必须用get("1--")这样的KEY

㈡ 用java语言实现LRU算法和FIFO算法。急急急！！！！！！！

您好，网络贴吧专家团很高兴能够回答您的问题。您的采纳是我们前进的动力。
public class LRU {

private int theArray[];
private int back; //定义队尾
private int currentSize; //队列中存放元素个数
private int maxSize=5; //队列中能存放元素的个数

public LRU(){
theArray=new int[maxSize];
back=0;
currentSize=0;
}
public void queue(int a[]){
for(int i=0;i<a.length;i++){
enQueue(a[i]);
}
}

public void enQueue(int x){ //入队
beUsed(x); //先判断是否已存在该页号，若存在，删除
if(currentSize<maxSize){
theArray[back]=x;
back++;
currentSize++;
}else if(currentSize==maxSize){ //满了
for(int i=0;i<maxSize-1;i++){
theArray[i]=theArray[i+1];
}
theArray[maxSize-1]=x;
}
for(int i=0;i<currentSize;i++){
System.out.print(theArray[i]);
}
System.out.println();
}
public void beUsed(int x){ //判断是否已存在该页号,若存在，删除已有的
for(int i=0;i<currentSize;i++){
if(theArray[i]==x){
for(int j=i;j<currentSize-1;j++){
theArray[j]=theArray[j+1];
}
currentSize--;
back--;
}
}
}
public static void main(String[] args) {
LRU lru=new LRU();
int a[]={4,7,0,7,1,0,1,2,1,2,6};
lru.queue(a);
}

}

㈢ 又没有c语言java语言比较厉害的帮我写个代码，不难，会的话估计不到20分钟就写完了页面lru算法

贴一个我写的LRU cache算法，用c++实现的
具体的数据结构用的一个链表加一张哈希表。
实现了set和get, 需要另外的功能我还可以再写。
class LRUCache{
struct cacheEntry{
int key;
int value;
cacheEntry(int c, int v):key(c),value(v){}
};

int _cap;
list<cacheEntry> entryList;
unordered_map<int, list<cacheEntry>::iterator> entryMap;

void moveToHead(list<cacheEntry>::iterator it, int key, int value)
{
entryList.erase(it);
cacheEntry tmp(key, value);
entryList.push_front(tmp);
entryMap[key]=entryList.begin();
}
public:
LRUCache(int capacity) {
_cap=capacity;
}

int get(int key) {
if(entryMap.find(key)==entryMap.end())
return -1;
else{
moveToHead(entryMap[key], key, entryMap[key]->value);
return entryMap[key]->value;
}
}

void set(int key, int value) {
if(entryMap.find(key)==entryMap.end()){
if(entryList.size()>=_cap){
entryMap.erase(entryList.back().key);
entryList.pop_back();
}
cacheEntry tmp(key, value);
entryList.push_front(tmp);
entryMap[key]=entryList.begin();
}
else{
entryMap[key]->value=value;
moveToHead(entryMap[key], key, value);
}
}
};

㈣ 如何用LinkedHashMap实现LRU缓存算法

缓存这个东西就是为了提高运行速度的，由于缓存是在寸土寸金的内存里面，不是在硬盘
里面，所以容量是很有限的。LRU这个算法就是把最近一次使用时间离现在时间最远的数据删除掉。先说说List：每次访问一个元素后把这个元素放在
List一端，这样一来最远使用的元素自然就被放到List的另一端。缓存满了t的时候就把那最远使用的元素remove掉。但更实用的是
HashMap。因为List太慢，要删掉的数据总是位于List底层数组的第一个位置，删掉之后，后面的数据要向前补位。。所以复杂度是O(n)，那就
用链表结构的LinkedHashMap呗~，LinkedHashMap默认的元素顺序是put的顺序，但是如果使用带参数的构造函数，那么
LinkedHashMap会根据访问顺序来调整内部 顺序。
LinkedHashMap的get()方法除了返回元素之外还可以把被访问的元素放到链表的底端，这样一来每次顶端的元素就是remove的元素。

构造函数如下：

public LinkedHashMap (int initialCapacity, float loadFactor, boolean accessOrder)；

initialCapacity 初始容量

loadFactor 加载因子，一般是 0.75f

accessOrder false 基于插入顺序 true 基于访问顺序（get一个元素后，这个元素被加到最后，使用了LRU 最近最少被使用的调度算法）

来个例子吧：

import java.util.*;

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

Map<Integer,Integer> map=new LinkedHashMap<>(10,0.75f,true);
map.put(9,3);
map.put(7,4);
map.put(5,9);
map.put(3,4);
//现在遍历的话顺序肯定是9,7,5,3
//下面访问了一下9,3这个键值对，输出顺序就变喽~
map.get(9);
for(Iterator<Map.Entry<Integer,Integer>> it=map.entrySet().iterator();it.hasNext();){
System.out.println(it.next().getKey());
}
}
}

输出

7
5
3
9

好玩吧~

下面开始实现LRU缓存喽~

import java.util.*;
//扩展一下LinkedHashMap这个类，让他实现LRU算法
class LRULinkedHashMap<K,V> extends LinkedHashMap<K,V>{
//定义缓存的容量
private int capacity;
private static final long serialVersionUID = 1L;
//带参数的构造器
LRULinkedHashMap(int capacity){
//调用LinkedHashMap的构造器，传入以下参数
super(16,0.75f,true);
//传入指定的缓存最大容量
this.capacity=capacity;
}
//实现LRU的关键方法，如果map里面的元素个数大于了缓存最大容量，则删除链表的顶端元素
@Override
public boolean removeEldestEntry(Map.Entry<K, V> eldest){
System.out.println(eldest.getKey() + "=" + eldest.getValue());
return size()>capacity;
}
}
//测试类
class Test{
public static void main(String[] args) throws Exception{

//指定缓存最大容量为4
Map<Integer,Integer> map=new LRULinkedHashMap<>(4);
map.put(9,3);
map.put(7,4);
map.put(5,9);
map.put(3,4);
map.put(6,6);
//总共put了5个元素，超过了指定的缓存最大容量
//遍历结果
for(Iterator<Map.Entry<Integer,Integer>> it=map.entrySet().iterator();it.hasNext();){
System.out.println(it.next().getKey());
}
}
}

输出结果如下

9=3
9=3
9=3
9=3
9=3
7
5
3
6

分析一下：使用带参数构造器，且启用LRU模式的LinkedHashMap会在每次有新元素加入的时候，判断当前储存元素是否超过了缓存上限，也就是执行
一次removeEldestEntry方法，看最后的遍历结果，发现果然把9删除了，LRU发挥作用了~

㈤ 去哪儿网java开发面试经验牛客

以下是某位求职者面经，仅供参考：

一面:

1.自我介绍

2.直接上手红黑树和平衡二叉树区别

3.红黑树的旋转
2node节点插入和3node节点插入时候旋转的情况 简述伪代码
4.问项目情况。大概半小时 5.concurrenthashmap
结构分析。 删除和获取操作过程描述。就是segment. Entry.

除了value 为volatile 其余都是final.
删除和获取操作等等。例如：删除操作是将entry要删除的节点的前半部分链表进行复制，并指向当前删除节点的后面节点。（因为next是final的，不可以进行修改，只有entry的表头可以修改）
不详述了。

6.索引的优缺点 什么时候索引不起作用？ 在什么地方可以使用索引？

7.jvm
多态原理。invokestatic invokeinterface
等指令。常量池中的符号引用 找到直接引用。在堆中找到实例对象，获取到偏移量，由偏移量在方法表中指出调用的具体方法。接口是在方法表中进行扫描）等等扯了半天

8.os: 页面调度算法 几种 分别说一下 LRU FIFO 最佳适应算法

9.内存管理： 固定分区 动态分区 段 页 都讲讲 （哈哈）

10.自己实现一下LRU算法

8.怎么学习。看过什么书

二面：

1.自我介绍

2.项目中与app移动端 的json格式设计

3.hashmap的缺点 具体提现在哪里？

4.Collections.sort()
的原理---本质上调用的是Arrays.sort() 内部是 使用的归并排序 接着写了一下归并（辅助数组的归并，和手摇算法的归并）

5.一个字符串数组，现给定一个string去进行找出对应的数组中字符串的下标 （可以有容错，但两字符串长度必须一致，容错为2）

例如：
["hello","hj","abc"]
key=“hellg" 返回下角标0

6.jvm参数调优 jvm堆的大小调优
MaxTureningShelod newratio -xxs -xxm -persize

7.图的 prime
算法
kruskal
算法
dijkstra算法 解决什么问题？ 分别写一下
伪代码

8.设计模式： 单例模式（懒汉饿汉） 工厂方法模式 观察者模式 责任链模式

9.项目 又问了一些

10.平时怎么学习？

三面：

1.自我介绍

2.自己优缺点

3.目前有几个offer

4.工作地点要求

5.在校实验室做项目，你认为最大的收获是什么

6.评价一下自己的大学生活

7.讲了一下福利 之类的

现场书面offer没了，所以只好等等邮寄，不过还好给了一个布偶纪念品

㈥ 如何用java实现fifo页面置换算法

[fifo.rar] - 操作系统中内存页面的先进先出的替换算法fifo
[先进先出页面算法程序.rar] - 分别实现最佳置换算法(optimal)、先进先出(fifo)页面置换算法和最近最久未使用（LRU）置换算法，并给出各算法缺页次数和缺页率。
[0022.rar] - 模拟分页式虚拟存储管理中硬件的地址转换和缺页中断，以及选择页面调度算法处理缺页中断
[Change.rar] - 用java实现操作系统的页面置换 其中包括 最佳置换算法(Optimal)、先进先出算法（First-in, First-out） 、最近最久不用的页面置换算法（LeastRecently Used Replacement）三种算法的实现
[M_Management.rar] - 操作系统中内存管理页面置换算法的模拟程序，采用的是LRU置换算法
[detail_of_44b0x_TCPIP.rar] - TCPIP 程序包加载到44b0x 的ADS1.2工程文件的说明书。说名了加载过程的细节和如何处理演示程序和代码。演示代码已经上传，大家可以搜索
[.rar] - java操作系统页面置换算法： （1）进先出的算法（fifo） （2）最近最少使用的算法（LRU） （3）最佳淘汰算法(OPT) （4）最少访问页面算法(LFU) （注：由本人改成改进型Clock算法） （5）最近最不经常使用算法(NUR)

㈦ Java程序设计

I am sorry; in China; please speak Chinese;谢谢；我之所以写了句英语只是因为担心你是外国人；哎；

㈧ redis八种淘汰策略是什么

redis八种淘汰策略如下：

Redis（Remote Dictionary Server )，即远程字典服务，是一个开源的使用ANSIC语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。从2010年3月15日起，Redis的开发工作由VMware主持。从2013年5月开始，Redis的开发由Pivotal赞助。

特点：

Redis 是一个高性能的key-value数据库。 redis的出现，很大程度补偿了memcached这类key/value存储的不足，在部 分场合可以对关系数据库起到很好的补充作用。它提供了Java，C/C++，C#，PHP，JavaScript，Perl，Object-C，Python，Ruby，Erlang等客户端，使用很方便。

Redis支持主从同步。数据可以从主服务器向任意数量的从服务器上同步，从服务器可以是关联其他从服务器的主服务器。这使得Redis可执行单层树复制。存盘可以有意无意的对数据进行写操作。由于完全实现了发布/订阅机制，使得从数据库在任何地方同步树时，可订阅一个频道并接收主服务器完整的消息发布记录。同步对读取操作的可扩展性和数据冗余很有帮助。

㈨ 请分别给出三种不同的页面置换算法,并简要说明他们的优缺点

[fifo.rar]
-
操作系统中内存页面的先进先出的替换算法fifo
[先进先出页面算法程序.rar]
-
分别实现最佳置换算法(optimal)、先进先出(fifo)页面置换算法和最近最久未使用（LRU）置换算法，并给出各算法缺页次数和缺页率。
[0022.rar]
-
模拟分页式虚拟存储管理中硬件的地址转换和缺页中断，以及选择页面调度算法处理缺页中断
[Change.rar]
-
用java实现操作系统的页面置换
其中包括
最佳置换算法(Optimal)、先进先出算法（First-in,
First-out）
、最近最久不用的页面置换算法（LeastRecently
Used
Replacement）三种算法的实现
[M_Management.rar]
-
操作系统中内存管理页面置换算法的模拟程序，采用的是LRU置换算法
[detail_of_44b0x_TCPIP.rar]
-
TCPIP
程序包加载到44b0x
的ADS1.2工程文件的说明书。说名了加载过程的细节和如何处理演示程序和代码。演示代码已经上传，大家可以搜索
[.rar]
-
java操作系统页面置换算法：
（1）进先出的算法（fifo）
（2）最近最少使用的算法（LRU）
（3）最佳淘汰算法(OPT)
（4）最少访问页面算法(LFU)
（注：由本人改成改进型Clock算法）
（5）最近最不经常使用算法(NUR)

㈩ java 怎么充分利用操作系统磁盘io性能

linux内核和各个文件系统采用了几个优化方案来提升磁盘访问速度。但这些优化方案需要在我们的服务器设计中进行配合才能得到充分发挥。
文件系统缓存
linux内核会将大部分空闲内存交给虚拟文件系统，来作为文件缓存，叫做page cache。在内存不足时，这部分内存会采用lru算法进行淘汰。通过free命令查看内存，显示为cached的部分就是文件缓存了。

如何针对性优化：
lru并不是一个优秀淘汰算法，lru最大的优势是普适性好，在各种使用场景下都能起到一定的效果。如果能找到当前使用场景下，文件被访问的统计特征，针 对性的写一个淘汰算法，可以大幅提升文件缓存的命中率。对于http正向代理来说，一个好的淘汰算法可以用1GB内存达到lru算法100GB内存的缓存 效果。如果不打算写一个新的淘汰算法，一般不需要在应用层再搭一个文件cache程序来做缓存。