Em Java, Lista é uma interface do Estrutura de coleção . Ele nos permite manter a coleção ordenada de objetos. As classes de implementação da interface List são ArrayList, LinkedList, Pilha , e Vetor . O ArrayList e o LinkedList são amplamente utilizados em Java . Nesta seção, aprenderemos como iterar uma lista em Java . Ao longo desta seção, usaremos ListaArray .
Java para Loop
- Básico para Loop
- Aprimorado para Loop
Iteradores Java
- Iterador
- ListIterator
Método Java forEach
grátis vs grátis
- Iterável.forEach()
- Stream.forEach()
Java para Loop
Básico para Loop
Java para loop é o loop de controle de fluxo mais comum para iteração. O loop for contém uma variável que atua como um número de índice. Ele é executado até que toda a lista não seja iterada.
Sintaxe:
for(initialization; condition; increment or decrement) { //body of the loop } IterateListExample1.java
import java.util.*; public class IterateListExample1 { public static void main(String args[]) { //defining a List List city = Arrays.asList('Boston', 'San Diego', 'Las Vegas', 'Houston', 'Miami', 'Austin'); //iterate list using for loop for (int i = 0; i <city.size(); i++) { prints the elements of list system.out.println(city.get(i)); } < pre> <p> <strong>Output</strong> </p> <pre> Boston San Diego Las Vegas Houston Miami Austin </pre> <h3>Enhanced for Loop</h3> <p>It is similar to the basic for loop. It is compact, easy, and readable. It is widely used to perform traversal over the List. It is easy in comparison to basic for loop.</p> <p> <strong>Syntax:</strong> </p> <pre> for(data_type variable : array | collection) { //body of the loop } </pre> <p> <strong>IterateListExample2.java</strong> </p> <pre> import java.util.*; public class IterateListExample2 { public static void main(String args[]) { //defining a List List city = Arrays.asList('Boston', 'San Diego', 'Las Vegas', 'Houston', 'Miami', 'Austin'); //iteration over List using enhanced for loop for (String cities : city) { //prints the elements of the List System.out.println(cities); } } } </pre> <p> <strong>Output</strong> </p> <pre> Boston San Diego Las Vegas Houston Miami Austin </pre> <h2>Java Iterator</h2> <h3>Iterator</h3> <p> <a href="/iterator-java">Java provides an interface Iterator</a> to <strong>iterate</strong> over the Collections, such as List, Map, etc. It contains two key methods next() and hasNaxt() that allows us to perform an iteration over the List.</p> <p> <strong>next():</strong> The next() method perform the iteration in forward order. It returns the next element in the List. It throws <strong>NoSuchElementException</strong> if the iteration does not contain the next element in the List. This method may be called repeatedly to iterate through the list, or intermixed with calls to previous() to go back and forth.</p> <p> <strong>Syntax:</strong> </p> <pre> E next() </pre> <p> <strong>hasNext():</strong> The hasNext() method helps us to find the last element of the List. It checks if the List has the next element or not. If the hasNext() method gets the element during traversing in the forward direction, returns true, else returns false and terminate the execution.</p> <p> <strong>Syntax:</strong> </p> <pre> boolean hasNext() </pre> <p> <strong>IterateListExample3.java</strong> </p> <pre> import java.util.*; public class IterateListExample3 { public static void main(String args[]) { //defining a List List city = Arrays.asList('Boston', 'San Diego', 'Las Vegas', 'Houston', 'Miami', 'Austin'); //iterate List using enhances for loop Iterator cityIterator = city.iterator(); //iterator over List using while loop while(cityIterator.hasNext()) { System.out.println(cityIterator.next()); } } } </pre> <p> <strong>Output</strong> </p> <pre> Boston San Diego Las Vegas Houston Miami Austin </pre> <h3>ListIterator</h3> <p>The ListIterator is also an interface that belongs to java.util package. It extends <strong>Iterator</strong> interface. It allows us to iterate over the List either in forward or backward order. The forward iteration over the List provides the same mechanism, as used by the Iterator. We use the next() and hasNext() method of the Iterator interface to iterate over the List.</p> <p> <strong>IterateListExample4.java</strong> </p> <pre> import java.util.*; public class IterateListExample4 { public static void main(String args[]) { //defining a List List city = Arrays.asList('Boston', 'San Diego', 'Las Vegas', 'Houston', 'Miami', 'Austin'); //iterate List using the ListIterator ListIterator listIterator = city.listIterator(); while(listIterator.hasNext()) { //prints the elements of the List System.out.println(listIterator.next()); } } } </pre> <p> <strong>Output</strong> </p> <pre> Boston San Diego Las Vegas Houston Miami Austin </pre> <h2>Java forEach Method</h2> <h3>Iterable.forEach()</h3> <p>The Iterable interface provides forEach() method to iterate over the List. It is available since Java 8. It performs the specified action for each element until all elements have been processed or the action throws an exception. It also accepts Lambda expressions as a parameter.</p> <p> <strong>Syntax:</strong> </p> <pre> default void forEach(Consumer action) </pre> <p>The default implementation behaves like:</p> <pre> for (T t : this) action.accept(t); </pre> <p>It accepts <strong>action</strong> as a parameter that is <strong>non-interfering</strong> (means that the data source is not modified at all during the execution of the stream pipeline) action to perform on the elements. It throws <strong>NullPointerException</strong> if the specified action is null.</p> <p>The <strong>Consumer</strong> is a functional interface that can be used as the assignment target for a lambda expression or method reference. T is the type of input to the operation. It represents an operation that accepts a single input argument and returns no result.</p> <p> <strong>IterateListExample5.java</strong> </p> <pre> import java.util.*; public class IterateListExample5 { public static void main(String args[]) { //defining a List List city = Arrays.asList('Boston', 'San Diego', 'Las Vegas', 'Houston', 'Miami', 'Austin'); //iterate List using forEach city.forEach(System.out::println); } } </pre> <p> <strong>Output</strong> </p> <pre> Boston San Diego Las Vegas Houston Miami Austin </pre> <h3>Stream.forEach()</h3> <p>Java Stream interface allows us to convert the List values into a stream. With the help of Stream interface we can access operations like forEach(), map(), and filter().</p> <p> <strong>Syntax:</strong> </p> <pre> void forEach(Consumer action) </pre> <p>It accepts <strong>action</strong> as a parameter that is <strong>non-interfering</strong> (means that the data source is not modified at all during the execution of the stream pipeline) action to perform on the elements.</p> <p>The <strong>Consumer</strong> is a functional interface that can be used as the assignment target for a lambda expression or method reference. T is the type of input to the operation. It represents an operation that accepts a single input argument and returns no result.</p> <p> <strong>IterateListExample5.java</strong> </p> <pre> import java.util.*; public class IterateListExample5 { public static void main(String args[]) { //defining a List List city = Arrays.asList('Boston', 'San Diego', 'Las Vegas', 'Houston', 'Miami', 'Austin'); //iterate List using forEach loop city.stream().forEach((c) -> System.out.println(c)); } } </pre> <p> <strong>Output</strong> </p> <pre> Boston San Diego Las Vegas Houston Miami Austin </pre> <hr></city.size();> Aprimorado para Loop
É semelhante ao loop for básico. É compacto, fácil e legível. É amplamente utilizado para realizar travessia na lista. É fácil em comparação com o loop for básico.
Sintaxe:
for(data_type variable : array | collection) { //body of the loop } IterateListExample2.java
import java.util.*; public class IterateListExample2 { public static void main(String args[]) { //defining a List List city = Arrays.asList('Boston', 'San Diego', 'Las Vegas', 'Houston', 'Miami', 'Austin'); //iteration over List using enhanced for loop for (String cities : city) { //prints the elements of the List System.out.println(cities); } } } Saída
Boston San Diego Las Vegas Houston Miami Austin
Iterador Java
Iterador
Java fornece um iterador de interface para iterar sobre as coleções, como List, Map, etc. Ele contém dois métodos principais next() e hasNaxt() que nos permitem realizar uma iteração sobre a lista.
próximo(): O método next() executa a iteração em ordem direta. Ele retorna o próximo elemento da lista. Isso joga NoSuchElementException se a iteração não contiver o próximo elemento na Lista. Este método pode ser chamado repetidamente para percorrer a lista ou misturado com chamadas para previous() para ir e voltar.
Sintaxe:
host linux
E next()
hasNext(): O método hasNext() nos ajuda a encontrar o último elemento da Lista. Verifica se a Lista possui o próximo elemento ou não. Se o método hasNext() obtiver o elemento durante a travessia na direção direta, retornará verdadeiro, caso contrário, retornará falso e encerrará a execução.
Sintaxe:
boolean hasNext()
IterateListExample3.java
import java.util.*; public class IterateListExample3 { public static void main(String args[]) { //defining a List List city = Arrays.asList('Boston', 'San Diego', 'Las Vegas', 'Houston', 'Miami', 'Austin'); //iterate List using enhances for loop Iterator cityIterator = city.iterator(); //iterator over List using while loop while(cityIterator.hasNext()) { System.out.println(cityIterator.next()); } } } Saída
Boston San Diego Las Vegas Houston Miami Austin
ListIterator
O ListIterator também é uma interface que pertence ao pacote java.util. Ele se estende Iterador interface. Isso nos permite iterar na lista em ordem progressiva ou inversa. A iteração direta sobre a Lista fornece o mesmo mecanismo usado pelo Iterador. Usamos os métodos next() e hasNext() da interface Iterator para iterar na Lista.
IterateListExample4.java
import java.util.*; public class IterateListExample4 { public static void main(String args[]) { //defining a List List city = Arrays.asList('Boston', 'San Diego', 'Las Vegas', 'Houston', 'Miami', 'Austin'); //iterate List using the ListIterator ListIterator listIterator = city.listIterator(); while(listIterator.hasNext()) { //prints the elements of the List System.out.println(listIterator.next()); } } } Saída
Boston San Diego Las Vegas Houston Miami Austin
Método Java forEach
Iterável.forEach()
A interface Iterable fornece o método forEach() para iterar na Lista. Está disponível desde Java 8. Ele executa a ação especificada para cada elemento até que todos os elementos tenham sido processados ou a ação gere uma exceção. Ele também aceita expressões Lambda como parâmetro.
Sintaxe:
default void forEach(Consumer action)
A implementação padrão se comporta como:
for (T t : this) action.accept(t);
Aceita Ação como um parâmetro que é não interferente (significa que a fonte de dados não é modificada durante a execução do pipeline de fluxo) ação a ser executada nos elementos. Isso joga Null Pointer Exception se a ação especificada for nula.
O Consumidor é uma interface funcional que pode ser usada como destino de atribuição para uma expressão lambda ou referência de método. T é o tipo de entrada para a operação. Representa uma operação que aceita um único argumento de entrada e não retorna nenhum resultado.
IterateListExample5.java
import java.util.*; public class IterateListExample5 { public static void main(String args[]) { //defining a List List city = Arrays.asList('Boston', 'San Diego', 'Las Vegas', 'Houston', 'Miami', 'Austin'); //iterate List using forEach city.forEach(System.out::println); } } Saída
Boston San Diego Las Vegas Houston Miami Austin
Stream.forEach()
A interface Java Stream nos permite converter os valores de List em um stream. Com a ajuda da interface Stream podemos acessar operações como forEach(), map() e filter().
como renomear um diretório linux
Sintaxe:
void forEach(Consumer action)
Aceita Ação como um parâmetro que é não interferente (significa que a fonte de dados não é modificada durante a execução do pipeline de fluxo) ação a ser executada nos elementos.
O Consumidor é uma interface funcional que pode ser usada como destino de atribuição para uma expressão lambda ou referência de método. T é o tipo de entrada para a operação. Representa uma operação que aceita um único argumento de entrada e não retorna nenhum resultado.
IterateListExample5.java
import java.util.*; public class IterateListExample5 { public static void main(String args[]) { //defining a List List city = Arrays.asList('Boston', 'San Diego', 'Las Vegas', 'Houston', 'Miami', 'Austin'); //iterate List using forEach loop city.stream().forEach((c) -> System.out.println(c)); } } Saída
Boston San Diego Las Vegas Houston Miami Austin