Task - Stream API - Book Market #53

akash-coded · 2022-03-08T07:59:46Z

akash-coded
Mar 8, 2022
Maintainer

Book Market

Using Stream operations on a Booklist

Define a class called Book. The skeleton of the Book class is given below:

class Book implements Comparable<Book> {
    int id;
    String name;
    String author;
    String publisher;
    int quantity;

    // parameterised constructor

    // override toString()

    // override hashCode()

    // override equals()

    // override compareTo(Book other): compares by id
}

Write the implementation for hashCode() and equals() manually. (Important fields: id)

In the driver class called BookMarket, create four instances of the Book class with the following:

Book b1 = new Book(121, "Let us C", "Yashwant Kanetkar", "BPB", 8);
Book b2 = new Book(233, "Operating System", "Galvin", "Wiley", 6);
Book b3 = new Book(101, "Data Communications & Networking", "Forouzan", "Mc Graw Hill", 4);
Book b4 = new Book(121, "Let us C", "Yashwant Kanetkar", "Mc Graw Hill", 11);

Create an ArrayList<Book> called books and insert the above book objects.

Use Stream API to do the following operations:

Print the details of each book in the given list of books.
Create a Set of books from the List by using a collector method, and then print the set.
Sort the List of books using the intermediate operation sorted(). Display the sorted results.
Double the quantity of each book in the List using the intermediate operation map(), and then display the updated books.
Use the intermediate operation filter() to keep only those books that quantity > 10 and collect them in a list, and print them.
Use the terminal operation reduce() to obtain the sum of quantity sold of books that have id < 200, and then print the sum obtained.

Reference

Refer to the Stream API demo program for syntax and other clues.

KaminiJha · 2022-03-08T08:54:57Z

KaminiJha
Mar 8, 2022

package Map;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collector;
import java.util.stream.Collectors;

class Books implements Comparable<Books> {
    int id;
    String name;
    String author;
    String publisher;
    int quantity;

    // parameterised constructor
    public Books(int id, String name, String author, String publisher, int quantity) {
        this.id = id;
        this.name = name;
        this.author = author;
        this.publisher = publisher;
        this.quantity = quantity;
    }

    // override equals()
    @Override
    public boolean equals(Object other) {
        if (this == other) {
            return true;
        } else if (other == null) {
            return false;
        } else if (this.getClass() != other.getClass())
            return false;
        Books obj = (Books) other;
        if (id != obj.id) {
            return false;
        } else {
            return true;
        }
    }

    // override hashCode()
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + id;
        return result;
    }

    @Override
    public int compareTo(Books o) {
        // TODO Auto-generated method stub
        return this.id - o.id;
    }

    // override toString()
    @Override
    public String toString() {
        return "Book [author=" + author + ", id=" + id + ", name=" + name + ", publisher=" + publisher + ", quantity="
                + quantity + "]";
    }

}

public class BookMarket {

    public static void main(String[] args) {

        Books b1 = new Books(121, "Let us C", "Yashwant Kanetkar", "BPB", 8);
        Books b2 = new Books(233, "Operating System", "Galvin", "Wiley", 6);
        Books b3 = new Books(101, "Data Communications & Networking", "Forouzan", "Mc Graw Hill", 4);
        Books b4 = new Books(121, "Let us C", "Yashwant Kanetkar", "Mc Graw Hill", 11);

        List<Books> books = new ArrayList<>();
        books.add(b1);
        books.add(b2);
        books.add(b3);
        books.add(b4);

        // print all the books
        System.out.println("-----Book list is------");
        books.stream().forEach(System.out::println);

        // create a Set of books by using the collector method and print it
        System.out.println("-----Book set is------");
        Set<Books> bookSet = books.stream().collect(Collectors.toSet());
        bookSet.stream().forEach(System.out::println);

        System.out.println("-----Sorted & Doubled quantity Book & filter books with quantity>10 list is------");
        books.stream().sorted().map(o -> {
            o.quantity = o.quantity * 2;
            return o;
        }).filter(o -> o.quantity > 10).collect(Collectors.toList()).forEach(System.out::println);
        
        // use reduce() to print the quantity sold of books having id < 200
        int soldBooks = books.stream().filter(o -> o.id < 200).map(o -> o.quantity).reduce(0, (ans, q) -> ans + q);
        System.out.println("quantity sold of books having id < 200 is " + soldBooks);
    }
}

0 replies

Ashwesh09 · 2022-03-08T09:12:05Z

Ashwesh09
Mar 8, 2022

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

public class StreamApi {
    public static void main(String[] args) {
        Book b1 = new Book(121, "Let us C", "Yashwant Kanetkar", "BPB", 8);
        Book b2 = new Book(233, "Operating System", "Galvin", "Wiley", 6);
        Book b3 = new Book(101, "Data Communications & Networking", "Forouzan", "Mc Graw Hill", 4);
        Book b4 = new Book(121, "Let us C", "Yashwant Kanetkar", "Mc Graw Hill", 11);
        List<Book> library = Arrays.asList(b1, b2, b3, b4);
        System.out.println("   ---   List of Books    --- ");
        library.forEach(System.out::println);
        Set<Book> setOfBooks = library.stream().collect(Collectors.toSet());
        System.out.println("   ----  Set of Books  ----- ");
        setOfBooks.stream().forEach(System.out::println);
        List<Book> sortedBooks = library.stream().sorted().toList();
        System.out.println(" ---- List of SORTED Books -----");
        sortedBooks.forEach(System.out::println);
        List<Book> doubleQunBook = library.stream()
                .map(b -> new Book(b.id, b.name, b.author, b.publisher, b.quantity * 2)).toList();
        System.out.println(" ---- Books quantity doubled  ---- ");
        doubleQunBook.stream().forEach(System.out::println);
        List<Book> booksQunLess = library.stream().filter(b -> b.quantity > 10).map(b -> b).toList();
        System.out.println(" --- Books quantity greater than 10 ---- ");
        booksQunLess.forEach(System.out::println);
        int soldBooks = library.stream().filter(b -> b.id < 200).map(b -> b.quantity).reduce(0, (ans, i) -> ans+i);
        System.out.println("\nQuantity of books sold with ID < 200 : "+ soldBooks);
    }
}

0 replies

shreiyarandive · 2022-03-08T09:15:05Z

shreiyarandive
Mar 8, 2022

package week6;

import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

class BookTwo implements Comparable<BookTwo> {
    protected int id;
    protected String name;
    protected String author;
    protected String publisher;
    protected int quantity;

    public BookTwo(int id, String name, String author, String publisher, int quantity) {
        this.id = id;
        this.name = name;
        this.author = author;
        this.publisher = publisher;
        this.quantity = quantity;
    }

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public String getPublisher() {
        return publisher;
    }

    public void setPublisher(String publisher) {
        this.publisher = publisher;
    }

    public int getQuantity() {
        return quantity;
    }

    public void setQuantity(int quantity) {
        this.quantity = quantity;
    }

    @Override
    public String toString() {
        return "Book [author=" + author + ", id=" + id + ", name=" + name + ", publisher=" + publisher + ", quantity="
                + quantity + "]";
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((author == null) ? 0 : author.hashCode());
        result = prime * result + id;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        BookTwo other = (BookTwo) obj;
        if (author == null) {
            if (other.author != null)
                return false;
        } else if (!author.equals(other.author))
            return false;
        if (id != other.id)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }

    @Override
    public int compareTo(BookTwo o) {
        return this.id - o.id;
    }

}

public class StreamAPI {
    public static void main(String[] args) {
        BookTwo b1 = new BookTwo(121, "Let us C", "Yashwant Kanetkar", "BPB", 8);
        BookTwo b2 = new BookTwo(233, "Operating System", "Galvin", "Wiley", 6);
        BookTwo b3 = new BookTwo(101, "Data Communications & Networking", "Forouzan", "Mc Graw Hill", 4);
        BookTwo b4 = new BookTwo(121, "Let us C", "Yashwant Kanetkar", "Mc Graw Hill", 11);

        List<BookTwo> list = new ArrayList<>();
        list.add(b1);
        list.add(b2);
        list.add(b3);
        list.add(b4);

        System.out.println("original list");
        list.forEach(System.out::println);

        System.out.println("Set created from List");
        Set<BookTwo> set = list.stream().collect(Collectors.toSet());
        set.forEach(System.out::println);

        System.out.println("Sorted list");
        List<BookTwo> sortedList = list.stream().sorted().collect(Collectors.toList());
        sortedList.forEach(System.out::println);

        System.out.println("Doubled list");
        List<BookTwo> doubledList = sortedList.stream().map(x -> {
            x.quantity *= 2;
            return x;
        }).collect(Collectors.toList());

        doubledList.forEach(System.out::println);

        System.out.println("Filtered list");
        List<BookTwo> filteredList = doubledList.stream().filter(x -> x.quantity > 10).collect(Collectors.toList());
        filteredList.forEach(System.out::println);

        int res = filteredList.stream().filter(x -> x.id < 200).map(o -> o.quantity).reduce(0,
                (ans, q) -> ans + q);

        System.out.println("Books sold id < 200: " + res);
    }
}

0 replies

Sarfinaa · 2022-03-08T09:15:13Z

Sarfinaa
Mar 8, 2022

package week_5;

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

class Bookss implements Comparable<Bookss> {
    int id;
    String name;
    String author;
    String publisher;
    int quantity;

    public int compareTo(Bookss other) {
        return this.id - other.id;
    }

    public Bookss(int id, String name, String author, String publisher, int quantity) {
        this.id = id;
        this.name = name;
        this.author = author;
        this.publisher = publisher;
        this.quantity = quantity;
    }

    @Override
    public String toString() {
        return "Books [author=" + author + ", id=" + id + ", name=" + name + ", publisher=" + publisher + ", quantity="
                + quantity + "]";
    }

    @Override
    public int hashCode() {
        int prime = 31;
        int result = 1;
        result = prime * result + id;
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Bookss other = (Bookss) obj;
        if (id != other.id)
            return false;
        return true;
    }

}

