Java Programming Masterclass - Mini Project || Fresco Play || 62237

Table of Contents

• Conditional Statements
• Object Oriented Programming
  • Classes and Objects - Singleton Pattern
  • Polymorphism
  • Multiple Inheritance
• Abstract Class
• Generic Class
• Packages
• Exceptions
• Collections
  • HashMap
  • TreeMap
  • ArrayList
  • HashSet
• Functional Programming : Lambda, Streams
• Multithreading
• Regular Expression
• Database Connectivity

Conditional Statements

public static String[] calculateGrade(int[][] students_marks) {
      String[] result = new String[students_marks.length];
      
      int avg = 0;
      for(int i=0; i<students_marks.length; i++) {
          avg = 0;
          for(int j=0; j<students_marks[i].length; j++) {
              avg += students_marks[i][j];
          }
          avg /= students_marks[i].length;
          
          if(avg >= 90) result[i] = "A+";
          else if(avg >= 80) result[i] = "A";
          else if(avg >= 70) result[i] = "B";
          else if(avg >= 60) result[i] = "C";
          else if(avg >= 50) result[i] = "D";
          else result[i] = "F";
      }
      
      return result;
  }

Object Oriented Programming

Classes and Objects - Singleton Pattern

class Register {
    
    private static Register register = null;
     
    /*
     * Complete the 'getTotalBill' function below.
     *
     * The function is expected to return a STRING.
     * The function accepts MAP itemDetails as parameter.
     */

    public String getTotalBill(Map<String,Integer> itemDetails) {
        Map<String,Double> itemPrice = new HashMap<>();
        itemPrice.put("apple", 2.0);
        itemPrice.put("orange", 1.5);
        itemPrice.put("mango", 1.2);
        itemPrice.put("grape", 1.0);
        
        // Write your code here
        double total = 0;
        for (String item : itemDetails.keySet()) {
            total += itemDetails.get(item) * itemPrice.get(item);
        }
        return String.format("%.1f",total);
    }
    
    public static Register getInstance() {
        register = new Register();
        return register;
    }

}

Polymorphism

class Parent {
    public int startElement, endElement;
    
    Parent(int start, int end) {
        this.startElement = start;
        this.endElement = end;
    }
    
    public String filter() {
        return null;
    }
}

class ChildOne extends Parent {
    ChildOne(int start, int end) {
        super(start, end);
    }
    
    boolean isPrime(int n) {
        if (n <= 1) return false;
        if (n <= 3) return true;
        if (n % 2 == 0) return false;
        if (n % 3 == 0) return false;
        
        for (int i = 5; i <= Math.sqrt(n); i+=2) {
            if (n % i == 0) return false;
        }
        return true;
    }
    @Override public String filter() {
        int i = startElement;     
        String res = "";
        while(i<=endElement){
            if(isPrime(i))
                res += String.valueOf(i) +" ";
            i++;
        }   
        return res.trim();
    }
}

class ChildTwo extends Parent {
    ChildTwo(int start, int end) {
        super(start, end);
    }
    
    int numSquareSum(int n) {
        int squareSum = 0;
        while (n != 0) {
            int digit = n % 10;
            squareSum += digit * digit;
            n /= 10;
        }
        return squareSum;
    }
    
    boolean isHappy(int n) {
        int slow = n, fast = n;
        do {
            slow = numSquareSum(slow); 
            fast = numSquareSum(numSquareSum(fast));
        } while (slow != fast);

        return slow == 1;
    }
    
    @Override public String filter() {
        int i = startElement;     
        String res = "";
        while(i<=endElement){
            if(isHappy(i))
                res += String.valueOf(i) + " ";
            i++;
        }   
        return res.trim();
    }
}

Multiple Inheritance

interface HockeyTeam {
    int calculateHockeyScore();
    
    int findHighestGoalByIndividualInHockey();
}

interface FootballTeam {
    int calculateFootballScore();
    
    int findHighestGoalByIndividualInFootball();
}

class Sport implements HockeyTeam, FootballTeam {
    private int[] hockeyPlayers, footballPlayers;
    Sport(int[] paramHockeyPlayers, int[] paramFootballPlayers) {
        this.hockeyPlayers = paramHockeyPlayers;
        this.footballPlayers = paramFootballPlayers;
    }
    
    public int calculateHockeyScore() {
        return Arrays.stream(this.hockeyPlayers).sum();
    }
    
    public int findHighestGoalByIndividualInHockey() {
        return Arrays.stream(this.hockeyPlayers).max().getAsInt();
    }
    
    public int calculateFootballScore() {
        return Arrays.stream(this.footballPlayers).sum();
    }
    
    public int findHighestGoalByIndividualInFootball() {
        return Arrays.stream(this.footballPlayers).max().getAsInt();
    }
}

Abstract Class

public abstract class Student {

