J'ai un ArrayList l1de taille 10. J'attribue l1à un nouveau type de référence de liste l2. Will l1et l2pointer vers le même ArrayListobjet? Ou une copie de l' ArrayListobjet est-elle affectée l2?

Lorsque l2j'utilise la référence, si je mets à jour l'objet de liste, il reflète également les changements dans le l1type de référence.

Par exemple:

List<Integer> l1 = new ArrayList<Integer>();
for (int i = 1; i <= 10; i++) {
    l1.add(i);
}

List l2 = l1;
l2.clear();

N'y a-t-il pas d'autre moyen d'affecter une copie d'un objet liste à une nouvelle variable de référence, à part la création de 2 objets liste et la copie sur des collections de l'ancien vers le nouveau?

Oui, l'affectation copiera simplement la valeur de l1(qui est une référence) dans l2. Ils feront tous deux référence au même objet.

La création d'une copie superficielle est assez simple cependant:

List<Integer> newList = new ArrayList<>(oldList);

(Juste un exemple.)

Essayez d'utiliser Collections.copy(destination, source);

Oui l1et l2pointera vers la même référence, le même objet.

Si vous souhaitez créer une nouvelle liste de tableaux basée sur l'autre liste de tableaux, procédez comme suit:

List<String> l1 = new ArrayList<String>();
l1.add("Hello");
l1.add("World");
List<String> l2 = new ArrayList<String>(l1); //A new arrayList.
l2.add("Everybody");

Le résultat sera l1aura toujours 2 éléments et l2aura 3 éléments.

Un autre moyen pratique de copier les valeurs de src ArrayList vers dest Arraylist est le suivant:

ArrayList<String> src = new ArrayList<String>();
src.add("test string1");
src.add("test string2");
ArrayList<String> dest= new ArrayList<String>();
dest.addAll(src);

Il s'agit d'une copie réelle de valeurs et pas seulement d'une copie de référence.

Il existe une méthode addAll () qui servira à copier un ArrayList dans un autre.

Par exemple, vous avez deux listes de tableaux : sourceList et targetList , utilisez le code ci-dessous.

targetList.addAll (sourceList);

Java ne transmet pas d'objets, il transmet des références (pointeurs) aux objets. Alors oui, l2 et l1 sont deux pointeurs vers le même objet.

Vous devez faire une copie explicite si vous avez besoin de deux listes différentes avec le même contenu.

List.copyOf List liste non modifiable

Tu as demandé:

N'y a-t-il pas d'autre moyen d'attribuer une copie d'une liste

Java 9 a apporté les List.ofméthodes d'utilisation des littéraux pour créer une Listclasse concrète inconnue et non modifiable .

LocalDate today = LocalDate.now( ZoneId.of( "Africa/Tunis" ) ) ;
List< LocalDate > dates = List.of( 
    today.minusDays( 1 ) ,  // Yesterday
    today ,                 // Today
    today.plusDays( 1 )     // Tomorrow
);

Parallèlement à cela, nous avons également obtenu List.copyOf. Cette méthode renvoie également une Listclasse concrète inconnue et non modifiable .

List< String > colors = new ArrayList<>( 4 ) ;          // Creates a modifiable `List`. 
colors.add ( "AliceBlue" ) ;
colors.add ( "PapayaWhip" ) ;
colors.add ( "Chartreuse" ) ;
colors.add ( "DarkSlateGray" ) ;
List< String > masterColors = List.copyOf( colors ) ;   // Creates an unmodifiable `List`.

Par «non modifiable», nous entendons le nombre d'éléments dans la liste, et le référent objet tenu dans chaque emplacement comme élément, est fixe. Vous ne pouvez pas ajouter, supprimer ou remplacer des éléments. Mais le référent objet contenu dans chaque élément peut ou non être mutable .

colors.remove( 2 ) ;          // SUCCEEDS. 
masterColors.remove( 2 ) ;    // FAIL - ERROR.

Découvrez ce code en direct sur IdeOne.com .

dates.toString (): [2020-02-02, 2020-02-03, 2020-02-04]

colours.toString (): [AliceBlue, PapayaWhip, DarkSlateGray]

masterColors.toString (): [AliceBlue, PapayaWhip, Chartreuse, DarkSlateGray]

Vous avez posé des questions sur les références d'objets. Comme d'autres l'ont dit, si vous créez une liste et l'affectez à deux variables de référence (pointeurs), vous n'avez toujours qu'une seule liste. Les deux pointent vers la même liste. Si vous utilisez l'un ou l'autre pointeur pour modifier la liste, les deux pointeurs verront ultérieurement les modifications, car il n'y a qu'une seule liste en mémoire.

Vous devez donc faire une copie de la liste. Si vous souhaitez que cette copie ne soit pas modifiable, utilisez la List.copyOfméthode décrite dans cette réponse. Dans cette approche, vous vous retrouvez avec deux listes distinctes, chacune avec des éléments qui contiennent une référence aux mêmes objets de contenu. Par exemple, dans notre exemple ci-dessus utilisant des Stringobjets pour représenter des couleurs, les objets de couleur flottent quelque part en mémoire. Les deux listes contiennent des pointeurs vers les mêmes objets de couleur. Voici un schéma.

La première liste colorsest modifiable. Cela signifie que certains éléments pourraient être supprimés comme indiqué dans le code ci-dessus, où nous avons supprimé le 3e élément d'origine Chartreuse(index de 2 = ordinal 3). Et des éléments peuvent être ajoutés. Et les éléments peuvent être modifiés pour pointer vers d'autres Stringtels que OliveDrabou CornflowerBlue.

En revanche, les quatre éléments de masterColorssont fixes. Aucun retrait, aucun ajout et aucun remplacement d'une autre couleur. Cette Listimplémentation n'est pas modifiable.