public class StreamTask {
    public static void main(String[] args) {
        Bookss b1 = new Bookss(121, "Let us C", "Yashwant Kanetkar", "BPB", 8);
        Bookss b2 = new Bookss(233, "Operating System", "Galvin", "Wiley", 6);
        Bookss b3 = new Bookss(101, "Data Communications & Networking", "Forouzan", "Mc Graw Hill", 4);
        Bookss b4 = new Bookss(121, "Let us C", "Yashwant Kanetkar", "Mc Graw Hill", 11);
        List<Bookss> list = new ArrayList<>(Arrays.asList(b1, b2, b3, b4));
        list.forEach(System.out::println);
        System.out.println("Set");
        list.stream().collect(Collectors.toSet()).forEach(System.out::println);
        System.out.println("Sorted List");
        list.stream().sorted().toList().forEach(System.out::println);
        System.out.println("Double val list");
        list.stream().map(book -> {
            book.quantity *= 2;
            return book;
        }).toList().forEach(System.out::println);
        System.out.println("Filtered List");
        list.stream().filter(book -> book.quantity > 10).toList().forEach(System.out::println);
        System.out.println("Reduced List");
        int reduced = list.stream().filter(book -> book.id < 200).map(book -> book.quantity).reduce(0, (ac, val) -> {
            return val + ac;
        });
        System.out.println(reduced);
    }
}

0 replies

Shubhi27 · 2022-03-08T09:17:50Z

Shubhi27
Mar 8, 2022

package maps;

import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

class Book1 implements Comparable<Book1> {
    int id;
    String name;
    String author;
    String publisher;
    int quantity;

    public Book1(int id, String name, String author, String publisher, int quantity) {
        this.id = id;
        this.name = name;
        this.author = author;
        this.publisher = publisher;
        this.quantity = quantity;
    }

    public int getId() {
        return id;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + id;
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Book1 other = (Book1) obj;
        if (id != other.id)
            return false;
        return true;
    }

    @Override
    public int compareTo(Book1 o) {
        return this.id - o.getId();
    }

    @Override
    public String toString() {
        return "Book1 [author=" + author + ", id=" + id + ", name=" + name + ", publisher=" + publisher + ", quantity="
                + quantity + "]";
    }

}

public class BookMarket {
    public static void main(String[] args) {
        Book1 b1 = new Book1(121, "Let us C", "Yashwant Kanetkar", "BPB", 8);
        Book1 b2 = new Book1(233, "Operating System", "Galvin", "Wiley", 6);
        Book1 b3 = new Book1(101, "Data Communications & Networking", "Forouzan", "Mc Graw Hill", 4);
        Book1 b4 = new Book1(121, "Let us C", "Yashwant Kanetkar", "Mc Graw Hill", 11);

        List<Book1> books = new ArrayList<>();
        books.add(b1);
        books.add(b2);
        books.add(b3);
        books.add(b4);
        books.stream().forEach(System.out::println);

        Set<Book1> Book1Set = books.stream().collect(Collectors.toSet());
        System.out.println("Printing Set");
        Book1Set.forEach(System.out::println);

        List<Book1> sortedBook1List = books.stream().sorted().toList();
        System.out.println("Printing Sorted List");
        sortedBook1List.forEach(System.out::println);

        System.out.println("Printing List with double quantity");
        books.stream().map(q -> {
            q.quantity = q.quantity * 2;
            return q;
        }).toList().forEach(System.out::println);

        System.out.println("Printing List with quantity greater than 10");
        books.stream().filter(q -> q.quantity > 10)
                .toList().forEach(System.out::println);

        int sold = books.stream().filter(q -> q.id < 200).map(q -> q.quantity).reduce(0, (ans, i) -> ans + i);
        System.out.println("Quantity of books with id < 200: " + sold);
    }

}

0 replies

preeti-max · 2022-03-08T09:25:19Z

preeti-max
Mar 8, 2022

`package StreamAPI;

import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

class Book1 implements Comparable<Book1> {
    int id;
    String name;
    String author;
    String publisher;
    int quantity;

    public Book1(int id, String name, String author, String publisher, int quantity) {
        this.id = id;
        this.name = name;
        this.author = author;
        this.publisher = publisher;
        this.quantity = quantity;
    }

    public int getId() {
        return id;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + id;
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Book1 other = (Book1) obj;
        if (id != other.id)
            return false;
        return true;
    }

    @Override
    public int compareTo(Book1 o) {
        return this.id - o.getId();
    }

    @Override
    public String toString() {
        return "Book1 [author=" + author + ", id=" + id + ", name=" + name + ", publisher=" + publisher + ", quantity="
                + quantity + "]";
    }

}

public class BookMarket {
    public static void main(String[] args) {
        Book1 b1 = new Book1(121, "Let us C", "Yashwant Kanetkar", "BPB", 8);
        Book1 b2 = new Book1(233, "Operating System", "Galvin", "Wiley", 6);
        Book1 b3 = new Book1(101, "Data Communications & Networking", "Forouzan", "Mc Graw Hill", 4);
        Book1 b4 = new Book1(121, "Let us C", "Yashwant Kanetkar", "Mc Graw Hill", 11);

        List<Book1> books = new ArrayList<>();
        books.add(b1);
        books.add(b2);
        books.add(b3);
        books.add(b4);
        books.stream().forEach(System.out::println);

        Set<Book1> set = books.stream().collect(Collectors.toSet());

        set.forEach(System.out::println);

        List<Book1> sortedBook1List = books.stream().sorted().collect(Collectors.toList());
        System.out.println("After sorting");
        sortedBook1List.forEach(System.out::println);

        System.out.println("After  doubling quantity");
        books.stream().map(q -> {
            q.quantity = q.quantity * 2;
            return q;
        }).collect(Collectors.toList()).forEach(System.out::println);

        System.out.println("Elements with quantity > 10");
        books.stream().filter(q -> q.quantity > 10)
                .collect(Collectors.toList()).forEach(System.out::println);

        int sold = books.stream().filter(i -> i.id < 200).map(x -> x.quantity).reduce(0, (ans, i) -> ans + i);
        System.out.println("Quantity of books with id < 200: " + sold);
    }
}`

0 replies

lalit-ky · 2022-03-08T09:27:37Z

lalit-ky
Mar 8, 2022

package collections;

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

class Book implements Comparable<Book> {
    protected int id;
    protected String name;
    protected String author;
    protected String publisher;
    protected int quantity;

    public Book(int id, String name, String author, String publisher, int quantity) {
        this.id = id;
        this.name = name;
        this.author = author;
        this.publisher = publisher;
        this.quantity = quantity;
    }

    @Override
    public String toString() {
        return "Book [author=" + author + ", id=" + id + ", name=" + name + ", publisher=" + publisher + ", quantity="
                + quantity + "]";
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + id;
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Book other = (Book) obj;
        if (id != other.id)
            return false;
        return true;
    }

    @Override
    public int compareTo(Book o) {
        return this.id - o.id;
    }

}

public class BookDriver {
    public static void main(String[] args) {

        Book b1 = new Book(121, "Let us C", "Yashwant Kanetkar", "BPB", 8);
        Book b2 = new Book(233, "Operating System", "Galvin", "Wiley", 6);
        Book b3 = new Book(101, "Data Communications & Networking", "Forouzan", "Mc Graw Hill", 4);
        Book b4 = new Book(121, "Let us C", "Yashwant Kanetkar", "Mc Graw Hill", 11);

        ArrayList<Book> books = new ArrayList<>();
        books.add(b1);
        books.add(b2);
        books.add(b3);
        books.add(b4);

        books.stream().forEach(System.out::println);
        System.out.println();

        System.out.println("***************** SET ***************************");
        Set<Book> set = books.stream().collect(Collectors.toSet());
        set.stream().forEach(System.out::println);
        System.out.println();

        System.out.println("***************** Sorted ***************************");
        books.stream().sorted().forEach(System.out::println);
        System.out.println();

        System.out.println("***************** Quantity Doubled *******************************");
        books.stream().map(x -> {
            x.quantity *= 2;
            return x;
        }).forEach(System.out::println);
        System.out.println();

        System.out.println("***************** HAving Quantity>10 *******************************");
        List<Book> newBooks = books.stream().filter(x -> x.quantity > 10).toList();
        newBooks.stream().forEach(System.out::println);
        System.out.println();

        int sumOfQuantity = books.stream().filter(x -> x.id < 200).map(x -> x.quantity).reduce(0, (x, y) -> x + y);
        System.out.println("quantity sold of books having id < 200 : " + sumOfQuantity);
    }
}

0 replies

SrideviYamala · 2022-03-08T09:28:04Z

SrideviYamala
Mar 8, 2022

package collections;

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

class Book implements Comparable<Book> {
    int id;
    String name;
    String author;
    String publisher;
    int quantity;

    public Book(int id, String name, String author, String publisher, int quantity) {
        this.id = id;
        this.name = name;
        this.author = author;
        this.publisher = publisher;
        this.quantity = quantity;
    }

    @Override
    public String toString() {
        return "Book [author=" + author + ", id=" + id + ", name=" + name + ", publisher=" + publisher + ", quantity="
                + quantity + "]";
    }



    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + id;
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Book other = (Book) obj;
        if (id != other.id)
            return false;
        return true;
    }

    @Override
    public int compareTo(Book o) {
        return this.id - o.id;
    }

}

