package com.jidesoft.utils;
import java.util.ArrayList;
import java.util.Arrays;
public class TestCacheArray {
private static void initArray(ArrayList<String> inArray, int inSize) {
long before, after;
before = System.nanoTime();
for (int i = 0; i < inSize; i++) {
inArray.add(String.valueOf(i));
}
after = System.nanoTime();
System.out.println("Creating ArrayList of length " + inArray.size()
+ " took " + String.valueOf((after - before) / 1000000) + "ms");
}
private static void testSpottedIndexOf(ArrayList<String> inArray, String[] inSearches) {
long before, after;
System.out.print("\tSearching for " + Arrays.toString(inSearches)
+ " in ArrayList size "
+ inArray.size() + " took ");
for (int i = 0; i < inSearches.length; i++) {
before = System.nanoTime();
inArray.indexOf(inSearches[i]);
after = System.nanoTime();
System.out.print(String.valueOf((after - before) / 1000000) + "ms ");
}
System.out.println();
}
private static void testSpottedIndexOf(String[] inSortedArray, String[] inSearches) {
long before, after;
for (int i = 0; i < inSearches.length; i++) {
before = System.nanoTime();
Arrays.binarySearch(inSortedArray, inSearches[i]);
after = System.nanoTime();
System.out.println("\tBinary Searching for "
+ inSearches[i]
+ " in Array of length " + inSortedArray.length
+ " took " + String.valueOf((after - before) / 1000000) + "ms");
}
}
/* Test every ten */
private static void testPartialIndexOf(ArrayList<String> inArray, int skip) {
long before, after;
before = System.nanoTime();
for (int i = 0; i < inArray.size() / skip; i++) {
inArray.indexOf(String.valueOf(i * skip));
}
after = System.nanoTime();
System.out.println("\tPartial " + skip + " IndexOf for ArrayList of length " + inArray.size()
+ " took " + String.valueOf((after - before) / 1000000) + "ms");
}
private static void testPartialIndexOf(String[] inSortedArray, int skip) {
long before, after;
before = System.nanoTime();
for (int i = 0; i < inSortedArray.length / skip; i++) {
Arrays.binarySearch(inSortedArray, String.valueOf(i * skip));
}
after = System.nanoTime();
System.out.println("\tPartial Binary Search " + skip + " IndexOf for ArrayList of length " + inSortedArray.length
+ " took " + String.valueOf((after - before) / 1000000) + "ms");
}
private static void sortArray(String[] inArray) {
long before, after;
before = System.nanoTime();
Arrays.sort(inArray);
after = System.nanoTime();
System.out.println("Sorting Array of length " + inArray.length
+ " took " + String.valueOf((after - before) / 1000000) + "ms");
}
private static boolean compareLists(ArrayList<String> inList1, ArrayList<String> inList2) {
long before, after;
boolean matched = true;
if (inList1.size() != inList2.size()) {
System.out.println("\tSizes do not much! "
+ String.valueOf(inList1.size())
+ " "
+ String.valueOf(inList2.size()));
return false;
}
before = System.nanoTime();
for (int i = 0; i < inList1.size(); i++) {
if (inList1.get(i).compareTo(inList2.get(i)) != 0) {
System.out.println("\t\tContents at " + i + " do not match! "
+ String.valueOf(inList1.get(i))
+ " "
+ String.valueOf(inList1.get(i)));
matched = false;
}
}
after = System.nanoTime();
System.out.println("\tComparison result " + matched + " took "
+ String.valueOf((after - before) / 1000000) + "ms");
return matched;
}
private static boolean compareIndices(ArrayList<String> ControlList, ArrayList<String> CheckList) {
long before, after;
boolean matched = true;
if (ControlList.size() != CheckList.size()) {
System.out.println("\tSizes do not much! "
+ String.valueOf(ControlList.size())
+ " "
+ String.valueOf(CheckList.size()));
return false;
}
before = System.nanoTime();
for (int i = 0; i < ControlList.size(); i++) {
String element = ControlList.get(i);
if (ControlList.indexOf(element) != CheckList.indexOf(element)) {
System.out.println("\t\tMismatch for Element " + element
+ " Control List " + String.valueOf(ControlList.indexOf(element))
+ " Check List " + String.valueOf(CheckList.indexOf(element)));
matched = false;
}
}
after = System.nanoTime();
System.out.println("\tComparison result " + matched + " took "
+ String.valueOf((after - before) / 1000000) + "ms");
return matched;
}
private static void testModifications(ArrayList<String> inList1) {
long before, after;
final String[] playValues1 = {"abc", "efg", "hij"};
final String[] playValues2 = {"klm", "nop", "qrs"};
final String[] playValues3 = {"tuv", "wxy", "zAB"};
final Integer[] removeIndices = {5, 444, 6666};
final Integer[] setIndices = {14, 454, 6676};
final String[] setValues = {"ABC", "DEF", "GHI"};
ArrayList<String> playValuesCollection1 = new ArrayList<String>();
ArrayList<String> playValuesCollection2 = new ArrayList<String>();
// initialize
for (int i = 0; i < playValues2.length; i++) playValuesCollection1.add(playValues2[i]);
for (int i = 0; i < playValues3.length; i++) playValuesCollection2.add(playValues3[i]);
// Test add (E)
before = System.nanoTime();
for (int i = 0; i < playValues1.length; i++) inList1.add(playValues1[i]);
after = System.nanoTime();
System.out.print("\tAppending " + String.valueOf((after - before) / 1000000) + "ms ");
// Test remove (E)
before = System.nanoTime();
for (int i = 0; i < playValues1.length; i++) inList1.remove(playValues1[i]);
after = System.nanoTime();
System.out.print("Removing " + String.valueOf((after - before) / 1000000) + "ms ");
// Test add (int, E)
before = System.nanoTime();
for (int i = 0; i < playValues1.length; i++) inList1.add(0, playValues1[i]);
after = System.nanoTime();
System.out.print("Prepending " + String.valueOf((after - before) / 1000000) + "ms ");
// Test addAll (Collection)
before = System.nanoTime();
inList1.addAll(playValuesCollection1);
after = System.nanoTime();
System.out.print("Appending Collection " + String.valueOf((after - before) / 1000000) + "ms ");
// Test addAll (int, Collection)
before = System.nanoTime();
inList1.addAll(0, playValuesCollection1);
after = System.nanoTime();
System.out.print("Prepending Collection " + String.valueOf((after - before) / 1000000) + "ms ");
// Test remove (int)
before = System.nanoTime();
for (int i = 0; i < removeIndices.length; i++)
if (inList1.size() > removeIndices[i]) inList1.remove(removeIndices[i]);
after = System.nanoTime();
System.out.print("Removing Index " + String.valueOf((after - before) / 1000000) + "ms ");
// Test set(int, obj)
before = System.nanoTime();
for (int i = 0; i < setIndices.length; i++)
if (inList1.size() > setIndices[i]) inList1.set(setIndices[i], setValues[i]);
after = System.nanoTime();
System.out.print("Setting " + String.valueOf((after - before) / 1000000) + "ms ");
System.out.println();
}
public static void main(String[] args) {
final String[] playValues1 = {"10", "20", "30", "40", "50", "50", "50", "60", "70", "80", "90", "100"};
final String[] modifyArray1 = {"20", "50", "70"};
final String[] modifyArray2 = {"30", "50", "80"};
final String[] modifyArray3 = {"40", "50", "90"};
ArrayList<String> myArrayList1 = new ArrayList<String>(Arrays.asList(playValues1));
CachedArrayList<String> myCachedArrayList1 = new CachedArrayList<String>(Arrays.asList(playValues1));
// Test remove(int)
System.out.println("Testing Remove(int)");
System.out.println("\tComparison Before");
compareLists(myArrayList1, myCachedArrayList1);
compareIndices(myArrayList1, myCachedArrayList1);
myArrayList1.remove(2);
myCachedArrayList1.remove(2);
myArrayList1.remove(5);
myCachedArrayList1.remove(5);
myArrayList1.remove(myArrayList1.size() - 1);
System.out.println("\tComparison After");
myCachedArrayList1.remove(myCachedArrayList1.size() - 1);
compareLists(myArrayList1, myCachedArrayList1);
compareIndices(myArrayList1, myCachedArrayList1);
myArrayList1.clear();
myCachedArrayList1.clear();
myCachedArrayList1.invalidateCache(); // need to call explicitly
myArrayList1.addAll(Arrays.asList(playValues1));
myCachedArrayList1.addAll(Arrays.asList(playValues1));
// Test remove (Object)
System.out.println("Testing Remove(Object)");
System.out.println("\tComparison Before");
compareLists(myArrayList1, myCachedArrayList1);
compareIndices(myArrayList1, myCachedArrayList1);
myArrayList1.remove("20");
myCachedArrayList1.remove("20");
myArrayList1.remove("50");
myCachedArrayList1.remove("50");
myArrayList1.remove("90");
myCachedArrayList1.remove("90");
myArrayList1.remove("1000");
myCachedArrayList1.remove("1000");
System.out.println("\tComparison After");
compareLists(myArrayList1, myCachedArrayList1);
compareIndices(myArrayList1, myCachedArrayList1);
myArrayList1.clear();
myCachedArrayList1.clear();
myCachedArrayList1.invalidateCache(); // need to call explicitly
myArrayList1.addAll(Arrays.asList(playValues1));
myCachedArrayList1.addAll(Arrays.asList(playValues1));
// Test add(int, E)
System.out.println("Testing add(int,E)");
System.out.println("\tComparison Before");
compareLists(myArrayList1, myCachedArrayList1);
compareIndices(myArrayList1, myCachedArrayList1);
myArrayList1.add(0, "50");
myCachedArrayList1.add(0, "50");
myArrayList1.add(7, "50");
myCachedArrayList1.add(7, "50");
myArrayList1.add(myArrayList1.size() - 1, "50");
myCachedArrayList1.add(myCachedArrayList1.size() - 1, "50");
System.out.println("\tComparison After");
compareLists(myArrayList1, myCachedArrayList1);
compareIndices(myArrayList1, myCachedArrayList1);
myArrayList1.clear();
myCachedArrayList1.clear();
myCachedArrayList1.invalidateCache(); // need to call explicitly
myArrayList1.addAll(Arrays.asList(playValues1));
myCachedArrayList1.addAll(Arrays.asList(playValues1));
// Test addAll(int, Collection)
System.out.println("Testing addAll(int,Collection)");
System.out.println("\tComparison Before");
compareLists(myArrayList1, myCachedArrayList1);
compareIndices(myArrayList1, myCachedArrayList1);
myArrayList1.addAll(0, Arrays.asList(modifyArray1));
myCachedArrayList1.addAll(0, Arrays.asList(modifyArray1));
myArrayList1.addAll(7, Arrays.asList(modifyArray2));
myCachedArrayList1.addAll(7, Arrays.asList(modifyArray2));
myArrayList1.addAll(15, Arrays.asList(modifyArray3));
myCachedArrayList1.addAll(15, Arrays.asList(modifyArray3));
System.out.println("\tComparison After");
compareLists(myArrayList1, myCachedArrayList1);
compareIndices(myArrayList1, myCachedArrayList1);
myArrayList1.clear();
myCachedArrayList1.clear();
myArrayList1.addAll(Arrays.asList(playValues1));
myCachedArrayList1.addAll(Arrays.asList(playValues1));
// Test set(int, E)
System.out.println("Testing set(int,E)");
System.out.println("\tComparison Before");
compareLists(myArrayList1, myCachedArrayList1);
compareIndices(myArrayList1, myCachedArrayList1);
myArrayList1.set(1, "50");
myCachedArrayList1.set(1, "50");
System.out.println("\tComparison After set 1");
compareLists(myArrayList1, myCachedArrayList1);
compareIndices(myArrayList1, myCachedArrayList1);
System.out.println("\tComparison After set 5");
myArrayList1.set(5, "50");
myCachedArrayList1.set(5, "50");
compareLists(myArrayList1, myCachedArrayList1);
compareIndices(myArrayList1, myCachedArrayList1);
myArrayList1.set(8, "50");
myCachedArrayList1.set(8, "50");
System.out.println("\tComparison After set 8");
compareLists(myArrayList1, myCachedArrayList1);
compareIndices(myArrayList1, myCachedArrayList1);
/*
int size1 = 50000;
int size2 = 5000000;
int skip = 1000;
final String[] lookFor1 = {"10","1000","10000","40000","20000000"};
final String[] deleteValues = {"11","1001","10001","40001","20000001"};
long before, after;
if (args.length >=1) {
size1 = Integer.valueOf(args[0]);
size2 = size1*100;
}
if (args.length >=2) {
skip = Integer.valueOf(args[1]);
}
ArrayList<String> myArrayList1 = new ArrayList<String>();
ArrayList<String> myArrayList2 = new ArrayList<String>();
initArray(myArrayList1,size1);
initArray(myArrayList2,size2);
String[] myArray1 = new String[size1];
String[] myArray2 = new String[size2];
String[] myArray3 = new String[size3];
CachedArrayList<String> myCachedArrayList1 = new CachedArrayList<String>(myArrayList1);
CachedArrayList<String> myCachedArrayList2 = new CachedArrayList<String>(myArrayList2);
ActiveCachedArrayList<String> myActiveActiveCachedArrayList1 = new ActiveCachedArrayList<String>(myArrayList1);
ActiveCachedArrayList<String> myActiveActiveCachedArrayList2 = new ActiveCachedArrayList<String>(myArrayList2);
ActiveCachedArrayList<String> myLazyActiveCachedArrayList1 = new ActiveCachedArrayList<String>(myArrayList1);
ActiveCachedArrayList<String> myLazyActiveCachedArrayList2 = new ActiveCachedArrayList<String>(myArrayList2);
myActiveActiveCachedArrayList2.setLazy(false);
myActiveActiveCachedArrayList1.setLazy(false);
myLazyActiveCachedArrayList1.setLazy(true);
myLazyActiveCachedArrayList2.setLazy(true);
// myArrayList1.toArray(myArray1);
// myArrayList2.toArray(myArray2);
// myArrayList3.toArray(myArray3);
// sortArray(myArray1);
// sortArray(myArray2);
// sortArray(myArray3);
// testSpottedIndexOf(myArrayList1,lookFor1);
// testSpottedIndexOf(myArrayList2,lookFor1);
// testSpottedIndexOf(myArrayList3,lookFor1);
// testPartialIndexOf(myArrayList1,skip);
// testPartialIndexOf(myArrayList2,skip);
// testPartialIndexOf(myArrayList3,skip);
// testSpottedIndexOf(myArray1,lookFor1);
// testSpottedIndexOf(myArray2,lookFor1);
// testSpottedIndexOf(myArray3,lookFor1);
// testPartialIndexOf(myArray1,skip);
// testPartialIndexOf(myArray2,skip);
// testPartialIndexOf(myArray3,skip);
/*
compareLists(myCachedArrayList1,myActiveActiveCachedArrayList1);
compareLists(myCachedArrayList1,myLazyActiveCachedArrayList1);
compareLists(myCachedArrayList2,myActiveActiveCachedArrayList2);
compareLists(myCachedArrayList2,myLazyActiveCachedArrayList2);
System.out.println ("Writing to small Cached Array List");
testModifications(myCachedArrayList1);
System.out.println ("Writing to big Cached Array List");
testModifications(myCachedArrayList2);
System.out.println ("Writing to small Lazy Cached Array List");
testModifications(myLazyActiveCachedArrayList1);
System.out.println ("Writing to big Lazy Cached Array List");
testModifications(myLazyActiveCachedArrayList2);
System.out.println ("Writing to small Active Cached Array List");
testModifications(myActiveActiveCachedArrayList1);
System.out.println ("Writing to big Active Cached Array List");
testModifications(myActiveActiveCachedArrayList2);
compareLists(myCachedArrayList1,myActiveActiveCachedArrayList1);
compareLists(myCachedArrayList1,myLazyActiveCachedArrayList1);
compareLists(myCachedArrayList2,myActiveActiveCachedArrayList2);
compareLists(myCachedArrayList2,myLazyActiveCachedArrayList2);
testSpottedIndexOf(myCachedArrayList1,lookFor1);
testSpottedIndexOf(myLazyActiveCachedArrayList1,lookFor1);
testSpottedIndexOf(myActiveActiveCachedArrayList1,lookFor1);
testSpottedIndexOf(myCachedArrayList2,lookFor1);
testSpottedIndexOf(myLazyActiveCachedArrayList2,lookFor1);
testSpottedIndexOf(myActiveActiveCachedArrayList2,lookFor1);
testPartialIndexOf(myCachedArrayList1,skip);
testPartialIndexOf(myLazyActiveCachedArrayList1,skip);
testPartialIndexOf(myActiveActiveCachedArrayList1,skip);
System.out.println ("Reading from Cached Array List");
testPartialIndexOf(myCachedArrayList2,skip);
System.out.println ("Reading from Lazy Cached Array List");
testPartialIndexOf(myLazyActiveCachedArrayList2,skip);
System.out.println ("Reading from Active Cached Array List");
testPartialIndexOf(myActiveActiveCachedArrayList2,skip);
*/
}
}