Looping

The primary looping statements in Java:

while Loop

In a while loop, a condition is evaluated before each iteration. If the condition is true, the block of code inside the loop is executed. This continues until the condition becomes false.

Here's a simple example:

int i = 0;

while(i < 5) {

    System.out.println(i);

    i++;

}

In this example, i is initially 0. The loop continues to print i and increment it by one as long as i is less than 5.


do-while Loop:

In a do-while loop, the block of code is executed once before the condition is checked. If the condition is true, the code block will execute again. This continues until the condition becomes false.

Here's a simple example:

int i = 0;

do {

    System.out.println(i);

    i++;

} while (i < 5);

In this example, even if i was initially 5 or greater, the code within the loop would still run once because the condition isn't checked until after the code block has been executed.


for Loop:

A for loop has three parts: the initialization, the condition, and the iteration. The loop continues to execute the block of code as long as the condition (checked before each iteration) is true. After each iteration, the iterator updates.


Here's a simple example:

for(int i = 0; i < 5; i++) {

    System.out.println(i);

}

In this example, i is initialized to 0, the loop continues as long as i is less than 5, and i increments by one after each iteration.


for-each Loop:

The for-each loop is used to iterate through arrays or collections. It is simpler and more readable than traditional for loops, especially when you want to iterate over all elements of an array/collection and don't need to know the index of each item.

Here's a simple example:

int[] numbers = {1, 2, 3, 4, 5};

for(int number : numbers) {

    System.out.println(number);

}

In this example, number takes on the value of each element in the numbers array, one by one, and the code within the loop is executed for each value.

The above are the primary loops in Java, and there are advanced concepts like iterators or stream API which allow for more complex types of iterations which are below:

Iterator:

An Iterator is an object that enables you to traverse through a collection and does not require you to know the number of elements in the collection.

Here's an example using the Iterator interface with an ArrayList:

import java.util.*;

ArrayList<String> list = new ArrayList<String>();

list.add("Alice");

list.add("Bob");

list.add("Charlie");

Iterator<String> it = list.iterator();

while(it.hasNext()) {

    String name = it.next();

    System.out.println(name);

}

In this example, an Iterator is used to traverse the ArrayList. The hasNext() method returns true if there is another element in the collection to process, and next() returns the next element.


ListIterator:

A ListIterator is similar to an Iterator, but it allows for bidirectional traversal of the list and also allows for the modification of elements.

Here's an example using the ListIterator interface with an ArrayList:

import java.util.*;

ArrayList<String> list = new ArrayList<String>();

list.add("Alice");

list.add("Bob");

list.add("Charlie");

ListIterator<String> lit = list.listIterator();

while(lit.hasNext()) {

    String name = lit.next();

    System.out.println(name);

}

while(lit.hasPrevious()) {

    String name = lit.previous();

    System.out.println(name);

}

In this example, a ListIterator is used to traverse the ArrayList in both forward and backward directions. The hasNext(), next(), hasPrevious(), and previous() methods are used for traversal.

Stream API:

Java 8 introduced the Stream API, which supports functional-style operations on streams of elements. The Stream API is used to process collections of objects. A stream is a sequence of objects that supports various methods that can be pipelined to produce the desired result.

Here's an example of using a Stream to filter and print elements:

import java.util.*;

List<String> list = Arrays.asList("Alice", "Bob", "Charlie", "David");

list.stream()

    .filter(name -> name.startsWith("A"))

    .forEach(System.out::println);

In this example, a Stream is used to filter and print the names that start with "A". The filter() method is used to filter data, and forEach() is used to iterate over the stream of elements.


Here are advanced methods for looping over collections and arrays, especially with the introduction of Java 8's Stream API. Here are a few examples:

Stream API:

Stream API is designed with a view to support functional programming. Stream API is used to process collections of objects and supports sequential and parallel processing.

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

numbers.stream()

       .filter(n -> n % 2 == 0)

       .forEach(System.out::println);

In this example, the stream() method is used to create a stream of elements from the list. The filter() method is used to filter out only even numbers, and the forEach() method is used to print each number.


Parallel Stream: 

Java 8 introduced the concept of parallel streams, which can leverage multi-core processors for improved performance.

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

numbers.parallelStream()

       .filter(n -> n % 2 == 0)

       .forEach(System.out::println);

Parallel streams can potentially speed up your code because they use multiple threads to perform operations simultaneously. However, they can also introduce complexity and might not always provide a speedup, depending on the task and number of available processors.


IntStream: 

If you're dealing with primitive int values, you can use an IntStream to avoid auto-boxing overhead.

IntStream.range(0, 10)

         .filter(n -> n % 2 == 0)

         .forEach(System.out::println);

The IntStream interface is a specialization of Stream for dealing with sequences of primitive int-valued elements.


Map.Entry:

If you want to iterate over a Map, you can use the Map.Entry interface.

Map<String, Integer> map = new HashMap<>();

map.put("one", 1);

map.put("two", 2);

map.put("three", 3);


for(Map.Entry<String, Integer> entry : map.entrySet()) {

    System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());

}

This example iterates over a Map, and for each key-value pair, it prints out the key and value.

Remember, each of these techniques is a tool with its own strengths and weaknesses, and the right one to use depends on your specific situation. For example, while parallel streams can speed up certain operations, they might not always be the right choice, especially for smaller datasets or operations where the ordering of elements matters.

Comments

Post a Comment

Popular posts from this blog

Wrapper

In Java, a wrapper class provides a way to wrap primitive data types into objects. It allows you to use the primitive data types as objects, enabling you to access their associated methods and utilize them in a more flexible manner. The wrapper classes are part of the java.lang package and provide classes for each of the primitive data types. Here's an example that demonstrates how to use a wrapper class in Java: ___________________________________________________________________________________ public class WrapperExample {     public static void main(String[] args) {         // Creating a wrapper object using the Integer wrapper class         Integer myInteger = new Integer(42);         // Accessing the value using wrapper object         int value = myInteger.intValue();         System.out.println( "Value: " + value);         // Using wrapper class methods         String binaryString = myInteger.toBinaryString(42);         System.out.println ("Binary: "
Read more

Conditional Statement

The basic conditional statements are if, if-else, and else-if, but as an intermediate or advanced Java developer, you should also know about the switch statement and the conditional (ternary) operator. If statement: This is the most basic form of control flow statement. It allows the program to decide to perform an action or not based on whether a condition is true or not. int age = 20; if (age > 18) {     System.out.println("You are an adult"); } In the above code, if the condition age > 18 is true, then the message "You are an adult" is printed. If the condition is false, nothing happens. If-Else statement: The if-else statement provides an alternative option if the if condition is false. int age = 15; if (age > 18) {     System.out.println("You are an adult"); } else {     System.out.println("You are not an adult"); } In this example, if age > 18 is false, then the message "You are not an adult" is printed. Else-If sta
Read more

DataType and Variable

Data Type And Variable: In Java, the fundamental components of any program include variables and data types. A variable is like a container that holds a value, and the data type specifies what kind of data that container can hold. Here is a simple analogy: you can think of a variable as a box and the data type as the label on the box that tells you what kind of items can be stored inside. Data Types Data types in Java are categorized into two types: Primitive Data Types: These include byte, short, int, long, float, double, boolean, and char. Non-Primitive Data Types (or Reference types): These include String, Array, Class, Interface, etc. Let's see a simple description for each primitive data type: byte: The byte data type is an 8-bit signed two's complement integer. It has a minimum value of -128 and a maximum value of 127 (inclusive). short: The short data type is a 16-bit signed two's complement integer. It has a minimum value of -32,768 and a maximum value of 32,767
Read more