What Are Lambda Expressions?

Lambda expressions eliminate the need for verbose anonymous classes when implementing functional interfaces. With Lambda, you can write cleaner and more expressive code.

For example, before Java 8, implementing a functional interface required writing a separate class:

Code Without Lambda Expressions:

interface FunctionalInterfaceExample {
    void abstractMethod(String str);
}
class InterfaceImplementation implements FunctionalInterfaceExample {
    @Override
    public void abstractMethod(String str) {
        System.out.println(str.length());
    }
}
public class Main {
    public static void main(String[] args) {
        FunctionalInterfaceExample pie = new InterfaceImplementation();
        pie.abstractMethod("String Example");
    }
}

With Lambda Expressions, the same functionality can be achieved concisely:

Code With Lambda Expressions:

interface FunctionalInterfaceExample {
    void abstractMethod(String str);
}
public class Main {
    public static void main(String[] args) {
        FunctionalInterfaceExample pie = (x) -> System.out.println(x.length());
        pie.abstractMethod("String Example");
    }
}

Syntax of Lambda Expressions

The general syntax of a lambda expression is:

(arguments) -> {body of the expression}Components of Lambda Expressions:

1. Arguments: Parameters passed to the method.
2. Arrow Token (->): Separates the arguments from the body.
3. Body: Logic to be executed.

Example:

(int a) -> System.out.println(a * 2);

Types of Lambda Expressions

Based on Lines of Code:

1. Single-line Lambda: Contains a single statement.
   Example:

() -> System.out.println("Hello World");

2. Block Lambda: Contains multiple statements enclosed in braces {}.
Example:

() -> {     
  System.out.println("Hello");     
  System.out.println("World"); 
};

Based on Parameters:

1. Zero Parameter: Lambda expression with no arguments.

() -> System.out.println("Zero parameter lambda");

2. Single Parameter: Lambda expression with one argument.

(x) -> System.out.println("Single parameter: " + x); 
// Parentheses can be omitted if there's one parameter 
x -> System.out.println("Single parameter: " + x);

3. Multiple Parameters: Lambda expression with more than one argument.

(x, y) -> System.out.println("Multiple parameters: " + x + y);

Examples Using Lambda Expressions

Below is an example demonstrating the use of zero, single, and multiple-parameter Lambda expressions:

interface FunctionalInterfaceNoParam {
    void noParamMethod();
}
interface FunctionalInterfaceOneParam {
    void oneParam(String str);
}
interface FunctionalInterfaceMultipleParam {
    void multiParamMethod(String a, String b);
}
public class Main {
    public static void main(String[] args) {
        FunctionalInterfaceNoParam noParam = () -> System.out.println("No Parameter Lambda Example");
        noParam.noParamMethod();
        
        FunctionalInterfaceOneParam singleParam = (str) -> System.out.println(str);
        singleParam.oneParam("Single Parameter Lambda Example");
        
        FunctionalInterfaceOneParam singleParam1 = str -> System.out.println(str);
        singleParam1.oneParam("Single Parameter Lambda Example");
        
        FunctionalInterfaceMultipleParam multiParam = (a, b) -> System.out.println(a + b);
        multiParam.multiParamMethod("Multi", " Param");
    }
}

Output:

No Parameter Lambda Example
Single Parameter Lambda Example
Single Parameter Lambda Example
Multi Param

Using Predefined Functional Interfaces

Instead of creating custom functional interfaces, we can use predefined functional interfaces like Runnable, Consumer, and BiConsumer.

Example:

import java.util.function.Consumer;
import java.util.function.BiConsumer;
public class Main {
    public static void main(String[] args) {
        Runnable noParamPredefined = () -> System.out.println("No Parameter Predefined Example");
        noParamPredefined.run();
        
        Consumer<String> singleParamPredefined = str -> System.out.println(str);
        singleParamPredefined.accept("Single Parameter Predefined Example");
        
        BiConsumer<String, String> multiParamPredefined = (a, b) -> System.out.println(a + b);
        multiParamPredefined.accept("Multi", " Param Predefined");
    }
}

