DEV Community: Cyrus Hardison

DELETE CASCADE AND UPDATE CASCADE rules in SQL Server foreign key

Cyrus Hardison — Thu, 23 Mar 2023 06:15:25 +0000

Cascade
Restrict
No action
sample code
- Auto ID increment with sequence No.

Cascade

When a "CASCADE" option is used, it means that when a row in the parent table is updated or deleted, the corresponding rows in the child table(s) will also be updated or deleted automatically. For example, if a row in a parent table is deleted, then all the related rows in the child table will also be deleted automatically. This ensures that there are no orphaned rows in the child table(s).

Restrict

On the other hand, when a "RESTRICT" option is used, it means that when a row in the parent table is updated or deleted, the corresponding rows in the child table(s) will not be updated or deleted automatically. The database system will prevent such changes and raise an error, unless the related rows in the child table(s) are first updated or deleted manually.

No action

When a "NO ACTION" option is used, it means that when a row in the parent table is updated or deleted, the corresponding rows in the child table(s) will not be updated or deleted automatically, just like in the case of "RESTRICT". However, unlike "RESTRICT", "NO ACTION" does not raise an error if a related row in the child table(s) exists that would violate the referential integrity constraint. Instead, it simply allows the update or deletion of the row in the parent table without affecting the child table(s).

sample code