public class BookStream {
    public static void main(String[] args) {
        Book b1 = new Book(121, "Let us C", "Yashwant Kanetkar", "BPB", 8);
        Book b2 = new Book(233, "Operating System", "Galvin", "Wiley", 6);
        Book b3 = new Book(101, "Data Communications & Networking", "Forouzan", "Mc Graw Hill", 4);
        Book b4 = new Book(121, "Let us C", "Yashwant Kanetkar", "Mc Graw Hill", 11);
        List<Book> books = new ArrayList<>();
        books.add(b1);
        books.add(b2);
        books.add(b3);
        books.add(b4);
        books.stream().forEach(System.out::println);
        System.out.println();

        Set<Book> bookSet = books.stream().collect(Collectors.toSet());
        bookSet.forEach(System.out::println);
        System.out.println();

        books = books.stream().sorted().toList();
        books.forEach(System.out::println);
        System.out.println();

        books.stream().map(obj -> {
            obj.quantity *= 2;
            return obj;
        }).toList().forEach(System.out::println);
        System.out.println();

        books = books.stream().filter(obj -> obj.quantity > 10).toList();
        books.forEach(System.out::println);
        System.out.println();

        int sold = books.stream().filter(obj -> obj.id < 200).map(obj -> obj.quantity).reduce(0, (ans, i) -> ans + i);
        System.out.println(sold);
    }
}

0 replies

VigneshVishwa · 2022-03-08T09:33:21Z

VigneshVishwa
Mar 8, 2022

package Maps;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.*;

class Book implements Comparable<Book> {
    int id;
    String name;
    String author;
    String publisher;
    int quantity;

    public Book(int id, String name, String author, String publisher, int quantity) {
        this.id = id;
        this.name = name;
        this.author = author;
        this.publisher = publisher;
        this.quantity = quantity;
    }

    @Override
    public int hashCode() {
        final int prime = 37;
        int result = 1;
        result = prime * result + ((author == null) ? 0 : author.hashCode());
        result = prime * result + id;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Book other = (Book) obj;
        if (id != other.id)
            return false;
        return true;
    }

    @Override
    public String toString() {
        return "[Author=" + author + ", Id=" + id + ", Name=" + name + ", Publisher=" + publisher + ", Quantity="
                + quantity + "]";
    }

    @Override
    public int compareTo(Book o) {
        return this.id - o.id;
    }

}

public class Mapwithfilter {

    public static void main(String[] args) {
        Book b1 = new Book(121, "Let us C", "Yashwant Kanetkar", "BPB", 8);
        Book b2 = new Book(233, "Operating System", "Galvin", "Wiley", 6);
        Book b3 = new Book(101, "Data Communications & Networking", "Forouzan", "Mc Graw Hill", 4);
        Book b4 = new Book(121, "Let us C", "Yashwant Kanetkar", "Mc Graw Hill", 11);

        List<Book> books = new ArrayList<Book>();

        books.add(b1);
        books.add(b2);
        books.add(b3);
        books.add(b4);
        System.out.println("Contents of Book");
        books.stream().collect(Collectors.toSet()).forEach(System.out::println);
        System.out.println("Sorted List");
        books.stream().sorted().toList().forEach(System.out::println);
        System.out.println("Doubled list");
        books.stream().map(book -> {
            book.quantity *= 2;
            return book;
        }).toList().forEach(System.out::println);
        System.out.println("Filtered List");
        books.stream().filter(book -> book.quantity > 10).toList().forEach(System.out::println);
        System.out.println("Reduced List");
        int reduced = books.stream().filter(book -> book.id < 200).map(book -> book.quantity).reduce(0, (ac, val) -> {
            return val + ac;
        });
        System.out.println(reduced);

    }

}

0 replies

ratnadeepikavuddagiri · 2022-03-08T09:38:18Z

ratnadeepikavuddagiri
Mar 8, 2022

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

class Book {
    int id;
    String name;
    String author;
    String publisher;
    int quantity;
    
    public Book(int id, String name, String author, String publisher, int quantity) {
        this.id = id;
        this.name = name;
        this.author = author;
        this.publisher = publisher;
        this.quantity = quantity;
    }

    public int getId() {
        return id;
    }

    public void setPublisher(String publisher) {
        this.publisher = publisher;
    }


    @Override
    public String toString() {
        return "Book [author=" + author + ", id=" + id + ", name=" + name + ", publisher=" + publisher + ", quantity="
                + quantity + "]";
    }


    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + id;
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Book other = (Book) obj;
        if (id != other.id)
            return false;
        return true;
    }
}

public class BookMarket {
    public static void main(String[] args) {
        Book b1 = new Book(121, "Let us C", "Yashwant Kanetkar", "BPB", 8);
        Book b2 = new Book(233, "Operating System", "Galvin", "Wiley", 6);
        Book b3 = new Book(101, "Data Communications & Networking", "Forouzan", "Mc Graw Hill", 4);
        Book b4 = new Book(121, "Let us C", "Yashwant Kanetkar", "Mc Graw Hill", 11);
        ArrayList<Book> books = new ArrayList<>();
        books.add(b1);
        books.add(b2);
        books.add(b3);
        books.add(b4);
        System.out.println("Initial Books");
        books.stream().forEach(System.out::println);

        System.out.println("Set of Books");
        Set<Book> bookSet = books.stream().collect(Collectors.toSet());
        bookSet.stream().forEach(System.out::println);

        System.out.println("Sorting by id");
        List<Book> sortedById = books.stream().sorted((p1, p2) -> p1.getId() - p2.getId()).collect(Collectors.toList());
        sortedById.stream().forEach(System.out::println);

        books.stream().map(p1 -> {
            p1.quantity *= 2;
            return p1;}).collect(Collectors.toList());
        System.out.println("Books after Doubling quantity");
        books.stream().forEach(System.out::println);
        
        List<Book> quantityBooks = books.stream().filter(p1 -> p1.quantity > 10).collect(Collectors.toList());
        System.out.println("Books after filtering with quantity>10");
        quantityBooks.stream().forEach(System.out::println);
        
        int soldQuantity = books.stream().filter(p1 -> p1.id<200).map(p1->p1.quantity).reduce(0,(res,p1)->res+p1);
        System.out.println("Quantity sold : "+soldQuantity);
    }
}

0 replies

rakeshGit419 · 2022-03-08T09:38:25Z

rakeshGit419
Mar 8, 2022

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

class Book implements Comparable<Book> {
    int id;
    String name;
    String author;
    String publisher;
    int quantity;

    public int compareTo(Book other) {
        return this.id-other.id;
    }
    public int getQuantity() {
        return quantity;
    }
    public void setQuantity(int quantity) {
        this.quantity = quantity;
    }
    public Book(int id, String name, String author, String publisher, int quantity) {
        this.id = id;
        this.name = name;
        this.author = author;
        this.publisher = publisher;
        this.quantity = quantity;
    }
    @Override
    public String toString() {
        return "Book [author=" + author + ", id=" + id + ", name=" + name + ", publisher=" + publisher + ", quantity="
                + quantity + "]";
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((author == null) ? 0 : author.hashCode());
        result = prime * result + id;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null) return false;
        if (getClass() != obj.getClass()) return false;
        Book other = (Book) obj;
        if (author == null) {
            if (other.author != null) return false;
        } else if (!author.equals(other.author)) return false;
        if (id != other.id) return false;
        if (name == null) {
            if (other.name != null) return false;
        } else if (!name.equals(other.name)) return false;
        return true;
    }

}


public class BookDriver {
    public static void main(String[] args) {
        Book b1 = new Book(121, "Let us C", "Yashwant Kanetkar", "BPB", 8);//16
        Book b2 = new Book(233, "Operating System", "Galvin", "Wiley", 6);
        Book b3 = new Book(101, "Data Communications & Networking", "Forouzan", "Mc Graw Hill", 4);//8
        Book b4 = new Book(123, "Let us C", "Yashwant Kanetkar", "Mc Graw Hill", 11);

        List<Book> books = Arrays.asList(b1,b2,b3,b4);
        books.stream().forEach(System.out::println);


        Set<Book> bookSet = books.stream().collect(Collectors.toSet());
        bookSet.stream().forEach(System.out::println);

        List<Book> newList = books.stream().sorted()
        .map(n->{n.setQuantity(2*n.getQuantity());return n;})
        .filter(n-> n.getQuantity()>10).toList();
        newList.forEach(System.out::println);

        int booksSold = books.stream().filter(n-> n.id<200).map(e->e.quantity).reduce(0,(ans,i)->ans+i);
        System.out.println(booksSold);
        


        
        

    }
}

0 replies

Batchusatyasri · 2022-03-08T09:38:58Z

Batchusatyasri
Mar 8, 2022

package Maps;

import java.util.;
import java.util.stream.;
import java.util.stream.Collector;
import java.util.stream.Collectors;

class Book implements Comparable {
int id;
String name;
String author;
String publisher;
int quantity;

Book(int id, String name, String author, String publisher, int quantity) {
    this.id = id;
    this.name = name;
    this.author = author;
    this.publisher = publisher;
    this.quantity = quantity;
}

@Override
public String toString() {
    return "Book id: " + id + ", Bookname: " + name + ", Bookauthor: " + author + ", Bookpublisher: " + publisher
            + ", Bookquantity: " + quantity;
}

public int hashCode() {
    final int prime = 31;
    int result = 1;
    result = prime * result + ((author == null) ? 0 : author.hashCode());
    result = prime * result + ((name == null) ? 0 : name.hashCode());
    result = prime * result + id;
    return result;
}

public boolean equals(Object obj) {
    if (this == obj)
        return true;
    if (obj == null)
        return false;
    if (this.getClass() != obj.getClass())
        return false;
    Book other = (Book) obj;
    if (this.author == null) {
        if (other.author != null)
            return false;
    } else if (!this.author.equals(other.author))
        return false;
    if (this.id != other.id)
        return false;
    if (this.name == null) {
        if (other.name != null)
            return false;
    } else if (!this.name.equals(other.name))
        return false;
    return true;
}

public int compareTo(Book other) {
    return this.id - other.id;
}

}