Output:

No Parameter Predefined Example  
Single Parameter Predefined Example  
Multi Param Predefined

Lambda Expressions With Collections

Lambda expressions can be seamlessly used with Collections for operations like iteration.

1. Using List:

import java.util.ArrayList;
import java.util.List;
public class Main {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.forEach(x -> System.out.println("The value is " + x));
    }
}

2. Using Set:

import java.util.HashSet;
import java.util.Set;
public class Main {
    public static void main(String[] args) {
        Set<Integer> set = new HashSet<>();
        set.add(1);
        set.add(2);
        set.forEach(x -> System.out.println("The value is " + x));
    }
}

3. Using Map:

import java.util.HashMap;
import java.util.Map;
public class Main {
    public static void main(String[] args) {
        Map<Integer, Character> map = new HashMap<>();
        map.put(1, 'a');
        map.put(2, 'b');
        map.forEach((key, value) -> {
            System.out.println("Key: " + key + ", Value: " + value);
        });
    }
}

Scope of Variables

1. We cannot modify a variable directly inside a lambda expression unless it is effectively final, the code is an example.

2. The variable can be accessed by just creating a local variable and providing our actual output.

3. The variable can be modified but it has to be assigned to a local variable of lambda body, We can perform the task but it won’t modify the count variable.

4. Now to increment the value of count, we’ll have to use multithreading concepts. Like here we can try to use AtomicInteger.

Conclusion

Lambda Expressions in Java 8 have revolutionized the way functional programming is approached. By introducing a concise and readable syntax, they enable developers to simplify the implementation of functional interfaces. Whether you’re working with single-line expressions or handling multiple parameters, Lambdas empower you to write cleaner, more expressive code. They are especially useful when combined with Java’s predefined functional interfaces and Collections API, making tasks like iteration and data processing seamless.

Furthermore, understanding the scope of variables in Lambda expressions is key to effectively utilizing them, especially when dealing with multithreading or shared state.

As we move forward, exploring the scope of variables in Lambda expressions will enhance your understanding of how to manage variables within functional programming paradigms.

• A Functional Interface is a type of interface that contains only one abstract method.
• It was introduced in Java 8 to support functional programming.
• Functional Interfaces are designed to fulfil a single purpose.

Defining a Functional Interface

There are multiple ways to define a Functional Interface:

1. Creating an Interface with One Abstract Method

• Create an interface with one abstract method.
• Problem: Without additional safeguards, adding more than one abstract method is possible, violating the core definition of a Functional Interface.
• To prevent this issue, the @FunctionalInterface annotation was introduced.

interface Person {
    void hello();
}

2. Using the @FunctionalInterface Annotation

• When you use the @FunctionalInterface annotation, it enforces that the interface contains only one abstract method.
• This helps ensure the correct use of the Functional Interface and prevents accidental additions of more abstract methods.

@FunctionalInterface
interface Person {
    void hello();
    
    static String helloFromString() {
        return "Hello from interface String";
    }
}

3. Functional Interfaces with Return Values

• A Functional Interface can have an abstract method that returns a value based on requirements.

@FunctionalInterface
interface Person {
    String hello();
    
    static String helloFromString() {
        return "Hello from interface String";
    }
}

4. Functional Interfaces with Parameters

• A Functional Interface can also have an abstract method that accepts parameters.

@FunctionalInterface
interface Person {
    String hello(String str);
    
    static String helloFromString() {
        return "Hello from interface String";
    }
}

Functional Interfaces: Static, Default Methods, and Extensions

As the name suggests, a Functional Interface can only have one abstract method. However, it is allowed to have multiple static or default methods without violating its definition.

Example with Static and Default Methods