    //Write your code. Use this class as abstract class.
    public abstract String result(String MarksOfStudent);

    public double calcGradePoint(int grade) {
        // double res=0;
        if (grade >= 75) {
            return Float.valueOf(String.format("%.1f", 9 + (grade - 75) / 25.0f));
        } else if (grade >= 60) {
            return Float.valueOf(String.format("%.1f", 8 + (9.0f / 140 * (grade - 60))));
        } else if (grade >= 50) {
            return 7 + (0.1f * (grade - 50));
        } else if (grade >= 40) {
            return 6 + (0.1f * (grade - 40));
        }
        return 0f;
    }
}


public class SelfFinance extends  Student {
    @Override public String result(String allMarks) {
        String[] marks= allMarks.split("\\|");
        String[] subjMarks = marks[0].split(","),
        sportsMarks = marks[1].split(",");

        int maxCred = 0, cred, grade;
        double totalGrade = 0, cgpa;
        for(String subjMark: subjMarks) {
            grade = Integer.parseInt(subjMark.split(" ")[0]);
            cred = Integer.parseInt(subjMark.split(" ")[1]);
            totalGrade += cred * calcGradePoint(grade);
            maxCred += 5;
        }

        if(sportsMarks[0].equals("1")) {
            grade = Integer.parseInt(sportsMarks[1]);
            cred = Integer.parseInt(sportsMarks[2]);
            totalGrade += cred * calcGradePoint(grade);
            maxCred += 5;
        }

        cgpa = totalGrade/maxCred;
        return String.format("%.2f", cgpa);
    }
}

public class Aided extends  Student {
    @Override public String result(String allMarks) {
        String[] marks= allMarks.split("\\|");
        String[] subjMarks = marks[0].split(","),
        nccMarks = marks[1].split(","),
        sportsMarks = marks[2].split(",");

        int maxCred = 0, cred, grade;
        double totalGrade = 0, cgpa;
        for(String subjMark: subjMarks) {
            grade = Integer.parseInt(subjMark.split(" ")[0]);
            cred = Integer.parseInt(subjMark.split(" ")[1]);
            totalGrade += cred * calcGradePoint(grade);
            maxCred += 5;
        }

        if(nccMarks[0].equals("1")) {
            grade = Integer.parseInt(nccMarks[1]);
            cred = Integer.parseInt(nccMarks[2]);
            totalGrade += cred * calcGradePoint(grade);
            maxCred += 5;
        }

        if(sportsMarks[0].equals("1")) {
            grade = Integer.parseInt(sportsMarks[1]);
            cred = Integer.parseInt(sportsMarks[2]);
            totalGrade += cred * calcGradePoint(grade);
            maxCred += 5;
        }

        cgpa = totalGrade/maxCred;
        return String.format("%.2f", cgpa);
    }
}

Generic Class

public class StudentClass {

    public String getQuery(String studentData, String query) {
        String[] queryParams = query.split(",");
        String[] studentArr = studentData.split(" ");
        int queryType = Integer.parseInt(queryParams[0]);
        if (queryType == 1) {
            StudentList<String> studentList = new StudentList<>();
            for (int i = 0; i < studentArr.length; i++) {
                studentList.addElement(studentArr[i]);
            }
            return studentList.beginsWith(queryParams[1]);
        } else if (queryType == 2) {
            StudentList<String> studentList = new StudentList<>();
            for (int i = 0; i < studentArr.length; i++) {
                studentList.addElement(studentArr[i]);
            }
            String bloodGroups[] = queryParams[1].split(" ");
            return studentList.bloodGroupOf(bloodGroups, queryParams[2]);
        } else if (queryType == 3) {
            StudentList<Integer> studentList = new StudentList<>();
            for (int i = 0; i < studentArr.length; i++) {
                studentList.addElement(Integer.parseInt(studentArr[i]));
            }
            int count = studentList.thresholdScore(Integer.parseInt(queryParams[1]));
            return String.format("%d students scored %d above", count, Integer.parseInt(queryParams[1]));
        } else if (queryType == 4) {
            ScoreList<Double> scoreList = new ScoreList<>();
            for (int i = 0; i < studentArr.length; i++) {
                scoreList.addElement(Double.parseDouble(studentArr[i]));
            }
            return String.format("%.2f", scoreList.averageValues());
        } else if (queryType == 5) {
            ScoreList<Double> scoreList = new ScoreList<>();
            for (int i = 0; i < studentArr.length; i++) {
                scoreList.addElement(Double.parseDouble(studentArr[i]));
            }
            return String.format("%.2f", scoreList.averageValues());
        }
        return "Not a valid query";
    }

}

public class ScoreList<Type> {
    //Write your code
     ArrayList<Type> list = new ArrayList<>();

    public void addElement(Type t){
        list.add(t);
    }

    public void removeElement(Type t) {
        list.remove(t);
    }