public class Streambook {
public static void main(String[] args) {
Book b1 = new Book(121, "Let us C", "Yashwant Kanetkar", "BPB", 8);
Book b2 = new Book(233, "Operating System", "Galvin", "Wiley", 6);
Book b3 = new Book(101, "Data Communications & Networking", "Forouzan", "Mc Graw Hill", 4);
Book b4 = new Book(121, "Let us C", "Yashwant Kanetkar", "Mc Graw Hill", 11);
ArrayList books = new ArrayList();
books.add(b1);
books.add(b2);
books.add(b3);
books.add(b4);
books.stream().forEach(System.out::println);
System.out.println("Creating a set of books");
Set bookset = books.stream().collect(Collectors.toSet());
bookset.stream().forEach(System.out::println);
System.out.println("After sorting the books");
List sorted = books.stream().sorted().toList();
sorted.stream().forEach(System.out::println);
System.out.println("Doubling the quantity");
books.stream().map(book -> {
book.quantity *= 2;
return book;
}).toList().forEach(System.out::println);
System.out.println("Filtering the books");
List filters = books.stream().filter(book -> book.quantity > 10).collect(Collectors.toList());
filters.stream().forEach(System.out::println);
int res = filters.stream().filter(x -> x.id < 200).map(o -> o.quantity).reduce(0,
(ans, q) -> ans + q);
System.out.println("Books by using reduce() " + res);
}
}

0 replies

mkaifahmed · 2022-03-08T09:43:05Z

mkaifahmed
Mar 8, 2022

package Week6;

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

class Book implements Comparable<Book> {
    int id;
    String name;
    String author;
    String publisher;
    int quantity;

    public Book(int id, String name, String author, String publisher, int quantity) {
        this.id = id;
        this.name = name;
        this.author = author;
        this.publisher = publisher;
        this.quantity = quantity;
    }

    public int getId() {
        return id;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + id;
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Book other = (Book) obj;
        if (id != other.id)
            return false;
        return true;
    }

    @Override
    public int compareTo(Book o) {
        return this.id - o.getId();
    }

    @Override
    public String toString() {
        return "Book [author=" + author + ", id=" + id + ", name=" + name + ", publisher=" + publisher + ", quantity="
                + quantity + "]";
    }

}

public class StreamApi {
    public static void main(String[] args) {
        Book b1 = new Book(121, "Let us C", "Yashwant Kanetkar", "BPB", 8);
        Book b2 = new Book(233, "Operating System", "Galvin", "Wiley", 6);
        Book b3 = new Book(101, "Data Communications & Networking", "Forouzan", "Mc Graw Hill", 4);
        Book b4 = new Book(121, "Let us C", "Yashwant Kanetkar", "Mc Graw Hill", 11);

        List<Book> books = new ArrayList<>();
        books.add(b1);
        books.add(b2);
        books.add(b3);
        books.add(b4);
        System.out.println("Printing Books");
        books.stream().forEach(System.out::println);

        Set<Book> bookSet = books.stream().collect(Collectors.toSet());
        System.out.println("Set :");
        bookSet.forEach(System.out::println);

        List<Book> sortedBookList = books.stream().sorted().toList();
        System.out.println("Sorted");
        sortedBookList.forEach(System.out::println);

        System.out.println("double quantity");
        books.stream().map(q -> {
            q.quantity = q.quantity * 2;
            return q;
        }).toList().forEach(System.out::println);

        System.out.println("quantity greater than 10");
        books.stream().filter(q -> q.quantity > 10)
                .toList().forEach(System.out::println);

        System.out.println("Quantity of books with id < 200: "
                + books.stream().filter(q -> q.id < 200).map(q -> q.quantity).reduce(0, (ans, i) -> ans + i));
    }

}

0 replies

Gaurav-Joshi-31 · 2022-03-08T09:45:30Z

Gaurav-Joshi-31
Mar 8, 2022

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

class Bookk implements Comparable<Bookk> {
    private int id;
    private String name;
    private String author;
    private String publisher;
    private int quantity;

    public int getQuantity() {
        return quantity;
    }

    public void setQuantity(int quantity) {
        this.quantity = quantity;
    }

    public Bookk(int id, String name, String author, String publisher, int quantity) {
        this.id = id;
        this.name = name;
        this.author = author;
        this.publisher = publisher;
        this.quantity = quantity;
    }

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public String getPublisher() {
        return publisher;
    }

    public void setPublisher(String publisher) {
        this.publisher = publisher;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + id;
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Bookk other = (Bookk) obj;
        if (id != other.id)
            return false;
        return true;
    }

    @Override
    public String toString() {
        return "Bookk [author=" + author + ", id=" + id + ", name=" + name + ", publisher=" + publisher + ", quantity="
                + quantity + "]";
    }

    @Override
    public int compareTo(Bookk o) {
        return this.id - o.getId();
    }

}

public class BooksDriver {
    public static void main(String[] args) {
        Bookk b1 = new Bookk(121, "Let us C", "Yashwant Kanetkar", "BPB", 8);
        Bookk b2 = new Bookk(233, "Operating System", "Galvin", "Wiley", 6);
        Bookk b3 = new Bookk(101, "Data Communications & Networking", "Forouzan", "Mc Graw Hill", 4);
        Bookk b4 = new Bookk(121, "Let us C", "Yashwant Kanetkar", "Mc Graw Hill", 11);

        System.out.println("Printing arraylist");
        List<Bookk> books = Arrays.asList(b1, b2, b3, b4);
        books.stream().forEach(System.out::println);

        System.out.println("Printing set");
        Set<Bookk> bookSet = books.stream().collect(Collectors.toSet());
        bookSet.forEach(System.out::println);

        System.out.println("Printing sorted list");
        List<Bookk> sortedBooks = books.stream().sorted().toList();
        sortedBooks.stream().forEach(System.out::println);

        System.out.println("Printing quantity doubled list");
        List<Bookk> doubleQuantity = books.stream().map(b -> {
            b.setQuantity(b.getQuantity() * 2);
            return b;
        }).toList();
        doubleQuantity.stream().forEach(System.out::println);

        System.out.println("Printing filtered list");
        List<Bookk> filteredList = books.stream().filter(b -> b.getQuantity() > 10).toList();
        filteredList.stream().forEach(System.out::println);

        System.out.println("Printing reduced sum");
       int quantity = books.stream().filter(b -> b.getId() < 200).map(b -> b.getQuantity()).reduce(0, (ans, i) -> ans+i);
       System.out.println("Quantity:  "+quantity);

       

    }
}

0 replies

RohitN09 · 2022-03-08T09:45:54Z

RohitN09
Mar 8, 2022

package Week_6.StreamAPI;

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

class Book implements Comparable<Book> {
    int id;
    String name;
    String author;
    String publisher;
    int quantity;

    Book(int id, String name, String author, String publisher, int quantity) {
        this.id = id;
        this.name = name;
        this.author = author;
        this.publisher = publisher;
        this.quantity = quantity;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + id;
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Book other = (Book) obj;
        return id != other.id;
    }

    @Override
    public String toString() {
        return "Book [author=" + author + ", id=" + id + ", name=" + name + ", publisher=" + publisher + ", quantity="
                + quantity + "]";
    }

    @Override
    public int compareTo(Book other) {
        return id - other.id;
    }

}

public class Library {

    public static void main(String[] args) {
        Book b1 = new Book(121, "Let us C", "Yashwant Kanetkar", "BPB", 8);
        Book b2 = new Book(233, "Operating System", "Galvin", "Wiley", 6);
        Book b3 = new Book(101, "Data Communications & Networking", "Forouzan", "Mc Graw Hill", 4);
        Book b4 = new Book(121, "Let us C", "Yashwant Kanetkar", "Mc Graw Hill", 11);

        List<Book> arr = new ArrayList<>(Arrays.asList(b1, b2, b3, b4));
        System.out.println("Book List: ");
        arr.forEach(System.out::println);

        System.out.println("\nBook Set: ");
        Set<Book> bookSet = arr.stream().collect(Collectors.toSet());
        bookSet.stream().forEach(System.out::println);

        System.out.println("\nSorted Book Set: ");
        List<Book> sortedArr = arr.stream().sorted().toList();
        sortedArr.forEach(System.out::println);

        System.out.println("\nQuantity Doubled");
        List<Book> doubleArr = sortedArr.stream().map(book -> {
            book.quantity *= 2;
            return book;
        }).toList();
        doubleArr.forEach(System.out::println);

        System.out.println("\nFiltered List");
        List<Book> filteredArr = doubleArr.stream().filter(book -> book.quantity > 10).toList();
        filteredArr.forEach(System.out::println);

        System.out.println("\nAfter Reducing:");
        int res = filteredArr.stream().filter(book -> book.id < 200).map(book -> book.quantity).reduce(0,
                (sum, quantity) -> sum + quantity);
        System.out.println(res);

    }
}

0 replies

Kalairajavadivel · 2022-04-21T04:42:26Z

Kalairajavadivel
Apr 21, 2022

0 replies

vamsi1234567891 · 2022-04-21T04:43:00Z

vamsi1234567891
Apr 21, 2022

package com.java.stream;

public class Book implements Comparable<Book>{
	int id;
    String name;
    String author;
    String publisher;
    int quantity;
    
	public Book(int id, String name, String author, String publisher, int quantity) {
		super();
		this.id = id;
		this.name = name;
		this.author = author;
		this.publisher = publisher;
		this.quantity = quantity;
	}

	@Override
	public String toString() {
		return "Book [id=" + id + ", name=" + name + ", author=" + author + ", publisher=" + publisher + ", quantity="
				+ quantity + "]";
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((author == null) ? 0 : author.hashCode());
		result = prime * result + id;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		result = prime * result + ((publisher == null) ? 0 : publisher.hashCode());
		result = prime * result + quantity;
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Book other = (Book) obj;
		if (author == null) {
			if (other.author != null)
				return false;
		} else if (!author.equals(other.author))
			return false;
		if (id != other.id)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		if (publisher == null) {
			if (other.publisher != null)
				return false;
		} else if (!publisher.equals(other.publisher))
			return false;
		if (quantity != other.quantity)
			return false;
		return true;
	}

	@Override
	public int compareTo(Book arg0) {
		// TODO Auto-generated method stub
		return this.id-arg0.id;
	}

}