@FunctionalInterface
interface Person {
    void hello(); // abstract method
    static String helloFromString1() {
        return "Hello from interface String 1";
    }
    static String helloFromString2() {
        return "Hello from interface String 2";
    }
    default void defaultExample1() {
        System.out.println("Default Example 1");
    }
    default void defaultExample2() {
        System.out.println("Default Example 2");
    }
}

In the example above, the Person interface is still a valid Functional Interface because it has only one abstract method, hello(), even though it includes multiple static and default methods.

Extending a Functional Interface

A Functional Interface can be extended by another interface without violating its definition. However, the child interface must ensure it doesn’t add additional abstract methods if it wants to remain a Functional Interface.

Example: Extending a Functional Interface

@FunctionalInterface
interface Person {
    void hello();  // abstract method
    static String helloFromString1() {
        return "Hello from interface String 1";
    }
    static String helloFromString2() {
        return "Hello from interface String 2";
    }
    default void defaultExample1() {
        System.out.println("Default Example 1");
    }
    default void defaultExample2() {
        System.out.println("Default Example 2");
    }
}

interface Male extends Person {
    void world(); // abstract method
    default void defaultMale() {
        System.out.println("Default Male Example");
    }
}

In this example, the Male interface extends the Person interface and introduces a new abstract method, world(). This makes Male a non-functional interface, while Person remains a Functional Interface.

Making the Child Interface a Functional Interface

To make the Male interface a Functional Interface, we can simply remove the additional abstract method (world()):

interface Male extends Person {
    default void defaultMale() {
        System.out.println("Default Male Example");
    }
}

Now, Male inherits the single abstract method hello() from Person and satisfies the criteria for being a Functional Interface.

Using a Functional Interface with Lambda Expressions

The real power of Functional Interfaces lies in their usage with Lambda Expressions. Lambda expressions allow you to define the abstract method’s implementation concisely without creating an explicit class.

Example: Functional Interface with a Lambda Expression

@FunctionalInterface
interface Person {
    void hello();
}

public class Main {
    public static void main(String[] args) {
        Person lam = () -> System.out.println("Lambda from Person");
        lam.hello();
    }
}

Explanation:

• In the example above, no concrete implementation class for Person was created.
• The hello() the method is implemented directly using a Lambda Expression.
• The output will be:

Lambda from Person

Lambda Expressions Overview

Lambda expressions provide a concise way to represent a method in a Functional Interface, enabling functional programming in Java. In the next chapter, we'll explore lambda expressions in detail.

Predefined Functional Interfaces in Java

Java provides several predefined functional interfaces under the java.util.function package. These interfaces can be directly used without the need to create custom functional interfaces.

Below are some commonly used predefined functional interfaces:

1. Function<T, R>

• Represents a function that takes one argument of type T and produces a result of type R.
• Example:

import java.util.function.Function;  
public class Main {     
  public static void main(String[] args) {         
    Function<String, Integer> function = str -> str.length();         
    System.out.println(function.apply("hello"));     
  } 
}

• Output:

5

2. BiFunction<T, U, R>

• Represents a function that takes two arguments of types T and U and produces a result of type R.
• Example:

import java.util.function.BiFunction;  
public class Main {     
  public static void main(String[] args) {         
    BiFunction<String, String, String> function = (a, b) -> a + b;         
    System.out.println(function.apply("hello", "world"));     
  } 
}

• Output:

helloworld

3. Consumer<T>

• Represents an operation that takes a single argument of type T and performs some operation without returning a result.
• Example:

import java.util.function.Consumer;  
public class Main {     
  public static void main(String[] args) {         
    Consumer<String> function = str -> System.out.println(str);         
    function.accept("hello");     
  } 
}

• Output:

hello

4. BiConsumer<T, U>

• Represents an operation that takes two arguments of types T and U and performs an operation without returning a result.
• Example:

import java.util.function.BiConsumer;  
public class Main {     
  public static void main(String[] args) {         
    BiConsumer<String, Integer> function = (str, number) -> System.out.println(String.format("The string is %s and the number is %d", str, number));         
    function.accept("hello", 3);     
  } 
}

• Output:

