package length;

public class StringLength {

              public static void main(String[] args) {

                     String str =”Jesus is my Lord”;

                     int count = 0;

                     for(int i=0; i<str.length(); i++) {

                           if(str.charAt(i)!= ‘ ‘) {

                                  count++;

                           }

                     }

                           System.out.println(“No of characters: ” +count);

              }

       }

Output:  No of characters: 13

Java8 Tutorial

Example 1

package tutorial;

public class Training {

      public void train() {

            System.out.println(“Welcome to Greenwich Business School!”);

      }

      public static void main(String[] args) {

            Training training = new Training();

            training.train();

      }

}

// Output: Welcome to Greenwich Business School!

Example 2

package game;

interface FootBall{

      void kickBall();

}

public class Soccer {

      public static void main(String[] args) {

            //lambda expression

            FootBall footBall=()->

                  System.out.println(“Is a GOAL!!”);

            footBall.kickBall();

      };

}

// Output:  Is a GOAL!!

Example 3

package game;

interface FootBall{

      //void kickBall();

      void score(int input);

}

public class Soccer {

      public static void main(String[] args) {

            //lambda expression

            /*FootBall footBall=()->

                  System.out.println(“Is a GOAL!!”);

            footBall.kickBall();*/

            FootBall footBall=(input)->

                  System.out.println(“Result: ” +input);

                  footBall.score(0);

            };

      }

//Output: Result: 0

Example

 package game;

interface FootBall{

      //void kickBall();

      //void score(int input);

      int scores(int i1, int i2);

}

public class Soccer {

      public static void main(String[] args) {

            //lambda expression

            /*FootBall footBall=()->

                  System.out.println(“Is a GOAL!!”);

            footBall.kickBall();*/

            /*FootBall footBall=(input)->

                  System.out.println(“Result: ” +input);

                  footBall.score(0);*/

            FootBall footBall=(i1, i2)->{

                  return i1-i2;

            };

                  System.out.println(footBall.scores(4, 3));

            }

      }

//Output: 1

package game;

interface FootBall{

      //void kickBall();

      //void score(int input);

      int scores(int i1, int i2);

}

public class Soccer {

      public static void main(String[] args) {

            //lambda expression

            /*FootBall footBall=()->

                  System.out.println(“Is a GOAL!!”);

            footBall.kickBall();*/

            /*FootBall footBall=(input)->

                  System.out.println(“Result: ” +input);

                  footBall.score(0);*/

            FootBall footBall=(i1, i2)->i1-i2;

                  System.out.println(footBall.scores(6, 3));

            }

      }

//Output: 3

Example of if statement

package game;

interface FootBall{

      //void kickBall();

      //void score(int input);

      int scores(int i1, int i2);

}

public class Soccer {

      public static void main(String[] args) {

            //lambda expression

            /*FootBall footBall=()->

                  System.out.println(“Is a GOAL!!”);

            footBall.kickBall();*/

            /*FootBall footBall=(input)->

                  System.out.println(“Result: ” +input);

                  footBall.score(0);*/

            FootBall footBall=(i1, i2)->{

                  if(i1 > i2) {

                        throw new RuntimeException(“message”);

                  }else{

                        return i1-i2;

                  }

            };

                  System.out.println(footBall.scores(6, 14));

            }

      }

//Output: -8

      }

     

}

String Length

package length;

public class StringLength {

      interface LengthOfString {

            int getLength(String s);

      }

      public static void main(String[] args) {

            LengthOfString strLength = (String s) -> s.length();

            System.out.println(strLength.getLength(“I son of God”));

      }

}

//Output: 12

package length;

public class StringLength {

      interface LengthOfString {

            int getLength(String s);

      }

      public static void main(String[] args) {

            LengthOfString strLength = (s) -> s.length();

            System.out.println(strLength.getLength(“I son of God”));

      }

}

//Output: 12

Shortest and more appropriate way of coding spring length

package length;

public class StringLength {

      interface LengthOfString {

            int getLength(String s);

      }

      public static void main(String[] args) {

            LengthOfString strLength = s-> s.length();

            System.out.println(strLength.getLength(“I son of God”));

      }

}

//Output: 12

Anonymous Example

package game;

public class Scoreable {