CREATE TABLE Q_list.dbo.software_tb (
 sn int IDENTITY(1,1) NOT NULL,
 id AS ('so'+right('000000'+CONVERT([varchar](6),[sn]),(6))) PERSISTED NOT NULL,
 name varchar(30) COLLATE SQL_Latin1_General_CP1_CI_AS NULL,
 sw_attributes varchar(25) COLLATE SQL_Latin1_General_CP1_CI_AS NULL,
 sw_license varchar(25) COLLATE SQL_Latin1_General_CP1_CI_AS NULL,
 version varchar(20) COLLATE SQL_Latin1_General_CP1_CI_AS NULL,
 description varchar(50) COLLATE SQL_Latin1_General_CP1_CI_AS NULL,
 vendor varchar(20) COLLATE SQL_Latin1_General_CP1_CI_AS NULL,
 network varchar(20) COLLATE SQL_Latin1_General_CP1_CI_AS NULL,
 eol_date date NULL,
 eos_date date NULL,
 authorized_quantity varchar(25) COLLATE SQL_Latin1_General_CP1_CI_AS NULL,
 server_name varchar(20) COLLATE SQL_Latin1_General_CP1_CI_AS NULL,
 installation_status varchar(15) COLLATE SQL_Latin1_General_CP1_CI_AS NULL,
 installation_environment varchar(30) COLLATE SQL_Latin1_General_CP1_CI_AS NULL,
 ip varchar(25) COLLATE SQL_Latin1_General_CP1_CI_AS NULL,
 port int NULL,
 department_of_use varchar(20) COLLATE SQL_Latin1_General_CP1_CI_AS NULL,
 in_charge varchar(20) COLLATE SQL_Latin1_General_CP1_CI_AS NULL,
 remarks varchar(50) COLLATE SQL_Latin1_General_CP1_CI_AS NULL,
 server_id varchar(8) NOT NULL,
 FOREIGN KEY (server_id) REFERENCES server_tb(id)
    ON DELETE CASCADE
    ON UPDATE CASCADE

Auto ID increment with sequence No.

...
sn int IDENTITY(1,1) NOT NULL,
 id AS ('so'+right('000000'+CONVERT([varchar](6),[sn]),(6))) PERSISTED NOT NULL,
...

sn	id
1	so000001
2	so000002

Introduction to AWS Cloud

Cyrus Hardison — Thu, 09 Mar 2023 13:16:13 +0000

1. Global Infrastructure
- Technology terminology
- Types of cloud services
2. Structures of the Cloud
3. AWS Console

1. Global Infrastructure

Technology terminology

- Cloud computing
The on-demand delivery of compute power, databases, storage, applications, and other IT resources using the internet with pay-as-you-go pricing.
- Amazon Web Services(AWS)
A platform that provides a wide range of cloud computing services.
- Cloud Storage
Saving data using a cloud service provider (CSP) instead of a physical machine.
- Server
A computer designed to process requests and deliver data to another computer over the Internet or a local network. In the cloud, a server is hosted by an outside provider, which is accessed over the internet.

Types of cloud services

- Infrastructure as a service (IaaS)
Kichen
- Platform as a service (PaaS)
Restaurant
- Software as a service (SaaS)
Buffet

2. Structures of the Cloud

3. AWS Console

- Amazon Simple Storage Service(Amazon S3)
A service provided by AWS that stores data for users in the cloud.

- Amazon Elastic Compute Cloud (Amazon EC2)
A web service that provides secure, resizable compute capacity in the cloud. Think of it as renting a computer in the cloud.

- Amazon Elastic Block Store (Amazon EBS)
  Storage for specific EC2 instances. Think of it as the storage drive for your EC2 instance

- Amazon Relational Database Service (Amazon RDS)
  This lets developers create and manage relational databases in the cloud. Think of a relational database as a set of data with one-to-one relationships. For example, a database of transactions in a department store would match every customer with their purchases. Amazon RDS lets developers track large amounts of this data, and organize and search through it easily. Relational databases are equipped with nonprocedural structured query language (SQL) that simplifies interactions with the database.

- Amazon DynamioDB
  The AWS nonrelational database service. Data is stored in key-value pairs.

- AWS Lambda
  Lambda lets you run code without provisioning or managing servers. You pay only for the compute time you consume—there is no charge when your code is not running. With Lambda, you can run code for virtually any type of application or backend service—all with zero administration. Upload your code, and Lambda takes care of everything required to run and scales your code with high availability. You can set up your code to automatically start from other AWS services or call it directly from any web or mobile app.

- Amazon Virtual Private Cloud (Amazon VPC)
  A service that provides a virtual network that is dedicated to your AWS account. It is logically isolated from other virtual networks in the AWS Cloud. All your AWS services can be launched from a VPC. It is useful for protecting your data and managing who can access your network.

- AWS Identity and Access Management (IAM)
  Involves the application of controls to users who need access to computing resources.

- AWS CloudTrail
  Monitors every action that is performed on your AWS account for security purposes.

- Amazon CloudWatch
  CloudWatch is a monitoring service to monitor your AWS resources and the applications that you run on AWS.

- Amazon RedShift
  The AWS data-warehousing service can store massive amounts of data in a way that makes it fast to query for business intelligence purposes.

Java Function Programming

Cyrus Hardison — Wed, 08 Mar 2023 13:50:11 +0000

Contents:

Re-think
- Openning Problem
- Opening Problem-Algorithm
- A Java Solution
- A LINQ Solution
Outline
- Revisit – Defining a method
- Lambda Expressions
- Syntax
- Implicit Parameter Types
- Implicit Return
- One Parameter
- Method Reference
- Lambdas Summary
- Quiz
- More Practise
- Function Interface
- An example - Consumer
- Instance Instantiation
- Functional Interfaces and Lambdas
- Using Functional Interfaces
  - A Example -Pridicate
  - An example – BinaryOperator
  - Common Functional Interfaces
- Streams
- Revisit - working with Collections
- What are Streams?
- Stream Pipelines
- Lazy vs eager operations
- Stream Advantages
- Creating Streams from Arrays
- Creating Streams from Collections
- Creating ordered sequence of integer Streams
- Common Intermediate Operations
- Filtering
- One way to understand a stream’s method
- Sorting
- Transforming
- Terminal Operations
- “Iterating"

Re-think

Openning Problem

Given a list or array of Person objects

public static List<Person> generatePersonList() {
    List<Person> l = new ArrayList<>();
    l.add(new Person("John", "Tan", 32, 2));
    l.add(new Person("Jessica", "Lim", 28, 3));
    l.add(new Person("Mary", "Lee", 42, 2));
    l.add(new Person("Jason", "Ng", 33, 1));
    l.add(new Person("Mike", "Ong", 22, 0));
    return l;
}

class Person {
    private String firstName;
    private String lastName;
    private int age;
    private int kids;
    // Constructors, getters 
    // omitted for brevity
}

How can we print the full names of the 3 youngest people?

Opening Problem-Algorithm

Sort the list of people by age, in ascending order
Get the first 3 people from the stored list
Get the respective names

A Java Solution

static void sortList(List<Person> persons) {
    for (int i = 0; i < persons.size(); i++) {
        for (int j = i + 1; j < persons.size(); j++) {
            if (persons.get(j).getAge() < persons.get(i).getAge()) {
                // Switch position of two persons
                Person temp = persons.get(i);
                persons.set(i, persons.get(j));
                persons.set(j, temp);
            }
        }
    }
}

Sort the list by age using Bubble SortNote: there’re many other ways to implement it.

static List<String> getTopThreeNames(
    List<Person> persons) {
    List<String> retNames = new ArrayList<String>();
    for (int i = 0; i < 3; i++) {
        Person curPerson = persons.get(i);
        retNames.add(curPerson.getFirstName() + " " + curPerson.getLastName());
    }
    return retNames;
}

Get the first 3 people in the sorted list, and.
Get the respective names.

A LINQ Solution

If working with C#, we can use LINQ

Persons.OrderBy(person => person.Age)
    .Take(3)
    .Select(person => new
    {
        FullName = person.FirstName + " " + person.LastName
});

Outline

Revisit – Defining a method

A method definition consist of

Method name
Parameters
Return type
Method body
Return value

int min(
    int num1, int num2){
        if(num1<num2){
            return num1;
        }
    return num2
}

How to make method definition shorter /more concise ?

Lambda Expressions

A lambda expression represents an anonymous methods, in short-hand notation

it consists of:

~~Method name~~
Parameters
~~Return type~~
Method boday
Return value


()->{}
Lambda Expression
(e1,e2)->e1+e2

Syntax

a lambda consists of a parameter list followed by theh arrow token (->) and a body
(parameter list) -> {statements}

Method:

int min(int num1,int num2){
    if(num1<num2){
        return num1;
    }
    return num2;
}

Lambda:

(int num1,int num2)->{
    if(num1<num2){
        return num1;
    }
    return num2;
}

Implicit Parameter Types

The parameter types are usually omitted

Method:

int min(int num1, int num2) {
    if (num1 < num2) {
        return num1;
    }
    return num2;
}

Lambda:

(num1, num2) -> {
    if (num1 < num2) {
        return num1;
    }
    return num2;
}

The compiler can determine the parameter types by the lambda’s context

Implicit Return

When the body contains only one expression, the return keyword and curly braces {} may also be omitted

Method:

int sum(int num1, int num2)
{
    return num1 + num2;
}

Lambda:

(num1, num2) -> {
return num1 + num2;
}

//......

(num1, num2) -> num1 + num2

The compiler can also determine the return type by the lambda’s context

Question
What is/are the data type(s) of variables n1, n2, and n1 + n2?

public static void sum() {
    double[] arr = { 1.1, 2.2, 3.3 };
    double sum =
        DoubleStream.of(arr)
            .reduce((n1, n2) -> n1 + n2))
            .getAsDouble();
    System.out.println("Sum: " + sum);
}