    public Type getElement(int i) {
        return list.get(i);
    }

    public double averageValues() {
        double avg = 0;
        for(int i=0; i<list.size(); i++) {
            avg += (Double)list.get(i);
        }
        avg /= list.size();
        return Double.parseDouble(String.format("%.2f",avg));
    }
}

public class StudentList<Type> {
    //Write your code
    ArrayList<Type> list = new ArrayList<>();

    public void addElement(Type t){
        list.add(t);
    }

    public void removeElement(Type t) {
        list.remove(t);
    }

    public Type getElement(int index) {
        return list.get(index);
    }

    public String beginsWith(String prefix) {
        String res = "";
        for(int i=0; i<list.size(); i++) {
            if(String.valueOf(list.get(i)).toLowerCase().startsWith(prefix.toLowerCase())){
                res += list.get(i).toString() + "\n";
            }
        }
        return res;
    }

    public String bloodGroupOf(String[] bloodGroups, String bloodGroup) {
        String res = "";
        for(int i=0; i<bloodGroups.length; i++) {
            if(bloodGroup.equalsIgnoreCase(bloodGroups[i])){
                res += list.get(i).toString() + "\n";
            }
        }
        return res;
    }

    public int thresholdScore(int score) {
        int count = 0;
        for(int i=0; i<list.size(); i++) {
            if((Integer)list.get(i) >= score) {
                count++;
            }
        }
        return count;
    }
}

Packages

public class NumberFinder {
  public static boolean isKeith(int n) {
    ArrayList<Integer> l = new ArrayList<>();

    int temp = n;
    while (temp > 0) {
      l.add(temp % 10);
      temp /= 10;
    }
    Collections.reverse(l);
    int i, len, nextTerm = 0;
    i=len = l.size();
    while(nextTerm < n) {
      nextTerm = 0;
      for (int j = 1; j <= len; j++) {
        nextTerm += l.get(i - j);
      }
      l.add(nextTerm);
      i++;
    }
    return nextTerm == n;
  }

  public static boolean isPrime(int n) {
    if (n <= 1) return false;
    if (n <= 3) return true;
    if (n % 2 == 0) return false;
    if (n % 3 == 0) return false;

    for (int i = 5; i <= Math.sqrt(n); i+=2) {
      if (n % i == 0) return false;
    }
    return true;
  }
}

public class ExtractString {
  public static int[] extractNumericNumbers(String s){
    ArrayList<Integer> nums = new ArrayList<>();
    String temp = "";
    for(int i = 0; i < s.length(); i++) {
      if((i==0|| !Character.isAlphabetic(s.charAt(i-1))) && Character.isDigit(s.charAt(i))) {
        temp += s.charAt(i);
      } else {
        if(!temp.trim().equals("") && !Character.isAlphabetic(s.charAt(i))) {
          nums.add(Integer.parseInt(temp));
        }
        temp = "";
      }
    }
    if (!temp.equals("")) nums.add(Integer.parseInt(temp));
    int arr[] = nums.stream().mapToInt(Integer::intValue).toArray();
    return arr;
  }

  public static int[] extractTextNumbers(String s){
    String words[] = s.split(" ");
    ArrayList<Integer> nums = new ArrayList<>();
    for(int i = 0; i < words.length; i++) {
        if(words[i].equalsIgnoreCase("one"))
            nums.add(1);
        else if(words[i].equalsIgnoreCase("two"))
            nums.add(2);
        else if(words[i].equalsIgnoreCase("three"))
            nums.add(3);
        else if(words[i].equalsIgnoreCase("four"))
            nums.add(4);
        else if(words[i].equalsIgnoreCase("five"))
            nums.add(5);
        else if(words[i].equalsIgnoreCase("six"))
            nums.add(6);
        else if(words[i].equalsIgnoreCase("seven"))
            nums.add(7);
        else if(words[i].equalsIgnoreCase("eight"))
            nums.add(8);
        else if(words[i].equalsIgnoreCase("nine"))
            nums.add(9);
        else if(words[i].equalsIgnoreCase("zero"))
            nums.add(0);
    }

    int numsArr[] = nums.stream().mapToInt(Integer::intValue).toArray();
    
    return numsArr;
  }
}

public class KeithClass {
    public String getInput(String conversation) {
        int[] numericNumbers = ExtractString.extractNumericNumbers(conversation);
        int[] textNumbers = ExtractString.extractTextNumbers(conversation);
        int sum = 0;
        String res = "";
        for(int i = 0; i < numericNumbers.length; i++) {
            if(NumberFinder.isKeith(numericNumbers[i]) && !NumberFinder.isPrime(numericNumbers[i])) {
                res+= Integer.toString(numericNumbers[i]);
            }
        }
        for(int i = 0; i < textNumbers.length; i++) {
            sum+=textNumbers[i];
        }
        res+= Integer.toString(sum);
        return res;
    }
 
}