The string is hello and the number is 3

5. Supplier<T>

• Represents a supplier of results. It does not take any arguments but produces a result of type T.
• Example:

import java.util.function.Supplier;  
public class Main {     
  public static void main(String[] args) {         
    Supplier<String> function = () -> "I am a message from the Supplier";
    System.out.println(function.get());     
  } 
}

• Output:

I am a message from the Supplier

6. Predicate<T>

• Represents a predicate (a boolean-valued function) that takes one argument of type T.
• Example:

import java.util.function.Predicate;  
public class Main {     
   public static void main(String[] args) {         
      Predicate<Integer> function = in -> in % 2 == 0;         
      System.out.println(function.test(6)); // true         
      System.out.println(function.test(7)); // false     
    } 
}

• EOutput:

true 
false

7. BiPredicate<T, U>

• Represents a predicate (a boolean-valued function) that takes two arguments of types T and U.
• Example:

import java.util.function.BiPredicate;  
public class Main {     
  public static void main(String[] args) {         
    BiPredicate<Integer, Integer> function = (a, b) -> a % b == 0;         
    System.out.println(function.test(6, 3)); // true         
    System.out.println(function.test(7, 2)); // false     
  } 
}

• Output:

true 
false

8. UnaryOperator<T>

• Represents an operation on a single operand that produces a result of the same type as the operand.
• Example:

import java.util.function.UnaryOperator;  
public class Main {     
  public static void main(String[] args) {         
    UnaryOperator<Integer> function = a -> a * a;         
    System.out.println(function.apply(2)); // 4     
  } 
}

• Output:

4

9. BinaryOperator<T>

• Represents an operation on two operands of the same type, producing a result of the same type.
• Example:

import java.util.function.BinaryOperator;  
public class Main {     
  public static void main(String[] args) 
  {         
    BinaryOperator<Integer> function = (a, b) -> a * b;         
    System.out.println(function.apply(3, 2)); // 6     
  } 
}

• Output:

6

Summary Chart of Functional Interfaces in java.util.function

Here is a comprehensive summary of all the functional interfaces in the java.util.function package:

+---------------------+-------------------------------------------------------------+------------------------+-------------+---------------------------------------------------+
|      Interface      |                           Purpose                           |    Abstract Method     | Utilization |                 Example Use Case                  |
+---------------------+-------------------------------------------------------------+------------------------+-------------+---------------------------------------------------+
| Function<T, R>      | Transforms an input of type T into an output of type R.     | R apply(T t)           | apply()     | Converting a string to its length.                |
| BiFunction<T, U, R> | Transforms two inputs (T, U) into an output of type R.      | R apply(T t, U u)      | apply()     | Concatenating two strings.                        |
| Consumer<T>         | Performs an operation on a single input of type T.          | void accept(T t)       | accept()    | Printing a message.                               |
| BiConsumer<T, U>    | Performs an operation on two inputs (T, U).                 | void accept(T t, U u)  | accept()    | Printing a string with a number.                  |
| Supplier<T>         | Supplies a value with no input.                             | T get()                | get()       | Providing a default value or lazy initialization. |
| Predicate<T>        | Evaluates a boolean condition for a single input of type T. | boolean test(T t)      | test()      | Checking if a number is even.                     |
| BiPredicate<T, U>   | Evaluates a boolean condition for two inputs (T, U).        | boolean test(T t, U u) | test()      | Checking divisibility of two numbers.             |
| UnaryOperator<T>    | Represents an operation on a single operand of type T.      | T apply(T t)           | apply()     | Squaring a number.                                |
| BinaryOperator<T>   | Represents an operation on two operands of the same type T. | T apply(T t1, T t2)    | apply()     | Multiplying two numbers.                          |
+---------------------+-------------------------------------------------------------+------------------------+-------------+---------------------------------------------------+

Conclusion