package com.java.stream;

import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

public class DriverClass {

	public static void main(String[] args) {
		Book b1 = new Book(121, "Let us C", "Yashwant Kanetkar", "BPB", 8);
		Book b2 = new Book(233, "Operating System", "Galvin", "Wiley", 6);
		Book b3 = new Book(101, "Data Communications & Networking", "Forouzan", "Mc Graw Hill", 4);
		Book b4 = new Book(121, "Let us C", "Yashwant Kanetkar", "Mc Graw Hill", 11);
		ArrayList<Book> list=new ArrayList<Book>();
		list.add(b1);
		list.add(b2);
		list.add(b3);
		list.add(b4);
		
		list.stream().forEach(book ->System.out.println(book));
		
		Set<Object> set=list.stream().collect(Collectors.toSet());
		System.out.println(set);
		
		list.stream().sorted().forEach(book -> System.out.println(book));
		
		list.stream().filter(book->book.quantity > 10).collect(Collectors.toList()).forEach(System.out::println);
		
		int value=list.stream().filter(b->b.id < 200).map(b ->b.quantity).reduce(0,(a ,val) -> a+val);
		System.out.println(value);
	}

}

0 replies

Svishva · 2022-04-21T04:47:48Z

Svishva
Apr 21, 2022

Visweshwaran M

Book.java

class Book implements Comparable<Book> {
    int id;
    String name;
    String author;
    String publisher;
    int quantity;

    public Book(int id, String name, String author, String publisher, int quantity) {
        this.id = id;
        this.name = name;
        this.author = author;
        this.publisher = publisher;
        this.quantity = quantity;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Book)) return false;
        Book book = (Book) o;
        return id == book.id;
    }

    @Override
    public int hashCode() {
        return Objects.hash(id);
    }

    @Override
    public int compareTo(Book book) {
        return Integer.valueOf(this.id).compareTo(book.id);
    }

    @Override
    public String toString() {
        return new StringJoiner(", ", Book.class.getSimpleName() + "[", "]")
                .add("id=" + id)
                .add("name='" + name + "'")
                .add("author='" + author + "'")
                .add("publisher='" + publisher + "'")
                .add("quantity=" + quantity)
                .toString();
    }
}

Driver Class

public class StreamApiBook {

    public static void main(String[] args) {

        Book b1 = new Book(121, "Let us C", "Yashwant Kanetkar", "BPB", 8);
        Book b2 = new Book(233, "Operating System", "Galvin", "Wiley", 6);
        Book b3 = new Book(101, "Data Communications & Networking", "Forouzan", "Mc Graw Hill", 4);
        Book b4 = new Book(121, "Let us C", "Yashwant Kanetkar", "Mc Graw Hill", 11);

        List<Book> books = new ArrayList<>();
        books.add(b1);
        books.add(b2);
        books.add(b3);
        books.add(b4);


        System.out.println("1. Print the details of each book in the given list of books.");
        books.stream().map(b -> b.name).forEach(System.out::println);

        System.out.println("2. Create a Set of books from the List by using a collector method. Display the contents of the set.");
        books.stream().collect(Collectors.toSet()).stream().map(b -> b.name).forEach(System.out::println);

        System.out.println("3. Sort the List of books using the intermediate operation sorted(). Display the sorted results.");
        books.stream().sorted().forEach(System.out::println);

        System.out.println("4. Double the quantity of each book in the List using the intermediate operation map(), and then display the updated books.");
        //books.stream().map(b -> {
         //   b.quantity = b.quantity * 2;
          //  return b;
        //}).forEach(System.out::println);
        books.stream().map(b -> b.quantity * 2).forEach(System.out::println); //new

        System.out.println("5. Use the intermediate operation filter() to keep only those books that quantity > 10 and collect them in a list, and print them.");
        books.stream().filter(b -> b.quantity > 10).forEach(System.out::println);

        System.out.println("6. Use the terminal operation reduce() to obtain the sum of quantity sold of books that have id < 200, and then print the sum obtained.");
        System.out.println(books.stream().filter(b -> b.id < 200).map(b -> b.quantity).reduce(0, (sum, quantity) -> sum + quantity));

    }
}

Screenshots

0 replies

Thiripurasundari-1223 · 2022-04-21T04:53:37Z

Thiripurasundari-1223
Apr 21, 2022

Book

class Book implements Comparable<Book> {
	    int id;
	    String name;
	    String author;
	    String publisher;
	    int quantity;
	    
		public Book(int id, String name, String author, String publisher, int quantity) {
			super();
			this.id = id;
			this.name = name;
			this.author = author;
			this.publisher = publisher;
			this.quantity = quantity;
		}


		
		@Override
		public int compareTo(Book o) {
			
				return this.id-o.id;
		}

		@Override
		public int hashCode() {
			return Objects.hash(id);
		}


		@Override
		public boolean equals(Object obj) {
			if (this == obj)
				return true;
			if (obj == null)
				return false;
			if (getClass() != obj.getClass())
				return false;
			Book other = (Book) obj;
			return id == other.id;
		}


		@Override
		public String toString() {
			return "Book [id=" + id + ", name=" + name + ", author=" + author + ", publisher=" + publisher
					+ ", quantity=" + quantity + "]";
		}
	}

# Driver Class

public class DriverClass {

	public static void main(String[] args) {
		Book b1 = new Book(121, "Let us C", "Yashwant Kanetkar", "BPB", 8);
		Book b2 = new Book(233, "Operating System", "Galvin", "Wiley", 6);
		Book b3 = new Book(101, "Data Communications & Networking", "Forouzan", "Mc Graw Hill", 4);
		Book b4 = new Book(121, "Let us C", "Yashwant Kanetkar", "Mc Graw Hill", 11);

		List<Book> books = Arrays.asList(b1, b2, b3, b4);
		Set<Book> setofBooks=books.stream().collect(Collectors.toSet());
		System.out.println("Books are"+setofBooks);
		books.stream().sorted().forEach(System.out::println);
		List<Integer> doublequality=books.stream().map(b->(b.quantity=b.quantity*2)).toList();
		System.out.println("Double the quality of each books will be"+doublequality);
		List<Book> booksOfQualityGreaterthantwenty=books.stream().filter(b->b.quantity>10).collect(Collectors.toList());
		System.out.println("Books of Quality Greater than Twenty will be"+booksOfQualityGreaterthantwenty);
		Integer sumofBooksQuality=books.stream().filter(b->b.id<200).map(b->b.quantity).reduce(0,(ans,i)-> ans+i);
		System.out.println("Sum of Quality of Books"+sumofBooksQuality);
	}

}

0 replies

AgeshAalam · 2022-04-21T04:55:08Z

AgeshAalam
Apr 21, 2022

Book

package com.company;

import java.util.Objects;