One Parameter

When the parameter list contains only one parameter, parameter parentheses may also be omitted

//Method:
void printValue(
        double myValue) {
    System.out.println(myValue);
}

//Lambda:
(myValue) -> 
    System.out.println(myValue)

//Lambda
myValue -> 
    System.out.println(myValue)

In the previous slide, how can the compiler know the method’s return type is integer while it is void in this slide?

Method Reference

When a lambda expression does nothing but calls one existing method, we can just refer to ClassName::methodName

//Method:
void printValue(double myValue) {
    System.out.println(myValue);
}

//Lambda:
myValue -> 
    System.out.println(myValue)

//Method Reference:
System.out::println

//Method:
int compare(Person a, Person b) {
    return a.compareByAge(b);
}

//Lambda
(a, b) -> a.compareByAge(b)

//Method Reference:
Person::compareByAge

Lambdas Summary

A lambda is a method with no method name, no return type
A nd remove types of parameters
One expression in method body? Remove return keyword and curly braces {}
Only one parameter? Remove parameter parentheses ()

Quiz

Convert each of the following methods to lambdas or method references, in its shortest form

int pow(int base, int exp) {
    int res = 1;
    for (int i = 0; i < exp; i++) {
        res *= base;
    }
return res;
}


//Answer:
(base, exp) -> {
    int res = 1;
    for (int i = 0; i < exp; i++) {
        res *= base;
    }
return res;
}