The java.util.function package provides a rich set of predefined functional interfaces that simplify functional programming in Java. These interfaces enable concise and expressive code, especially when combined with Lambdas and the Stream API. By leveraging these functional interfaces, developers can perform common operations such as data transformation, filtering, and result generation with minimal effort.

Next Topic: Lambda Expressions

The next topic, Lambda Expressions, dives deeper into how these functional interfaces are implemented in Java. Lambda expressions allow us to write functional interface implementations compactly and elegantly, eliminating the need for verbose anonymous inner classes. We’ll explore the syntax, use cases, and how Lambdas enhance functional programming in Java.

Stay tuned for a hands-on exploration of Lambda expressions!

What is a List in Java?
The List interface in Java, part of the java.util package, extends the Collection interface. It is designed to store ordered collections of elements, allowing you to manage data sequentially.

What are the advantages of using a List?
1. It maintains the order of elements as they are added.
2. Allows insertion of duplicate elements.
3. Can include null values, depending on the implementation.
4. ListIterator, helps to traverse through the list in both directions.

Implement a List in Java?
List<Obj>list = new ArrayList<>();
Here Obj is the type of Object and It can be any class or Object of your choice.

Types of List in Java
1. ArrayList: It is a resizeable array implementation of the List interface, which allows fast random access but slower insertion or deletion compared to LinkedList. It is suitable for applications that require frequent access to elements by index.
2. LinkedList: It is a doubly-linked list implementation of the List interface, allowing faster insertion and deletion than ArrayList slower random access. It is ideal for applications that require frequent insertion and deletion of elements.
3. Vector: A synchronized, resizable array implementation of the List interface. It is thread-safe due to the synchronization overhead. It is ideal for applications that require thread-safe operations on lists.
4. Stack: A subclass that implements a last-in, first-out (LIFO) stack, which provides operations like push, pop and peek making it useful for stack operations.

Operations available in List:
The List of operations available in List are:
1. size()
2. isEmpty()
3. contains(Object o)
4. iterator()
5. toArray()
6. add(E e)
7. remove(Object o)
8. containsAll(Collection<?> c)
9. add(Collection<? extends E> c)
10. add(int index, Collection<? extends E> c)
11. removeAll(Collection<?> c)
12. retainAll(Collection<?> c)
13. sort(Comparator<? super E> c)
14. equals(Object o)
15. clear()
16. hashCode()
17. E get(int index)
18. E set(int index, E element)
19. void add(int index, E element)
20. int indexOf(Object o)
21. E remove(int index)
22. int lastIndexOf(Object o)
23. ListIterator<E> listIterator()
24. ListIterator<E> listIterator(int index)
25. List<E> subList(int fromIndex, int toIndex)
26. <E> List<E> of(E e1, E e2)
27. static <E> List<E> copyOf(Collection<? extends E> coll)
and many more which can be seen in the package java.util;

Let us Dive into implementing the code for all of the above.

Problem statement 1: write a code showcasing to create a LinkedList
Solution (Way 1): Versions before Java 10 had to add all the data sequences by increasing the code's length.

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> listOfIntegers = new ArrayList<>();
        listOfIntegers.add(1);
        listOfIntegers.add(2);
        listOfIntegers.add(3);
        listOfIntegers.add(4);
        listOfIntegers.add(5);
        listOfIntegers.forEach(System.out::println);
    }
}

Solution (Way 2): Versions from Java 10 had received an of method in the List interface which reduced the code significantly.

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> listOfIntegers = new ArrayList<>(List.of(1,2,3,4,5,6,7));
        listOfIntegers.forEach(System.out::println);
    }
}

Problem statement 2: write a code in Java to show the use of List and perform several operations on it.
Solution: Please follow the comments to understand each line of code

