java arraylist conversions other collections
Este tutorial discute conversões de ArrayList para outras coleções como Set, LinkedList, Lists, etc. junto com as diferenças entre essas coleções:
Até agora, vimos quase todos os conceitos relacionados a ArrayList em Java. Além de criar e manipular ArrayList usando várias operações ou métodos fornecidos pela classe ArrayList, às vezes também é necessário converter ArrayList em uma ou mais coleções.
=> Visite aqui para aprender Java do zero.
Neste tutorial, discutiremos algumas das conversões de ArrayList para outras coleções que incluem List, LinkedList, Vector, Set, etc. Também consideraremos a conversão entre ArrayList e String. Após as conversões, também discutiremos as diferenças entre ArrayLists e outras coleções - Arrays, List, Vector, LinkedList, etc.
O que você aprenderá:
- ArrayList para conversão de string
- Conversão de String para ArrayList
- Converter lista em ArrayList em Java
- Converter ArrayList para definir em Java
- Converter conjunto em ArrayList em Java
- Uma matriz de ArrayList em Java
- ArrayList Of Arrays Em Java
- Lista Vs ArrayList em Java
- Vector Vs ArrayList
- ArrayList vs LinkedList
- perguntas frequentes
- Conclusão
- Leitura recomendada
ArrayList para conversão de string
Os métodos a seguir podem ser usados para converter ArrayList em String.
# 1) Usando um objeto StringBuilder
import java.util.ArrayList; public class Main { public static void main(String args()) { //Create and initialize the ArrayList ArrayList strList = new ArrayList(); strList.add('Software'); strList.add('Testing'); strList.add('Help'); //print the ArrayList System.out.println('The ArrayList: ' + strList); //define a stringbuilder object StringBuffer sb = new StringBuffer(); //append each ArrayList element to the stringbuilder object for (String str : strList) { sb.append(str + ' '); } //convert stringbuilder to string and print it. String myStr = sb.toString(); System.out.println('
String from ArrayList: ' + myStr); } } Resultado:
The ArrayList: (Software, Testing, Help)
String de ArrayList: Ajuda de teste de software
perguntas da entrevista do oracle sql pl sql
No programa acima, um objeto StringBuilder é criado. Em seguida, usando o loop forEach, cada elemento em ArrayList é anexado ao objeto StringBuilder. Em seguida, o objeto StringBuilder é convertido em uma string. Observe que usar o método StringBuilder ‘append’; você também pode anexar o delimitador apropriado à string.
No exemplo acima, usamos o espaço (““) como delimitador.
# 2) Usando o método String.join ()
O método String.join () pode ser usado para converter ArrayList em String. Aqui, você também pode passar o delimitador apropriado para o método de junção.
O programa abaixo demonstra isso.
import java.util.ArrayList; public class Main { public static void main(String() args) { // create and initialize the ArrayList ArrayList metroList = new ArrayList(); metroList.add('Delhi'); metroList.add('Mumbai'); metroList.add('Chennai'); metroList.add('Kolkata'); //print the ArrayList System.out.println('The ArrayList: ' + metroList); // Join with an empty delimiter to concat all strings. String resultStr = String.join(' ', metroList); System.out.println('
String converted from ArrayList: '+resultStr); } }Resultado:
The ArrayList: (Delhi, Mumbai, Chennai, Kolkata)
String convertida de ArrayList: Delhi Mumbai Chennai Kolkata
Você pode ver que passamos diretamente o ArrayList como um argumento para o método String.join () junto com o delimitador.
Para String ArrayLists simples, String.join () é o melhor método para converter em String. Mas para objetos ArrayLists mais complexos, usar StringBuilder é mais eficiente.
Conversão de String para ArrayList
Para converter uma String em ArrayList, existem duas etapas:
- A string é dividida usando a função split () e as substrings (divididas no delimitador apropriado) são armazenadas em uma matriz de string.
- A matriz de string obtida da divisão da string é então convertida em ArrayList usando o método ‘asList ()’ da classe Arrays.
O programa para converter string em ArrayList é fornecido abaixo.
import java.util.ArrayList; import java.util.List; import java.util.Arrays; public class Main { public static void main(String args()){ //define a string String myStr = 'The string to ArrayList program'; //convert string to array using split function on spaces String strArray() = myStr.split(' '); //print the string System.out.println('The input string : ' + myStr); //declare an ArrayList List strList = new ArrayList(); //convert string array to ArrayList using asList method strList = Arrays.asList(strArray); //print the resultant ArrayList System.out.println('
The ArrayList from String:' + strList ); } } Resultado:
A string de entrada: a string para o programa ArrayList
A ArrayList de String: (The, string, to, ArrayList, programa)
No programa acima, dividimos a string em espaços e a reunimos em um array de strings. Essa matriz é então convertida em uma ArrayList de strings.
Converter lista em ArrayList em Java
ArrayList implementa a interface List. Se você deseja converter uma Lista em sua implementação, como ArrayList, pode fazer isso usando o método addAll da interface List.
O programa abaixo mostra a conversão da lista em ArrayList adicionando todos os elementos da lista a ArrayList.
import java.util.ArrayList; import java.util.List; public class Main { public static void main(String a()){ //create a list & initiliaze it List collections_List = new ArrayList(); collections_List.add('ArrayList'); collections_List.add('Vector'); collections_List.add('LinkedList'); collections_List.add('Stack'); collections_List.add('Set'); collections_List.add('Map'); //print the list System.out.println('List contents: '+collections_List); //create an ArrayList ArrayList myList = new ArrayList(); //use addAll() method to add list elements to ArrayList myList.addAll(collections_List); //print the ArrayList System.out.println('
ArrayList after adding elements: '+myList); } } Resultado:
Conteúdo da lista: (ArrayList, Vector, LinkedList, Stack, Set, Map)
ArrayList após adicionar elementos: (ArrayList, Vector, LinkedList, Stack, Set, Map)
Converter ArrayList para definir em Java
Os métodos a seguir convertem um ArrayList em um Conjunto.
# 1) Usando uma abordagem iterativa tradicional
Esta é a abordagem tradicional. Aqui, iteramos pela lista e adicionamos cada elemento da ArrayList ao conjunto.
No programa abaixo, temos uma ArrayList de string. Declaramos um HashSet de string. Em seguida, usando o loop forEach, iteramos sobre o ArrayList e adicionamos cada elemento ao HashSet.
De maneira semelhante, também podemos converter ArrayList em um treeSet.
import java.util.*; class Main { public static void main(String() args) { // Create & initialize an ArrayList ArrayList colorsList = new ArrayList (Arrays.asList('Red', 'Green', 'Blue', 'Cyan', 'Magenta', 'Yellow')); //print the ArrayList System.out.println('The ArrayList:' + colorsList); //Declare a HashSet Set hSet = new HashSet(); //Add each ArrayList element to the set for (String x : colorsList) hSet.add(x); //Print the HashSet System.out.println('
HashSet obtained from ArrayList: ' + hSet); } } Resultado:
The ArrayList: (Red, Green, Blue, Cyan, Magenta, Yellow)
HashSet obtido de ArrayList: (Vermelho, Ciano, Azul, Amarelo, Magenta, Verde)
# 2) Usando o Construtor de conjunto
O próximo método para converter um ArrayList em um conjunto é usar o construtor. Neste método, passamos o ArrayList como um argumento para o construtor do conjunto e, assim, inicializamos o objeto do conjunto com os elementos ArrayList.
O programa abaixo mostra o uso de ArrayList na criação de um objeto definido.
import java.util.*; class Main { public static void main(String() args) { // Create & initialize an ArrayList ArrayList colorsList = new ArrayList (Arrays.asList('Red', 'Green', 'Blue', 'Cyan', 'Magenta', 'Yellow')); //print the ArrayList System.out.println('The ArrayList:' + colorsList); //Declare a TreeSet Set tSet = new TreeSet(colorsList); //Print the TreeSet System.out.println('
TreeSet obtained from ArrayList: ' + tSet); } } Resultado:
The ArrayList: (Red, Green, Blue, Cyan, Magenta, Yellow
TreeSet obtido de ArrayList: (Blue, Cyan, Green, Magenta, Red, Yellow)
# 3) Usando o método addAll
Você também pode usar o método addAll de Set para adicionar todos os elementos de ArrayList ao conjunto.
O programa a seguir usa o método addAll para adicionar os elementos de ArrayList ao HashSet.
import java.util.*; class Main { public static void main(String() args) { // Create & initialize an ArrayList ArrayList colorsList = new ArrayList (Arrays.asList('Red', 'Green', 'Blue', 'Cyan', 'Magenta', 'Yellow')); //print the ArrayList System.out.println('The ArrayList:' + colorsList); //Declare a HashSet Set hSet = new HashSet(); //use addAll method of HashSet to add elements of ArrayList hSet.addAll(colorsList); //Print the HashSet System.out.println('
HashSet obtained from ArrayList: ' + hSet); } } Resultado:
The ArrayList: (Red, Green, Blue, Cyan, Magenta, Yellow)
HashSet obtido de ArrayList: (Vermelho, Ciano, Azul, Amarelo, Magenta, Verde)
# 4) Usando Java 8 Stream
Streams são as novas adições ao Java 8. Esta classe stream fornece um método para converter ArrayList em stream e depois em set.
O programa Java abaixo demonstra o uso do método da classe stream para converter ArrayList em set.
import java.util.*; import java.util.stream.*; class Main { public static void main(String() args) { // Create & initialize an ArrayList ArrayList colorsList = new ArrayList (Arrays.asList('Red', 'Green', 'Blue', 'Cyan', 'Magenta', 'Yellow')); //print the ArrayList System.out.println('The ArrayList:' + colorsList); // Convert ArrayList to set using stream Set set = colorsList.stream().collect(Collectors.toSet()); //Print the Set System.out.println('
Set obtained from ArrayList: ' + set); } } Resultado:
The ArrayList: (Red, Green, Blue, Cyan, Magenta, Yellow)
Conjunto obtido na ArrayList: (Vermelho, Ciano, Azul, Amarelo, Magenta, Verde)
Converter conjunto em ArrayList em Java
Na última seção, vimos a conversão de ArrayList em Set. A conversão de Set em ArrayList também usa os mesmos métodos descritos acima, com a diferença de que a posição do conjunto e de ArrayList muda.
A seguir, exemplos de programação para converter Set em ArrayList. A outra descrição de cada método permanece a mesma.
# 1) Abordagem Iterativa
import java.util.*; class Main { public static void main(String() args) { // Create a set of strings & add elements to it Set set = new HashSet(); set.add('One'); set.add('Two'); set.add('Three'); //print the set System.out.println('The given Set: ' + set); //create an ArrayList ArrayList numList = new ArrayList(set.size()); //add each set element to the ArrayList using add method for (String str : set) numList.add(str); //print the ArrayList System.out.println('
ArrayList obtained from Set: ' + numList); } } Resultado:
O conjunto fornecido: (um, dois, três)
ArrayList obtido de Set: (One, Two, Three)
No programa acima, iteramos através do Set e cada elemento do set é adicionado ao ArrayList.
# 2) Usando o construtor
import java.util.*; class Main { public static void main(String() args) { // Create a set of strings & add elements to it Set set = new HashSet(); set.add('One'); set.add('Two'); set.add('Three'); //print the set System.out.println('The given Set: ' + set); //create an ArrayList and pass set to the constructor List numList = new ArrayList(set); //print the ArrayList System.out.println('
ArrayList obtained from Set: ' + numList); } } Resultado:
O conjunto fornecido: (um, dois, três)
ArrayList obtido de Set: (One, Two, Three)
O programa acima cria um conjunto e um ArrayList. O objeto ArrayList é criado fornecendo um objeto definido como um argumento em seu construtor.
# 3) Usando o método addAll
import java.util.*; class Main { public static void main(String() args) { // Create a set of strings & add elements to it Set set = new HashSet(); set.add('One'); set.add('Two'); set.add('Three'); //print the set System.out.println('The given Set: ' + set); //create an ArrayList List numList = new ArrayList(); //use addAll method of ArrayList to add elements of set numList.addAll(set); //print the ArrayList System.out.println('
ArrayList obtained from Set: ' + numList); } } Resultado:
O conjunto fornecido: (um, dois, três)
ArrayList obtido de Set: (One, Two, Three)
Aqui, usamos o método addAll de ArrayList para adicionar os elementos do conjunto ao ArrayList.
# 4) Usando Java 8 Stream
import java.util.*; import java.util.stream.*; class Main { public static void main(String() args) { // Create a set of strings & add elements to it Set set = new HashSet(); set.add('One'); set.add('Two'); set.add('Three'); //print the set System.out.println('The given Set: ' + set); //create an ArrayList and using stream method,assign stream of elements to ArrayList List numList = set.stream().collect(Collectors.toList()); //print the ArrayList System.out.println('
ArrayList obtained from Set: ' + numList); } } Resultado:
O conjunto fornecido: (um, dois, três)
ArrayList obtido de Set: (One, Two, Three)
O programa acima usa a classe stream para converter Set em ArrayList.
Uma matriz de ArrayList em Java
Um Array of ArrayList, como o nome sugere, consiste em ArrayLists como seus elementos. Embora o recurso não seja usado regularmente, ele é usado quando o uso eficiente de espaço de memória é um requisito.
O programa a seguir implementa um Array of ArrayLists em Java.
import java.util.ArrayList; import java.util.List; public class Main { public static void main(String() args) { //define and initialize a num_list List num_list = new ArrayList(); num_list.add('One'); num_list.add('Two'); num_list.add('Two'); //define and initialize a colors_list List colors_list = new ArrayList(); colors_list.add('Red'); colors_list.add('Green'); colors_list.add('Blue'); //define Array of ArrayList with two elements List() arrayOfArrayList = new List(2); //add num_list as first element arrayOfArrayList(0) = num_list; //add colors_list as second element arrayOfArrayList(1) = colors_list; //print the contents of Array of ArrayList System.out.println('Contents of Array of ArrayList:'); for (int i = 0; i Resultado:
Conteúdo da matriz de ArrayList:
(Um, Dois, Dois)
(Vermelho, Verde, Azul)
No programa acima, primeiro definimos duas listas. Em seguida, declaramos um Array de dois ArrayList. Cada elemento deste array é o ArrayList definido anteriormente. Finalmente, o conteúdo de um Array de ArrayList é exibido usando um loop for.
ArrayList Of Arrays Em Java
Assim como temos um Array de ArrayLists, também podemos ter um ArrayList de Arrays. Aqui, cada elemento individual de um ArrayList é um Array.
O programa a seguir demonstra ArrayList de Arrays.
import java.util.*; public class Main { public static void main(String() args) { // declare ArrayList of String arrays ArrayList ArrayList_Of_Arrays = new ArrayList(); //define individual string arrays String() colors = { 'Red', 'Green', 'Blue' }; String() cities = { 'Pune', 'Mumbai', 'Delhi'}; //add each array as element to ArrayList ArrayList_Of_Arrays.add(colors); ArrayList_Of_Arrays.add(cities); // print ArrayList of Arrays System.out.println('Contents of ArrayList of Arrays:'); for (String() strArr : ArrayList_Of_Arrays) { System.out.println(Arrays.toString(strArr)); } } } Resultado:
Conteúdo de ArrayList of Arrays:
(Vermelho, Verde, Azul)
(Pune, Mumbai, Delhi)
O programa acima demonstra ArrayList de Arrays. Inicialmente, declaramos um ArrayList de String Arrays. Isso significa que cada elemento de ArrayList será um String Array. A seguir, definimos dois Arrays de string. Em seguida, cada um dos Arrays é adicionado ao ArrayList. Por fim, imprimimos o conteúdo de ArrayList de Arrays.
Para imprimir o conteúdo, percorremos a ArrayList usando o loop for. Para cada iteração, imprimimos o conteúdo do elemento ArrayList que possui um Array usando o método Arrays.toString ().
Lista Vs ArrayList em Java
As tabelas a seguir mostram algumas das diferenças entre List e ArrayList.
Lista ArrayList A lista é uma interface em Java ArrayList é uma parte da estrutura Java Collection A lista é implementada como uma interface ArrayList é implementado como uma classe de coleção Estende interface de coleção implementa a interface List e estende AbstractList Parte do namespace System.Collection.generic Parte do namespace System.Collections Usando List, uma lista de elementos pode ser criada e acessada por meio de índices. Usando ArrayList, podemos criar um Array dinâmico de elementos ou objetos cujo tamanho é alterado automaticamente com as mudanças no conteúdo.
Vector Vs ArrayList
Abaixo estão algumas das diferenças entre um Vector e um ArrayList.
ArrayList LinkedList ArrayList implementa a interface List LinkedList implementa interfaces List e Deque. O armazenamento e o acesso de dados são eficientes em ArrayList. LinkedList é bom em manipular dados. ArrayList implementa internamente uma matriz dinâmica. LinkedList implementa internamente uma lista duplamente vinculada. Como o ArrayList implementa internamente o array dinâmico, a adição / exclusão de elementos é lenta, pois é necessário muito deslocamento de bits. LinkedList é mais rápido no que diz respeito à adição / remoção de elementos, uma vez que nenhum deslocamento de bits é necessário. Menos sobrecarga de memória, pois em ArrayList apenas os dados reais são armazenados. Mais sobrecarga de memória, já que cada nó em LinkedList contém dados, bem como o endereço do próximo nó.
ArrayList vs LinkedList
Vamos agora discutir as várias diferenças entre um ArrayList e um LinkedList.
ArrayList LinkedList ArrayList implementa a interface List LinkedList implementa interfaces List e Deque. O armazenamento e o acesso de dados são eficientes em ArrayList. LinkedList é bom em manipular dados. ArrayList implementa internamente uma matriz dinâmica. LinkedList implementa internamente uma lista duplamente vinculada. Como o ArrayList implementa internamente o array dinâmico, a adição / exclusão de elementos é lenta, pois é necessário muito deslocamento de bits. LinkedList é mais rápido no que diz respeito à adição / remoção de elementos, uma vez que nenhum deslocamento de bits é necessário. Menos sobrecarga de memória, pois em ArrayList apenas os dados reais são armazenados. Mais sobrecarga de memória, já que cada nó em LinkedList contém dados, bem como o endereço do próximo nó.
perguntas frequentes
Q # 1) Como você converte um ArrayList em um Array em Java?
Responda: Para converter um ArrayList em um Array em Java, pode-se usar o método toArray () da API ArrayList que converte um determinado ArrayList em um Array.
Q # 2) Como você divide uma string e a armazena em um ArrayList em Java?
Responda: A string é dividida usando uma função split (). Este método retorna um Array de strings. Em seguida, usando o método Arrays.asList (), a matriz de string pode ser convertida em uma ArrayList de strings.
Q # 3) Qual é o tamanho padrão de um ArrayList?
Responda: Um objeto ArrayList criado sem especificar a capacidade tem um tamanho 0, pois não há elementos adicionados à lista. Mas a capacidade padrão deste ArrayList é 10.
Q # 4) Qual é a diferença entre length () e size () de ArrayList?
Responda: Um ArrayList não tem uma propriedade ou método length (). Ele fornece apenas o método size () que retorna o número total de elementos em ArrayList.
Q # 5) Qual é a diferença entre a capacidade e o tamanho do ArrayList?
Responda: ArrayList possui capacidade e tamanho. A capacidade é o tamanho total da ArrayList ou o número total de elementos que ela pode conter. Tamanho é o número de elementos ou locais que contêm dados.
Por exemplo, se a capacidade da ArrayList for 10 e seu tamanho for 5, isso significa que uma ArrayList pode conter até 10 elementos, mas no momento apenas 5 locais têm dados neles.
Conclusão
Neste tutorial, discutimos alguns dos conceitos adicionais relacionados a ArrayList, como converter ArrayList em uma string, lista, conjunto e vice-versa. Também discutimos as diferenças entre ArrayList e Vector, ArrayList e LinkedList, etc.
Em nosso próximo tutorial, pegaremos outra coleção e a aprenderemos completamente.
=> Verifique aqui para ver A-Z dos tutoriais de treinamento de Java aqui.
Leitura recomendada
- Tutorial Java String com String Buffer e String Builder
- Java ArrayList - Como declarar, inicializar e imprimir uma ArrayList
- Tutorial de reflexão Java com exemplos
- Tutorial de Java String | Métodos Java String com exemplos
- Threads Java com métodos e ciclo de vida
- Implantação Java: Criação e execução de arquivo JAR Java
- Java Basics: Java Syntax, Java Class e Core Java Concepts
- Java Virtual Machine: como a JVM ajuda na execução de aplicativos Java