Convert each of the following methods to lambdas or method references, in its shortest form

boolean isPrime(int num) {
    for (int divisor = 2; 
        divisor < num - 1; divisor++) {
        if (num % divisor == 0)
        return false;
    }
return true;
}

//Answer:

num -> {
    for (int divisor = 2; divisor<num-1; divisor++) {
        if (num % divisor == 0)
        return false;
    }
return true;
}

More Practise

Convert the following methods to lambda expressions or method references, in its shortest form

String getFullName(Person p) {
    return p.getFirstName() + " " + p.getLastName();
}

//Answer:
p -> p.getFirstName() + " " + p.getLastName()

void printFullName(Person p) {
    System.out.println(p.getFirstName() + " " + p.getLastName());
}

//Answer:
p -> System.out.println(p.getFirstName() + " "+ p.getLastName())

String getFirstName(Person p) {
    return p.getFirstName();
}

class Person {
    private String firstName;
    private String lastName;
    // Other code omitted 
    // for brevity
}

//Answer:
Person::getFirstName

Function Interface

A functional interface contains exactly one abstract method, called functional method
Compiler can map a lambda to some respective functional interfaces

interface Consumer<T> {
    void accept(T t);
}

interface Predicate<T> {
    boolean test(T t);
}

interface BinaryOperator<T> {
    T apply(T t1, T t2);
}

An example - Consumer

Interface Consumer, method accept(T) Perform a*task* with the given T, e.g.,

interface Consumer<T> {
    void accept(T t);
}

Like other interfaces, we need to implement the
abstract method when implementing a functional
interface

How to implement and instantiate instances of functional interfaces?

Instance Instantiation

We can implement and instantiate an instance of a functional interface by new keyword and implement its abstract methods

new Consumer< Integer>() {
    @Override
    public void accept(Integer num) {
        System.out.println(num);
    }
}

To instantiate an instance, start with new and the interface name Consumer
Because interface Consumer supports generic type, specify the generic type. In here, it is Integer
Implement the interface’s abstract method. In here, accept(T) becomes accept(Integer)

Functional Interfaces and Lambdas

We can also implement and instantiate an instance of a functional interface with the respective lambdas

new Consumer<Integer>() {
    @Override
    public void accept(Integer num) {
        System.out.println(num);
    }
}

//lambda
num -> System.out.println(num)

//Lambda
System.out::println

Both lambdas can be used as instances of Consumer

Conversely, given the above lambdas, can the compiler know how to map to Consumer?
Hint: a functional interface only has 1 functional method

Using Functional Interfaces

Functional interfaces are usually used as method parameters For example,later we’ll study streams, which can be iterated using
forEach(Consumer) method

Integer[] arr = {1, 2, 3, 4};
    Arrays.stream(arr)
        .forEach( new Consumer<Integer>() {
            @Override
            public void accept(Integer num) {
                System.out.println(num);
            }
        });


Integer[] arr = {1, 2, 3, 4};
Arrays.stream(arr)
    .forEach( num -> 
        System.out.println(num));

In both cases, an instance of Consumer is used as the method parameters

A Example -Pridicate