package com.journaldev.collections.linkedlist.example1;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> listOfIntegers = new ArrayList<>(List.of(1,2,3,4,4,5,6,7));
        System.out.println("Initial list: " + listOfIntegers);

        //To add data to the list
        listOfIntegers.add(8);
        System.out.println("After adding 8: " + listOfIntegers);

        // To remove data from the list using index
        listOfIntegers.remove(0);
        System.out.println("After removing element at index 0: " + listOfIntegers);

        // To remove data based on value
        listOfIntegers.remove(Integer.valueOf(8));
        System.out.println("After removing value 8: " + listOfIntegers);

        // To get data from the list
        System.out.println("Element at index 0: " + listOfIntegers.get(0));

        // To get the size of the list
        System.out.println("Size of list: " + listOfIntegers.size());

        // To check if the list is empty
        System.out.println("Is list empty: " + listOfIntegers.isEmpty());

        // To check if the list contains a particular value
        System.out.println("Does list contain 2: " + listOfIntegers.contains(2));

        // To add a data in the index
        listOfIntegers.add(0, 0);
        System.out.println("After adding 0 at index 0: " + listOfIntegers);

        // To get the first element of the list
        System.out.println("First element: " + listOfIntegers.getFirst());

        // To get the last element of the list
        System.out.println("Last element: " + listOfIntegers.getLast());

        // To get the index of a particular element
        System.out.println("Index of 2: " + listOfIntegers.indexOf(2));

        // To get the index of a particular element
        System.out.println("Index of 4: " + listOfIntegers.indexOf(4));

        // To get the last index of a particular element
        System.out.println("Last index of 2: " + listOfIntegers.lastIndexOf(2));

        // To get the sublist from the list
        System.out.println("Sublist from index 0 to 2: " + listOfIntegers.subList(0, 2));

        // To replace the element at a particular index
        listOfIntegers.set(0, 1);
        System.out.println("After replacing element at index 0 with 1: " + listOfIntegers);

        System.out.print("Final list elements: " + listOfIntegers);
    }
}

Output is:

Initial list: [1, 2, 3, 4, 4, 5, 6, 7]
After adding 8: [1, 2, 3, 4, 4, 5, 6, 7, 8]
After removing element at index 0: [2, 3, 4, 4, 5, 6, 7, 8]
After removing value 8: [2, 3, 4, 4, 5, 6, 7]
Element at index 0: 2
Size of list: 7
Is list empty: false
Does list contain 2: true
After adding 0 at index 0: [0, 2, 3, 4, 4, 5, 6, 7]
First element: 0
Last element: 7
Index of 2: 1
Index of 4: 3
Last index of 2: 1
Sublist from index 0 to 2: [0, 2]
After replacing element at index 0 with 1: [1, 2, 3, 4, 4, 5, 6, 7]
Final list elements: 12344567

Problem statement 3: write a code in Java to show the difference in operation speeds while reading or insertion and deletion in ArrayList, Vectors and LinkedList.
Solution: Please follow the comments to understand each line of code

