Java：内存有效存储整数数组

Question

Premise : This problem might be already known, and I might be using the wrong wording, please refer me elsewhere if this is the case.

Quick Problem Overview : I have to store a high number of arrays of integers in order to avoid duplication. I am doing the following:

LinkedList<int[]> ArraysAlreadyUsed;

Upon using an array, I add it to the list. Before using an array I see if it is in the list. Since I need to use many high dimensional arrays I run into memory issues.

Question : What is a good/the best way of doing this in order to minimize the amount of memory occupied? Is there a way to represent such arrays with a hash string? And would this be better?

Answer 1

It may make sense to create a wrapper that implements equals and hashcode so that you can place the arrays in a Set for O(1) contains / add . Something like:

public class IntArray {
  private final int[] array;
  private final int hash;

  public IntArray(int[] array) {
    this.array = array;
    this.hash = Arrays.hashCode(this.array); //cache hashcode for better performance
  }

  @Override
  public int hashCode() {
    return hash;
  }

  @Override
  public boolean equals(Object obj) {
    if (obj == null) return false;
    if (getClass() != obj.getClass()) return false;
    final IntArray other = (IntArray) obj;
    return Arrays.equals(this.array, other.array);
  }
}

You can then simply use a set:

Set<IntArray> arrays = new HashSet<> ();

That will create a small overhead (guestimate less than 20 bytes per wrapper) but will perform much better than your LinkedList.

If memory is your only concern then you could go for an int[][] but that will be more painful...

Answer 2

If you need to check the presence of an element in a data structure the best solution is to use a Map . So use an HashMap .

Retrieve of elements happens in O(1) . In a list ( LinkedList or ArrayList ) the search happens in O(n) .

A linked list is also a poor choice in term of memory occupation. Infact for each element you have a reference to the previous element and a reference to the next element.

Just in term of memory occupations the best solution is using an array of int (not an ArrayList ) with a reference to the last inserted id.

Answer 3

使用BitSet代替int[]可能会减少内存占用。