Exceptions

Solution.java

class InvalidMessageException extends Exception {
    InvalidMessageException(String message){
        super(message);
    }
}

class Encrypter {
    public static String encryptMessage(String message) throws InvalidMessageException{
        if(!Validator.validate(message)) {
            throw new InvalidMessageException("Try again with valid message");
        }
        String res = (new StringBuilder(message)).reverse().toString().toLowerCase();
        return res;
    }
}

class Validator {
    public static boolean validate(String message) {
        return message.matches("[A-Za-z0-9 ]+");
    }
}

public class Solution {
    private static final Scanner INPUT_READER = new Scanner(System.in);
    
    public static void main(String[] args) {
        String message = INPUT_READER.nextLine();
        
        try {
            String encrypted_message = Encrypter.encryptMessage(message);
            if(! encrypted_message.startsWith("InvalidMessageException"))
                System.out.println(encrypted_message);
        } catch (Exception e) {
            System.out.println(e);
        }
    }
}

Collections

HashMap

class Library
{
    
    String bookName;
    String author;
    Library()
    {
    }

    @Override
    public int hashCode() {
        int hash = 3;
        hash = 83 * hash + Objects.hashCode(this.bookName);
        hash = 83 * hash + Objects.hashCode(this.author);
        return hash;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null) {
            return false;
        }
        if (getClass() != obj.getClass()) {
            return false;
        }
        final Library other = (Library) obj;
        if (!Objects.equals(this.bookName, other.bookName)) {
            return false;
        }
        if (!Objects.equals(this.author, other.author)) {
            return false;
        }
        return true;
    }
    
    
    Library(String bookName,String author)
    {
        this.bookName=bookName;
        this.author=author;
    }
    public HashMap<Integer,Library> createLibraryMap(String booksInLibrary)
    {
        HashMap<Integer,Library> map = new HashMap<>();
        String books[] = booksInLibrary.split("\\|");
        for(String book: books) {
            String bookParams[] = book.split(",");
            Library lib = new Library(bookParams[1], bookParams[2]);
            map.put(Integer.parseInt(bookParams[0]), lib);
        }
        return map;
    }
    public HashMap<Integer,Integer> createUserMap(String borrowedUsers)
    {
        HashMap<Integer,Integer> map = new HashMap<>();
        String users[] = borrowedUsers.split("\\|");
        for(String user: users) {
            String userParams[] = user.split(",");
            map.put(Integer.parseInt(userParams[0]), Integer.parseInt(userParams[1]));
        }
        return map;
    }

    
    public String getQuery(String booksInLibrary,String borrowedUsers,String query)
    {
        HashMap<Integer,Library> libraryMap = createLibraryMap(booksInLibrary);
        HashMap<Integer,Integer> userMap = createUserMap(borrowedUsers);
        String queryParams[] = query.split(",");
        int queryType = Integer.parseInt(queryParams[0]), userId, inCnt = 0, outCnt = 0;
        String res = "";
        Library lib;
        switch(queryType) {
            case 1: 
            if(userMap.containsKey(Integer.parseInt(queryParams[1]))){
                userId = userMap.get(Integer.parseInt(queryParams[1]));
                res = String.format("No Stock\nIt is owned by %d\n", userId);
            } else {
                lib = libraryMap.get(Integer.parseInt(queryParams[1]));
                res = String.format("It is available\nAuthor is %s\n", lib.author);
            }
            break;
            case 2: 
            for(int bookId: userMap.keySet()) {
                if(userMap.get(bookId) == Integer.parseInt(queryParams[1])) {
                    lib = libraryMap.get(bookId);
                    res+=String.format("%d %s\n", bookId, lib.bookName);
                }
            }
            break;
            case 3: inCnt = outCnt = 0;
            for(int bookId: libraryMap.keySet()) {
                if(libraryMap.get(bookId).bookName.equals(queryParams[1])) {
                    if(userMap.containsKey(bookId)) outCnt++;
                    else inCnt++;
                }
            }
            res = String.format("%d out\n%d in\n", outCnt, inCnt);
            break;
            case 4:
            for(int bookId: libraryMap.keySet()) {
                if(libraryMap.get(bookId).author.equals(queryParams[1])) {
                    res +=libraryMap.get(bookId).bookName+"\n";
                }
            }
            break;
            case 5: 
            for(int bookId: libraryMap.keySet()) {
                if(libraryMap.get(bookId).bookName.toLowerCase().contains(queryParams[1].toLowerCase())) {
                    res +=String.format("%d %s\n", bookId,libraryMap.get(bookId).bookName);
                }
            }
            break;
            default: return "Invalid Query Type";
        }

        return res;
    }
}

TreeMap