      public static void main(String[] args) {

            Thread thread = new Thread(new Runnable() {

                  @Override

                  public void run() {

                        System.out.println(“Scored on extra time”);

                  }

            });

            thread.run();

      }

}

//Output: Scored on extra time

package game;

public class Scoreable {

      public static void main(String[] args) {

            Thread thread = new Thread(new Runnable() {

                  @Override

                  public void run() {

                        System.out.println(“Scored on extra time”);

                  }

            });

            thread.run();

            Thread myLambda = new Thread(() -> System.out.println(“Lambda without argument”));

            myLambda.run();

      }

}

//Output:

Scored on extra time

Lambda without argument

Practise Exercise to print names

package practise;

import java.util.Arrays;

import java.util.Collections;

import java.util.Comparator;

import java.util.List;

public class Exercise1Solution {

       public static void main(String[] args) {

               List<Person> people = Arrays.asList(

                            new Person(“John”, “Doe”, 25),

                            new Person(“Peter”, “Jones”, 23),

                            new Person(“Joseph”, “Golden”, 26),

                            new Person(“John”, “David”, 25),

                            new Person(“David”, “Paul”, 22)

                            );

               //Sort list by lastname

               Collections.sort(people, new Comparator<Person>() {

                     @Override

                     public int compare(Person o1, Person o2) {

                           return o1.getLastName().compareTo(o2.getLastName());

                     }

              });

               //Display list

               printAll(people);

               //Display lastname with D

               lastNameBeginningWithD(people);

       }

       private static void lastNameBeginningWithD(List<Person> people) {

              for(Person p : people) {

                     if(p.getLastName().startsWith(“D”)) {

                           System.out.println(p);

                     }

              }

       }

       private static void printAll(List<Person> people) {

              for(Person p : people) {

                     System.out.println(p);

              }

       }

}

//Output:

Person [firstName=John, lastName=David, age=25]

Person [firstName=John, lastName=Doe, age=25]

Person [firstName=Joseph, lastName=Golden, age=26]

Person [firstName=Peter, lastName=Jones, age=23]

Person [firstName=David, lastName=Paul, age=22]

Person [firstName=John, lastName=David, age=25]

Person [firstName=John, lastName=Doe, age=25]

Implementation using Java 8

package practise;

import java.util.Arrays;

import java.util.Collections;

import java.util.Comparator;

import java.util.List;

public class Exercise1SolutionJava8 {

       public static void main(String[] args) {

               List<Person> people = Arrays.asList(

                            new Person(“John”, “Doe”, 25),

                            new Person(“Peter”, “Jones”, 23),

                            new Person(“Joseph”, “Golden”, 26),

                            new Person(“John”, “David”, 25),

                            new Person(“David”, “Paul”, 22)

                            );

               //Sort list by lastname

               Collections.sort(people, (p1, p2) -> p1.getLastName().compareTo(p2.getLastName()));

               //Display list

               printAll(people);

               //Display lastname with D

               lastNameBeginningWithD(people);

       }

       private static void lastNameBeginningWithD(List<Person> people) {

              for(Person p : people) {

                     if(p.getLastName().startsWith(“D”)) {

                           System.out.println(p);

                     }

              }

       }

       private static void printAll(List<Person> people) {

              for(Person p : people) {

                     System.out.println(p);

              }

       }

       }

//Output:

Person [firstName=John, lastName=David, age=25]

Person [firstName=John, lastName=Doe, age=25]

Person [firstName=Joseph, lastName=Golden, age=26]

Person [firstName=Peter, lastName=Jones, age=23]

Person [firstName=David, lastName=Paul, age=22]

Person [firstName=John, lastName=David, age=25]

Person [firstName=John, lastName=Doe, age=25]

Java 8: lambda Expression

package practise;

import java.util.Arrays;

import java.util.Collections;

import java.util.Comparator;

import java.util.List;

import java.util.concurrent.locks.Condition;

public class Exercise1Solution {