public class Book implements Comparable {
int id;
String name;
String author;
String publisher;
int quantity;

public Book() {
}

public Book(int id, String name, String author, String publisher, int quantity) {
this.id = id;
this.name = name;
this.author = author;
this.publisher = publisher;
this.quantity = quantity;
}

@OverRide
public String toString() {
return "Book{" +
"id=" + id +
", name='" + name + ''' +
", author='" + author + ''' +
", publisher='" + publisher + ''' +
", quantity=" + quantity +
'}';
}

@OverRide
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Book book = (Book) o;
return id == book.id && quantity == book.quantity && Objects.equals(name, book.name) && Objects.equals(author, book.author) && Objects.equals(publisher, book.publisher);
}

@OverRide
public int hashCode() {
return Objects.hash(id);
}

@OverRide
public int compareTo(Book o) {
return this.id - o.id;
}
}

Driver

package com.company;

import java.util.ArrayList;
import java.util.stream.Collectors;

public class BookMArket {
public static void main(String[] args) {

  Book b1 = new Book(121, "Let us C", "Yashwant Kanetkar", "BPB", 8);
  Book b2 = new Book(233, "Operating System", "Galvin", "Wiley", 6);
  Book b3 = new Book(101, "Data Communications & Networking", "Forouzan", "Mc Graw Hill", 4);
  Book b4 = new Book(121, "Let us C", "Yashwant Kanetkar", "Mc Graw Hill", 11);

  ArrayList<Book> books = new ArrayList<>();
  books.add(b1);
  books.add(b2);
  books.add(b3);
  books.add(b4);
  //Print the details of each book in the given list of books.
  System.out.println("-------------------");

  books.stream().forEach(System.out::println);
  System.out.println("-------------------");
  //Create a Set of books from the List by using a collector method, and then print the set.
  books.stream().collect(Collectors.toSet()).forEach(System.out::println);
  System.out.println("-------------------");

  //  Sort the List of books using the intermediate operation sorted(). Display the sorted results.
  books.stream().sorted().forEach(System.out::println);
  System.out.println("-------------------");
  //Double the quantity of each book in the List using the intermediate operation map(), and then display the updated books.
  books.stream().map(x -> x.quantity = x.quantity * 2).forEach(System.out::println);
  System.out.println("-------------------");

  //Use the intermediate operation filter() to keep only those books that quantity > 10 and collect them in a list, and print them.
  System.out.println(books.stream().filter(x -> x.quantity > 10).collect(Collectors.toList()));
  System.out.println("-------------------");

  //Use the terminal operation reduce() to obtain the sum of quantity sold of books that have id < 200, and then print the sum obtained.
  int total = books.stream().filter(x -> x.id < 200).map(x -> x.quantity).reduce(0, (sum, x) -> sum + x);
  System.out.println("total = " + total);

}
}

SS

0 replies

Narutoram · 2022-04-21T05:42:43Z

Narutoram
Apr 21, 2022

//Ramprasad

``
java
Book class

package Streams;

public class Book implements Comparable {

int id;
String name;
String author;
String publisher;
int quantity;

// parameterised constructor
public Book(int id, String name, String author, String publisher, int quantity) {
	super();
	this.id = id;
	this.name = name;
	this.author = author;
	this.publisher = publisher;
	this.quantity = quantity;
}

// override toString()
@Override
public String toString() {
	return "Book [id=" + id + ", name=" + name + ", author=" + author + ", publisher=" + publisher + ", quantity="
			+ quantity + "]";
}

// override hashCode()
@Override
public int hashCode() {
	final int prime = 31;
	int result = 1;
	result = prime * result + id;
	return result;
}

// override equals()
@Override
public boolean equals(Object other) {
	if (this == other) {
		return true;
	}
	if (other == null) {
		return false;
	}
	Book b = (Book) other;
	if (this.id != b.id) {
		return false;
	}

	return true;
}

// override compareTo(Book other): compares by id

@Override
public int compareTo(Book o) {
	Book b = (Book) o;
	return this.id - b.id;
}

}

Main class

package Streams;

import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

public class BookStream {

public static void main(String[] args) {

	Book b1 = new Book(121, "Let us C", "Yashwant Kanetkar", "BPB", 8);
	Book b2 = new Book(233, "Operating System", "Galvin", "Wiley", 6);
	Book b3 = new Book(101, "Data Communications & Networking", "Forouzan", "Mc Graw Hill", 4);
	Book b4 = new Book(121, "Let us C", "Yashwant Kanetkar", "Mc Graw Hill", 11);

	List<Book> books = new ArrayList<>();
	books.add(b1);
	books.add(b2);
	books.add(b3);
	books.add(b4);

	// printing the Books
	books.stream().forEach(System.out::println);

	Set<Book> setBooks = books.stream().collect(Collectors.toSet());
	setBooks.stream().forEach(System.out::println);

	books.stream().sorted().forEach(System.out::println);

	books.stream().map(q -> {
		q.quantity = q.quantity * 2;
		return q;
	}).collect(Collectors.toList()).forEach(System.out::println);

	books.stream().filter(q -> q.quantity > 10).collect(Collectors.toList()).forEach(System.out::println);

	int sold = books.stream().filter(id -> id.id < 200).map(q -> q.quantity).reduce(0, (ans, i) -> ans + i);
	System.out.println(sold);
}

}
``

0 replies

Kuntapaliwal · 2022-07-19T05:58:41Z

Kuntapaliwal
Jul 19, 2022

package java_programs;

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

class Books implements Comparable<Books> {
    int id;
    String name;
    String author;
    String publisher;
    int quantity;

    // parameterised constructor
    public Books(int id, String name, String author, String publisher, int quantity) {
        this.id = id;
        this.name = name;
        this.author = author;
        this.publisher = publisher;
        this.quantity = quantity;
    }

    // override toString()
    @Override
    public String toString() {
        return "Book [author=" + author + ", id=" + id + ", name=" + name + ", publisher=" + publisher + ", quantity="
                + quantity + "]";
    }

    // override hashCode()
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((author == null) ? 0 : author.hashCode());
        result = prime * result + id;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        result = prime * result + ((publisher == null) ? 0 : publisher.hashCode());
        result = prime * result + quantity;
        return result;
    }

    // override equals()
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Books other = (Books) obj;
        if (author == null) {
            if (other.author != null)
                return false;
        } else if (!author.equals(other.author))
            return false;
        if (id != other.id)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        if (publisher == null) {
            if (other.publisher != null)
                return false;
        } else if (!publisher.equals(other.publisher))
            return false;
        if (quantity != other.quantity)
            return false;
        return true;
    }

    @Override
    public int compareTo(Books o) {
        // TODO Auto-generated method stub

        return this.id = o.id;
    }

}

public class StreamsDemo {
    public static void main(String[] args) {
        Books b1 = new Books(121, "Let us C", "Yashwant Kanetkar", "BPB", 8);
        Books b2 = new Books(233, "Operating System", "Galvin", "Wiley", 6);
        Books b3 = new Books(101, "Data Communications & Networking", "Forouzan", "Mc Graw Hill", 4);
        Books b4 = new Books(121, "Let us C", "Yashwant Kanetkar", "Mc Graw Hill", 11);

        List<Books> list = Arrays.asList(b1, b2, b3, b4);

        //Print the details of each book in the given list of books.

        list.forEach(System.out::println);
//Create a Set of books from the List by using a collector method, and then print the set.

        Set<Books> set = new HashSet<>();
        list.stream().forEach(set::add);
        System.out.println(set);

        //Sort the List of books using the intermediate operation sorted(). Display the sorted results.

        list.stream().sorted(Books::compareTo).forEach(System.out::println);
//Double the quantity of each book in the List using the intermediate operation map(), and then display the updated books.
        list.stream().map(e -> new Books(e.id, e.author, e.name, e.publisher, e.quantity = 2 * e.quantity))
                .forEach(System.out::println);
        ;

        // Use the intermediate operation filter() to keep only those books that
        // quantity > 10 and collect them in a list, and print them.

        list.stream().filter(e -> e.quantity > 10).forEach(System.out::println);

        // Use the terminal operation reduce() to obtain the sum of quantity sold of
        // books that have id < 200, and then print the sum obtained.

        long sumData = list.stream().filter(e -> e.id < 200).map(q -> q.quantity).reduce(0,
                (sum, quantity) -> sum + quantity);
        System.out.println("Sum=" + sumData);

    }

}

0 replies

ghost · 2022-07-19T06:09:51Z

ghost
Jul 19, 2022

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collector;
import java.util.stream.Collectors;

class Book implements Comparable<Book> {
    int id;
    String name;
    String author;
    String publisher;
    int quantity;

    public Book(int id, String name, String author, String publisher, int quantity) {
        this.id = id;
        this.name = name;
        this.author = author;
        this.publisher = publisher;
        this.quantity = quantity;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((author == null) ? 0 : author.hashCode());
        result = prime * result + id;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        result = prime * result + ((publisher == null) ? 0 : publisher.hashCode());
        result = prime * result + quantity;
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Book other = (Book) obj;
        if (author == null) {
            if (other.author != null)
                return false;
        } else if (!author.equals(other.author))
            return false;
        if (id != other.id)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        if (publisher == null) {
            if (other.publisher != null)
                return false;
        } else if (!publisher.equals(other.publisher))
            return false;
        if (quantity != other.quantity)
            return false;
        return true;
    }

    @Override
    public String toString() {
        return "Book [author=" + author + ", id=" + id + ", name=" + name + ", publisher=" + publisher + ", quantity="
                + quantity + "]";
    }

    // parameterised constructor

    // override toString()

    // override hashCode()

    // override equals()

    // override compareTo(Book other): compares by id
}

public class assignment {

    public static void main(String[] args) {

        Book b1 = new Book(121, "Let us C", "Yashwant Kanetkar", "BPB", 8);
        Book b2 = new Book(233, "Operating System", "Galvin", "Wiley", 6);
        Book b3 = new Book(101, "Data Communications & Networking", "Forouzan", "Mc Graw Hill", 4);
        Book b4 = new Book(121, "Let us C", "Yashwant Kanetkar", "Mc Graw Hill", 11);
        ArrayList<Book> book = new ArrayList<>();
        book.add(b1);
        book.add(b2);
        book.add(b3);

        book.add(b4);
        book.stream().forEach(System.out::println);
        Set<Book> bookSet = book.stream().collect(Collectors.toSet());
        bookSet.stream().forEach(System.out::println);

        List<Book> sortedBook1List = book.stream().sorted().toList();
        System.out.println("Printing Sorted List");
        sortedBook1List.forEach(System.out::println);
        // List<Book> sortedList = book.stream().sorted().collect(Collectors.toList());
        // sortedList.forEach(System.out::println);
        System.out.println("Doubling the quantity");
        List<Book> doubleQuantity = book.stream()
                .map(b -> new Book(b.id, b.name, b.author, b.publisher, b.quantity * 2)).toList();
        doubleQuantity.forEach(System.out::println);
        System.out.println("Quantity greater than 10");
        List<Book> greaterThanTen = book.stream().filter(b -> b.quantity > 10).collect(Collectors.toList());
        greaterThanTen.forEach(System.out::println);
        System.out.println("Quantity of books with id lesser than 200");
        int total = book.stream().filter(q -> q.id < 200).map(q -> q.quantity).reduce(0, (quan, val) -> {
            return val + quan;
        });
        System.out.println(total);

    }

}

0 replies

ghost · 2022-07-19T06:15:08Z

ghost
Jul 19, 2022

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

class Books implements Comparable<Books> {
    int id;
    String name;
    String author;
    String publisher;
    int quantity;

    public Books(int id, String name, String author, String publisher, int quantity) {
        this.id = id;
        this.name = name;
        this.author = author;
        this.publisher = publisher;
        this.quantity = quantity;
    }

    @Override
    public String toString() {
        return "Book [author=" + author + ", id=" + id + ", name=" + name + ", publisher=" + publisher + ", quantity="
                + quantity + "]";
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((author == null) ? 0 : author.hashCode());
        result = prime * result + id;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        result = prime * result + ((publisher == null) ? 0 : publisher.hashCode());
        result = prime * result + quantity;
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Books other = (Books) obj;
        if (author == null) {
            if (other.author != null)
                return false;
        } else if (!author.equals(other.author))
            return false;
        if (id != other.id)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        if (publisher == null) {
            if (other.publisher != null)
                return false;
        } else if (!publisher.equals(other.publisher))
            return false;
        if (quantity != other.quantity)
            return false;
        return true;
    }

    @Override
    public int compareTo(Books o) {
        return this.id = o.id;
    }
}

public class d53 {
    public static void main(String[] args) {
        Books obj1 = new Books(1, "Let us C", "Yashwant Kanetkar", "BPB", 8);
        Books obj2 = new Books(2, "Operating System", "Galvin", "Wiley", 6);
        Books obj3 = new Books(3, "Data Communications & Networking", "Forouzan", "Mc Graw Hill", 4);
        Books obj4 = new Books(4, "Let us C", "Yashwant Kanetkar", "Mc Graw Hill", 11);

        List<Books> list = Arrays.asList(obj1, obj2, obj3, obj4);
        list.forEach(System.out::println);
        Set<Books> set = new HashSet<>();
        list.stream().forEach(set::add);
        System.out.println(set);

        list.stream().sorted(Books::compareTo).forEach(System.out::println);
        list.stream().map(e -> new Books(e.id, e.author, e.name, e.publisher, e.quantity = 2 * e.quantity)).forEach(System.out::println);;
        list.stream().filter(e -> e.quantity > 10).forEach(System.out::println);

        long sumData = list.stream().filter(e -> e.id < 200).map(q -> q.quantity).reduce(0,
                (sum, quantity) -> sum + quantity);
        System.out.println("Sum=" + sumData);
    }
}

0 replies

gayatribabar · 2022-07-19T06:17:12Z

gayatribabar
Jul 19, 2022

import java.util.List;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.function.ToDoubleBiFunction;
import java.util.stream.Collector;
import java.util.stream.Collectors;

class Book53 {
    int id;
    String name;
    String author;
    String publisher;
    int quantity;

    // parameterised constructor
    public Book53(int id, String name, String author, String publisher, int quantity) {
        this.id = id;
        this.name = name;
        this.author = author;
        this.publisher = publisher;
        this.quantity = quantity;
    }

    @Override
    public String toString() {
        return "Book53 [author=" + author + ", id=" + id + ", name=" + name + ", publisher=" + publisher + ", quantity="
                + quantity + "]";
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((author == null) ? 0 : author.hashCode());
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Book53 other = (Book53) obj;
        if (author == null) {
            if (other.author != null)
                return false;
        } else if (!author.equals(other.author))
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }

}

public class Discussion53 {
    public static void main(String[] args) {

        Book53 b1 = new Book53(121, "Let us C", "Yashwant Kanetkar", "BPB", 8);
        Book53 b2 = new Book53(233, "Operating System", "Galvin", "Wiley", 6);
        Book53 b3 = new Book53(101, "Data Communications & Networking", "Forouzan", "Mc Graw Hill", 4);
        Book53 b4 = new Book53(121, "Let us C", "Yashwant Kanetkar", "Mc Graw Hill", 11);

        List<Book53> Library = new ArrayList<>();
        Library.add(b1);
        Library.add(b2);
        Library.add(b3);
        Library.add(b4);

        System.out.println("Book List: ");
        Library.stream().forEach(System.out::println);

        System.out.println();

        Set<Book53> LibraryList = Library.stream().collect(Collectors.toSet());
        System.out.println("Library converted to set:");
        LibraryList.stream().forEach(System.out::println);

        System.out.println();

        /*
         * List<Book53> LibraryList2 =
         * Library.stream().sorted(Book53::compareTo).toList();
         * System.out.println("Sorted LibraryList: ");
         */
        /* LibraryList.stream().sorted().forEach(System.out::println); */

        List<Book53> LibraryList3 = Library.stream().map(x -> {
            x.quantity *= 2;
            return x;
        }).toList();
        System.out.println("Quantity Doubled: ");
        LibraryList3.stream().forEach(System.out::println);

        System.out.println();

        List<Book53> LibraryList4 = Library.stream().filter(x -> x.quantity > 10).toList();
        System.out.println("Quantity greater than 10: ");
        LibraryList4.stream().forEach(System.out::println);

        System.out.println();

        int soldBooks = Library.stream().filter(o -> o.id < 200).map(o -> o.quantity).reduce(0, (ans, q) -> ans + q);
        System.out.println("quantity sold of books having id < 200 is " + soldBooks);

    }
}

0 replies

Coder-093 · 2022-07-19T06:33:12Z

Coder-093
Jul 19, 2022

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

public class task53 {
  public static void main(String[] args) {
    Books b1 = new Books(121, "Let us C", "Yashwant Kanetkar", "BPB", 8);
    Books b2 = new Books(233, "Operating System", "Galvin", "Wiley", 6);
    Books b3 = new Books(101, "Data Communications & Networking", "Forouzan", "Mc Graw Hill", 4);
    Books b4 = new Books(121, "Let us C", "Yashwant Kanetkar", "Mc Graw Hill", 11);

    ArrayList<Books> books = new ArrayList<Books>();
    books.add(b1);
    books.add(b2);
    books.add(b3);
    books.add(b4);

    System.out.println("Print the details of each book in the given list of books");
    books.forEach(System.out::println);
    System.out.println();

    System.out.println("Create a Set of books from the List by using a collector method, and then print the set.");
    System.out.println(books.stream().collect(Collectors.toSet()));
    System.out.println();

    System.out.println("Sort the List of books using the intermediate operation sorted(). Display the sorted results.");
    System.out.println(books.stream().sorted().collect(Collectors.toList()));
    System.out.println();

    System.out.println(
        "Double the quantity of each book in the List using the intermediate operation map(), and then display the updated books.");
    System.out.println(
        books.stream().sorted().map(b -> new Books(b.id, b.name, b.author, b.publisher, b.quantity * 2)).toList());
    System.out.println();

    System.out.println(
        "Use the intermediate operation filter() to keep only those books that quantity > 10 and collect them in a list, and print them.");
    System.out.println(books.stream().filter(b -> b.quantity > 10).toList());
    System.out.println();

    System.out.println(
        "Use the terminal operation reduce() to obtain the sum of quantity sold of books that have id < 200, and then print the sum obtained.");
    System.out.println(books.stream().filter(b -> b.id < 200).map(b -> b.quantity).reduce(0, (sum, i) -> sum + i));
    System.out.println();
  }
}

class Books implements Comparable<Books> {
  int id;
  String name;
  String author;
  String publisher;
  int quantity;

  public Books(int id, String name, String author, String publisher, int quantity) {
    this.id = id;
    this.name = name;
    this.author = author;
    this.publisher = publisher;
    this.quantity = quantity;
  }

  @Override
  public String toString() {
    return "Books [author=" + author + ", id=" + id + ", name=" + name + ", publisher=" + publisher + ", quantity="
        + quantity + "]";
  }

  @Override
  public int hashCode() {
    final int prime = 31;
    int result = 1;
    result = prime * result + ((author == null) ? 0 : author.hashCode());
    result = prime * result + id;
    result = prime * result + ((name == null) ? 0 : name.hashCode());
    result = prime * result + ((publisher == null) ? 0 : publisher.hashCode());
    result = prime * result + quantity;
    return result;
  }

  @Override
  public boolean equals(Object obj) {
    if (this == obj)
      return true;
    if (obj == null)
      return false;
    if (getClass() != obj.getClass())
      return false;
    Books other = (Books) obj;
    if (author == null) {
      if (other.author != null)
        return false;
    } else if (!author.equals(other.author))
      return false;
    if (id != other.id)
      return false;
    if (name == null) {
      if (other.name != null)
        return false;
    } else if (!name.equals(other.name))
      return false;
    if (publisher == null) {
      if (other.publisher != null)
        return false;
    } else if (!publisher.equals(other.publisher))
      return false;
    if (quantity != other.quantity)
      return false;
    return true;
  }

  @Override
  public int compareTo(Books o) {
    // TODO Auto-generated method stub
    return this.id - o.id;
  }

}

0 replies

meghvi-raj · 2022-07-19T06:46:02Z

meghvi-raj
Jul 19, 2022

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collector;
import java.util.stream.Collectors;

public class D53

{
    public static void main(String[] args) {
        Books b1 = new Books(121, "Let us C", "Yashwant Kanetkar", "BPB", 8);
        Books b2 = new Books(233, "Operating System", "Galvin", "Wiley", 6);
        Books b3 = new Books(101, "Data Communications & Networking", "Forouzan", "Mc Graw Hill", 4);
        Books b4 = new Books(121, "Let us C", "Yashwant Kanetkar", "Mc Graw Hill", 11);

        List<Books> books = new ArrayList<>();
        books.add(b1);
        books.add(b2);
        books.add(b3);
        books.add(b4);

        // task 1
        books.stream().forEach(System.out::println);
        System.out.println();

        // task 2
        Set<Books> bookSet = books.stream().collect(Collectors.toSet());
        bookSet.stream().forEach(System.out::println);
        System.out.println();

        // task 3
        books.stream().sorted().forEach(System.out::println);
        System.out.println();

        // task 4
        books.stream().sorted().map(o -> {
            o.quantity = o.quantity * 2;
            return o;
        }).collect(Collectors.toList()).forEach(System.out::println);
        System.out.println();

        // task 5
        books.stream().filter(o -> o.quantity > 10).collect(Collectors.toList()).forEach(System.out::println);
        System.out.println();

        // task 6
        int soldBooks = books.stream().filter(o -> o.id < 200).map(o -> o.quantity).reduce(0, (ans, q) -> ans + q);
        System.out.println("quantity sold of books having id < 200 is " + soldBooks);

    }

}

class Books implements Comparable<Books>

{
    int id;
    String name;
    String author;
    String publisher;
    int quantity;

    // parameterised constructor
    public Books(int id, String name, String author, String publisher, int quantity) {
        this.id = id;
        this.name = name;
        this.author = author;
        this.publisher = publisher;
        this.quantity = quantity;
    }

    // override equals()
    @Override
    public boolean equals(Object other) {
        if (this == other) {
            return true;
        } else if (other == null) {
            return false;
        } else if (this.getClass() != other.getClass())
            return false;
        Books obj = (Books) other;
        if (id != obj.id) {
            return false;
        } else {
            return true;
        }
    }

    // override hashCode()
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + id;
        return result;
    }

    @Override
    public int compareTo(Books o) {

        return this.id - o.id;
    }

    // override toString()
    @Override
    public String toString() {
        return "Book [author=" + author + ", id=" + id + ", name=" + name + ", publisher=" + publisher + ", quantity="
                + quantity + "]";
    }

}

0 replies

uzma23 · 2022-07-19T06:49:12Z

uzma23
Jul 19, 2022

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

class Books implements Comparable<Books> {
    int id;
    String name;
    String author;
    String publisher;
    int quantity;

    public Books(int id, String name, String author, String publisher, int quantity) {
        this.id = id;
        this.name = name;
        this.author = author;
        this.publisher = publisher;
        this.quantity = quantity;
    }

    @Override
    public String toString() {
        return "Books [author=" + author + ", id=" + id + ", name=" + name + ", publisher=" + publisher + ", quantity="
                + quantity + "]";
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((author == null) ? 0 : author.hashCode());
        result = prime * result + id;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        result = prime * result + ((publisher == null) ? 0 : publisher.hashCode());
        result = prime * result + quantity;
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Books other = (Books) obj;
        if (author == null) {
            if (other.author != null)
                return false;
        } else if (!author.equals(other.author))
            return false;
        if (id != other.id)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        if (publisher == null) {
            if (other.publisher != null)
                return false;
        } else if (!publisher.equals(other.publisher))
            return false;
        if (quantity != other.quantity)
            return false;
        return true;
    }

    @Override
    public int compareTo(Books o) {
        return this.id - o.id;
    }

}

public class discussion50 {
    public static void main(String[] args) {
        Books b1 = new Books(121, "Let us C", "Yashwant Kanetkar", "BPB", 8);
        Books b2 = new Books(233, "Operating System", "Galvin", "Wiley", 6);
        Books b3 = new Books(101, "Data Communications & Networking", "Forouzan", "Mc Graw Hill", 4);
        Books b4 = new Books(121, "Let us C", "Yashwant Kanetkar", "Mc Graw Hill", 11);

        ArrayList<Books> books = new ArrayList<Books>();
        books.add(b1);
        books.add(b2);
        books.add(b3);
        books.add(b4);

        System.out.println("Print the details of each book in the given list of books");
        books.forEach(System.out::println);
        System.out.println();

        System.out.println("Create a Set of books from the List by using a collector method, and then print the set.");
        System.out.println(books.stream().collect(Collectors.toSet()));
        System.out.println();

        System.out.println(
                "Sort the List of books using the intermediate operation sorted(). Display the sorted results.");
        System.out.println(books.stream().sorted().collect(Collectors.toList()));
        System.out.println();

        System.out.println(
                "Double the quantity of each book in the List using the intermediate operation map(), and then display the updated books.");
        System.out.println(
                books.stream().sorted().map(b -> new Books(b.id, b.name, b.author, b.publisher, b.quantity * 2))
                        .toList());
        System.out.println();

        System.out.println(
                "Use the intermediate operation filter() to keep only those books that quantity > 10 and collect them in a list, and print them.");
        System.out.println(books.stream().filter(b -> b.quantity > 10).toList());
        System.out.println();

        System.out.println(
                "Use the terminal operation reduce() to obtain the sum of quantity sold of books that have id < 200, and then print the sum obtained.");
        System.out.println(books.stream().filter(b -> b.id < 200).map(b -> b.quantity).reduce(0, (sum, i) -> sum + i));
        System.out.println();
    }

}

0 replies

vshvandana · 2022-07-19T07:58:51Z

vshvandana
Jul 19, 2022

import java.util.ArrayList;

import java.util.List;
import java.util.Set;
import java.util.stream.Collector;
import java.util.stream.Collectors;

class BookMarket implements Comparable<BookMarket> {
    int id;
    String name;
    String author;
    String publisher;
    int quantity;

    public BookMarket(int id, String name, String author, String publisher, int quantity) {
        this.id = id;
        this.name = name;
        this.author = author;
        this.publisher = publisher;
        this.quantity = quantity;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((author == null) ? 0 : author.hashCode());
        result = prime * result + id;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        result = prime * result + ((publisher == null) ? 0 : publisher.hashCode());
        result = prime * result + quantity;
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        BookMarket other = (BookMarket) obj;
        if (author == null) {
            if (other.author != null)
                return false;
        } else if (!author.equals(other.author))
            return false;
        if (id != other.id)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        if (publisher == null) {
            if (other.publisher != null)
                return false;
        } else if (!publisher.equals(other.publisher))
            return false;
        if (quantity != other.quantity)
            return false;
        return true;
    }

    @Override
    public String toString() {
        return "BookMarket [author=" + author + ", id=" + id + ", name=" + name + ", publisher=" + publisher
                + ", quantity=" + quantity + "]";
    }

    @Override
    public int compareTo(BookMarket o) {
        // TODO Auto-generated method stub
        return 0;
    }

}

class market {
    public static void main(String args[]) {
        BookMarket b1 = new BookMarket(121, "Let us C", "Yashwant Kanetkar", "BPB", 8);
        BookMarket b2 = new BookMarket(233, "Operating System", "Galvin", "Wiley", 6);
        BookMarket b3 = new BookMarket(101, "Data Communications & Networking", "Forouzan", "Mc Graw Hill", 4);
        BookMarket b4 = new BookMarket(121, "Let us C", "Yashwant Kanetkar", "Mc Graw Hill", 11);

        List<BookMarket> book = new ArrayList<>();
        book.add(b1);
        book.add(b2);
        book.add(b3);
        book.add(b4);
 
        System.out.println("Details of the books: ");
        book.stream().forEach(System.out::println);
        Set<BookMarket> s = book.stream().collect(Collectors.toSet());
        System.out.println("Set of the books: ");
        s.stream().forEach(System.out::println);

        System.out.println("Sorted books: ");
        List<BookMarket> sortedl = book.stream().sorted().toList();
        sortedl.forEach(System.out::println);

        System.out.println("Doubled Quantity: ");
        List<BookMarket> d = book.stream().map(x -> {
            x.quantity *= 2;
            return x;
        }).toList();
        d.forEach(System.out::println);

        System.out.println("Filtered details of the books: ");
        List<BookMarket> a = book.stream().filter(x -> x.quantity > 12).toList();
        a.forEach(System.out::println);

        System.out.println("Sum of qunatity sold: ");
        int r = book.stream().filter(x -> x.id < 200).map(o -> o.quantity).reduce(0, (ans, q) -> ans + q);
        System.out.println("Book sold: " + r);
    }
}

0 replies

rrajbanshi · 2022-08-19T09:13:00Z

rrajbanshi
Aug 19, 2022

code

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

class Book implements Comparable<Book> {
    int id;
    String name;
    String author;
    String publisher;
    int quantity;
    
    public Book(int id, String name, String author, String publisher, int quantity) {
        this.id = id;
        this.name = name;
        this.author = author;
        this.publisher = publisher;
        this.quantity = quantity;
    }
    public int getId() {
        return id;
    }
    public String getName() {
        return name;
    }
    public String getAuthor() {
        return author;
    }
    public String getPublisher() {
        return publisher;
    }
    public int getQuantity() {
        return quantity;
    }
    public void setId(int id) {
        this.id = id;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void setAuthor(String author) {
        this.author = author;
    }
    public void setPublisher(String publisher) {
        this.publisher = publisher;
    }
    public void setQuantity(int quantity) {
        this.quantity = quantity;
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((author == null) ? 0 : author.hashCode());
        result = prime * result + id;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        result = prime * result + ((publisher == null) ? 0 : publisher.hashCode());
        result = prime * result + quantity;
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Book other = (Book) obj;
        if (author == null) {
            if (other.author != null)
                return false;
        } else if (!author.equals(other.author))
            return false;
        if (id != other.id)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        if (publisher == null) {
            if (other.publisher != null)
                return false;
        } else if (!publisher.equals(other.publisher))
            return false;
        if (quantity != other.quantity)
            return false;
        return true;
    }
    @Override
    public int compareTo(Book o) {
        return this.id - o.id;
    }
    @Override
    public String toString() {
        return "Book [author=" + author + ", id=" + id + ", name=" + name + ", publisher=" + publisher + ", quantity="
                + quantity + "]";
    }
    
}

public class Discussion53{
    public static void main(String[] args) {
        Book b1 = new Book(121, "Let us C", "Yashwant Kanetkar", "BPB", 8);
        Book b2 = new Book(233, "Operating System", "Galvin", "Wiley", 6);
        Book b3 = new Book(101, "Data Communications & Networking", "Forouzan", "Mc Graw Hill", 4);
        Book b4 = new Book(121, "Let us C", "Yashwant Kanetkar", "Mc Graw Hill", 11);

        ArrayList<Book> books = new ArrayList<>();
        books.add(b1);
        books.add(b2);
        books.add(b3);
        books.add(b4);

        System.out.println("Printing using streams");
        books.stream().forEach(System.out::println);

        System.out.println("storing in set");
        Set<Book> setOfBook = books.stream().collect(Collectors.toSet());
        setOfBook.stream().forEach(System.out::println);
      
        System.out.println("Sorted the List of books using the intermediate operation sorted()");
        books.stream().sorted().forEach(System.out::println);
        
        System.out.println("Double the quantity of each book in the List using the intermediate operation map()");
        List<Book> booklist = books.stream().sorted().map(o->{
            o.quantity = o.quantity * 2;
            return o;
        }).toList();
        booklist.stream().forEach(System.out::println);

        System.out.println("quantity > 10");
        List<Book> Quant = books.stream().filter(x -> x.quantity > 10).toList();
        Quant.stream().forEach(System.out::println);


        System.out.println("sold of books that have id < 200");
        int soldBooks = books.stream().filter(o -> o.id < 200).map(o -> o.quantity).reduce(0, (ans, q) -> ans + q);
        System.out.println("quantity sold of books having id < 200 is " + soldBooks);
    }
}

0 replies

Task - Stream API - Book Market #53

Uh oh!

Uh oh!

akash-coded Mar 8, 2022 Maintainer

Book Market

Using Stream operations on a Booklist

Reference

Replies: 54 comments

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Book.java

Driver Class

Screenshots

Uh oh!

Uh oh!

Book

# Driver Class

Uh oh!

Uh oh!

Book

Driver

SS

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

akash-coded
Mar 8, 2022
Maintainer