Simple KTop

Author: GreenWizard2015

src/Tests/Test_Estimator.java

@@ -22,7 +22,7 @@ public void simplest() {
 		}
 
 		Assert.assertEquals( //
-		    "4 -> 4.0, 3 -> 3.0, 2 -> 2.0, 1 -> 1.0", //
+		    "4 -> 4, 3 -> 3, 2 -> 2, 1 -> 1", //
 		    est.estimate().toString() //
 		);
 	}

src/Tests/Test_KTopCollector.java

@@ -0,0 +1,37 @@
+package Tests;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import YASL.IEstimationCollector;
+import YASL.KTopCollector;
+
+public class Test_KTopCollector {
+
+	@Test
+	public void simplest() {
+		IEstimationCollector<Integer> collector = new KTopCollector<>(2);
+		for (int i = 1; i <= 4; i++) {
+			collector.put(i, i);
+		}
+
+		Assert.assertEquals( //
+		    "4 -> 4, 3 -> 3", //
+		    collector.collect().toString() //
+		);
+	}
+
+	@Test
+	public void sameCounts() {
+		IEstimationCollector<Integer> collector = new KTopCollector<>(3);
+		collector.put(2, 3);
+		collector.put(3, 4);
+		collector.put(4, 4);
+		collector.put(5, 5);
+
+		Assert.assertEquals( //
+		    "5 -> 5, 4 -> 4, 3 -> 4", //
+		    collector.collect().toString() //
+		);
+	}
+}

src/YASL/CEstimationFor.java

@@ -1,27 +1,34 @@
 package YASL;
 
 public class CEstimationFor<T> implements Comparable<CEstimationFor<T>> {
-	public final T			Item;
-	public final double	Frequence;
+	public final T		Item;
+	public final long	Count;
 
-	public CEstimationFor(T item, double frequence) {
+	public CEstimationFor(T item, long frequence) {
 		Item = item;
-		Frequence = frequence;
+		Count = frequence;
 	}
 
 	@Override
 	public String toString() {
-		return Item.toString() + " -> " + Frequence;
+		return Item.toString() + " -> " + Count;
 	}
 
+	@SuppressWarnings("unchecked")
 	@Override
 	public int compareTo(CEstimationFor<T> o) {
-		final double delta = o.Frequence - Frequence;
+		final double delta = o.Count - Count;
 		if (0 < delta)
 			return 1;
 		if (delta < 0)
 			return -1;
-		return 0;
+		return -((Comparable)Item).compareTo(o.Item);
+	}
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public boolean equals(Object obj) {
+		return ((CEstimationFor<T>)obj).Item.equals(Item);
 	}
 
 }

src/YASL/KTopCollector.java

@@ -0,0 +1,50 @@
+package YASL;
+
+import java.util.Comparator;
+import java.util.PriorityQueue;
+import java.util.stream.Collectors;
+
+public class KTopCollector<T> implements IEstimationCollector<T> {
+	private final long															_K;
+	private final PriorityQueue<CEstimationFor<T>>	_queue;
+	private long																		_min	= 0L;
+
+	public KTopCollector(long K) {
+		this._K = K;
+		_queue = new PriorityQueue<>(new Comparator<CEstimationFor<T>>() {
+
+			@Override
+			public int compare(CEstimationFor<T> o1, CEstimationFor<T> o2) {
+				return o2.compareTo(o1);
+			}
+		});
+	}
+
+	@Override
+	public void put(T item, long cnt) {
+		if (cnt < _min)
+			return;
+
+		CEstimationFor<T> est = new CEstimationFor<>(item, cnt);
+		if (_queue.contains(est)) {
+			_queue.remove(est);
+		}
+		_queue.offer(est);
+
+		while (_K < _queue.size())
+			_queue.poll();
+
+		if (_queue.size() == _K)
+			_min = _queue.peek().Count;
+	}
+
+	@Override
+	public CEstimatedItems<T> collect() {
+		return new CEstimatedItems<>( //
+		    _queue.stream() //
+		        .map(e -> new CEstimationFor<>(e.Item, e.Count)) //
+		        .sorted() //
+		        .collect(Collectors.toList()) //
+		);
+	}
+}