public class TreemapHandson {
    public TreeMap<Integer, String> createPlayerPositionMap(String cricketDataset) {
        TreeMap<Integer, String> map = new TreeMap<>();
        String players[] = cricketDataset.split("\\|");
        for (String player : players) {
            String playerParams[] = player.split(",");
            map.put(Integer.parseInt(playerParams[0]), playerParams[1]);
        }
        return map;
    }

    public TreeMap<String, Integer> createPlayerScoreMap(String cricketDataset) {
        TreeMap<String, Integer> map = new TreeMap<>();
        String players[] = cricketDataset.split("\\|");
        for (String player : players) {
            String playerParams[] = player.split(",");
            map.put(playerParams[1], Integer.parseInt(playerParams[2]));
        }
        return map;
    }

    public TreeMap<String, double[]> createMatchesMap(String cricketDataset) {
        String matches[] = cricketDataset.split("\\n");
        TreeMap<String, double[]> map = new TreeMap<>();
        for (String match : matches) {
            for (String player : match.split("\\|")) {
                String playerParams[] = player.split(",");
                if (playerParams[0].equals("1") || playerParams[0].equals("2")) {
                    if (map.containsKey(playerParams[1])) {
                        double[] arr = map.get(playerParams[1]);
                        arr[0] += 1;
                        arr[1] += Integer.parseInt(playerParams[2]);
                        map.put(playerParams[1], arr);
                    } else {
                        map.put(playerParams[1], new double[]{1, Integer.parseInt(playerParams[2])});
                    }
                }
            }
        }
        return map;
    }

    public String getQuery(String cricketDataset, String query) {
        String queryParams[] = query.split(" ");
        TreeMap<Integer, String> playerPositionMap;
        TreeMap<String, Integer> playerScoreMap;
        TreeMap<String, double[]> matchesMap;
        String res = "", maxPlayer = "";
        double maxScore = 0;
        switch (queryParams[0]) {
            case "1":
                playerPositionMap = createPlayerPositionMap(cricketDataset);
                for (int playerPosition : playerPositionMap.keySet()) {
                    if (playerPosition >= Integer.parseInt(queryParams[1]) && playerPosition <= Integer.parseInt(queryParams[2])) {
                        res += String.format("%d %s\n", playerPosition, playerPositionMap.get(playerPosition));
                    }
                }
                break;
            case "2":
                playerPositionMap = createPlayerPositionMap(cricketDataset);
                playerScoreMap = createPlayerScoreMap(cricketDataset);
                for (int playerPosition : playerPositionMap.keySet()) {
                    if (playerScoreMap.get(playerPositionMap.get(playerPosition)) > Integer.parseInt(queryParams[1])) {
                        res += String.format("%d %s\n", playerPosition, playerPositionMap.get(playerPosition));
                    }
                }
                break;
            case "3":
                matchesMap = createMatchesMap(cricketDataset);
                for (String playerName : matchesMap.keySet()) {
                    double[] params = matchesMap.get(playerName);
                    if ((params[1] / params[0]) > maxScore) {
                        maxPlayer = playerName;
                        maxScore = (params[1] / params[0]);
                    }
                }
                res = String.format("The Efficient Opener is %s", maxPlayer);
                break;
            default:
                return "Invalid Query Type";
        }
        return res;
    }
}

ArrayList

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

class Passanger {
    int id;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public float getFare() {
        return fare;
    }

    public void setFare(float fare) {
        this.fare = fare;
    }

    float fare;

    public Passanger(int id, float fare) {
        this.id = id;
        this.fare = fare;
    }

    public static float calculateFare(int capacity, int currentCapacity) {
        if (currentCapacity <= Math.ceil(capacity / 4.0)) {
            return capacity * 1.6f;
        }
        if (currentCapacity <= Math.ceil(capacity / 2.0)) {
            return capacity * 1.3f;
        }
        return capacity;
    }
}

public class BusProb {

