在java中存储未知数量的字符串的最快方法是什么？

Question

I want to store an unknown amount of strings and later read them in the order they were added. As I said the only features I need are:

• Possibility to add an unknown amount of strings without slowing down because of resizing
• Possibility to read the elements in the order they were added

The problem is that I want to output strings from part of a trie. So counting the strings before returning them would double the amount of time needed for the operation.

(Another solution would be to keep track of the number of strings in the trie using an attribute but as I want to return just a part of the trie this isn't a perfect solution either)

Answer 1

LinkedList<string> sounds like a good bet to me...

• Maintains order
• O(1) addition at head or tail
• O(1) removal at head or tail
• Cheap iteration

It's expensive to get at an arbitrary element, which is the normal reason not to use it... but it sounds like that isn't a problem in your case.

Answer 2

An ArrayList is generally faster than a LinkedList. If you don't specify an appropriate size, each time the capacity is exhausted, it will have to reassign a new array (with the double size) and copy the elements to a new array, though.

You could use a LinkedList to avoid this cost, but the average time will probably be bigger.

Whatever the collection you use, if you don't have enough memory, the GC will trigger, which could also introduce some delay. An "unknown amount", without any limit, is impossible to store in any in-memory collection. If "unknown" can be very very large and forbid the usage of an in-memory collection, you'll have to us a file or a database.

Answer 3

The two obvious choices are ArrayList and LinkedList . A LinkedList appears to be slightly slower than ArrayList . Here's my benchmarking code:

import java.util.*;

public class ListTest {
    private static final int N = 50000;
    private static final float NANO_TO_MILLI = 1.0e-6f;

    public static void main(String[] args) {
        String[] strings = new String[N];
        for (int i = 0; i < N; ++i) {
            strings[i] = Integer.toString(i);
        }

        System.out.print("ArrayList: ");
        benchmark(strings, new ArrayList<String>());

        System.out.print("LinkedList: ");
        benchmark(strings, new LinkedList<String>());
    }

    private static void benchmark(String[] strings, List<String> list) {
        // measure how long it takes to add the strings
        long start = System.nanoTime();
        for (String s : strings) {
            list.add(s);
        }
        long addTime = System.nanoTime() - start;

        // measure how long it takes to iterate the list
        start = System.nanoTime();
        int i = 0;
        for (String s : list) {
            ++i;
        }
        long iterateTime = System.nanoTime() - start;

        // report the results
        System.out.println(String.format("add: %.2fms; iterate: %.2fms (%d strings)",
            addTime * NANO_TO_MILLI,
            iterateTime * NANO_TO_MILLI,
            i));
    }
}

And here are the results of a typical run:

ArrayList: add: 5.52ms; iterate: 7.66ms (50000 strings)
LinkedList: add: 7.79ms; iterate: 8.32ms (50000 strings)

This was on a Windows machine with an Intel Core2 Quad Q6600 2.4GHz cpu.

Note that this only measures the overall time. It doesn't measure the variation in add time of individual strings, which I would expect to be higher for ArrayList than for LinkedList , due to the need to reallocate the internal array.

EDIT: If I modify main to repeat the test five times in a row, with a call to System.gc() after each call to benchmark , then I get some interesting results:

ArrayList: add: 5.84ms; iterate: 7.84ms (50000 strings)
LinkedList: add: 7.24ms; iterate: 8.27ms (50000 strings)

ArrayList: add: 0.45ms; iterate: 0.60ms (50000 strings)
LinkedList: add: 0.84ms; iterate: 5.35ms (50000 strings)

ArrayList: add: 0.52ms; iterate: 0.72ms (50000 strings)
LinkedList: add: 0.81ms; iterate: 5.57ms (50000 strings)

ArrayList: add: 3.77ms; iterate: 0.71ms (50000 strings)
LinkedList: add: 3.35ms; iterate: 0.93ms (50000 strings)

ArrayList: add: 3.39ms; iterate: 0.87ms (50000 strings)
LinkedList: add: 3.38ms; iterate: 0.86ms (50000 strings)

This is probably due to caching by the cpu. Note that LinkedList can be slightly faster (eg, the last to iterations) for adding strings, although it can also be much slower. Iteration can also be drastically slower for LinkedList , also probably because of lack of locality.

Answer 4

Use an implementation of the List interface. It's generally considered that ArrayList is the best general-purpose collection to use, so do something as simple as this for storing your strings:

List<String> stringList = new ArrayList<String>();