উত্তর:
জাভা ভাষা এবং রানটাইমে কোনও বিদ্যমান প্রয়োগ নেই। সকল লাইনগুলি প্রসারিত AbstractQueue , এবং তার ডক পরিষ্কারভাবে বলে যে, একটি পূর্ণ সারিতে একটি উপাদান যোগ সবসময় ব্যতিক্রম দিয়ে শেষ হয়। আপনার প্রয়োজনীয় ক্রিয়াকলাপটি থাকার জন্য আপনার নিজের একটি শ্রেণিতে একটি ক্যু মুড়ে ফেলা ভাল (এবং বেশ সহজ) হবে।
আবার, কারণ সমস্ত সারি AbstractQueue এর সন্তান, কেবল আপনার অভ্যন্তরীণ ডেটা টাইপ হিসাবে এটি ব্যবহার করুন এবং আপনার কোনও কার্যকরী সময় নেই: নমনীয় বাস্তবায়ন হওয়া উচিত :-)
হালনাগাদ:
নীচে বর্ণিত হিসাবে, দুটি উন্মুক্ত বাস্তবায়ন উপলব্ধ (এই উত্তরটি বেশ পুরানো, ভাবেন!), বিশদটির জন্য এই উত্তরটি দেখুন।
collection.dequeএকটি নির্দিষ্ট একটি ব্যবহার করতে পারেন maxlen।
আসলে লিঙ্কডহ্যাশম্যাপ আপনি যা চান ঠিক তেমন করে। আপনাকে removeEldestEntryপদ্ধতিটি ওভাররাইড করতে হবে ।
সর্বোচ্চ 10 টি উপাদান সহ একটি সারি উদাহরণ:
queue = new LinkedHashMap<Integer, String>()
{
@Override
protected boolean removeEldestEntry(Map.Entry<Integer, String> eldest)
{
return this.size() > 10;
}
};যদি "রিলেডএলস্টেস্ট্রি" সত্যটি প্রত্যাবর্তন করে তবে মানচিত্রে সর্বাধিক প্রবীণ এন্ট্রি সরানো হবে।
এই সঠিক উত্তরের সাথে আমার নিজের সদৃশ প্রশ্ন থেকে আমি দুটিটি শিখেছি:
আমি পেয়ারা উত্পাদনশীল ব্যবহার করেছি EvictingQueue, ভাল কাজ।
কোনও EvictingQueueকলকে তাত্ক্ষণিকভাবে স্থিতিশীল কারখানার পদ্ধতিতে কল করতে createএবং আপনার সর্বোচ্চ আকার নির্দিষ্ট করে specify
EvictingQueue< Person > people = com.google.common.collect.EvictingQueue.create( 100 ) ; // Set maximum size to 100. CircularFifoQueueলিঙ্কটি মারা গেছে, পরিবর্তে commons.apache.org/proper/commons-collections/apidocs/org/…
আমি স্রেফ এইভাবে একটি নির্দিষ্ট আকারের সারিটি প্রয়োগ করেছি:
public class LimitedSizeQueue<K> extends ArrayList<K> {
private int maxSize;
public LimitedSizeQueue(int size){
this.maxSize = size;
}
public boolean add(K k){
boolean r = super.add(k);
if (size() > maxSize){
removeRange(0, size() - maxSize);
}
return r;
}
public K getYoungest() {
return get(size() - 1);
}
public K getOldest() {
return get(0);
}
}removeRange(0, size() - maxSize)
এটি আমি Queueমোড়ানো দিয়ে LinkedListযা করেছি, এটি স্থির আকারের যা আমি এখানে দিচ্ছি 2;
public static Queue<String> pageQueue;
pageQueue = new LinkedList<String>(){
private static final long serialVersionUID = -6707803882461262867L;
public boolean add(String object) {
boolean result;
if(this.size() < 2)
result = super.add(object);
else
{
super.removeFirst();
result = super.add(object);
}
return result;
}
};
....
TMarket.pageQueue.add("ScreenOne");
....
TMarket.pageQueue.add("ScreenTwo");
.....এই শ্রেণিটি উত্তরাধিকারের পরিবর্তে রচনা (এখানে অন্যান্য উত্তর) ব্যবহার করে কাজ করে যা কিছু নির্দিষ্ট পার্শ্ব-প্রতিক্রিয়া হওয়ার সম্ভাবনা সরিয়ে দেয় (প্রয়োজনীয় জাভাতে জোশ ব্লচের আচ্ছাদন হিসাবে)। অন্তর্নিহিত লিংকডলিস্টের ছাঁটাই পদ্ধতিগুলি অ্যাড, অ্যাডএল এবং অফারগুলিতে ঘটে।
import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Queue;
public class LimitedQueue<T> implements Queue<T>, Iterable<T> {
private final int limit;
private final LinkedList<T> list = new LinkedList<T>();
public LimitedQueue(int limit) {
this.limit = limit;
}
private boolean trim() {
boolean changed = list.size() > limit;
while (list.size() > limit) {
list.remove();
}
return changed;
}
@Override
public boolean add(T o) {
boolean changed = list.add(o);
boolean trimmed = trim();
return changed || trimmed;
}
@Override
public int size() {
return list.size();
}
@Override
public boolean isEmpty() {
return list.isEmpty();
}
@Override
public boolean contains(Object o) {
return list.contains(o);
}
@Override
public Iterator<T> iterator() {
return list.iterator();
}
@Override
public Object[] toArray() {
return list.toArray();
}
@Override
public <T> T[] toArray(T[] a) {
return list.toArray(a);
}
@Override
public boolean remove(Object o) {
return list.remove(o);
}
@Override
public boolean containsAll(Collection<?> c) {
return list.containsAll(c);
}
@Override
public boolean addAll(Collection<? extends T> c) {
boolean changed = list.addAll(c);
boolean trimmed = trim();
return changed || trimmed;
}
@Override
public boolean removeAll(Collection<?> c) {
return list.removeAll(c);
}
@Override
public boolean retainAll(Collection<?> c) {
return list.retainAll(c);
}
@Override
public void clear() {
list.clear();
}
@Override
public boolean offer(T e) {
boolean changed = list.offer(e);
boolean trimmed = trim();
return changed || trimmed;
}
@Override
public T remove() {
return list.remove();
}
@Override
public T poll() {
return list.poll();
}
@Override
public T element() {
return list.element();
}
@Override
public T peek() {
return list.peek();
}
}public class CircularQueue<E> extends LinkedList<E> {
private int capacity = 10;
public CircularQueue(int capacity){
this.capacity = capacity;
}
@Override
public boolean add(E e) {
if(size() >= capacity)
removeFirst();
return super.add(e);
}
}ব্যবহার এবং পরীক্ষার ফলাফল:
public static void main(String[] args) {
CircularQueue<String> queue = new CircularQueue<>(3);
queue.add("a");
queue.add("b");
queue.add("c");
System.out.println(queue.toString()); //[a, b, c]
String first = queue.pollFirst(); //a
System.out.println(queue.toString()); //[b,c]
queue.add("d");
queue.add("e");
queue.add("f");
System.out.println(queue.toString()); //[d, e, f]
}একটি সাধারণ তালিকার মতো শোনাচ্ছে যেখানে অ্যাড পদ্ধতিতে একটি অতিরিক্ত স্নিপেট থাকে যা যদি খুব দীর্ঘ হয়ে যায় তবে তালিকাটি কেটে যায়।
যদি এটি খুব সহজ হয় তবে আপনার সমস্যার বিবরণ সম্ভবত সম্পাদনা করতে হবে।
এছাড়াও এই এই প্রশ্ন , বা অ্যারেব্লকিংকিউ দেখুন (অবরুদ্ধ করার বিষয়ে সতর্ক থাকুন, এটি আপনার ক্ষেত্রে অযাচিত হতে পারে)।
আপনার কী প্রয়োজনীয়তা যা আপনাকে এই প্রশ্ন জিজ্ঞাসা করতে পরিচালিত করেছিল তা পুরোপুরি পরিষ্কার নয়। আপনার যদি একটি নির্দিষ্ট আকারের ডেটা কাঠামো প্রয়োজন হয় তবে আপনি বিভিন্ন ক্যাশে নীতিগুলিও দেখতে চাইতে পারেন। তবে আপনার যেহেতু একটি সারি রয়েছে তাই আমার সেরা অনুমান যে আপনি কোনও ধরণের রাউটার কার্যকারিতা সন্ধান করছেন। সেক্ষেত্রে, আমি একটি রিং বাফার নিয়ে যাব: একটি অ্যারে যার প্রথম এবং শেষ সূচক রয়েছে। যখনই কোনও উপাদান যুক্ত করা হয় আপনি কেবল সর্বশেষ উপাদান সূচকটি বৃদ্ধি করেন এবং যখন কোনও উপাদান সরানো হয় তখন প্রথম উপাদান সূচকটি বৃদ্ধি করুন। উভয় ক্ষেত্রেই অ্যারে আকারটি সংযোজন করা হয় এবং প্রয়োজনের সময় অন্য সূচকটি বাড়িয়ে দেওয়া নিশ্চিত করুন, যখন সারিটি পূর্ণ বা খালি থাকে।
এছাড়াও, যদি এটি রাউটার-ধরণের অ্যাপ্লিকেশন হয় তবে আপনি এলোমোথিম আর্লি ড্রপিং (আরইডি) এর মতো অ্যালগরিদম নিয়েও পরীক্ষা করতে চাইতে পারেন, যা ভরাট হওয়ার আগেই এলোমেলোভাবে সারির উপাদানগুলি ফেলে দেয়। কিছু ক্ষেত্রে, রেডকে ড্রপ করার আগে সারিটি পূরণ করার সহজ পদ্ধতির চেয়ে ভাল সামগ্রিক পারফরম্যান্স পাওয়া গেছে।
আমি মনে করি সেরা মিলের উত্তরটি এই অন্যান্য প্রশ্ন থেকে ।
অ্যাপাচি কমন্স সংগ্রহ 4 এর একটি সার্কুলারফাইকিউ রয়েছে যা আপনি যা খুঁজছেন তা। জাভাডোকের উদ্ধৃতি:
সার্কুলারফাইফিউ কিউ একটি স্থির আকারের সাথে প্রথম-ইন প্রথম-আউট সারি যা পূর্ণ হলে তার প্রাচীনতম উপাদানটি প্রতিস্থাপন করে।
একটি সহজ সমাধান নীচে "স্ট্রিং" এর একটি সারি দেওয়া আছে
LinkedHashMap<Integer, String> queue;
int queueKeysCounter;
queue.put(queueKeysCounter++, "My String");
queueKeysCounter %= QUEUE_SIZE;নোট করুন যে এটি কাতারে থাকা আইটেমগুলির ক্রম বজায় রাখবে না, তবে এটি পুরানো এন্ট্রি প্রতিস্থাপন করবে।
যেমন এটি ওওপিগুলিতে পরামর্শ দেওয়া হয়েছে যে উত্তরাধিকারের চেয়ে আমাদের রচনাটি পছন্দ করা উচিত
এখানে আমার সমাধান যে বিষয়টি মাথায় রেখে।
package com.choiceview;
import java.util.ArrayDeque;
class Ideone {
public static void main(String[] args) {
LimitedArrayDeque<Integer> q = new LimitedArrayDeque<>(3);
q.add(1);
q.add(2);
q.add(3);
System.out.println(q);
q.add(4);
// First entry ie 1 got pushed out
System.out.println(q);
}
}
class LimitedArrayDeque<T> {
private int maxSize;
private ArrayDeque<T> queue;
private LimitedArrayDeque() {
}
public LimitedArrayDeque(int maxSize) {
this.maxSize = maxSize;
queue = new ArrayDeque<T>(maxSize);
}
public void add(T t) {
if (queue.size() == maxSize) {
queue.removeFirst();
}
queue.add(t);
}
public boolean remove(T t) {
return queue.remove(t);
}
public boolean contains(T t) {
return queue.contains(t);
}
@Override
public String toString() {
return queue.toString();
}
}