    public String output(int capacity, int stops, List<String> listOfInputStrings, String query) {
        String[] queryParams = query.split(", ");
        int queryType = Integer.parseInt(queryParams[0]);
        List<Integer> busQueue = new ArrayList<>();
        List<Passanger> passengerList = new ArrayList<>();
        int onCnt = 0, offCnt = 0, cnt = 0, i;
        float fare;
        float[] fares = { 0, 0, 0 };
        int[] farePass = { 0, 0, 0 };

        for (i = 0; i < stops; i++) {
            onCnt = offCnt = 0;
            for (String p : listOfInputStrings.get(i).split(" ")) {
                if (p.startsWith("+")) {
                    onCnt++;
                }
                if (p.startsWith("-")) {
                    offCnt++;
                }
            }
            cnt += onCnt - offCnt;

            for (String p : listOfInputStrings.get(i).split(" ")) {
                if (p.startsWith("+")) {
                    busQueue.add(Integer.parseInt(p.substring(1)));
                    passengerList.add(new Passanger(Integer.parseInt(p.substring(1)), Passanger.calculateFare(capacity, cnt)));
                } 
                if(p.startsWith("-")) {
                    busQueue.removeIf(p1 -> p1 == Integer.parseInt(p.substring(1)));
                }
            }
        }

        switch (queryType) {
            case 1:
                onCnt = offCnt = 0;
                for (i = 0; i < stops; i++) {
                    for (String p : listOfInputStrings.get(i).split(" ")) {
                        if (p.startsWith("+")) {
                            onCnt++;
                        } else {
                            offCnt++;
                        }
                    }
                }
                return String.format("%d passengers got on the bus and %d passengers got out of the bus", onCnt,
                        offCnt);

            case 2:
                fares[0] = capacity * 1.6f;
                fares[1] = capacity * 1.3f;
                fares[2] = capacity;
                farePass[0] = (int) passengerList.stream().filter(p -> p.getFare() == fares[0]).count();
                farePass[1] = (int) passengerList.stream().filter(p -> p.getFare() == fares[1]).count();
                farePass[2] = (int) passengerList.stream().filter(p -> p.getFare() == fares[2]).count();

                return String.format(
                        "%d passengers traveled with a fare of %.1f, %d passengers traveled with a fare of %.1f and %d passengers traveled with a fare of %.1f",
                        farePass[0], fares[0], farePass[1], fares[1], farePass[2], fares[2]);

            case 3:
                fare = passengerList.stream()
                        .filter(p -> p.getId() == Integer.parseInt(queryParams[1]))
                        .map(p -> p.getFare())
                        .reduce(0.0f, Float::sum);
                return String.format("Passenger %s spent a total fare of %.1f", queryParams[1], fare);

            case 4:
                cnt = (int) passengerList.stream().filter(p -> p.getId() == Integer.parseInt(queryParams[1])).count();
                return String.format("Passenger %s has got on the bus for %d times",
                        queryParams[1], cnt);

            case 5:
                // Check if passenger exists
                if (busQueue.removeIf(p1 -> p1 == Integer.parseInt(queryParams[1]))) {
                    return String.format("Passenger %s was inside the bus at the end of the trip",
                            queryParams[1]);
                }
                return String.format("Passenger %s was not inside the bus at the end of the trip",
                        queryParams[1]);
            default:
                return "Invalid Query Type";
        }
    }
}

HashSet

Hashset.java

import java.util.HashSet;

public class Hashset {

    public static String getOut(int numberOfMatches, String squads, int squad1, int squad2) {
        // write your code here
        String res = "";
        String[] matchSet = squads.split("#");
        String[] players;
        HashSet<String> intersectionSet = new HashSet<String>(),
                unionSet = new HashSet<String>(),
                inMatchSet = new HashSet<String>(),
                notInMatchSet = new HashSet<String>();

        for (int i = 0; i < matchSet.length; i++) {
            players = matchSet[i].split(" ");
            HashSet<String> curSet = new HashSet<String>();
            for (String playerName : players) {
                curSet.add(playerName);
            }
            if (i == 0) {
                intersectionSet.addAll(curSet);
            } else {
                intersectionSet.retainAll(curSet);
            }
            unionSet.addAll(curSet);
            if (i == squad1 - 1) {
                notInMatchSet.addAll(curSet);
            }
            if (i == squad2 - 1) {
                inMatchSet.addAll(curSet);
            }
        }
        unionSet.removeAll(notInMatchSet);
        inMatchSet.retainAll(unionSet);
        res = String.format("%s, %s", String.join(" ", intersectionSet), String.join(" ", inMatchSet));
        return res;
    }
}

Functional Programming : Lambda, Streams

LambdaFn.java

import java.util.*;
import java.util.stream.Collectors;

public class LambdaFn {

    public boolean isNarcissisticNumber(String s) {
        long r = 0;
        for (int i = 0; i < s.length(); i++) {
            long l = Long.parseLong(s.charAt(i) + "");
            r += Math.pow(l, s.length());
        }
        return r == Long.parseLong(s);
    }

    public List<Long> functionalProgramming(List<String> listOfIntegers) {
        //Write your code here
        List<Long> outputList = Collections.emptyList();
        outputList = listOfIntegers.stream()
                .filter(s -> isNarcissisticNumber(s))
                .map(s -> Long.valueOf(s))
                .collect(Collectors.toList());
        return outputList;
    }
}

Multithreading

Solution.java

class Task1 extends Thread {
    public static int beg, a;

    public void run() {
        try {
            for (int i = beg; i < a + beg; i++) {
                synchronized (Solution.i) {
                    int index = Integer.parseInt(Solution.i);
                    Solution.threadArray[index++] = i;
                    Solution.i = Integer.toString(index);
                    System.err.printf("1: %d\n",index);
                    Thread.sleep(3);
                }
            }
        } catch (Exception e) {
            Thread.currentThread().interrupt();
        }
    }
}

