Eu tenho um ArrayList l1tamanho 10. Atribuo l1ao novo tipo de referência de lista l2. Will l1e l2apontar para o mesmo ArrayListobjeto? Ou é uma cópia do ArrayListobjeto atribuída l2?

Ao usar a l2referência, se eu atualizar o objeto de lista, ele também refletirá as alterações no l1tipo de referência.

Por exemplo:

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

List l2 = l1;
l2.clear();

Não há outra maneira de atribuir uma cópia de um objeto de lista a uma nova variável de referência, além de criar 2 objetos de lista e fazer cópias em coleções de antigas para novas?

Sim, a tarefa apenas copiará o valor de l1(que é uma referência) para l2. Ambos se referirão ao mesmo objeto.

Criar uma cópia superficial é bastante fácil:

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

(Apenas como um exemplo.)

Tente usar Collections.copy(destination, source);

Sim l1e l2apontará para a mesma referência, o mesmo objeto.

Se você deseja criar um novo ArrayList com base no outro ArrayList, faça isso:

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

O resultado será l1ainda terá 2 elementos e l2terá 3 elementos.

Outra maneira conveniente de copiar os valores de src ArrayList para dest Arraylist é a seguinte:

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

Isso é cópia de valores real e não apenas cópia de referência.

Existe um método addAll () que servirá ao propósito de copiar um ArrayList para outro.

Por exemplo, você tem duas listas de matrizes : sourceList e targetList , use o código abaixo.

targetList.addAll (sourceList);

Java não passa objetos, ele passa referências (ponteiros) para objetos. Então sim, l2 e l1 são dois ponteiros para o mesmo objeto.

Você precisa fazer uma cópia explícita se precisar de duas listas diferentes com o mesmo conteúdo.

List.copyOf List lista não modificável

Você perguntou:

Não há outra maneira de atribuir uma cópia de uma lista

O Java 9 trouxe os List.ofmétodos para o uso de literais para criar uma Listclasse concreta não modificável e desconhecida.

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

Junto com isso, também conseguimos List.copyOf. Esse método também retorna uma Listclasse concreta não modificável e desconhecida.

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`.

Por "não modificável", queremos dizer que o número de elementos na lista e o referente referente ao objeto mantido em cada slot como um elemento são fixos. Você não pode adicionar, soltar ou substituir elementos. Mas o objeto referente mantido em cada elemento pode ou não ser mutável .

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

Veja este código executado ao vivo em IdeOne.com .

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

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

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

Você perguntou sobre referências a objetos. Como outros disseram, se você criar uma lista e atribuí-la a duas variáveis ​​de referência (ponteiros), ainda terá apenas uma lista. Ambos apontam para a mesma lista. Se você usar um ponteiro para modificar a lista, os dois ponteiros verão as alterações posteriormente, pois há apenas uma lista na memória.

Então você precisa fazer uma cópia da lista. Se você deseja que a cópia não seja modificável, use o List.copyOfmétodo conforme discutido nesta resposta. Nesta abordagem, você acaba com duas listas separadas, cada uma com elementos que mantêm uma referência aos mesmos objetos de conteúdo. Por exemplo, em nosso exemplo acima, usando Stringobjetos para representar cores, os objetos de cores estão flutuando na memória em algum lugar. As duas listas contêm ponteiros para os mesmos objetos de cor. Aqui está um diagrama.

A primeira lista colorsé modificável. Isso significa que alguns elementos podem ser removidos como visto no código acima, onde removemos o terceiro elemento original Chartreuse(índice de 2 = ordinal 3). E elementos podem ser adicionados. E os elementos podem ser alterados para apontar para outros String, como OliveDrabou CornflowerBlue.

Por outro lado, os quatro elementos de masterColorssão fixos. Sem remoção, sem adição e sem substituição de outra cor. Essa Listimplementação não é modificável.