Interface Predicate, method test(T) Test whether the T argument satisfy a condition

interface Predicate<T> {
    boolean test(T t);
}

Like Consumer, we can implement and instantiate an instance of Predicate as follows

new Predicate<Person>() {
    @Override
    public boolean test(Person p) {
        return p.getKids() == 2; 
    }
}

//Lambda

An example – BinaryOperator

Interface BinaryOperator, method apply(T, T)Performs an operation on the 2 arguments (such as a calculation) and returns a value of the same type

interface BinaryOperator<T> {
    T apply(T t1, T t2);
}

Some lambdas that may be used as instances of
BinaryOperator

(x, y) -> x + y

(str1, str2) -> 
str1 + " " + str2

(x, y) -> {
    if (x > y)
        return x - y;
    return y - x;
};

Common Functional Interfaces

interface	Method	Arguments	What does it do	Return
Consumer	accept	T	Perform a task with T, e.g., printing	void
Function	apply	T	Call a method on the T argument and return that method’s result	R
Predicate	test	T	Test whether the T argument satisfies a condition	bool
Supplier	get	Empty	Produce a value of type T, e.g., creating a collection object	T
UnaryOperator	apply	T	Perform an operation on the T argument and return a value of T	T
BinaryOperator	apply	T, T	Perform an operation on the two	T

Streams

Revisit - working with Collections

When processing a collection, we usually

Iterate over its elements
Do some work with each element

public static int
    sumOfEven(int[] arr) {
        int sum = 0;
        for (int num: arr) {
            if (num % 2 == 0) {
                sum += num;
        }
    }
    return sum;
}

What are Streams?

A Stream is a sequence of elements on which we perform tasks
Specify only what we want to do
Then simply let the Stream deal with how to do it

public static int
    sumOfEven2(int[] arr) {
        return IntStream
    .of(arr)
    .filter(x -> x%2==0)
    .sum();
}

Stream Pipelines

Source=>Create Stream=>Operation 1=>Operation2=>.....Operation N=>Terminal Operation=>Result

Source: Usually , an array or a collection
Operation: Filtering, sorting,type conversions, mapping...
Terminal operation: Aggregate results, eg., count, sum or collecting a collection.

IntStream.of(arr).filter(x -> x % 2 ==0).sum()

//arr: Source
//of: Create stream
//filter: Intermediate operation
//sum: Terminal operation

Lazy vs eager operations

Intermediate operations are lazy

=> Not perform until a
terminal operation is
called

Terminal operations are eager
=> Perform right away when being called

Stream Advantages

Allows us to write more declarative and more concise programs
Allows us to focus on the problem rather than the code
Facilitates parallelism

Creating Streams from Arrays

Streams can be created from arrays with different
approaches

public static void streamFromArray1() {
    int[] arr = {3, 10, 6, 1, 4}; 
        IntStream.of(arr)
            .forEach(e -> System.out.print(e + " "));
}

//3 10 6 1 4

public static void streamFromArray2() {
    Integer[] arr = {2, 9, 5, 0, 3};
        Arrays.stream(arr)
            .forEach(e -> System.out.print(e + " "));
}
//2 9 5 0 3

Creating Streams from Collections

Streams can also be created from any implementation of Collection interface, e.g., List, Set…

public static void streamFromList() {
    List<String> myList = new ArrayList<>();
    myList.add("Hi");
    myList.add("SA");
    myList.add("students");
    myList.stream()
        .forEach(System.out::println);
}

//Hi
//SA
//students

Creating ordered sequence of integer Streams

Ordered sequence of integers can be created using
IntStream.range() and IntStream.rangeClosed()

public static void orderedSequenceStream1() {
    IntStream
        .range(1, 10)
        .forEach(e -> System.out.print(e + " "));
}
//1 2 3 4 5 6 7 8 9

public static void orderedSequenceStream2() {
    IntStream
        .rangeClosed(1, 10)
        .forEach(e -> System.out.print(e + " "));
}

//1 2 3 4 5 6 7 8 9 10

