如何在Java中声明无限大小/动态的字节数组？

Question

我声明的字节数组在不断更新时对我来说是未知的，那么如何声明无限大小/可变大小的字节数组呢？

Answer 1

You cannot declare an array of infinite size, as that would require infinite memory. Additionally, all the allocation calls deal with numbers, not infinite quantities.

You can allocate a byte buffer that resizes on demand. I believe the easiest choice would be a ByteArrayOutputStream .

ByteBuffer has an API which makes manipulation of the buffer easier, but you would have to build the resize functionality yourself. The easiest way will be to allocate a new, larger array, copy the old contents in, and swap the new buffer for the old.

Other answers have mentioned using a List<Byte> of some sort. It is worth noting that if you create a bunch of new Byte() objects, you can dramatically increase memory consumption. Byte.valueOf sidesteps this problem, but you have to ensure that it is consistently used throughout your code. If you intend to use this list in many places, I might consider writing a simple List decorator which interns all the elements. For example:

public class InterningList extends AbstractList<Byte>
{
    ...
    @Override
    public boolean add(Byte b) {
        return super.add(Byte.valueOf(b));
    }
    ...
}

This is not a complete (or even tested) example, just something to start with...

Answer 2

Arrays in Java are not dynamic. You can use list instead.

List<Byte> list = new ArrayList<Byte>();

Due to autoboxing feature you can freely add either Byte objects or primitive bytes to this list.

Answer 3

To define a bytearray of varying length just use the apache commons.io.IOUtils library instead of assigning manual length like

byte[] b=new byte[50];

You can pass your input stream to IOUtils function which will perform a read function on this inputstream thus byte array will have exact length of bytes as required. ex.

byte[] b = IOUtils.toByteArray(inpustream);

Chaos..

Answer 4

Your best bet is to use an ArrayList. As it resizes as you fill it.

List<Byte> array = new ArrayList<Byte>();

Answer 5

The obvious solution would be to use an ArrayList.

But this is a bad solution if you need performance or are constrained in memory, as it doesn't really store bytes but Bytes (that is, objects).

For any real application, the answer is simple : you have to manage yourself the byte array, by using methods making it grow as necessary. You may embed it in a specific class if needed :

public class AlmostInfiniteByteArray {

    private byte[] array;
    private int size;

    public AlmostInfiniteByteArray(int cap) {
        array = new byte[cap];
            size = 0;
    }

    public int get(int pos) {
        if (pos>=size) throw new ArrayIndexOutOfBoundsException();
        return array[pos];
    }

    public void set(int pos, byte val) {
        if (pos>=size) {
            if (pos>=array.length) {
                byte[] newarray = new byte[(pos+1)*5/4];
                System.arraycopy(array, 0, newarray, 0, size);
                array = newarray;
            }
            size = pos+1;
        }
        array[pos] = val;
    }
}

Answer 6

ByteArrayOutputStream will allow for writing to a dynamic byte array. However, methods such as remove, replace and insert are not available. One has to extract the byte array and then manipulate it directly.

Answer 7

Use an ArrayList of any subtype of List

The different implementations of List can allow you to do different things on the list (eg different traversal strategy, different performance etc)

Answer 8

Initial capacity of ArrayList is 10. You can change it by ArrayList(5000). ArrayList will double it's size when needed (it will create new array and copy the old one to to the new one).

Answer 9

I would tweak slightly other people's answers.

Create a LargeByteArray class to manage your array. It will have get and set methods, etc, whatever you will need.

Behind the scenes that class will use a long to hold the current length and use an ArrayList to store the contents of the array.

I would pick to store byte[8192] or byte[16384] arrays in the ArrayList. That will give a reasonable trade off in terms of size wasted and reduce the need for resizing.

You can even make the array 'sparse' ie only allocate the list.get(index/8192) entry if there is a non-zero value stored in that box.

Such a structure can give you significantly more storage in some cases.

Another strategy you can use is to compress the byte[] boxes after write and uncompress before read (use a LRU cache for reading) which can allow storing twice or more than available ram... Though that depends on the compression strategy.

After that you can look at paging some boxes out to disk...

That's as close to an infinite array as I can get you ;-)

Answer 10

You can make use of IOUtils from piece, as Prashant already told.

Here's a little piece from it which can solve the task (you will need IOUtils.toByteArray):

public class IOUtils {

private static final int DEFAULT_BUFFER_SIZE = 1024 * 4;

public static byte[] toByteArray(InputStream input) throws IOException {
    ByteArrayOutputStream output = new ByteArrayOutputStream();
    copy(input, output);
    return output.toByteArray();
}

public static int copy(InputStream input, OutputStream output)
        throws IOException {
    long count = copyLarge(input, output);
    if (count > Integer.MAX_VALUE) {
        return -1;
    }
    return (int) count;
}

public static long copyLarge(InputStream input, OutputStream output)
        throws IOException {
    byte[] buffer = new byte[DEFAULT_BUFFER_SIZE];
    long count = 0;
    int n = 0;
    while (-1 != (n = input.read(buffer))) {
        output.write(buffer, 0, n);
        count += n;
    }

    return count;

}
}