Hoe maak je een array van arrays in Java

Hypothetisch heb ik 5 stringarray-objecten:

String[] array1 = new String[];
String[] array2 = new String[];
String[] array3 = new String[];
String[] array4 = new String[];
String[] array5 = new String[];

en ik wil dat een ander array-object die array-objecten met 5 strings bevat. Hoe doe ik het? Kan ik het in een andere array plaatsen?

Antwoord 1, autoriteit 100%

Zoals dit:

String[][] arrays = { array1, array2, array3, array4, array5 };

of

String[][] arrays = new String[][] { array1, array2, array3, array4, array5 };

(De laatste syntaxis kan worden gebruikt in andere toewijzingen dan op het punt van de variabeledeclaratie, terwijl de kortere syntaxis alleen werkt met declaraties.)

Antwoord 2, autoriteit 48%

probeer

String[][] arrays = new String[5][];

Antwoord 3, autoriteit 18%

Hoewel er twee uitstekende antwoorden zijn die je vertellen hoe je het moet doen, heb ik het gevoel dat er nog een antwoord ontbreekt: in de meeste gevallen zou je het helemaal niet moeten doen.

Arrays zijn omslachtig, in de meeste gevallen kunt u beter de Collection API.

Met Collecties kun je elementen toevoegen en verwijderen en er zijn gespecialiseerde Collecties voor verschillende functionaliteiten (op index gebaseerd opzoeken, sorteren, uniciteit, FIFO-toegang, gelijktijdigheid enz.).

Hoewel het natuurlijk goed en belangrijk is om te weten over arrays en hun gebruik, maakt het gebruik van collecties in de meeste gevallen API’s een stuk beter beheersbaar (daarom zijn nieuwe bibliotheken zoals Google Guavagebruikt nauwelijks arrays).

Dus voor jouw scenario heb ik liever een lijst met lijsten, en ik zou het maken met Guava:

List<List<String>> listOfLists = Lists.newArrayList();
listOfLists.add(Lists.newArrayList("abc","def","ghi"));
listOfLists.add(Lists.newArrayList("jkl","mno","pqr"));

Antwoord 4, autoriteit 4%

er is de klasse die ik noemde in de opmerking die we hadden met Sean Patrick Floyd: ik deed het met een eigenaardig gebruik dat WeakReference nodig heeft, maar je kunt het gemakkelijk door elk object wijzigen.

In de hoop dat dit ooit iemand kan helpen 🙂

import java.lang.ref.WeakReference;
import java.util.LinkedList;
import java.util.NoSuchElementException;
import java.util.Queue;
/**
 *
 * @author leBenj
 */
public class Array2DWeakRefsBuffered<T>
{
    private final WeakReference<T>[][] _array;
    private final Queue<T> _buffer;
    private final int _width;
    private final int _height;
    private final int _bufferSize;
    @SuppressWarnings( "unchecked" )
    public Array2DWeakRefsBuffered( int w , int h , int bufferSize )
    {
        _width = w;
        _height = h;
        _bufferSize = bufferSize;
        _array = new WeakReference[_width][_height];
        _buffer = new LinkedList<T>();
    }
    /**
     * Tests the existence of the encapsulated object
     * /!\ This DOES NOT ensure that the object will be available on next call !
     * @param x
     * @param y
     * @return
     * @throws IndexOutOfBoundsException
     */public boolean exists( int x , int y ) throws IndexOutOfBoundsException
    {
        if( x >= _width || x < 0 )
        {
            throw new IndexOutOfBoundsException( "Index out of bounds (get) : [ x = " + x + "]" );
        }
        if( y >= _height || y < 0 )
        {
            throw new IndexOutOfBoundsException( "Index out of bounds (get) : [ y = " + y + "]" );
        }
        if( _array[x][y] != null )
        {
            T elem = _array[x][y].get();
            if( elem != null )
            {
            return true;
            }
        }
        return false;
    }
    /**
     * Gets the encapsulated object
     * @param x
     * @param y
     * @return
     * @throws IndexOutOfBoundsException
     * @throws NoSuchElementException
     */
    public T get( int x , int y ) throws IndexOutOfBoundsException , NoSuchElementException
    {
        T retour = null;
        if( x >= _width || x < 0 )
        {
            throw new IndexOutOfBoundsException( "Index out of bounds (get) : [ x = " + x + "]" );
        }
        if( y >= _height || y < 0 )
        {
            throw new IndexOutOfBoundsException( "Index out of bounds (get) : [ y = " + y + "]" );
        }
        if( _array[x][y] != null )
        {
            retour = _array[x][y].get();
            if( retour == null )
            {
            throw new NoSuchElementException( "Dereferenced WeakReference element at [ " + x + " ; " + y + "]" );
            }
        }
        else
        {
            throw new NoSuchElementException( "No WeakReference element at [ " + x + " ; " + y + "]" );
        }
        return retour;
    }
    /**
     * Add/replace an object
     * @param o
     * @param x
     * @param y
     * @throws IndexOutOfBoundsException
     */
    public void set( T o , int x , int y ) throws IndexOutOfBoundsException
    {
        if( x >= _width || x < 0 )
        {
            throw new IndexOutOfBoundsException( "Index out of bounds (set) : [ x = " + x + "]" );
        }
        if( y >= _height || y < 0 )
        {
            throw new IndexOutOfBoundsException( "Index out of bounds (set) : [ y = " + y + "]" );
        }
        _array[x][y] = new WeakReference<T>( o );
        // store local "visible" references : avoids deletion, works in FIFO mode
        _buffer.add( o );
        if(_buffer.size() > _bufferSize)
        {
            _buffer.poll();
        }
    }
}

Voorbeeld van het gebruik ervan:

// a 5x5 array, with at most 10 elements "bufferized" -> the last 10 elements will not be taken by GC process
Array2DWeakRefsBuffered<Image> myArray = new Array2DWeakRefsBuffered<Image>(5,5,10);
Image img = myArray.set(anImage,0,0);
if(myArray.exists(3,3))
{
    System.out.println("Image at 3,3 is still in memory");
}