class Task2 extends Thread {
    public static int beg, a;

    public void run() {
        try {
            for (int i = beg; i < a + beg; i++) {
                synchronized (Solution.i) {
                    Thread.sleep(6);
                    int index = Integer.parseInt(Solution.i);
                    Solution.threadArray[index++] = i;
                    Solution.i = Integer.toString(index);
                    System.err.printf("2: %d\n",index);
                }
            }
        } catch (Exception e) {
            Thread.currentThread().interrupt();
        }
    }
}

class Task3 extends Thread {
    public static int beg, a;

    public void run() {

        try {
            for (int i = beg; i < a + beg; i++) {
                synchronized (Solution.threadArray) {
                int index = Integer.parseInt(Solution.i);
                Solution.threadArray[index++] = i;
                Solution.i = Integer.toString(index);
                }
            }
        } catch (Exception e) {
            Thread.currentThread().interrupt();
        }
    }
}
public class Solution {
    public static final int[] threadArray = new int[300];
    public static volatile String i = 0 + "";

    public boolean test() throws InterruptedException {
        Task1 task1 = new Task1();
        Task2 task2 = new Task2();
        Task3 task3 = new Task3();
        Thread task2Thread = new Thread(task2);
        Thread task3Thread = new Thread(task3);
        task1.start();
        task2Thread.start();
        task1.join();
        task2Thread.join();
        task3Thread.start();
        int first = Task1.a + Task2.a;
        int containsSecondThread = Task1.a;
        String oneAndTwo = "";
        String sizeOfTask1 = "";
        for (int i = 0; i < first; i++) {
            oneAndTwo += threadArray[i] + " ";
        }
        for (int i = 0; i < containsSecondThread; i++) {
            sizeOfTask1 += threadArray[i] + " ";
        }
        int begOfTask3 = Task3.beg;
        String checkingString = "";
        for (int i = begOfTask3; i < threadArray.length; i++) {
            checkingString += i + " ";
        }
        String task3String = "";
        for (int j = begOfTask3; j < threadArray.length; j++) {
            task3String += threadArray[j] + " ";
        }
        if ((!oneAndTwo.contains(begOfTask3 + "") && sizeOfTask1.contains(Task2.beg + ""))
                && task3String.equals(checkingString)) {
            return true;
        }
        return false;
    }

    public static void main(String[] args) throws InterruptedException {
        Scanner sc = new Scanner(System.in);
        Solution solution = new Solution();
        int one = sc.nextInt();
        Task1.a = one;
        Task1.beg = 0;
        int two = sc.nextInt();
        Task2.a = two;
        Task2.beg = one;
        int three = sc.nextInt();
        Task3.a = three;
        Task3.beg = one + two;
        System.out.print(solution.test());
        sc.close();
    }
}

Regular Expression

RegEx.java

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegEx {

    public String findCardTypeNumbers(String conversation, String cardType) {
        // Write your code here
        StringBuilder res = new StringBuilder();
        Pattern pattern;
        Matcher matcher;

        switch (cardType) {
            case "Visa":
                pattern = Pattern.compile("\\b4(\\d{15}|\\d{12})\\b");
                break;

            case "American Express":
                pattern = Pattern.compile("\\b(34|37)\\d{13}\\b");
                break;

            case "Discover":
                pattern = Pattern.compile("\\b(65\\d{14})|(6011\\d{12})\\b");
                break;

            case "JCB":
                pattern = Pattern.compile("\\b((2131|1800)\\d{11})|(35\\d{14})\\b");
                break;
            default:
                return "Not a valid card type";
        }

        matcher = pattern.matcher(conversation);
        while (matcher.find()) {
            res.append(matcher.group() + " ");
        }

        return res.toString().trim();
    }
}

Database Connectivity

RunningScripts.java

import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.sql.Connection;
import org.apache.ibatis.jdbc.ScriptRunner;

public class RunningScripts {

    public void runDbScript() throws Exception {
        Connection conn = DbUtil.getConnection();
        ScriptRunner runner = new ScriptRunner(conn);
        InputStreamReader reader = new InputStreamReader(new FileInputStream("db.sql"));
        runner.runScript(reader);
        reader.close();
        DbUtil.closeConnection(conn);
    }
}

DBUtil.java

import java.sql.*;

public class DbUtil {
    private static String DB_URL = "jdbc:mysql://localhost:3306/grocery";
    private static String USERNAME = "user1";
    private static String PASSWORD = "MySQL123$";

    public static Connection getConnection() {
        Connection con = null;
        try {
            Class.forName("com.mysql.jdbc.Driver");
            con = DriverManager.getConnection(DB_URL, USERNAME, PASSWORD);
        } catch (Exception e) {
            System.out.println(e);
        }
        return con;
    }