       public static void main(String[] args) {

               List<Person> people = Arrays.asList(

                            new Person(“John”, “Doe”, 25),

                            new Person(“Peter”, “Jones”, 23),

                            new Person(“Joseph”, “Golden”, 26),

                            new Person(“John”, “David”, 25),

                            new Person(“David”, “Paul”, 22)

                            );

               //Sort list by lastName

               Collections.sort(people, (p1, p2)->p1.getLastName().compareTo(p2.getLastName()));         

               //Display list

               System.out.print(“Print all people”);

               printConditionally(people, p -> true);

               //Display lastname with D

               System.out.println(“Print all lastNames beginning with a ‘D'”);

               printConditionally(people, p->p.getLastName().startsWith(“D”));

               System.out.println(“Print all person with the firstname beginning with ‘J'”);

               printConditionally(people, p->p.getFirstName().startsWith(“J”));

       }

        private static void printConditionally(List<Person> people, Condition condition) {

              for(Person p : people) {

                     if(condition.test(p)) {

                           System.out.println(p);

                     }

              }

       }

        /*

       private static void printAll1(List<Person> people) {

              for(Person p : people) {

                           System.out.println(p);

              }

       }

       private static void printAll(List<Person> people) {

              for(Person p : people) {

                     System.out.println(p);

              }

       }

       */

       interface Condition {

              boolean test(Person p);         

       }

}

Output:

Print all people

Person [firstName=John, lastName=David, age=25]

Person [firstName=John, lastName=Doe, age=25]

Person [firstName=Joseph, lastName=Golden, age=26]

Person [firstName=Peter, lastName=Jones, age=23]

Person [firstName=David, lastName=Paul, age=22]

Print all lastNames beginning with a ‘D’

Person [firstName=John, lastName=David, age=25]

Person [firstName=John, lastName=Doe, age=25]

Print all person with the firstname beginning with ‘J’

Person [firstName=John, lastName=David, age=25]

Person [firstName=John, lastName=Doe, age=25]

Person [firstName=Joseph, lastName=Golden, age=26]

Lambda Expression – Predicate

package practise;

import java.util.Arrays;

import java.util.Collections;

import java.util.Comparator;

import java.util.List;

import java.util.concurrent.locks.Condition;

import java.util.function.Predicate;

public class Exercise1Solution {

       public static void main(String[] args) {

               List<Person> people = Arrays.asList(

                            new Person(“John”, “Doe”, 25),

                            new Person(“Peter”, “Jones”, 23),

                            new Person(“Joseph”, “Golden”, 26),

                            new Person(“John”, “David”, 25),

                            new Person(“David”, “Paul”, 22)

                            );

               //Sort list by lastName

               Collections.sort(people, (p1, p2)->p1.getLastName().compareTo(p2.getLastName()));         

               //Display list

               System.out.print(“Print all people”);

               printConditionally(people, p -> true);

               //Display lastName with D

               System.out.println(“Print all lastNames beginning with a ‘D'”);

               printConditionally(people, p->p.getLastName().startsWith(“D”));

               System.out.println(“Print all person with the firstname beginning with ‘J'”);

               printConditionally(people, p->p.getFirstName().startsWith(“J”));

       }

        private static void printConditionally(List<Person> people, Predicate <Person> predicate) {

              for(Person p : people) {

                     if(predicate.test(p)) {

                           System.out.println(p);

                     }

              }

       }

        /*

       private static void printAll1(List<Person> people) {

              for(Person p : people) {

                           System.out.println(p);

              }

       }

       private static void printAll(List<Person> people) {

              for(Person p : people) {

                     System.out.println(p);

              }

       }

       */

       interface Condition {

              boolean test(Person p);         

       }

}

Output:

Print all peoplePerson [firstName=John, lastName=David, age=25]

Person [firstName=John, lastName=Doe, age=25]

Person [firstName=Joseph, lastName=Golden, age=26]

Person [firstName=Peter, lastName=Jones, age=23]

Person [firstName=David, lastName=Paul, age=22]

Print all lastNames beginning with a ‘D’

Person [firstName=John, lastName=David, age=25]

Person [firstName=John, lastName=Doe, age=25]

Print all person with the firstname beginning with ‘J’

Person [firstName=John, lastName=David, age=25]

Person [firstName=John, lastName=Doe, age=25]

Person [firstName=Joseph, lastName=Golden, age=26]

Functional Interface Example

package practise;

import java.util.Arrays;

import java.util.Collections;

import java.util.List;

import java.util.function.Consumer;

import java.util.function.Predicate;

public class FunxrionalInterfacePractise1 {

       public static void main(String[] args) {

               List<Person> people = Arrays.asList(

                            new Person(“John”, “Doe”, 25),

                            new Person(“Peter”, “Jones”, 23),

                            new Person(“Joseph”, “Golden”, 26),

                            new Person(“John”, “David”, 25),

                            new Person(“David”, “Paul”, 22)

                            );

               //Sort list by lastName

               Collections.sort(people, (p1, p2)->p1.getLastName().compareTo(p2.getLastName()));         

               //Display list

               System.out.print(“Print all people”);

               performConditionally(people, p -> true, p -> System.out.println(p));

               //Display lastName with D

               System.out.println(“Print all lastNames beginning with a ‘D'”);

               performConditionally(people, p->p.getLastName().startsWith(“D”),p -> System.out.println(p));

               System.out.println(“Print all person with the firstname beginning with ‘J'”);

               performConditionally(people, p->p.getFirstName().startsWith(“J”),p -> System.out.println(p));

       }

        private static void performConditionally(List<Person> people, Predicate<Person>predicate, Consumer consumer) {

              for(Person p : people) {

                     if(predicate.test(p)) {

                           consumer.accept(p);

                     }

              }

       }

       interface Condition {

              boolean test(Person p);         

       }

       }

Output:

Print all peoplePerson [firstName=John, lastName=David, age=25]

Person [firstName=John, lastName=Doe, age=25]

Person [firstName=Joseph, lastName=Golden, age=26]

Person [firstName=Peter, lastName=Jones, age=23]

Person [firstName=David, lastName=Paul, age=22]

Print all lastNames beginning with a ‘D’

Person [firstName=John, lastName=David, age=25]

Person [firstName=John, lastName=Doe, age=25]

Print all person with the firstname beginning with ‘J’

Person [firstName=John, lastName=David, age=25]

Person [firstName=John, lastName=Doe, age=25]

Person [firstName=Joseph, lastName=Golden, age=26]

Java 8 Streaming

package java8streaming;

import java.util.ArrayList;

import java.util.Comparator;

import java.util.List;

import java.util.Map;

import java.util.Optional;

import java.util.function.BinaryOperator;

import java.util.stream.Collectors;

public class JavaCount {

       public static void main(String[] args) {

              List<Employee> empList = new ArrayList<>();

              empList.add(new Employee (101, “John”, 101, “active”, 51000));

              empList.add(new Employee (103, “Doe”, 102, “inactive”, 90000));

              empList.add(new Employee (104, “Joseph”, 102, “active”, 210002));

              empList.add(new Employee (105, “Golf”, 101, “active”, 331003));

              //Display employee details based on dept

              Map<Integer, List<Employee>> empListBasedOnDept = empList.stream().collect(Collectors.groupingBy(Employee::getDeptId, Collectors.toList()));

              empListBasedOnDept.entrySet().forEach( entry -> {

                     System.out.println(entry.getKey() + “—” + entry.getValue());

              });

              //Display and count departments

              Map<Integer, Long> empCountDept = empList.stream().collect(Collectors.groupingBy(Employee::getDeptId, Collectors.counting()));

              empCountDept.entrySet().forEach( entry -> {

                     System.out.println(“dept ” + entry.getKey() + “–” + entry.getValue());

              });

              //Display number of active and inactive departs

              Long activeEmpCount = empList.stream().filter(e -> “active”.equals(e.getStatus())).count();

              Long inactiveEmpCount = empList.stream().filter(e -> “inactive”.equals(e.getStatus())).count();

              System.out.println(“active emp count ” + activeEmpCount);

              System.out.println(“inactive emp count ” + inactiveEmpCount);

              //Get maximum and min salaries

              Optional<Employee> emp1 = empList.stream().max(Comparator.comparing(Employee::getSalary));

              Optional<Employee> emp2 = empList.stream().min(Comparator.comparing(Employee::getSalary));

              System.out.println(emp1);

              System.out.println(emp2);

//Display highest salary according to depart        

              Map <Integer, Optional<Employee>> topSalaryDeptWise = empList.stream().collect(Collectors.groupingBy(Employee::getDeptId,

                            Collectors.reducing(BinaryOperator.maxBy(Comparator.comparing(Employee::getSalary)))));

              topSalaryDeptWise.entrySet().forEach(entry -> {

                     System.out.println(“dept ” + entry.getKey() + ” top emp ” + entry.getValue());

              });

       }

}

Output:

//Display employee details based on dept

101—[Employee [empId=101, empName=John, deptId=101, status=active, salary=51000], Employee [empId=105, empName=Golf, deptId=101, status=active, salary=331003]]

102—[Employee [empId=103, empName=Doe, deptId=102, status=inactive, salary=90000], Employee [empId=104, empName=Joseph, deptId=102, status=active, salary=210002]]

//Display and count departments

dept 101–2

dept 102—2

//Active/inactive employees

active emp count 3

inactive emp count 1

//Max and min salaries

Optional[Employee [empId=105, empName=Golf, deptId=101, status=active, salary=331003]]

Optional[Employee [empId=101, empName=John, deptId=101, status=active, salary=51000]]

//Highest salaries by department

dept 101 top emp Optional[Employee [empId=105, empName=Golf, deptId=101, status=active, salary=331003]]

dept 102 top emp Optional[Employee [empId=104, empName=Joseph, deptId=102, status=active, salary=210002]]

mport java.util.HashSet;

import java.util.Set;

public class TestCoding {

 //Check if a string is Isogram or not

                public static void main(String[] args) {

                                System.out.println(isIsogram(“pen”));

                }

                static boolean isIsogram(String s) {

                                boolean isogram = true;

                                char[] ch = s.toCharArray();

                                Set<Character> chSet = new HashSet<Character>();

                                for(Character c : ch) {

                                                if(chSet.contains(c)) {

                                                                isogram = false;

                                                }else {

                                                                chSet.add(c);

                                                }

                                }

                                return isogram;

                }

}             

//Output: true.  Will be false if pen is not there

package recursion;

public class TestRecursion {

                public static void main(String[] args) {

                                // TODO Auto-generated method stub

                                System.out.println(num(7));

                }

                public static int num(int n) {

                                if(n<=1)

                                                return n;

                                else

                                                return num(n-1)+num(n-2);                                          

                }

}

//Output 13 ie 7+6

public class Counting {

                public static void main(String[] args) {

                                // TODO Auto-generated method stub

                                String str =”The Lord is is my shephard”;

                                List<String> list = Arrays.asList(str.split(” “));

list.stream().collect(Collectors.groupingBy(Function.identity(),Collectors.counting()));

                                Function<String, String> fn=Function.identity();

                                 System.out.println(fn.apply(str));

                                Map<String, Long> map = list.stream().collect(Collectors.groupingBy(Function.identity(),Collectors.counting()));

                    System.out.println(map);

                }

}

//Output

//The Lord is is my shephard

//{The=1, Lord=1, shephard=1, is=2, my=1}

package myProject;

@FunctionalInterface

public interface Multiplication {

                public int multiply(int a, int b);

}

package myProject;

public class Multiply {

                public static void main(String[] args) {

                                // TODO Auto-generated method stub

                                 Multiplication answer=(a,b)->a*b;

                                 System.out.println(answer.multiply(6, 8));

                }

}

//Output 48

import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

public class Sum {

public static void main (String[] args) {
    List<Integer> list = Arrays.asList(2, 10, 22,33, 46, 77, 67);
    Set<Integer> Set = new HashSet();
     list.stream().filter(x->Set.add(x)).collect(Collectors.toSet()).forEach(x->System.out.println(x));
    //list.stream().limit(2).forEach(x->System.out.println(x));
    //list.stream().skip(4).forEach(x->System.out.println(x));
}

}
//Output
22
10
77
46

package person;

public class Employee {

       private int empid;

       private String empName;

       private int deptId;

       private String status =”active”;

       private int salary;

       public Employee(int empid, String empName, int deptId, String status, int salary) {

              super();

              this.empid = empid;

              this.empName = empName;

              this.deptId = deptId;

              this.status = status;

              this.salary = salary;

       }

       public int getEmpid() {

              return empid;

       }

       public void setEmpid(int empid) {

              this.empid = empid;

       }

       public String getEmpName() {

              return empName;

       }

       public void setEmpName(String empName) {

              this.empName = empName;

       }

       public int getDeptId() {

              return deptId;

       }

       public void setDeptId(int deptId) {

              this.deptId = deptId;

       }

       public String getStatus() {

              return status;

       }

       public void setStatus(String status) {

              this.status = status;

       }

       public int getSalary() {

              return salary;

       }

       public void setSalary(int salary) {

              this.salary = salary;

       }

       @Override

       public String toString() {

              return “Employee [empid=” + empid + “, empName=” + empName + “, deptId=” + deptId + “, status=” + status

                           + “, salary=” + salary + “]”;

       }

}

package person;

import java.util.ArrayList;

import java.util.Comparator;

import java.util.List;

import java.util.Map;

import java.util.Optional;

import java.util.function.BinaryOperator;

import java.util.stream.Collectors;

public class EmployeeProgram {

       public static void main(String[] args) {

              // TODO Auto-generated method stub

              List<Employee> list = new ArrayList<>();

              list.add(new Employee(1, “John Doe”, 111, “inactive”, 25000));

              list.add(new Employee(2, “Mark Bruce”, 221, “active”, 55000));

              list.add(new Employee(3, “Gary King”, 221, “active”, 85000));

              list.add(new Employee(4, “Jerry Khan”, 111, “active”, 80000));

              list.add(new Employee(5, “Congo Box”, 111, “active”, 66000));

              //List all employees by department

              //list.stream().collect(Collectors.groupingBy(Employee::getDeptId, Collectors.toList()));

         Map<Integer, List<Employee>>listBasedOnDept=list.stream().collect(Collectors.groupingBy(Employee::getDeptId, Collectors.toList()));   

               listBasedOnDept.entrySet().forEach(x -> {

                      System.out.println(x.getKey() + “–” + x.getValue()

                      );

               });

               //Counting no. of departments and employees in each department

              Map<Integer, Long> empCountDept = list.stream().collect(Collectors.groupingBy(Employee::getDeptId, Collectors.counting()));

              empCountDept.entrySet().forEach(x-> {

                     System.out.println(x.getKey() + “–” + x.getValue());

              });

              //Count active and inactive employees

              Long activeEmpCount = list.stream().filter(x -> “active”.equals(x.getStatus())).count();

              Long inactiveEmpCount = list.stream().filter(x -> “inactive”.equals(x.getStatus())).count();

           System.out.println(“active emp count — ” + activeEmpCount);

           System.out.println(“inactive emp count — ” + inactiveEmpCount);

           //Print maximum and minimum salaries

           Optional<Employee> emp1 =list.stream().max(Comparator.comparing(Employee::getSalary));

           Optional<Employee> emp2 =list.stream().min(Comparator.comparing(Employee::getSalary));

           System.out.println(emp1);

           System.out.println(emp2);

           //List department and top salary earners

           Map<Integer, Optional<Employee>> topSalaryEmpDept = list.stream().collect(Collectors.groupingBy(Employee::getDeptId,

                     Collectors.reducing(BinaryOperator.maxBy(Comparator.comparing(Employee::getSalary)))));

                     topSalaryEmpDept.entrySet().forEach(x-> {

                           System.out.println(“Dept ” + x.getKey() + ” topEmp ” + x.getValue());

                     });

       }

}

//Output

221–[Employee [empid=2, empName=Mark Bruce, deptId=221, status=active, salary=55000], Employee [empid=3, empName=Gary King, deptId=221, status=active, salary=85000]]

111–[Employee [empid=1, empName=John Doe, deptId=111, status=inactive, salary=25000], Employee [empid=4, empName=Jerry Khan, deptId=111, status=active, salary=80000], Employee [empid=5, empName=Congo Box, deptId=111, status=active, salary=66000]]

221–2

111–3

active emp count — 4

inactive emp count — 1

Optional[Employee [empid=3, empName=Gary King, deptId=221, status=active, salary=85000]]

Optional[Employee [empid=1, empName=John Doe, deptId=111, status=inactive, salary=25000]]

Dept 221 topEmp Optional[Employee [empid=3, empName=Gary King, deptId=221, status=active, salary=85000]]

Dept 111 topEmp Optional[Employee [empid=4, empName=Jerry Khan, deptId=111, status=active, salary=80000]]