- package com.itstyle.list;
- import java.util.Collection;
- import java.util.Iterator;
- import java.util.LinkedList;
- import java.util.Queue;
- /**
- * 实现一个固定长度的集合队列
- * 在开发中,有时候我们会遇到这样的需求:
- * 对一个集合操作,提前为集合指定最大大小,在我们不断向集合中添加数据的时候,当数据内容超过最大值的时候,自动将最先入队的元素移除队列。
- * @param <E>
- */
- public class LimitQueue<E> implements Queue<E> {
- /**
- * 队列长度,实例化类的时候指定
- */
- private int limit;
- Queue<E> queue = new LinkedList<E>();
- public LimitQueue(int limit){
- this.limit = limit;
- }
- /**
- * 入队
- */
- @Override
- public boolean offer(E e){
- if(queue.size() >= limit){
- //如果超出长度,入队时,先出队
- queue.poll();
- }
- return queue.offer(e);
- }
- /**
- * 出队
- */
- @Override
- public E poll() {
- return queue.poll();
- }
- /**
- * 获取队列
- */
- public Queue<E> getQueue(){
- return queue;
- }
- /**
- * 获取限制大小
- */
- public int getLimit(){
- return limit;
- }
- @Override
- public boolean add(E e) {
- return queue.add(e);
- }
- @Override
- public E element() {
- return queue.element();
- }
- @Override
- public E peek() {
- return queue.peek();
- }
- @Override
- public boolean isEmpty() {
- return queue.size() == 0 ? true : false;
- }
- @Override
- public int size() {
- return queue.size();
- }
- @Override
- public E remove() {
- return queue.remove();
- }
- @Override
- public boolean addAll(Collection<? extends E> c) {
- return queue.addAll(c);
- }
- @Override
- public void clear() {
- queue.clear();
- }
- @Override
- public boolean contains(Object o) {
- return queue.contains(o);
- }
- @Override
- public boolean containsAll(Collection<?> c) {
- return queue.containsAll(c);
- }
- @Override
- public Iterator<E> iterator() {
- return queue.iterator();
- }
- @Override
- public boolean remove(Object o) {
- return queue.remove(o);
- }
- @Override
- public boolean removeAll(Collection<?> c) {
- return queue.removeAll(c);
- }
- @Override
- public boolean retainAll(Collection<?> c) {
- return queue.retainAll(c);
- }
- @Override
- public Object[] toArray() {
- return queue.toArray();
- }
- @Override
- public <T> T[] toArray(T[] a) {
- return queue.toArray(a);
- }
- }
- package com.itstyle.list;
- import java.util.ArrayList;
- import java.util.List;
- /**
- * 操作系统中可以使用LRU(Least Recently Used)内存淘汰旧数据的策略,如果内存需要加载新数据但空间不足,
- * 则会按照最近访问时间进行排序,并将最老的数据淘汰。假设现在内存空间大小为5,原本内存中没有数据,对内存中数据的访问顺序如下:
- * 1, 2, 5, 3, 4, 6,1, 4, 3, 6, 7, 8, 3, 9 问访问过程中发生缺页的次数是多少次?
- *
- */
- public class LRU {
- public static void main(String[] args) {
- LimitQueue < String > list = new LimitQueue < String > (5);
- Integer[] array = new Integer[] {
- 1,
- 2,
- 5,
- 3,
- 4,
- 6,
- 1,
- 4,
- 3,
- 6,
- 7,
- 8,
- 3,
- 9
- };
- List < Integer > page = new ArrayList < Integer > ();
- for (Integer i: array) {
- if (list.contains(i.toString())) {
- list.remove(i);
- } else {
- page.add(i);
- }
- list.offer(i.toString());
- }
- System.out.println("缺页数量" + page.size() + ",缺页数据" + page.toString());
- }
- }
来源: https://yq.aliyun.com/articles/70456