    public static void closeConnection(Connection con) {
        try {
            con.close();
        } catch (Exception e) {

        }
    }
}

DbOperations.java

import DbUtil;
import java.sql.Connection;
import java.sql.Date;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;

public class DbOperations {

    public boolean insertCategory(String type) throws SQLException {
        try {
            Connection conn = DbUtil.getConnection();
            PreparedStatement stmt = conn.prepareStatement("INSERT INTO category(type) values (?)");
            stmt.setString(1, type);
            stmt.executeUpdate();
            return true;
        } catch (Exception e) {
        }
        return false;
    }

    public ArrayList getCategoryById(int id) throws SQLException {
        ArrayList res = new ArrayList();
        try {
            Connection conn = DbUtil.getConnection();
            PreparedStatement stmt = conn.prepareStatement("SELECT id, type FROM category where id = ?");
            stmt.setInt(1, id);
            ResultSet rs = stmt.executeQuery();
            while (rs.next()) {
                res.add(rs.getInt("id"));
                res.add(rs.getString("type"));
            }
            return res;
        } catch (Exception e) {
        }
        return null;
    }

    public ResultSet getAllCategory() throws SQLException {
        try {
            Connection conn = DbUtil.getConnection();
            PreparedStatement stmt = conn.prepareStatement("SELECT id, type FROM category");
            ResultSet rs = stmt.executeQuery();
            return rs;
        } catch (Exception e) {
        }
        return null;
    }

    public boolean insertProduct(String name, float price, String type) throws SQLException {
        try {
            Connection conn = DbUtil.getConnection();
            PreparedStatement stmt1 = conn.prepareStatement("SELECT id FROM category where type = ?");
            stmt1.setString(1, type);
            ResultSet rs = stmt1.executeQuery();

            int categoryId = -1;
            while (rs.next()) {
                categoryId = rs.getInt("id");
            }
            PreparedStatement stmt = conn.prepareStatement("INSERT INTO product(name, price, category_id) values (?,?,?)");
            stmt.setString(1, name);
            stmt.setFloat(2, price);
            stmt.setInt(3, categoryId);
            stmt.executeUpdate();
            return true;
        } catch (Exception e) {
        }
        return false;
    }

    public ArrayList getProductById(int id) throws SQLException {
        ArrayList res = new ArrayList();
        try {
            Connection conn = DbUtil.getConnection();
            PreparedStatement stmt = conn.prepareStatement("select id, name, price, category_id from product where id = ?");
            stmt.setInt(1, id);
            ResultSet rs = stmt.executeQuery();
            while (rs.next()) {
                res.add(rs.getInt("id"));
                res.add(rs.getString("name"));
                res.add(rs.getFloat("price"));
                res.add(rs.getInt("category_id"));
            }
            return res;
        } catch (Exception e) {
        }
        return null;
    }

    public ResultSet getAllProduct() throws SQLException {
        try {
            Connection conn = DbUtil.getConnection();
            PreparedStatement stmt = conn.prepareStatement("select id, name, price, category_id from product");
            ResultSet rs = stmt.executeQuery();
            return rs;
        } catch (Exception e) {
        }
        return null;
    }

    public boolean insertOrder(String product_name, Date date) throws SQLException {
        try {
            Connection conn = DbUtil.getConnection();
            PreparedStatement stmt1 = conn.prepareStatement("SELECT id FROM product where name = ?");
            stmt1.setString(1, product_name);
            ResultSet rs = stmt1.executeQuery();
            int productId = -1;
            while (rs.next()) {
                productId = rs.getInt("id");
            }
            PreparedStatement stmt = conn.prepareStatement("INSERT INTO product(product_id, order_date) values (?,?)");
            stmt.setInt(1, productId);
            stmt.setDate(2, date);
            stmt.executeUpdate();
            return true;
        } catch (Exception e) {
        }
        return false;
    }

    public ArrayList getOrderById(int id) throws SQLException {
        ArrayList res = new ArrayList();
        try {
            Connection conn = DbUtil.getConnection();
            PreparedStatement stmt = conn.prepareStatement("SELECT id, product_id, order_date FROM orders where id = ?");
            stmt.setInt(1, id);
            ResultSet rs = stmt.executeQuery();
            while (rs.next()) {
                res.add(rs.getInt("id"));
                res.add(rs.getInt("product_id"));
                res.add(rs.getDate("order_date"));
            }
            return res;
        } catch (Exception e) {
        }
        return null;
    }

    public ResultSet getAllOrder() throws SQLException {
        try {
            Connection conn = DbUtil.getConnection();
            PreparedStatement stmt = conn.prepareStatement("select id, product_id, order_date from orders");
            ResultSet rs = stmt.executeQuery();
            return rs;
        } catch (Exception e) {
        }
        return null;
    }
}

Read More