Comment créer un tableau de tableaux en Java ?

Question

Hypothétiquement, j'ai 5 objets de type tableau de chaînes de caractères :

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

et je veux qu'un autre objet tableau contienne ces 5 objets tableaux de chaînes. Comment dois-je m'y prendre ? Puis-je les placer dans un autre tableau ?

Answer 1

Comme ça :

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

ou

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

(Cette dernière syntaxe peut être utilisée dans des affectations autres qu'au point de déclaration de la variable, alors que la syntaxe la plus courte ne fonctionne qu'avec les déclarations).

Answer 2

Essayez

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

Answer 3

Bien qu'il existe deux excellentes réponses vous indiquant comment procéder, je pense qu'une autre réponse manque : Dans la plupart des cas, vous ne devriez pas le faire du tout.

Les tableaux sont encombrants, dans la plupart des cas, il est préférable d'utiliser la fonction API de collecte .

Avec les collections, vous pouvez ajouter et supprimer des éléments et il existe des collections spécialisées pour différentes fonctionnalités (recherche par index, tri, unicité, accès FIFO, concurrence, etc.)

Bien qu'il soit bien sûr bon et important de connaître les tableaux et leur utilisation, dans la plupart des cas, l'utilisation des collections rend les API beaucoup plus faciles à gérer (c'est pourquoi les nouvelles bibliothèques telles que Google Guava n'utilisent pas du tout les tableaux).

Ainsi, pour votre scénario, je préférerais une liste de listes, et je la créerais en utilisant Guava :

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

Answer 4

Il y a la classe que j'ai mentionnée dans le commentaire que nous avons eu avec Sean Patrick Floyd : je l'ai fait avec une utilisation particulière qui nécessite WeakReference, mais vous pouvez la changer par n'importe quel objet avec facilité.

J'espère que cela pourra aider quelqu'un un jour :)

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();
        }
    }

}

Exemple d'utilisation :

// 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");
}