package com.journaldev.collections.linkedlist.example1;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Vector;

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> arrayList = new ArrayList<>();
        LinkedList<Integer> linkedList = new LinkedList<>();
        Vector<Integer> vector = new Vector<>();

        // Test insertion at end
        long startTime = System.nanoTime();
        for(int i = 0; i < 100000; i++) {
            arrayList.add(i);
        }
        long endTime = System.nanoTime();
        System.out.println("Time taken for ArrayList insertion at end: " + (endTime - startTime) + " ns");

        startTime = System.nanoTime();
        for(int i = 0; i < 100000; i++) {
            linkedList.add(i);
        }
        endTime = System.nanoTime();
        System.out.println("Time taken for LinkedList insertion at end: " + (endTime - startTime) + " ns");

        startTime = System.nanoTime();
        for(int i = 0; i < 100000; i++) {
            vector.add(i);
        }
        endTime = System.nanoTime();
        System.out.println("Time taken for Vector insertion at end: " + (endTime - startTime) + " ns");

        // Test insertion at beginning
        startTime = System.nanoTime();
        for(int i = 0; i < 1000; i++) {
            arrayList.add(0, i);
        }
        endTime = System.nanoTime();
        System.out.println("Time taken for ArrayList insertion at beginning: " + (endTime - startTime) + " ns");

        startTime = System.nanoTime();
        for(int i = 0; i < 1000; i++) {
            linkedList.addFirst(i);
        }
        endTime = System.nanoTime();
        System.out.println("Time taken for LinkedList insertion at beginning: " + (endTime - startTime) + " ns");

        startTime = System.nanoTime();
        for(int i = 0; i < 1000; i++) {
            vector.add(0, i);
        }
        endTime = System.nanoTime();
        System.out.println("Time taken for Vector insertion at beginning: " + (endTime - startTime) + " ns");

        // Test random access
        startTime = System.nanoTime();
        for(int i = 0; i < 1000; i++) {
            arrayList.get(i);
        }
        endTime = System.nanoTime();
        System.out.println("Time taken for ArrayList random access: " + (endTime - startTime) + " ns");

        startTime = System.nanoTime();
        for(int i = 0; i < 1000; i++) {
            linkedList.get(i);
        }
        endTime = System.nanoTime();
        System.out.println("Time taken for LinkedList random access: " + (endTime - startTime) + " ns");

        startTime = System.nanoTime();
        for(int i = 0; i < 1000; i++) {
            vector.get(i);
        }
        endTime = System.nanoTime();
        System.out.println("Time taken for Vector random access: " + (endTime - startTime) + " ns");

        // Test deletion from beginning
        startTime = System.nanoTime();
        for(int i = 0; i < 1000; i++) {
            arrayList.remove(0);
        }
        endTime = System.nanoTime();
        System.out.println("Time taken for ArrayList deletion from beginning: " + (endTime - startTime) + " ns");

        startTime = System.nanoTime();
        for(int i = 0; i < 1000; i++) {
            linkedList.removeFirst();
        }
        endTime = System.nanoTime();
        System.out.println("Time taken for LinkedList deletion from beginning: " + (endTime - startTime) + " ns");

        startTime = System.nanoTime();
        for(int i = 0; i < 1000; i++) {
            vector.remove(0);
        }
        endTime = System.nanoTime();
        System.out.println("Time taken for Vector deletion from beginning: " + (endTime - startTime) + " ns");
    }
}

Time taken for ArrayList insertion at end: 7714000 ns
Time taken for LinkedList insertion at end: 15606800 ns
Time taken for Vector insertion at end: 10998900 ns
Time taken for ArrayList insertion at beginning: 28226200 ns
Time taken for LinkedList insertion at beginning: 147900 ns
Time taken for Vector insertion at beginning: 26981300 ns
Time taken for ArrayList random access: 74400 ns
Time taken for LinkedList random access: 2685300 ns
Time taken for Vector random access: 45900 ns
Time taken for ArrayList deletion from beginning: 24694500 ns
Time taken for LinkedList deletion from beginning: 93200 ns
Time taken for Vector deletion from beginning: 18161300 ns

As it can be seen the difference between the different List Implementation are compared below.

1. ArrayList performs the best with the lowest time (7,714,000).
2. LinkedList is the slowest (15,606,800), likely due to its need to traverse the list to find the end.
3. Vector is in between (10,998,900), but still slower than ArrayList.
4. LinkedList excels with the lowest time (147,900) due to its efficient handling of insertions at the beginning.
5. ArrayList and Vector are significantly slower (28,226,200 and 26,981,300, respectively) because they need to shift all elements to accommodate the new element.
6. ArrayList and Vector perform similarly well (74,400 and 45,900, respectively) due to their array-based structure, which allows fast random access.
7. LinkedList is much slower (2,685,300) because it needs to traverse the list to access elements randomly.
8. LinkedList is the fastest (93,200) due to its efficient handling of deletions at the beginning.
9. ArrayList and Vector are slower (24,694,500 and 18,161,300, respectively) because they need to shift all elements after the deletion.

Problem Statement 4: Write the program in Java to create a department class and show the use of an iterator
Solution:

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

class Department {
    private String name;
    private List<String> employees;

