From 294b29d8391ae45770d9f30f04fbabd931ad3ae9 Mon Sep 17 00:00:00 2001 From: Gabriel Tofvesson Date: Mon, 24 Oct 2016 21:54:38 +0200 Subject: [PATCH] - Added ShiftingList Features: - Fixed size - Load prediction and memory allocation optimization - Uses previous input to estimate future load - Allocates memory according to previous input and a user-changeable constant - Custom data handling with optimization for this specific case --- src/com/tofvesson/async/Test.java | 9 - .../tofvesson/collections/ShiftingList.java | 168 +++++++++++++++--- 2 files changed, 142 insertions(+), 35 deletions(-) delete mode 100644 src/com/tofvesson/async/Test.java diff --git a/src/com/tofvesson/async/Test.java b/src/com/tofvesson/async/Test.java deleted file mode 100644 index 6cd9918..0000000 --- a/src/com/tofvesson/async/Test.java +++ /dev/null @@ -1,9 +0,0 @@ -package com.tofvesson.async; - -import com.tofvesson.collections.ShiftingList; - -public class Test { - public static void main(String[] args) throws Exception { - ShiftingList l = new ShiftingList<>(5); - } -} diff --git a/src/com/tofvesson/collections/ShiftingList.java b/src/com/tofvesson/collections/ShiftingList.java index 0f78026..fc4bf9c 100644 --- a/src/com/tofvesson/collections/ShiftingList.java +++ b/src/com/tofvesson/collections/ShiftingList.java @@ -2,11 +2,13 @@ package com.tofvesson.collections; import java.util.*; +import java.util.function.Predicate; public class ShiftingList implements Map { final ShiftingSet keys; final ShiftingSet values; + final UnchangingSet> entrySet; public ShiftingList(int maxSize){ @@ -16,77 +18,116 @@ public class ShiftingList implements Map { public ShiftingList(int maxSize, float load){ keys = new ShiftingSet<>(maxSize, load); values = new ShiftingSet<>(maxSize, load); + entrySet = new UnchangingSet<>(maxSize, load); } @Override public int size() { - return 0; + return keys.size(); } @Override public boolean isEmpty() { - return true; + return keys.isEmpty(); } @Override public boolean containsKey(Object key) { - return false; + return keys.contains(key); } @Override public boolean containsValue(Object value) { - return false; + return values.contains(value); } @Override public V get(Object key) { - return null; + int i = keys.indexOf(key); + return i!=-1?(V) values.set[i]:null; } @Override public V remove(Object key) { - return null; + int i = keys.indexOf(key); + if(i==-1) return null; + V v; + keys.remove(key); + values.remove(v=(V)values.set[i]); + return v; } + @SuppressWarnings({"unchecked", "MismatchedQueryAndUpdateOfCollection"}) @Override public void putAll(Map m) { - + ArrayList l = new ArrayList(); + ArrayList l1 = new ArrayList(); + m.keySet().stream().filter(this::isKey).forEach(l::add); + m.values().stream().filter(this::isValue).forEach(l1::add); + K[] k; + V[] v; + if(l.size()!=l1.size()){ + if(l.size()> l2 = new ArrayList<>(); + for(int i = k.length-1; i>0; --i) l2.add(new ShiftingEntry<>(keys, values, i)); + entrySet.addAll(l2); } @Override public void clear() { - + keys.clear(); + values.clear(); + entrySet.clear(); } @Override public Set keySet() { - - return null; + return keys; } @Override public Collection values() { - return null; + return values; } @Override public Set> entrySet() { - return null; + return entrySet; } @Override public V put(K key, V value) { - return null; + V v = null; + if(keys.contains(key)) v = (V) values.set[keys.indexOf(key)]; + else keys.add(key); + values.add(value); + return v; } + public boolean isKey(Object o){ try{ K k = (K) o; return true; }catch(Exception e){} return false; } + public boolean isValue(Object o){ try{ V v = (V) o; return true; }catch(Exception e){} return false; } + /** * Entries dynamically update as underlying sets change * @param * @param */ - static class ShiftingEntry implements Entry{ + protected static class ShiftingEntry implements Entry{ private ShiftingSet keys; private ShiftingSet values; @@ -116,12 +157,42 @@ public class ShiftingList implements Map { } } - static class ShiftingSet implements Set{ + protected static class UnchangingSet extends ShiftingSet{ + + public UnchangingSet(int maxSize, float loadFactor) { + super(maxSize, loadFactor); + } + + @Override + public boolean remove(Object o1) { + return false; + } + + @Override + public boolean retainAll(Collection c) { + return false; + } + + @Override + public boolean removeAll(Collection c) { + return false; + } + + @Override + public boolean removeIf(Predicate filter) { + return false; + } + } + + protected static class ShiftingSet implements Set{ Object[] set = new Object[1]; final int maxSize; final float loadFactor; - int populatedEntries = 0; + int populatedEntries = 0, load = 1; // Defines currently populated entries + double avgLoad = 1; // Used to optimize allocation algorithm to - + // most adequately fit the average amount of elements + // stored during any one operation public ShiftingSet(int maxSize, float loadFactor){ this.maxSize = maxSize<=0?20:maxSize; @@ -165,10 +236,13 @@ public class ShiftingList implements Map { @Override public boolean add(E e) { if(contains(e)) return false; + ++load; + avgLoad = (avgLoad+1)/2; populatedEntries=populatedEntries implements Map { l.add(e); } if(l.size()==0) return false; - int tmp = populatedEntries; + ++load; + avgLoad = (avgLoad+l.size()*avgLoad/load)/2; // Improve prediction using relative applied load (to a point) + int tmp = populatedEntries, cal; populatedEntries=populatedEntries+l.size()0; --i) if(i=maxSize?maxSize:cal]; // Create new array + for (int i = l.size(); i > 0; --i) + if (i < o.length - 1) + o[l.size() - i] = l.get(i); // Move new values to start of array relative to their position + if (l.size() < tmp) for (int i = 0; i < tmp - l.size(); ++i) + if (l.size() + i < o.length) o[l.size()] = set[i]; // Move old values to relative location + set = o; // Update reference + } return true; } @Override public boolean retainAll(Collection c) { - return false; + ArrayList l = new ArrayList<>(); + for(Object e : c) + for (Object o : set) + if (e.equals(o)){ + l.add(e); + break; + } + if(l.size() == 0 || set.length == l.size()) return false; + clear(); + addAll((Collection) c); + return true; } @Override @@ -244,20 +339,41 @@ public class ShiftingList implements Map { */ void shift(){ for(int i = 0; i=set.length && + ((int)(100/(100/populatedEntries+(avgLoad/2)*loadFactor)))<=set.length) return; // Array is roughly the right size Object[] o = new Object[Math.min((int)(100/(100/populatedEntries*loadFactor)), maxSize)]; System.arraycopy(set, 0, o, 0, o.length); set = o; } + + /** + * Reset prediction algorithm judgement. + * (Makes newly stored values more valuable when accounting for free space) + */ + public void resetLoadCount(){ load = 0; } + + /** + * Reset whole prediction algorithm. + * May cause RAM to suffer at the expense of better processing times. + */ + public void resetLoadAlgo(){ load = 0; avgLoad = 2; } + + + public int indexOf(Object o){ + for(int i = 0; i implements Iterator{ + protected static class ShiftingIterator implements Iterator{ private final ShiftingSet s; private int ctr = -1;