Common Intermediate Operations

Method	Parameter	Description
filter	Predicate	Returns a stream consisting of the elements of this stream that match the given predicate.
sorted	Comparator	Returns a stream consisting of the elements of this stream, sorted according to the provided Comparator.
map	Function	Returns a stream consisting of the results of applying the given function to the elements of this stream.
distinct	No	Returns a stream consisting of the distinct elements (according to Object.equals(Object)) of this stream.
limit	long	Returns a stream consisting of the elements of this stream, truncated to be no longer than the given number in length.
skip	long	Returns a stream consisting of the remaining elements of this stream after discarding the first n elements of the stream. If this stream contains fewer than n elements then an empty stream will be returned

Filtering

Elements in a stream can be filtered using filter(Predicate)

public static List<Person> generatePersonList() 
{
    List<Person> l = new ArrayList<>();
    l.add(new Person("John", "Tan", 32, 2));
    l.add(new Person("Jessica", "Lim", 28, 3));
    l.add(new Person("Mary", "Lee", 42, 2));
    l.add(new Person("Jason", "Ng", 33, 1));
    l.add(new Person("Mike", "Ong", 22, 0));
    return l;
}

public static void filtering() {
    List<Person> persons = 
    generatePersonList();
    persons
    .stream()
    .filter( x -> x.getKids() == 2)
    .forEach(System.out::println);
}


class Person {
    private String 
    firstName;
    private String 
    lastName;
    private int age;
    private int kids;
    // Other code omitted 
    // for brevity
}


//John, Tan, 32, 2
//Mary, Lee, 42, 2

One way to understand a stream’s method

.filter(x -> x.getKids() == 2)

I want to filter elements in a stream
Ok, you need to call filter() method, and give me a Predicate in form of a lambda
I will loop through every element in the stream, and with the current element…
Let’s name that element as x, the left side of the lambda
You need to let me know what to do with x, using any method of the data type in the stream holding x. For example, Person in the last slide
I want to filter only x having 2 kids, so I return a Boolean Expression with such condition. It is put in the body, the right side of the lambda

=>Most of stream methods happen in this manner. Step 2, 4 and 6 change depending on the scenario

Sorting

Streams can be sorted using sorted(Comparator) As usual, a Comparator object can be created using a lambda

public static List<Person> generatePersonList() {
    List<Person> l = new ArrayList<>();
    l.add(new Person("John", "Tan", 32, 2));
    l.add(new Person("Jessica", "Lim", 28, 3));
    l.add(new Person("Mary", "Lee", 42, 2));
    l.add(new Person("Jason", "Ng", 33, 1));
    l.add(new Person("Mike", "Ong", 22, 0));
    return l;
}

public static void sortBySingleField() {
    List<Person> persons = generatePersonList();
    persons
    .stream()
    .sorted( (p1, p2) -> 
    p1.getFirstName().compareTo( 
    p2.getFirstName()))
    .forEach(x -> System.out.println(x));
}


//Jason, Ng, 33, 1
//Jessica, Lim, 28, 3
//John, Tan, 32, 2
//Mary, Lee, 42, 2
//Mike, Ong, 22, 0

Alternatively, a Comparator object can be created using Comparator.comparing(Function)

public static List<Person> generatePersonList() {
    List<Person> l = new ArrayList<>();
    l.add(new Person("John", "Tan", 32, 2));
    l.add(new Person("Jessica", "Lim", 28, 3));
    l.add(new Person("Mary", "Lee", 42, 2));
    l.add(new Person("Jason", "Ng", 33, 1));
    l.add(new Person("Mike", "Ong", 22, 0));
    return l;
}

public static void sortBySingleField () {
    List<Person> persons = generatePersonList();
    persons
    .stream()
    .sorted( Comparator.comparing(
    Person::getFirstName))
    .forEach(x -> System.out.println(x));
}

//Jason, Ng, 33, 1
//Jessica, Lim, 28, 3
//John, Tan, 32, 2
//Mary, Lee, 42, 2
//Mike, Ong, 22, 0

