Re: Summating Strings
Mike wrote:
Please bear with me. I'm a bit new to Java. I have a list of strings
that I'd like to summate. For example I'd like to take this data:
Apple
Orange
Apple
Apple
Pear
Peach
Banana
Banana
And generate this data:
Term Count
---- -----
Apple 3
Orange 1
Pear 1
Peach 1
Banana 2
I'd then like to sort this data so the items with the higher counts come
first in the list. The list of source strings can be anywhere from 1 -
20000 strings having anywhere from 1 - 500 unique terms. The average
set will be roughly 300 strings with about 30 unique terms. I am
currently doing this now by looping through the strings and keeping the
term/count data in an ArrayList. I use a binary search to determine if
the string is already in my list. If not I insert the string into the
ArrayList in the appropriate location to keep the list sorted so the
binary search will continue to work.
Here is a little class I wrote for a similar problem. Once you have the
set of keys, you can sort it using a Comparator that orders based on the
associated count. You will need to modify it to remove the generics to
use with 1.4. I'd be interested in hearing whether it is faster or
slower than your current solution.
/*
* Created on Aug 14, 2004
*/
package utilities;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/**
* Utility class for counting instances of equal objects.
*/
public class Counter {
private Map<Object,Count> data = new HashMap<Object,Count>();
/**
* Increment by one the count associated with a specified
* key.
* @param key
*/
public void increment(Object key) {
Count count = data.get(key);
if (count == null) {
count = new Count();
data.put(key, count);
}
count.increment();
}
/**
* Get the count associated with a specified key.
* @param key The key whose count is required.
* @return The number of times increment has been called with
* a key equal to this one.
*/
public int get(Object key) {
Count count = data.get(key);
if (count == null) {
return 0;
} else {
return count.get();
}
}
/**
* Get number of unique counted objects
*
* @return Number of key objects for which increment
* has been called. Equal objects are only counted once.
*/
public int size() {
return data.size();
}
/**
* Get all the unique counted objects
* @return A set containing a refence to the counted objects.
*/
public Set getKeys() {
return Collections.unmodifiableSet(data.keySet());
}
private static class Count {
private int val = 0;
private void increment() {
val++;
}
private int get() {
return val;
}
}
}