操作系统中可以使用LRU（Least Recently Used）内存淘汰旧数据的策略，如果内存需要加载新数据但空间不足，则会按照最近访问时间进行排序，并将最老的数据淘汰。假设现在内存空间大小为5，原本内存中没有数据，对内存中数据的访问顺序如下：1, 2, 5, 3, 4, 6,1, 4, 3, 6, 7, 8, 3, 9 问访问过程中发生缺页的次数是多少次？

JAVA实现：
首先实现一个固定长度的集合队列

1. package com.itstyle.list;
3. import java.util.Collection;
4. import java.util.Iterator;
5. import java.util.LinkedList;
6. import java.util.Queue;
8. /**
9. * 实现一个固定长度的集合队列
10. * 在开发中，有时候我们会遇到这样的需求：
11. * 对一个集合操作，提前为集合指定最大大小，在我们不断向集合中添加数据的时候，当数据内容超过最大值的时候，自动将最先入队的元素移除队列。
12. * @param <E>
13. */
14. public class LimitQueue<E> implements Queue<E> {
16. /**
17. * 队列长度，实例化类的时候指定
18. */
19. private int limit;
21. Queue<E> queue = new LinkedList<E>();
23. public LimitQueue(int limit){
24. this.limit = limit;
25. }
27. /**
28. * 入队
29. */
30. @Override
31. public boolean offer(E e){
32. if(queue.size() >= limit){
33. //如果超出长度,入队时,先出队
34. queue.poll();
35. }
36. return queue.offer(e);
37. }
39. /**
40. * 出队
41. */
42. @Override
43. public E poll() {
44. return queue.poll();
45. }
47. /**
48. * 获取队列
49. */
50. public Queue<E> getQueue(){
51. return queue;
52. }
54. /**
55. * 获取限制大小
56. */
57. public int getLimit(){
58. return limit;
59. }
61. @Override
62. public boolean add(E e) {
63. return queue.add(e);
64. }
66. @Override
67. public E element() {
68. return queue.element();
69. }
71. @Override
72. public E peek() {
73. return queue.peek();
74. }
76. @Override
77. public boolean isEmpty() {
78. return queue.size() == 0 ? true : false;
79. }
81. @Override
82. public int size() {
83. return queue.size();
84. }
86. @Override
87. public E remove() {
88. return queue.remove();
89. }
91. @Override
92. public boolean addAll(Collection<? extends E> c) {
93. return queue.addAll(c);
94. }
96. @Override
97. public void clear() {
98. queue.clear();
99. }
101. @Override
102. public boolean contains(Object o) {
103. return queue.contains(o);
104. }
106. @Override
107. public boolean containsAll(Collection<?> c) {
108. return queue.containsAll(c);
109. }
111. @Override
112. public Iterator<E> iterator() {
113. return queue.iterator();
114. }
116. @Override
117. public boolean remove(Object o) {
118. return queue.remove(o);
119. }
121. @Override
122. public boolean removeAll(Collection<?> c) {
123. return queue.removeAll(c);
124. }
126. @Override
127. public boolean retainAll(Collection<?> c) {
128. return queue.retainAll(c);
129. }
131. @Override
132. public Object[] toArray() {
133. return queue.toArray();
134. }
136. @Override
137. public <T> T[] toArray(T[] a) {
138. return queue.toArray(a);
139. }
140. }

执行方法：

1. package com.itstyle.list;
3. import java.util.ArrayList;
4. import java.util.List;
7. /**
8. * 操作系统中可以使用LRU（Least Recently Used）内存淘汰旧数据的策略，如果内存需要加载新数据但空间不足，
9. * 则会按照最近访问时间进行排序，并将最老的数据淘汰。假设现在内存空间大小为5，原本内存中没有数据，对内存中数据的访问顺序如下：
10. * 1, 2, 5, 3, 4, 6,1, 4, 3, 6, 7, 8, 3, 9 问访问过程中发生缺页的次数是多少次？
11. *
12. */
13. public class LRU {
14. public static void main(String[] args) {
15. LimitQueue<String> list = new LimitQueue<String>(5);
16. Integer[] array = new Integer[]{1, 2, 5, 3, 4, 6,1, 4, 3, 6, 7, 8, 3, 9 };
17. List<Integer> page = new ArrayList<Integer>();
18. for(Integer i :array){
19. if(list.contains(i.toString())){
20. list.remove(i);
21. }else{
22. page.add(i);
23. }
24. list.offer(i.toString());
25. }
26. System.out.println("缺页数量"+page.size()+",缺页数据"+page.toString());
27. }
28. }