Streams can also be sorted with multiple fields and in reversed order

public static List<Person> generatePersonList() {
    List<Person> l = new ArrayList<>();
    l.add(new Person("John", "Tan", 32, 2));
    l.add(new Person("Jessica", "Lim", 28, 3));
    l.add(new Person("Mary", "Lee", 42, 2));
    l.add(new Person("Jason", "Ng", 33, 1));
    l.add(new Person("Mike", "Ong", 22, 0));
    return l;
}

public static void sortByMultiFields () {
    List<Person> persons = generatePersonList();
    persons.stream()
    .sorted(Comparator
    .comparing(Person::getKids)
    .thenComparing(Person::getAge)
    .reversed())
    .forEach(x -> System.out.println(x));
}

//Jason, Ng, 33, 1
//Jessica, Lim, 28, 3
//John, Tan, 32, 2
//Mary, Lee, 42, 2
//Mike, Ong, 22, 0

Transforming

Each of elements in a Stream can be transformed to another value (even another type) using map(Function)

public static List<Person> generatePersonList() {
    List<Person> l = new ArrayList<>();
    l.add(new Person("John", "Tan", 32, 2));
    l.add(new Person("Jessica", "Lim", 28, 3));
    l.add(new Person("Mary", "Lee", 42, 2));
    l.add(new Person("Jason", "Ng", 33, 1));
    l.add(new Person("Mike", "Ong", 22, 0));
    return l;
}

public static void transforming1() {
    List<Person> persons = generatePersonList();
    persons
    .stream()
    .sorted(Comparator.comparing(
    Person::getFirstName))
    .map( x -> x.getFirstName() + 
    " " + x.getLastName())
    .forEach(System.out::println);
}


//Jason Ng
//Jessica Lim
//John Tan
//Mary Lee
//Mike Ong

Of course, map(Function) can also be applied to
other types of streams

public static void transforming2() {
    int[] arr = {0, 1, 2, 3, 4, 5};
    IntStream.of(arr)
    .map(e -> e * 2)
    .forEach(e -> System.out.print(e + " "));
}

//0 2 4 6 8 10

public static void transforming3() {
    String[] arr = {"aa", "bb", "cc", "dd"};
    Arrays.stream(arr)
    .map(String::toUpperCase)
    .forEach(e -> System.out.print(e + " "));
}
//AA BB CC DC

A stream can be mapped to a numeric stream

public static void transforming4() {
String[] names = 
{"John", "Jessica", "Mary", "Jason", "Mike"};
int maxLength =
Stream.of(names)
.mapToInt(x -> x.length())
.max()
.getAsInt();
System.out.println("Name with maximum length is " + 
maxLength);

//Name with maximum length is 7

Terminal Operations

Method	Parameters	Description
forEach	Consumer	Performs an action for each element of this stream.
reduce	T, BinaryOperator	Performs a reduction on the elements of this stream, using the provided identity value and an associative accumulation function, and returns the reduced value.
reduce	BinaryOperator	Performs a reduction on the elements of this stream, using an associative accumulation function, and returns an Optional describing the reduced value, if any.
min	Comparator	Returns the minimum element of this stream according to the provided Comparator. This is a special case of a reduction.
max	Comparator	Returns the maximum element of this stream according to the provided Comparator. This is a special case of a reduction.
average	No Return	the average of all elements in a numeric stream.

“Iterating"

Performs an action for each element of the stream using forEach(Consumer)

public static void forEachStream() 
{
    List<String> list = new ArrayList<>();
    list.add("aa");
    list.add("bb");
    list.add("cc");
    list
    .stream()
    .forEach( e
    -> System.out.print(e + " "));
}

//aa bb cc

Call forEach()
Given a Consumer object in the form of lambda as the argument We can think like this: given each element e, what Java should do with it (and return nothing as defined in Consumer interface)? In here,we ask Java to print the value of element e

=>List also has forEach() method, operating in the
same manner