    public Department(String name) {
        this.name = name;
        this.employees = new ArrayList<>();
    }

    public void addEmployee(String employee) {
        employees.add(employee);
    }

    public Iterator<String> getEmployeeIterator() {
        return employees.iterator();
    }

    public String getName() {
        return name;
    }
}

public class Main {
    public static void main(String[] args) {
        // Create department
        Department dept = new Department("Engineering");

        // Add employees
        dept.addEmployee("John");
        dept.addEmployee("Mary");
        dept.addEmployee("Steve");

        // Get iterator
        Iterator<String> iterator = dept.getEmployeeIterator();

        // Iterate through employees
        System.out.println("Employees in " + dept.getName() + " department:");
        while(iterator.hasNext()) {
            String employee = iterator.next();
            System.out.println(employee);
        }

        // Use iterator to remove an employee
        iterator = dept.getEmployeeIterator();
        while(iterator.hasNext()) {
            String employee = iterator.next();
            if(employee.equals("Mary")) {
                iterator.remove();
            }
        }

        // Print remaining employees
        System.out.println("\nEmployees after removal:");
        iterator = dept.getEmployeeIterator();
        while(iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

Employees in Engineering department:
John
Mary
Steve

Employees after removal:
John
Steve

I went through a lot of blogs and posts on the internet as well as tutorials on youtube but was not able to find anything feasible for my work.

Introduction

Our app is built in Angular and Spring boot you can find the code here: Github

Let’s get started.

Let’s take an insight into the application:

1. The application’s Frontend is built in Angular
2. The application’s Backend is built in Spring boot
3. We are going to use Docker for the deployment
4. You can find the docker-compose.yml that contains the run configuration
5. We’ll deploy the code on Azure app services

I guess now we are ready to dive into the code

Dive in Practical

Step 1: create a folder, open in vs code and clone the directory

git clone https://github.com/Nikhil8bph/deployment.git .

Step 2: Install Azure cli from here

Step 3: open a new terminal in Visual Studio Studio Code and run the following command to log in to azure

az login

Step 4: Now we need to create a resource group and for that we can use the following command

az group create --name demoaci --location centralindia

• Resource Group: demoaci
• Location: centralindia

depending on the name you like and the region, the above configurations can be changed

Step 5: In this step we need to build a docker repository, using the following command

az acr create --resource-group demoaci --name demoacirepo --sku Basic

• Resource Group: demoaci
• Repository name: demoacirepo
• SKU: Basic

Step 6: Log in to the repository created above with name demoacirepo

az acr login --name demoacirepo

Step 7: Enable admin sign-in to this repository

az acr update -n demoacirepo --admin-enabled true

Step 8: Adding tags to the image

Our compose file looks like this and now we need to add docker tags to the image

The image tags will look like this `reponame.azure.io/image-name’

Step 9: Time to build docker image

docker-compose up --build -d

Step 10: check the image if it’s running

docker ps

Step 11: stop docker-compose

docker-compose down

Step 12: push the images to Azure Container Repository

docker-compose push

Step 13: login to docker azure

docker login azure

Step 14: create docker context for azure container instance followed by use, in my case context is already present so it may not look similar to yours

docker context create aci myacicontext

docker context use myacicontext

Step 15: Now let’s start the docker in Azure Container Instance

docker compose up

Step 15: Time to check the app linkAzure Container Instance

docker ps

Step 16: Hey, got our app running successfully :)

Step 17: If you find any error as shown below

Use the command given below to change context to default

docker context use default

Issues that persist

While deploying the app to the azure container instance we face some issues like

• No Static IP address
• Operational cost is high (it may not to feasible for small businesses)

Solutions

• Static IP address: Using v-net
• Operational cost is high (it may not to feasible for small businesses): Using Azure App Services

Reference:

• https://docs.microsoft.com/en-us/azure/container-instances/tutorial-docker-compose
• https://docs.microsoft.com/en-us/azure/container-instances/container-instances-overview