Task - Collections - Student Statistics #56

akash-coded · 2022-03-10T01:28:21Z

akash-coded
Mar 10, 2022
Maintainer

You are given the following blueprint for representing a college Student:

class Student {
    private String name;
    private int id;
    private String subject;

    double percentage;

    public Student(String name, int id, String subject, double percentage) {
        this.name = name;
        this.id = id;
        this.subject = subject;
        this.percentage = percentage;
    }

    public String getName() {
        return name;
    }

    public int getId() {
        return id;
    }

    public String getSubject() {
        return subject;
    }

    public double getPercentage() {
        return percentage;
    }

    @Override
    public String toString() {
        return name + "-" + id + "-" + subject + "-" + percentage;
    }
}

Create four Student instances:

Student student1 = new Student("Dinesh", 1, "Algorithms", 75);
Student student2 = new Student("Arnav", 2, "Automata", 55);
Student student3 = new Student("Anamika", 3, "Databases", 80);
Student student4 = new Student("Vishal", 4, "Networking", 40);

Create a list of these students called studentList and do the following operations:

Partition the students who got above 60% from those who didn’t.
Get the names of the top 3 performing students.
Get the name and percentage of each student.
Get the set of subjects offered in the college
Get the highest, the lowest, and the average percentage of students
Get the total number of students from the given list of students
Get the students grouped by subject from the given list of students

Expected Output:

{false=[Arnav-2-Automata-55.0, Vishal-4-Networking-40.0], true=[Dinesh-1-Algorithms-75.0, Anamika-3-Databases-80.0]}

[Anamika-3-Databases-80.0, Dinesh-1-Algorithms-75.0, Arnav-2-Automata-55.0]

{Anamika=80.0, Dinesh=75.0, Arnav=55.0, Vishal=40.0}

[Algorithms, Databases, Networking, Automata]

Highest Percentage: 80.0
Lowest Percentage: 40.0
Average Percentage: 62.5

4

{Databases=[Anamika-3-Databases-80.0], Algorithms=[Dinesh-1-Algorithms-75.0], Networking=[Vishal-4-Networking-40.0], Automata=[Arnav-2-Automata-55.0]}

Gaurav-Joshi-31 · 2022-03-10T08:00:47Z

Gaurav-Joshi-31
Mar 10, 2022

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Optional;
import java.util.OptionalDouble;
import java.util.Set;
import java.util.stream.Collectors;

class Student {
    private String name;
    private int id;
    private String subject;

    double percentage;

    public Student(String name, int id, String subject, double percentage) {
        this.name = name;
        this.id = id;
        this.subject = subject;
        this.percentage = percentage;
    }

    public String getName() {
        return name;
    }

    public int getId() {
        return id;
    }

    public String getSubject() {
        return subject;
    }

    public double getPercentage() {
        return percentage;
    }

    @Override
    public String toString() {
        return name + "-" + id + "-" + subject + "-" + percentage;
    }

}

public class StudentDriver {
    public static void main(String[] args) {
        Student student1 = new Student("Dinesh", 1, "Algorithms", 75);
        Student student2 = new Student("Arnav", 2, "Automata", 55);
        Student student3 = new Student("Anamika", 3, "Databases", 80);
        Student student4 = new Student("Vishal", 4, "Networking", 40);
        List<Student> studentList = Arrays.asList(student1, student2, student3, student4);

        Map<Boolean, List<Student>> map = studentList.stream()
                .collect(Collectors.partitioningBy(stu -> stu.getPercentage() > 60));
        System.out.println(map);

        List<Student> topPerformer = studentList.stream()
                .sorted(Comparator.comparing(Student::getPercentage, Comparator.reverseOrder())).limit(3)
                .collect(Collectors.toList());

        System.out.println(topPerformer);

        Map<String, Double> map2 = studentList.stream()
                .collect(Collectors.toMap(Student::getName, Student::getPercentage));
        System.out.println(map2);

        Set<String> subjectSet = studentList.stream().map(Student::getSubject).collect(Collectors.toSet());
        System.out.println(subjectSet);

        OptionalDouble highest = studentList.stream().mapToDouble(Student::getPercentage).max();
        System.out.println("Highest Percentage :" + highest.getAsDouble());

        OptionalDouble lowest = studentList.stream().mapToDouble(Student::getPercentage).min();
        System.out.println("Lowest Percentage :" + lowest.getAsDouble());

        OptionalDouble average = studentList.stream().mapToDouble(Student::getPercentage).average();

        System.out.println("Average Percentage :" + average.getAsDouble());
        System.out.println("Total students: " + studentList.size());

        Map<String, List<Student>> groupBySubject = studentList.stream()
                .collect(Collectors.groupingBy(Student::getSubject));
        System.out.println(groupBySubject);
    }
}

0 replies

KaminiJha · 2022-03-10T09:11:48Z

KaminiJha
Mar 10, 2022

class Student {
    private String name;
    private int id;
    private String subject;

    double percentage;

    public Student(String name, int id, String subject, double percentage) {
        this.name = name;
        this.id = id;
        this.subject = subject;
        this.percentage = percentage;
    }

    public String getName() {
        return name;
    }

    public int getId() {
        return id;
    }

    public String getSubject() {
        return subject;
    }

    public double getPercentage() {
        return percentage;
    }

    @Override
    public String toString() {
        return name + "-" + id + "-" + subject + "-" + percentage;
    }
}

public class StudentStatistics {
    public static void main(String[] args) {
        Student student1 = new Student("Dinesh", 1, "Algorithms", 75);
        Student student2 = new Student("Arnav", 2, "Automata", 55);
        Student student3 = new Student("Anamika", 3, "Databases", 80);
        Student student4 = new Student("Vishal", 4, "Networking", 40);
        List<Student> stdList = new ArrayList<>();
        stdList.add(student1);
        stdList.add(student2);
        stdList.add(student3);
        stdList.add(student4);

        // Partition the students who got above 60% from those who didn’t.
        List<Student> above60 = new ArrayList<>();
        List<Student> below60 = new ArrayList<>();
        System.out.println(stdList);
        stdList.forEach(std -> {
            if (std.percentage >= 60) {
                above60.add(std);
            } else {
                below60.add(std);
            }
        });
        System.out.println("{false=" + below60 + ",true=" + above60);
        // Get the names of the top 3 performing students.
        List<Student> topPer = stdList.stream().sorted((std1, std2) -> (int) (std2.percentage - std1.percentage))
                .limit(3)
                .collect(Collectors.toList());
        System.out.println(topPer);
        // Get the name and percentage of each student.
        List<String> stdWithNameAndPer = stdList.stream()
                .sorted((std1, std2) -> (int) (std2.percentage - std1.percentage))
                .map(std -> std.getName() + "=" + std.percentage).collect(Collectors.toList());
        System.out.println(stdWithNameAndPer);
        // Get the set of subjects offered in the college
        Set<String> subjects = stdList.stream().map(std -> std.getSubject()).collect(Collectors.toSet());
        System.out.println(subjects);
        // Get the highest, the lowest, and the average percentage of students
        System.out.println("Highest Percentage: " + stdWithNameAndPer.get(0).split("=")[1]);
        System.out.println("Lowest Percentage: " + stdWithNameAndPer.get(3).split("=")[1]);
        OptionalDouble avg = stdList.stream().mapToDouble(Student::getPercentage).average();
        System.out.println("Average: " + avg);
        // Get the total number of students from the given list of students
        System.out.println(stdList.size());
        // Get the students grouped by subject from the given list of students
        stdList.stream().collect(Collectors.groupingBy(Student::getSubject))
                .forEach((sub, list) -> System.out.println(sub + " = " + list));
    }
}

0 replies

ratnadeepikavuddagiri · 2022-03-10T09:27:03Z

ratnadeepikavuddagiri
Mar 10, 2022

package JavaCollections;

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

class Student implements Comparable<Student>{
    private String name;
    private int id;
    private String subject;

    double percentage;

    public Student(String name, int id, String subject, double percentage) {
        this.name = name;
        this.id = id;
        this.subject = subject;
        this.percentage = percentage;
    }

    public String getName() {
        return name;
    }

    public int getId() {
        return id;
    }

    public String getSubject() {
        return subject;
    }

    public double getPercentage() {
        return percentage;
    }

    @Override
    public String toString() {
        return name + "-" + id + "-" + subject + "-" + percentage;
    }

    @Override
    public int compareTo(Student o) {
    
        return (int) (o.percentage - this.percentage);
    }


}
public class StudentStatistics {
    public static void main(String[] args) {
        Student student1 = new Student("Dinesh", 1, "Algorithms", 75);
        Student student2 = new Student("Arnav", 2, "Automata", 55);
        Student student3 = new Student("Anamika", 3, "Databases", 80);
        Student student4 = new Student("Vishal", 4, "Networking", 40);
        List<Student> studentList = new ArrayList<>();
        studentList.add(student1);
        studentList.add(student2);
        studentList.add(student3);
        studentList.add(student4);
        System.out.println("Students with percentage>60 :");
        studentList.stream().filter(p1->p1.getPercentage()>60).forEach(System.out::println);
        System.out.println("\nTop 3 students:");
        List<Student> sortedList = studentList.stream().sorted().collect(Collectors.toList());
        for(int i=0;i<3;i++) 
            System.out.println(sortedList.get(i));
        System.out.println("\nStudents and Percentages:");
        studentList.stream().map(p1->p1.getName()+" "+p1.getPercentage()).forEach(System.out::println);
        System.out.println("\nSubjects:");
        studentList.stream().map(p1->p1.getSubject()).collect(Collectors.toSet()).forEach(System.out::println);
        System.out.println("\nHighest Percentage : "+sortedList.get(0).getPercentage());
        System.out.println("Lowest Percentage : "+sortedList.get(sortedList.size()-1).getPercentage());
        double sum =studentList.stream().map(p1->p1.getPercentage()).reduce(0.0,(res,p1)->res+p1);
        System.out.println("Average Percentage : "+sum/studentList.size());
        System.out.println("\nTotal No.Of Students : "+studentList.size());
        System.out.println();
        studentList.stream().collect(Collectors.groupingBy(Student::getSubject)).forEach((sub, list) -> System.out.println(sub + " = " + list));   
    }
}

0 replies

Shubhi27 · 2022-03-10T09:30:04Z

Shubhi27
Mar 10, 2022

package collections;

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

class Student {
    private String name;
    private int id;
    private String subject;

    double percentage;

    public Student(String name, int id, String subject, double percentage) {
        this.name = name;
        this.id = id;
        this.subject = subject;
        this.percentage = percentage;
    }

    public String getName() {
        return name;
    }

    public int getId() {
        return id;
    }

    public String getSubject() {
        return subject;
    }

    public double getPercentage() {
        return percentage;
    }

    @Override
    public String toString() {
        return name + "-" + id + "-" + subject + "-" + percentage;
    }
}

public class StudentStatistics {
    public static void main(String[] args) {
        Student student1 = new Student("Dinesh", 1, "Algorithms", 75);
        Student student2 = new Student("Arnav", 2, "Automata", 55);
        Student student3 = new Student("Anamika", 3, "Databases", 80);
        Student student4 = new Student("Vishal", 4, "Networking", 40);

        List<Student> students = new ArrayList<>();
        students.add(student1);
        students.add(student2);
        students.add(student3);
        students.add(student4);

        // Above and below 60
        List<Student> above = new ArrayList<>();
        List<Student> below = new ArrayList<>();
        System.out.println(students);

        students.forEach(s -> {
            if (s.percentage >= 60) {
                above.add(s);
            } else {
                below.add(s);
            }
        });
        System.out.println("{false=" + below + ",true=" + above);

        // top performers
        List<Student> topPerformance = students.stream()
                .sorted((s1, s2) -> (int) (s2.percentage - s1.percentage))
                .limit(3).toList();

        System.out.println(topPerformance);

        // get name and percentage
        Map<String, Double> map2 = students.stream()
                .collect(Collectors.toMap(Student::getName, Student::getPercentage));
        System.out.println(map2);

        // set of subjects
        Set<String> subjectToSet = students.stream().map(Student::getSubject).collect(Collectors.toSet());
        System.out.println(subjectToSet);

        // highest
        Double highest = students.stream().mapToDouble(Student::getPercentage).max()
                .orElseThrow(NoSuchElementException::new);

        // lowest
        Double lowest = students.stream().mapToDouble(Student::getPercentage).min()
                .orElseThrow(NoSuchElementException::new);

        // average
        Double average = students.stream().mapToDouble(Student::getPercentage).average()
                .orElseThrow(NoSuchElementException::new);

        System.out.println("Highest Marks: " + highest);
        System.out.println("Lowest Marks: " + lowest);
        System.out.println("Average: " + average);
        System.out.println("Total students: " + students.size());
        // group By subject
        Map<String, List<Student>> subjectGroup = students.stream()
                .collect(Collectors.groupingBy(Student::getSubject));
        System.out.println(subjectGroup);

    }
}

0 replies

Ashwesh09 · 2022-03-10T09:37:44Z

Ashwesh09
Mar 10, 2022

import java.util.*;
import java.util.stream.*;
class Student {
    private String name;
    private int id;
    private String subject;

    double percentage;

    public Student(String name, int id, String subject, double percentage) {
        this.name = name;
        this.id = id;
        this.subject = subject;
        this.percentage = percentage;
    }

    public String getName() {
        return name;
    }

    public int getId() {
        return id;
    }

    public String getSubject() {
        return subject;
    }

    public double getPercentage() {
        return percentage;
    }

    @Override
    public String toString() {
        return name + "-" + id + "-" + subject + "-" + percentage;
    }
}
public class StudentStaticstics {
    public static void main(String[] args) {
        Student student1 = new Student("Dinesh", 1, "Algorithms", 75);
        Student student2 = new Student("Arnav", 2, "Automata", 55);
        Student student3 = new Student("Anamika", 3, "Databases", 80);
        Student student4 = new Student("Vishal", 4, "Networking", 40);
        List<Student> students = Arrays.asList(student1, student2, student3, student4);
        Map<Boolean, List<Student>> stdsLessThanSixty = students.stream()
                .collect(Collectors.partitioningBy(s -> s.getPercentage() > 60));
        System.out.println("Students less < 60 are: \n" + stdsLessThanSixty);
        List<Student> top3 = students.stream().sorted((st1, st2) -> (int) (st2.getPercentage() - st1.getPercentage()))
                .limit(3).toList();
        System.out.println("Top 3 students are: " + top3);
        Map<String, Double> nameAndperc = students.stream()
                .collect(Collectors.toMap(Student::getName, Student::getPercentage));
        System.out.println("Students with marks:" + nameAndperc);
        Set<String> subjects = students.stream().map(Student::getSubject).collect(Collectors.toSet());
        System.out.println("Subjects are : " + subjects);
        System.out.println(
                "Highest Marks : " + students.stream().mapToDouble(Student::getPercentage).max().getAsDouble());
        System.out
                .println("Lowest Marks : " + students.stream().mapToDouble(Student::getPercentage).min().getAsDouble());
        System.out.println(
                "Average Marks : " + students.stream().mapToDouble(Student::getPercentage).average().getAsDouble());
        System.out.println("Total students are: " + students.size());
        Map<String, Student> groupingBySubject = students.stream().collect(Collectors.toMap(Student::getSubject, s->s));
        System.out.println("Students with based on subject: " + groupingBySubject);
    }
}

0 replies

mkaifahmed · 2022-03-10T09:40:10Z

mkaifahmed
Mar 10, 2022



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

class Student {
    private String name;
    private int id;
    private String subject;

    double percentage;

    public Student(String name, int id, String subject, double percentage) {
        this.name = name;
        this.id = id;
        this.subject = subject;
        this.percentage = percentage;
    }

    public String getName() {
        return name;
    }

    public int getId() {
        return id;
    }

    public String getSubject() {
        return subject;
    }

    public double getPercentage() {
        return percentage;
    }

    @Override
    public String toString() {
        return name + "-" + id + "-" + subject + "-" + percentage;
    }
}

public class StudentDriver {
    public static void main(String[] args) {
        Student student1 = new Student("Dinesh", 1, "Algorithms", 75);
        Student student2 = new Student("Arnav", 2, "Automata", 55);
        Student student3 = new Student("Anamika", 3, "Databases", 80);
        Student student4 = new Student("Vishal", 4, "Networking", 40);
        Student student5 = new Student("Ravi", 5, "Networking", 42);
        List<Student> students = new ArrayList<Student>();
        students.add(student1);
        students.add(student2);
        students.add(student3);
        students.add(student4);
        students.add(student5);
        // Partition the students who got above 60% from those who didn’t.
        Map<Boolean, List<Student>> partition = students.stream()
                .collect(Collectors.partitioningBy(student -> student.getPercentage() > 60));
        System.out.println(partition);
        // Names and Percentage of each student
        for (Student x : students) {
            System.out.print(x.getName() + " " + x.getPercentage() + "||");
        }
        System.out.println();
        // Get the names of the top 3 performing students.
        List<Student> top3 = students.stream()
                .sorted(Comparator.comparing(Student::getPercentage, Comparator.reverseOrder())).limit(3)
                .collect(Collectors.toList());
        System.out.println(top3);

        // Get the set of subjects offered in the college
        Set<String> subjects = new HashSet<String>();
        for (Student x : students) {
            subjects.add(x.getSubject());
        }
        System.out.println(subjects);
        // Get the highest, the lowest, and the average percentage of students
        Double[] percentage = new Double[students.size()];
        int i = 0;
        double average = 0;
        for (Student x : students) {
            percentage[i++] = x.getPercentage();
            average += x.getPercentage();
        }
        double min = Collections.min(Arrays.asList(percentage));
        double max = Collections.max(Arrays.asList(percentage));
        System.out.println("Highest Percentage: " + max + "\nLowest Percentage: " + min + "\nAverage Percentage: "
                + average / students.size());
        // Total No of Students in list
        System.out.println(students.size());
        // Get the students grouped by subject from the given list of students
        students.stream().collect(Collectors.groupingBy(Student::getSubject))
                .forEach((sub, list) -> System.out.println(sub + " = " + list));

    }
}

0 replies

Batchusatyasri · 2022-03-10T09:42:44Z

Batchusatyasri
Mar 10, 2022

package Datastructures;

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

class Student {
private String name;
private int id;
private String subject;

double percentage;

public Student(String name, int id, String subject, double percentage) {
    this.name = name;
    this.id = id;
    this.subject = subject;
    this.percentage = percentage;
}

public String getName() {
    return name;
}

public int getId() {
    return id;
}

public String getSubject() {
    return subject;
}

public double getPercentage() {
    return percentage;
}

@Override
public String toString() {
    return name + "-" + id + "-" + subject + "-" + percentage;
}

}

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

    Student student1 = new Student("Dinesh", 1, "Algorithms", 75);
    Student student2 = new Student("Arnav", 2, "Automata", 55);
    Student student3 = new Student("Anamika", 3, "Databases", 80);
    Student student4 = new Student("Vishal", 4, "Networking", 40);
    List<Student> studentList = new ArrayList<>();
    studentList.add(student1);
    studentList.add(student2);
    studentList.add(student3);
    studentList.add(student4);
    Map<Boolean, List<Student>> part = studentList.stream()
            .collect(Collectors.partitioningBy(s -> s.getPercentage() > 60));
    System.out.println(part);
    List<Student> toppers = studentList.stream()
            .sorted(Comparator.comparing(Student::getPercentage, Comparator.reverseOrder())).limit(3)
            .collect(Collectors.toList());
    System.out.println(toppers);
    Map<String, Double> stud = studentList.stream()
            .collect(Collectors.toMap(Student::getName, Student::getPercentage));
    System.out.println(stud);
    List<String> subj = studentList.stream().map(Student::getSubject).collect(Collectors.toList());
    System.out.println(subj);
    List<Double> gpa = studentList.stream().map(Student::getPercentage).collect(Collectors.toList());
    System.out.println("Highest percentage: " + Collections.max(gpa));
    System.out.println("Lowest percentage: " + Collections.min(gpa));
    double avgper = student1.getPercentage() + student2.getPercentage() + student3.getPercentage()
            + student4.getPercentage();
    double percent = (avgper) / studentList.size();
    System.out.println("Average percentage: " + percent);
    Map<String, List<Student>> database = studentList.stream().collect(Collectors.groupingBy(Student::getSubject));
    System.out.println(database);

}

}

0 replies

RohitNaikade1 · 2022-03-10T09:45:15Z

RohitNaikade1
Mar 10, 2022

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

class Student implements Comparable<Student>{
    private String name;
    private int id;
    private String subject;

    double percentage;

    public Student(String name, int id, String subject, double percentage) {
        this.name = name;
        this.id = id;
        this.subject = subject;
        this.percentage = percentage;
    }

    public String getName() {
        return name;
    }

    public int getId() {
        return id;
    }

    public String getSubject() {
        return subject;
    }

    public double getPercentage() {
        return percentage;
    }

    @Override
    public String toString() {
        return name + "-" + id + "-" + subject + "-" + percentage;
    }

    @Override
    public int compareTo(Student o) {
        return (int) (o.percentage-this.percentage);
    }
}

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

        Student student1 = new Student("Dinesh", 1, "Algorithms", 75);
        Student student2 = new Student("Arnav", 2, "Automata", 55);
        Student student3 = new Student("Anamika", 3, "Databases", 80);
        Student student4 = new Student("Vishal", 4, "Networking", 40);

        ArrayList<Student> students = new ArrayList<Student>();
        students.add(student1);
        students.add(student2);
        students.add(student3);
        students.add(student4);

        System.out.println("*******Students with above 60 percentage**********");
        Map<Boolean, List<Student>> map = students.stream()
                .collect(Collectors.partitioningBy(stu -> stu.getPercentage() > 60));
        System.out.println(map);
        ArrayList<Student> TopThree=(ArrayList<Student>) students.stream().sorted().limit(3).collect(Collectors.toList());
        System.out.println("*********Top 3 performers***********");
        TopThree.forEach(System.out::println);
        System.out.println("*********Name and Percentage********");
        Map<String, Double> map2 = students.stream()
                .collect(Collectors.toMap(Student::getName, Student::getPercentage));
        System.out.println(map2);
        Set<String> subject=students.stream().map(student -> student.getSubject()).collect(Collectors.toSet());
        System.out.println("*********Subjects***********");
        subject.forEach(System.out::println);
        System.out.println("Max Persentage: "+students.stream().mapToDouble(Student::getPercentage).max());
        System.out.println("Min Percentage: "+students.stream().mapToDouble(Student::getPercentage).min());
        System.out.println("Average: "+students.stream().mapToDouble(Student::getPercentage).average());

        System.out.println("Total no of students: "+students.stream().count());
    }
}

0 replies

SabaMhabar · 2022-03-10T09:48:21Z

SabaMhabar
Mar 10, 2022

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.OptionalDouble;
import java.util.Set;
import java.util.stream.Collectors;

class Student {
private String name;
private int id;
private String subject;

double percentage;

public Student(String name, int id, String subject, double percentage) {
    this.name = name;
    this.id = id;
    this.subject = subject;
    this.percentage = percentage;
}

public String getName() {
    return name;
}

public int getId() {
    return id;
}

public String getSubject() {
    return subject;
}

public double getPercentage() {
    return percentage;
}

@Override
public String toString() {
    return name + "-" + id + "-" + subject + "-" + percentage;
}

}

public class StudentDriver {
public static void main(String[] args) {
Student student1 = new Student("Dinesh", 1, "Algorithms", 75);
Student student2 = new Student("Arnav", 2, "Automata", 55);
Student student3 = new Student("Anamika", 3, "Databases", 80);
Student student4 = new Student("Vishal", 4, "Networking", 40);
Student student5 = new Student("Saba", 5, "Databases", 70);

    List<Student> studentList = Arrays.asList(student1, student2, student3, student4, student5);

    Map<Boolean, List<Student>> map = studentList.stream()
            .collect(Collectors.partitioningBy(stu -> stu.getPercentage() > 60));
    System.out.println(map);

    List<Student> topPerformer = studentList.stream()
            .sorted(Comparator.comparing(Student::getPercentage, Comparator.reverseOrder())).limit(3)
            .collect(Collectors.toList());

    System.out.println(topPerformer);

    Map<String, Double> map2 = studentList.stream()
            .collect(Collectors.toMap(Student::getName, Student::getPercentage));
    System.out.println(map2);

    Set<String> subjectSet = studentList.stream().map(Student::getSubject).collect(Collectors.toSet());
    System.out.println(subjectSet);

    OptionalDouble highest = studentList.stream().mapToDouble(Student::getPercentage).max();
    System.out.println("Highest Percentage :" + highest.getAsDouble());

    OptionalDouble lowest = studentList.stream().mapToDouble(Student::getPercentage).min();
    System.out.println("Lowest Percentage :" + lowest.getAsDouble());

    OptionalDouble average = studentList.stream().mapToDouble(Student::getPercentage).average();

    System.out.println("Average Percentage :" + average.getAsDouble());
    System.out.println("Total students: " + studentList.size());
    Map<String, List<Student>> groupBySubject = studentList.stream()
            .collect(Collectors.groupingBy(Student::getSubject));
    System.out.println(groupBySubject);
}

}

0 replies

sruthi-15-sketch · 2022-03-10T09:56:12Z

sruthi-15-sketch
Mar 10, 2022

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

class Student implements Comparable<Student> {
    private String name;
    private int id;
    private String subject;

    double percentage;

    Student() {
    }

    public Student(String name, int id, String subject, double percentage) {
        this.name = name;
        this.id = id;
        this.subject = subject;
        this.percentage = percentage;
    }

    public String getName() {
        return name;
    }

    public int getId() {
        return id;
    }

    public String getSubject() {
        return subject;
    }

    public double getPercentage() {
        return percentage;
    }

    @Override
    public String toString() {
        return name + "-" + id + "-" + subject + "-" + percentage;
    }

    @Override
    public int compareTo(Student o) {

        return (int) (o.percentage - this.percentage);
    }

}

public class StudentStatistics {
    public static void main(String[] args) {
        Student student1 = new Student("Dinesh", 1, "Algorithms", 75);
        Student student2 = new Student("Arnav", 2, "Automata", 55);
        Student student3 = new Student("Anamika", 3, "Databases", 80);
        Student student4 = new Student("Vishal", 4, "Networking", 40);
        ArrayList<Student> studentList = new ArrayList<>(Arrays.asList(student1, student2, student3, student4));
        HashMap<Boolean, ArrayList<Student>> h = new HashMap<>();
        ArrayList<Student> l1 = new ArrayList<>();
        ArrayList<Student> l2 = new ArrayList<>();
        System.out.println("Students with less than and greater than 60%:");
        for (Student i : studentList) {
            if (i.percentage >= 60) {
                l1.add(i);
                h.put(true, l1);
            } else {
                l2.add(i);
                h.put(false, new ArrayList<Student>(l2));
            }
        }
        System.out.println(h);
        System.out.println("Top 3 performing students:");
        List<Student> sortedList = studentList.stream().sorted().collect(Collectors.toList());
        for (int i = 0; i < 3; i++)
            System.out.println(sortedList.get(i));

        System.out.println("Student names and percentage:");
        for (Student i : studentList) {
            System.out.println(i.getName() + "=" + i.percentage);
        }
        HashSet<String> set = new HashSet<>();
        for (Student i : studentList) {
            set.add(i.getSubject());
        }
        System.out.println("Subjects " + set);
        System.out.println("Highest Percentage: " + sortedList.get(0).getPercentage());
        System.out.println("Lowest Percentage: " + sortedList.get(sortedList.size() - 1).getPercentage());
        float sum = 0;
        for (int i = 0; i < sortedList.size(); i++) {
            sum += sortedList.get(i).getPercentage();
        }
        System.out.println("Average Percentage: " + (sum / sortedList.size()));

        System.out.println(studentList.size());
        HashMap<String, ArrayList<Student>> hmap = new HashMap<>();
        ArrayList<Student> l = new ArrayList<>();
        for (Student i : studentList) {
            if (i.getSubject().equals("Databases")) {
                l.add(i);
                hmap.put("Databases", new ArrayList<Student>(l));
                l.removeAll(l);
            } else if (i.getSubject().equals("Algorithms")) {
                l.add(i);
                hmap.put("Algorithms", new ArrayList<Student>(l));
                l.removeAll(l);
            } else if (i.getSubject().equals("Networking")) {
                l.add(i);
                hmap.put("Networking", new ArrayList<Student>(l));
                l.removeAll(l);
            } else {
                l.add(i);
                hmap.put("Automata", new ArrayList<Student>(l));
                l.removeAll(l);
            }
        }
        System.out.println(hmap);
    }
}

0 replies

deepak775035 · 2022-03-10T09:59:48Z

deepak775035
Mar 10, 2022

package week1.day4;

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

class Student {
    private String name;
    private int id;
    private String subject;

    double percentage;

    public Student(String name, int id, String subject, double percentage) {
        this.name = name;
        this.id = id;
        this.subject = subject;
        this.percentage = percentage;
    }

    public String getName() {
        return name;
    }

    public int getId() {
        return id;
    }

    public String getSubject() {
        return subject;
    }

    public double getPercentage() {
        return percentage;
    }

    @Override
    public String toString() {
        return name + "-" + id + "-" + subject + "-" + percentage;
    }
}

public class StudentStatisticsDriver {
    public static void main(String[] args) {
        Student student1 = new Student("Dinesh", 1, "Algorithms", 75);
        Student student2 = new Student("Arnav", 2, "Automata", 55);
        Student student3 = new Student("Anamika", 3, "Databases", 80);
        Student student4 = new Student("Vishal", 4, "Networking", 40);
        Student student5 = new Student("Deepak", 5, "Databases", 46);

        List<Student> studentList = Arrays.asList(student1,student2,student3,student4,student5);

        List<Student> above60Students = new ArrayList<>();
        List<Student> below60Students = new ArrayList<>();
        for (Student student : studentList) {
            if(student.getPercentage()>60)
                above60Students.add(student);
            
            else
                below60Students.add(student);
        }

        System.out.println("Above 60:"+above60Students);
        System.out.println("Below or equals to 60:"+below60Students);
        
        
        System.out.println();
        Collections.sort(studentList, (o1, o2) -> (int)(o2.getPercentage()-o1.getPercentage()));
        for (int i = 0; i < 3; i++) {
            System.out.println(studentList.get(i));
        }

        System.out.println();
        //Get the name and percentage of each student.
        for (Student student : studentList) {
            System.out.println("Name:"+student.getName()+" Percentage:"+student.getPercentage());
        }

        System.out.println();
        //Get the set of subjects offered in the college
        Set<String> subjectsOffered = new HashSet<>();
        for (Student student : studentList) {
            subjectsOffered.add(student.getSubject().toLowerCase());
        }
        System.out.println(subjectsOffered);



        System.out.println();
        //Get the highest, the lowest, and the average percentage of students
        double highestPercentage=0.0;
        double lowestPercentage=100.0;
        double total=0;
        int noOfPer=0;
        for (Student student : studentList) {
            double per = student.getPercentage();
            total+= per;
            noOfPer++;
            if(per>highestPercentage)highestPercentage=per;
            if(per<lowestPercentage)lowestPercentage=per;
        }
        System.out.println("Highest:"+highestPercentage+" Lowest:"+lowestPercentage+" Avg:"+(total/noOfPer));

        System.out.println();
        System.out.println("Total No of student:"+studentList.size());

        System.out.println();
        studentList.stream().collect(Collectors.groupingBy(Student::getSubject))
                .forEach((sub, list) -> System.out.println(sub + " = " + list));

    }
}

0 replies

amruth2211 · 2022-03-10T10:39:50Z

amruth2211
Mar 10, 2022

package week6;

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


class Student implements Comparable<Student> {
    private String name;
    private int id;
    private String subject;

    double percentage;

    public Student(String name, int id, String subject, double percentage) {
        this.name = name;
        this.id = id;
        this.subject = subject;
        this.percentage = percentage;
    }

    public String getName() {
        return name;
    }

    public int getId() {
        return id;
    }

    public String getSubject() {
        return subject;
    }

    public double getPercentage() {
        return percentage;
    }

    @Override
    public int compareTo(Student o) {

        return (int) (o.percentage - this.percentage);
    }

    @Override
    public String toString() {
        return name + "-" + id + "-" + subject + "-" + percentage;
    }
}

public class StudentStatics {
    public static void main(String[] args) {
        Student student1 = new Student("Dinesh", 1, "Algorithms", 75);
        Student student2 = new Student("Arnav", 2, "Automata", 55);
        Student student3 = new Student("Anamika", 3, "Databases", 80);
        Student student4 = new Student("Vishal", 4, "Networking", 40);
        List<Student> studentList = new ArrayList<>();
        studentList.add(student1);
        studentList.add(student2);
        studentList.add(student3);
        studentList.add(student4);
        // Partition the students who got above 60% from those who didn’t.
        List<Student> a = new ArrayList<>();
        List<Student> b = new ArrayList<>();
        for (int i = 0; i < studentList.size(); i++) {
            if (studentList.get(i).getPercentage() > 60) {
                a.add(studentList.get(i));
            } else
                b.add(studentList.get(i));
        }
        System.out.println("{false=" + b + ", true=" + a);

        // Get the names of the top 3 performing students
        List<Student> topList = studentList.stream().sorted().toList();
        for (int i = 0; i < 3; i++) {
            System.out.print(topList.get(i) + " , ");
        }

        System.out.println();
        // " Get the name and percentage of each student."
        for (Student student : studentList) {
            System.out.print(student.getName() + "=" + student.getPercentage() + " ");
        }

        System.out.println();
        // Get the set of subjects offered in the college
        for (Student student : studentList) {
            System.out.print(student.getSubject() + " , ");
        }

        System.out.println("\nHighest Percentage: " + topList.get(0).getPercentage());
        System.out.println("Lowest Percentage: " + topList.get(topList.size() - 1).getPercentage());
        double average = studentList.stream().mapToDouble(Student::getPercentage).average().getAsDouble();
        System.out.println("Average Percentage: " + average);

        // Get total number of students from the given list of students
        System.out.println(studentList.size());

        // Get the students grouped by subject from the given list of students
        for (Student student : studentList) {
            System.out.print(student.getSubject() + " [ " + student + " ] ");
        }

    }
}

0 replies

rakeshGit419 · 2022-03-10T14:38:23Z

rakeshGit419
Mar 10, 2022

import java.util.*;
import java.util.stream.*;
class Student implements Comparable<Student>{
    private String name;
    private int id;
    private String subject;
    double percentage;

    public Student(String name, int id, String subject, double percentage) {
        this.name = name;
        this.id = id;
        this.subject = subject;
        this.percentage = percentage;
    }

    public String getName() {return name;}

    public int getId() {return id;}

    public String getSubject() {return subject;}

    public double getPercentage() {return percentage;}
    @Override
    public String toString() {
        return name + "-" + id + "-" + subject + "-" + percentage;
    }

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

    

    
}

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

        Student student1 = new Student("Dinesh", 1, "Algorithms", 75);
        Student student2 = new Student("Arnav", 2, "Automata", 55);
        Student student3 = new Student("Anamika", 3, "Databases", 80);
        Student student4 = new Student("Vishal", 4, "Networking", 40);
        Student student5 = new Student("Antony", 5, "Databases", 65);
        Student student6 = new Student("Vijay", 6, "Networking", 90);

        List<Student> studentList = Arrays.asList(student1,student2,student3,student4,student5,student6);
        Map<Boolean,List<Student>> stdAbove60 = studentList.stream()
        .collect(Collectors.partitioningBy(n->n.getPercentage() > 60));
        System.out.println(stdAbove60);

        Collections.sort(studentList);
        List<Student> studentTop = studentList.stream().map(n->n).limit(3).collect(Collectors.toList());
        System.out.println(studentTop);



        Map<String,Double> namePercentage = studentList.stream().collect(Collectors.toMap(Student::getName,Student::getPercentage));
        System.out.println(namePercentage);

        Set<String> set = studentList.stream().map(n->n.getSubject()).collect(Collectors.toSet());
        System.out.println(set);

        DoubleSummaryStatistics studentStats = studentList.stream().collect(Collectors.summarizingDouble(Student::getPercentage));
        System.out.println("Highest Percentage : "+studentStats.getMax());
        System.out.println("Lowest Percentage : "+studentStats.getMin());
        System.out.println("Average Percentage : "+studentStats.getAverage());

        //6 count of student
        Long countOfStudnet = studentList.stream().collect(Collectors.counting());
        System.out.println(countOfStudnet);

        Map<String,List<Student>> mapStudentBySubjects = studentList.stream().collect(Collectors.groupingBy(Student::getSubject));
        System.out.println(mapStudentBySubjects);
    }
}

0 replies

GantaGreeshma · 2022-03-10T16:32:43Z

GantaGreeshma
Mar 10, 2022

package collection_framework.datastructues;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.OptionalDouble;
import java.util.stream.Collectors;

class Student implements Comparable<Student> {
    private String name;
    private int id;
    private String subject;

    double percentage;

    public Student(String name, int id, String subject, double percentage) {
        this.name = name;
        this.id = id;
        this.subject = subject;
        this.percentage = percentage;
    }

    public String getName() {
        return name;
    }

    public int getId() {
        return id;
    }

    public String getSubject() {
        return subject;
    }

    public double getPercentage() {
        return percentage;
    }

    @Override
    public String toString() {
        return name + "-" + id + "-" + subject + "-" + percentage;
    }

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

public class StudentsInfo {
    public static void main(String[] args) {
        Student student1 = new Student("Dinesh", 1, "Algorithms", 75);
        Student student2 = new Student("Arnav", 2, "Automata", 55);
        Student student3 = new Student("Anamika", 3, "Databases", 80);
        Student student4 = new Student("Vishal", 4, "Networking", 40);
        List<Student> studentList = new ArrayList<>();
        studentList.add(student1);
        studentList.add(student2);
        studentList.add(student3);
        studentList.add(student4);
        HashMap<Boolean, List<Student>> map = new HashMap<>();
        for (Student ele : studentList) {
            if (ele.getPercentage() > 60) {
                map.put(true, studentList);
            } else {
                map.put(false, studentList);
            }
        }
        map.values().stream().forEach(System.out::println);
        List<Student> sortedList = studentList.stream().sorted().collect(Collectors.toList());
        for (int i = 0; i < 3; i++)
            System.out.print(sortedList.get(i));
        studentList.stream().map(i -> i.getName() + " " + i.getPercentage()).forEach(System.out::println);
        studentList.stream().map(i -> i.getSubject()).collect(Collectors.toSet()).forEach(System.out::println);
        System.out.println("Higest percentage: " + sortedList.get(0).getPercentage());
        System.out.println("Lowest percentage: " + sortedList.get(sortedList.size() - 1).getPercentage());
        OptionalDouble avg = studentList.stream().mapToDouble(Student::getPercentage).average();
        System.out.println("Average percentage: " + avg);
        System.out.println(studentList.size());
        studentList.stream().collect(Collectors.groupingBy(Student::getSubject))
                .forEach((subject, list) -> System.out.println(subject + " = " + list));

    }
}

0 replies

PavanArvapally · 2022-03-10T17:50:36Z

PavanArvapally
Mar 10, 2022

package Week6.Tasks;


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

class Student {
    private String name;
    private int id;
    private String subject;

    double percentage;

    public Student(String name, int id, String subject, double percentage) {
        this.name = name;
        this.id = id;
        this.subject = subject;
        this.percentage = percentage;
    }

    public String getName() {
        return name;
    }

    public int getId() {
        return id;
    }

    public String getSubject() {
        return subject;
    }

    public double getPercentage() {
        return percentage;
    }

    @Override
    public String toString() {
        return name + "-" + id + "-" + subject + "-" + percentage;
    }
}

public class StudentDriver {
    public static void main(String[] args) {
        Student student1 = new Student("Dinesh", 1, "Algorithms", 75);
        Student student2 = new Student("Arnav", 2, "Automata", 55);
        Student student3 = new Student("Anamika", 3, "Databases", 80);
        Student student4 = new Student("Vishal", 4, "Networking", 40);

        List<Student> studentList = Arrays.asList(student1, student2, student3, student4);
        System.out.print("{false=[");
        studentList.stream().filter(student -> student.getPercentage()<60).forEach(System.out::print);
        System.out.print("], true=[");
        studentList.stream().filter(student -> student.getPercentage()>60).forEach(System.out::print);
        System.out.println("]}");

        List<Student> sortedList = studentList.stream().sorted((s1, s2) -> (int)(s2.getPercentage()-s1.getPercentage())).limit(3).collect(Collectors.toList());
        System.out.println(sortedList);

        Map<String, Double> map = studentList.stream().collect(Collectors.toMap(Student::getName, Student::getPercentage));
        System.out.println(map);

        Set<String> subjects = studentList.stream().map(Student::getSubject).collect(Collectors.toSet());
        System.out.println(subjects);

        List<Student> sortedList2 = studentList.stream().sorted((s1, s2) -> (int)(s2.getPercentage()-s1.getPercentage())).collect(Collectors.toList());

        System.out.println("Highest Percentage: "+ sortedList2.get(0).getPercentage());
        System.out.println("Lowest Percentage : "+sortedList2.get(sortedList.size()-1).getPercentage());
        System.out.println("Average Percentage : "+(studentList.stream().map(student -> student.getPercentage()).reduce(0.0,(ans, i)->ans+i))/studentList.size());

        System.out.println(studentList.size());

        Map<String, List<Student>> a= studentList.stream().collect(Collectors.groupingBy(Student::getSubject));
        System.out.println(a);
    }
}

0 replies

Shivani2145 · 2022-08-28T05:03:59Z

Shivani2145
Aug 28, 2022

package task56;

public class Student {
	private String name;
    private int id;
    private String subject;
    double percentage;

    public Student(String name, int id, String subject, double percentage) {
        this.name = name;
        this.id = id;
        this.subject = subject;
        this.percentage = percentage;
    }

	public String getName() {
		return name;
	}

	public int getId() {
		return id;
	}

	public String getSubject() {
		return subject;
	}



	public double getPercentage() {
		return percentage;
	}

	@Override
	public String toString() {
		return "Student [name=" + name + ", id=" + id + ", subject=" + subject + ", percentage=" + percentage + "]";
	}
		
	
}


package task56;

import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

public class StudentDriver {
	public static void main(String[] args) {
		Student student1 = new Student("Dinesh", 1, "Algorithms", 75);
		Student student2 = new Student("Arnav", 2, "Automata", 55);
		Student student3 = new Student("Anamika", 3, "Databases", 80);
		Student student4 = new Student("Vishal", 4, "Networking", 40);
		
		List<Student> studentList = Arrays.asList(student1,student2,student3,student4);
		
		Map<Boolean,List<Student>>less60 = studentList.stream().collect(Collectors.partitioningBy(s->s.getPercentage()>60));
		System.out.println(less60);
		
		List<Student> topper = studentList.stream().sorted(Comparator.comparing(Student::getPercentage,Comparator.reverseOrder())).limit(3).collect(Collectors.toList());
		System.out.println(topper);
		
		Map<String, Double> names = studentList.stream().collect(Collectors.toMap(Student::getName, Student::getPercentage));
		System.out.println(names);
		
		Set<String> subject = studentList.stream().map(Student::getSubject).collect(Collectors.toSet());
		System.out.println(subject);
		
		List<Double> cgpa = studentList.stream().map(Student::getPercentage).collect(Collectors.toList());
		System.out.println("highestpercentage:"+Collections.max(cgpa));
		System.out.println("lowestpercentage:"+Collections.min(cgpa));
		
		Double avg = student1.getPercentage()+student2.getPercentage()+student3.getPercentage()+student4.getPercentage();
		Double avgPer = ((avg)/studentList.size());
		System.out.println(avgPer);
		
		int length = studentList.size();
		System.out.println(length);
		
		studentList.stream().collect(Collectors.groupingBy(Student::getSubject)).forEach((k,v)->System.out.println("\n"+ k +"Group By" + v + "\n"));
	}
}

0 replies

sayanp-12 · 2023-09-26T15:38:08Z

sayanp-12
Sep 26, 2023

Hi @akash-coded , Please find my solution. My name sayan panja.

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

class Student {
    private String name;
    private int id;
    private String subject;

    double percentage;

    public Student(String name, int id, String subject, double percentage) {
        this.name = name;
        this.id = id;
        this.subject = subject;
        this.percentage = percentage;
    }


    public String getName() {
        return name;
    }

    public int getId() {
        return id;
    }

    public String getSubject() {
        return subject;
    }

    public double getPercentage() {
        return percentage;
    }

    @Override
    public String toString() {
        return name + "-" + id + "-" + subject + "-" + percentage;
    }
}

public class EdurecaStudentStatics{

public static void main(String[] args) {
	
   // Create four Student instances:
	Student student1 = new Student("Dinesh", 1, "Algorithms", 75);
	Student student2 = new Student("Arnav", 2, "Automata", 55);
	Student student3 = new Student("Anamika", 3, "Databases", 80);
	Student student4 = new Student("Vishal", 4, "Networking", 40);
	
	List<Student> studentList = new ArrayList<>();
	studentList.add(student1);
	studentList.add(student2);
	studentList.add(student3);
	studentList.add(student4);
	
	// Partition the students who got above 60% from those who didn’t.
    List<Student> student_60_plus = new ArrayList<>();
    List<Student> student_less_than_60 = new ArrayList<>();
    System.out.println(studentList);
    studentList.forEach(stdObj -> {
        if (stdObj.percentage >= 60) {
        	student_60_plus.add(stdObj);
        } else {
        	student_less_than_60.add(stdObj);
        }
    });
    
    System.out.println("{false=" + student_less_than_60 + ",true=" + student_60_plus);
    
    // Get the names of the top 3 performing students.
    List<Student> topPerormingStudent = studentList.stream().sorted((stdent1, stdent2) -> (int) (stdent2.percentage - stdent1.percentage))
            .limit(3)
            .collect(Collectors.toList());
    System.out.println(topPerormingStudent);
    
    // Get the name and percentage of each student.
    List<String> student_name_percentage_obj = studentList.stream()
            .sorted((std1, std2) -> (int) (std2.percentage - std1.percentage))
            .map(std -> std.getName() + "=" + std.percentage).collect(Collectors.toList());
    System.out.println(student_name_percentage_obj);
    
    // Get the set of subjects offered in the college
    Set<String> subjects = studentList.stream().map(std -> std.getSubject()).collect(Collectors.toSet());
    System.out.println(subjects);
    
    // Get the highest, the lowest, and the average percentage of students
    System.out.println("Highest Percentage: " + student_name_percentage_obj.get(0).split("=")[1]);
    System.out.println("Lowest Percentage: " + student_name_percentage_obj.get(3).split("=")[1]);
    OptionalDouble student_avg_marks = studentList.stream().mapToDouble(Student::getPercentage).average();
    System.out.println("Average: " + student_avg_marks);
    
    // Get the total number of students from the given list of students
    System.out.println(studentList.size());
    
    // Get the students grouped by subject from the given list of students
    studentList.stream().collect(Collectors.groupingBy(Student::getSubject))
            .forEach((sub, list) -> System.out.println(sub + " = " + list));
			
}

}

0 replies

manideep-vv · 2023-09-26T15:38:18Z

manideep-vv
Sep 26, 2023

package edureka;

import java.util.*;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Student {
private String name;
private int id;
private String subject;

double percentage;

public Student(String name, int id, String subject, double percentage) {
    this.name = name;
    this.id = id;
    this.subject = subject;
    this.percentage = percentage;
}

public String getName() {
    return name;
}

public int getId() {
    return id;
}

public String getSubject() {
    return subject;
}

public double getPercentage() {
    return percentage;
}

@Override
public String toString() {
    return name + "-" + id + "-" + subject + "-" + percentage;
}

public static void main(String[] args) {
    Student student1 = new Student("Dinesh", 1, "Algorithms", 75);
    Student student2 = new Student("Arnav", 2, "Automata", 55);
    Student student3 = new Student("Anamika", 3, "Databases", 80);
    Student student4 = new Student("Vishal", 4, "Networking", 40);


    List<Student> list= Arrays.asList(student1,student2,student3,student4);
    Predicate<Student> p= s->s.getPercentage()>60;
    Map<Boolean, List<Student>> segregatedListWithPercentage60 = list.stream().collect(Collectors.partitioningBy(p));
    System.out.println(segregatedListWithPercentage60);

    Comparator<Student> c= (s1,s2)-> Double.compare(s2.getPercentage() ,s1.getPercentage());
    List<Student> sortedByPercentage = list.stream().sorted(c).collect(Collectors.toList()).subList(0,3);
    System.out.println(sortedByPercentage);

    Map<String, Double> nameAndPErcentageOfEachStudent = list.stream().collect(Collectors.toMap(Student::getName, Student::getPercentage));
    System.out.println(nameAndPErcentageOfEachStudent);

    List<String> subjectsOffered = list.stream().map(Student::getSubject).collect(Collectors.toList());
    System.out.println(subjectsOffered);

    OptionalDouble highestPercentage = list.stream().mapToDouble(Student::getPercentage).max();
    System.out.println("Highest Percentage: "+highestPercentage.getAsDouble());

    OptionalDouble lowestPercentage = list.stream().mapToDouble(Student::getPercentage).min();
    System.out.println("Lowest Percentage: "+lowestPercentage.getAsDouble());

    OptionalDouble averagePercentage = list.stream().mapToDouble(Student::getPercentage).average();
    System.out.println("Average Percentage: "+averagePercentage.getAsDouble());

    System.out.println(list.stream().count());

    Map<String, List<Student>> groupBySubject = list.stream().collect(Collectors.groupingBy(Student::getSubject));
    System.out.println(groupBySubject);

}

}

0 replies

Aniruth-raman · 2023-09-26T16:01:25Z

Aniruth-raman
Sep 26, 2023

`
import java.util.*;

public class StudentImplementation {
public static void main(String[] args) {
Student student1 = new Student("Dinesh", 1, "Algorithms", 75);
Student student2 = new Student("Arnav", 2, "Automata", 55);
Student student3 = new Student("Anamika", 3, "Databases", 80);
Student student4 = new Student("Vishal", 4, "Networking", 40);
ArrayList studentList = new ArrayList<>();
studentList.add(student1);
studentList.add(student2);
studentList.add(student3);
studentList.add(student4);
Map<Boolean, List> partition = partitionStudents(studentList);
System.out.println(partition);
List top3PerformingStudents = topPerformingStudents(studentList);
System.out.println(top3PerformingStudents);
Map<String, Double> nameAndPercentage = namePercentage(studentList);
System.out.println(nameAndPercentage);
Set subjects = allSubjects(studentList);
System.out.println(subjects);
highestLowestAverage(studentList);
System.out.println(studentList.size());
Map<String, List> studentsgroup = studentsGroupedBySubject(studentList);
System.out.println(studentsgroup);
}

private static Map<String, List<String>> studentsGroupedBySubject(ArrayList<Student> studentList) {
    Map<String, List<String>> groupedBySubject = new HashMap<>();
    for (Student s : studentList) {
        String sub = s.getSubject();
        if (!groupedBySubject.containsKey(sub)) {
            groupedBySubject.put(sub, new ArrayList<>());
        }
        groupedBySubject.get(sub).add(s.toString());
    }
    return groupedBySubject;
}

private static void highestLowestAverage(ArrayList<Student> studentList) {
    double highest = Double.MIN_VALUE;
    double lowest = Double.MAX_VALUE;
    double sum = 0;
    for (Student s : studentList) {
        double p = s.getPercentage();
        if (p > highest) {
            highest = p;
        }
        if (p < lowest) {
            lowest = p;
        }
        sum += p;
    }
    double average = sum / studentList.size();
    System.out.println("Highest Percentage: " + highest);
    System.out.println("Lowest Percentage: " + lowest);
    System.out.println("Average Percentage: " + average);
}

private static Set<String> allSubjects(ArrayList<Student> studentList) {
    Set<String> subjects = new HashSet<>();
    for (Student s : studentList) {
        subjects.add(s.getSubject());
    }
    return subjects;
}

private static Map<String, Double> namePercentage(ArrayList<Student> studentList) {
    Map<String, Double> nameAndPercentage = new HashMap<>();
    for (Student s : studentList) {
        nameAndPercentage.put(s.getName(), s.getPercentage());
    }
    return nameAndPercentage;

}

private static List<String> topPerformingStudents(ArrayList<Student> studentList) {
    List<String> topStudents = new ArrayList<>();
    Collections.sort(studentList, new Comparator<Student>() {
        @Override
        public int compare(Student s1, Student s2) {
            return (int) (s2.getPercentage() - s1.getPercentage());
        }
    });
    for (int i = 0; i < 3; i++) {
        topStudents.add(studentList.get(i).toString());
    }
    return topStudents;
}

private static Map<Boolean, List<String>> partitionStudents(ArrayList<Student> studentList) {
    List<String> above60 = new ArrayList<>();
    List<String> below60 = new ArrayList<>();
    for (Student student : studentList) {
        if (student.getPercentage() > 60) {
            above60.add(student.toString());
        } else {
            below60.add(student.toString());
        }
    }
    Map<Boolean, List<String>> partitionMap = new HashMap<>();
    partitionMap.put(false, below60);
    partitionMap.put(true, above60);
    return partitionMap;
}

}

`

0 replies

Sourav21071998 · 2023-09-26T16:25:59Z

Sourav21071998
Sep 26, 2023

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Optional;
import java.util.OptionalDouble;
import java.util.Set;
import java.util.stream.Collectors;

class Student {
private String name;
private int id;
private String subject;

double percentage;

public Student(String name, int id, String subject, double percentage) {
    this.name = name;
    this.id = id;
    this.subject = subject;
    this.percentage = percentage;
}

public String getName() {
    return name;
}

public int getId() {
    return id;
}

public String getSubject() {
    return subject;
}

public double getPercentage() {
    return percentage;
}

@Override
public String toString() {
    return name + "-" + id + "-" + subject + "-" + percentage;
}

}

public class StudentDriver {
public static void main(String[] args) {
Student student1 = new Student("Dinesh", 1, "Algorithms", 75);
Student student2 = new Student("Arnav", 2, "Automata", 55);
Student student3 = new Student("Anamika", 3, "Databases", 80);
Student student4 = new Student("Vishal", 4, "Networking", 40);
List studentList = Arrays.asList(student1, student2, student3, student4);

    Map<Boolean, List<Student>> map = studentList.stream()
            .collect(Collectors.partitioningBy(stu -> stu.getPercentage() > 60));
    System.out.println(map);

    List<Student> topPerformer = studentList.stream()
            .sorted(Comparator.comparing(Student::getPercentage, Comparator.reverseOrder())).limit(3)
            .collect(Collectors.toList());

    System.out.println(topPerformer);

    Map<String, Double> map2 = studentList.stream()
            .collect(Collectors.toMap(Student::getName, Student::getPercentage));
    System.out.println(map2);

    Set<String> subjectSet = studentList.stream().map(Student::getSubject).collect(Collectors.toSet());
    System.out.println(subjectSet);

    OptionalDouble highest = studentList.stream().mapToDouble(Student::getPercentage).max();
    System.out.println("Highest Percentage :" + highest.getAsDouble());

    OptionalDouble lowest = studentList.stream().mapToDouble(Student::getPercentage).min();
    System.out.println("Lowest Percentage :" + lowest.getAsDouble());

    OptionalDouble average = studentList.stream().mapToDouble(Student::getPercentage).average();

    System.out.println("Average Percentage :" + average.getAsDouble());
    System.out.println("Total students: " + studentList.size());

    Map<String, List<Student>> groupBySubject = studentList.stream()
            .collect(Collectors.groupingBy(Student::getSubject));
    System.out.println(groupBySubject);
}

}

0 replies

akratimishra22 · 2023-09-26T19:01:59Z

akratimishra22
Sep 26, 2023

AkratiMishraCollectionsStudentStatistics.zip

0 replies

jay4tech · 2023-09-27T04:48:20Z

jay4tech
Sep 27, 2023

@akash-coded
Name - Jay Prakash Kumar
Description - Implemented the discussion numbers 51, 56 and 61

core-java.zip

0 replies

shriramram · 2023-09-27T06:53:35Z

shriramram
Sep 27, 2023

@akash-coded
Name - Dattatraya Rajaram Shriram
Description - Attached the assignments i.e. 51, 56 and 61, and added same in one package

dattatraya-shriram-assignments.zip

0 replies

arghyagiri · 2023-09-27T14:17:13Z

arghyagiri
Sep 27, 2023

@akash-coded : Below is the solution.

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

public class StudentStats {
public static void main(String[] args) {
//create student list
Student student1 = new Student("Dinesh", 1, "Algorithms", 75);
Student student2 = new Student("Arnav", 2, "Automata", 55);
Student student3 = new Student("Anamika", 3, "Databases", 80);
Student student4 = new Student("Vishal", 4, "Networking", 40);
List students = List.of(student1, student2, student3, student4);

    //Partition the students who got above 60% from those who didn’t.
    Map<Boolean, List<Student>> studentsAbove60Pct = students.stream().collect(Collectors.partitioningBy(s -> s.getPercentage() > 60));
    System.out.println(studentsAbove60Pct);

    //Get the names of the top 3 performing students.
    Comparator<Student> compareByPercentage =
            (Student s1, Student s2) -> Double.compare(s2.getPercentage(), s1.getPercentage());
    List<Student> top3Performer = new ArrayList<>(students);
    Collections.sort(top3Performer, compareByPercentage);
    System.out.println(top3Performer.stream().limit(3).toList());

    //Get the name and percentage of each student.
    Map<String, Double> namePctMap = students.stream().collect(Collectors.toMap(Student::getName, Student::getPercentage));
    System.out.println(namePctMap);

    //Get the set of subjects offered in the college
    Set<String> subjectSet = students.stream().map(Student::getSubject).collect(Collectors.toSet());
    System.out.println(subjectSet);

    //Get the highest, the lowest, and the average percentage of students
    OptionalDouble highestPercentage = students.stream().mapToDouble(Student::getPercentage).max();
    System.out.println("Highest Percentage: " + highestPercentage.getAsDouble());

    OptionalDouble lowestPercentage = students.stream().mapToDouble(Student::getPercentage).min();
    System.out.println("Lowest Percentage: " + highestPercentage.getAsDouble());

    OptionalDouble averagePercentage = students.stream().mapToDouble(Student::getPercentage).average();
    System.out.println("Average Percentage: " + highestPercentage.getAsDouble());

    //Get the total number of students from the given list of students
    System.out.println(students.size());

    //Get the students grouped by subject from the given list of students
    Map<String, List<Student>> groupBySubject = students.stream().collect(Collectors.groupingBy(Student::getSubject));
    System.out.println(groupBySubject);
}

}

class Student {
private String name;
private int id;
private String subject;

double percentage;

public Student(String name, int id, String subject, double percentage) {
    this.name = name;
    this.id = id;
    this.subject = subject;
    this.percentage = percentage;
}

public String getName() {
    return name;
}

public int getId() {
    return id;
}

public String getSubject() {
    return subject;
}

public double getPercentage() {
    return percentage;
}

@Override
public String toString() {
    return name + "-" + id + "-" + subject + "-" + percentage;
}

}
`

0 replies

tarusoft531 · 2023-09-27T15:57:20Z

tarusoft531
Sep 27, 2023

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

public class Main {
public static void main(String[] args) {
// Create Student instances
Student student1 = new Student("Dinesh", 1, "Algorithms", 75);
Student student2 = new Student("Arnav", 2, "Automata", 55);
Student student3 = new Student("Anamika", 3, "Databases", 80);
Student student4 = new Student("Vishal", 4, "Networking", 40);

    // Create a list of students
    List<Student> studentList = Arrays.asList(student1, student2, student3, student4);

    // Partition students into those who got above 60% and those who didn't
    Map<Boolean, List<Student>> partitionedStudents = studentList.stream()
            .collect(Collectors.partitioningBy(student -> student.getPercentage() > 60));

    System.out.println(partitionedStudents);

    // Get the names of the top 3 performing students
    List<String> topPerformers = studentList.stream()
            .sorted(Comparator.comparingDouble(Student::getPercentage).reversed())
            .limit(3)
            .map(Student::toString)
            .collect(Collectors.toList());

    System.out.println(topPerformers);

    // Get the name and percentage of each student
    Map<String, Double> studentNamePercentageMap = studentList.stream()
            .collect(Collectors.toMap(Student::getName, Student::getPercentage));

    System.out.println(studentNamePercentageMap);

    // Get the set of subjects offered in the college
    Set<String> subjects = studentList.stream()
            .map(Student::getSubject)
            .collect(Collectors.toSet());

    System.out.println(subjects);

    // Get the highest, lowest, and average percentage of students
    double highestPercentage = studentList.stream()
            .mapToDouble(Student::getPercentage)
            .max()
            .orElse(0);

    double lowestPercentage = studentList.stream()
            .mapToDouble(Student::getPercentage)
            .min()
            .orElse(0);

    double averagePercentage = studentList.stream()
            .mapToDouble(Student::getPercentage)
            .average()
            .orElse(0);

    System.out.println("Highest Percentage: " + highestPercentage);
    System.out.println("Lowest Percentage: " + lowestPercentage);
    System.out.println("Average Percentage: " + averagePercentage);

    // Get the total number of students
    int totalStudents = studentList.size();
    System.out.println(totalStudents);

    // Get the students grouped by subject
    Map<String, List<Student>> studentsBySubject = studentList.stream()
            .collect(Collectors.groupingBy(Student::getSubject));

    System.out.println(studentsBySubject);
}

}

class Student {
private String name;
private int id;
private String subject;

double percentage;

public Student(String name, int id, String subject, double percentage) {
    this.name = name;
    this.id = id;
    this.subject = subject;
    this.percentage = percentage;
}

public String getName() {
    return name;
}

public int getId() {
    return id;
}

public String getSubject() {
    return subject;
}

public double getPercentage() {
    return percentage;
}

@Override
public String toString() {
    return name + "-" + id + "-" + subject + "-" + percentage;
}

}

0 replies

vysaga9 · 2023-09-27T18:22:52Z

vysaga9
Sep 27, 2023

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Set;
import java.util.stream.Collectors;

class Student {
private String name;
private int id;
private String subject;

double percentage;

public Student(String name, int id, String subject, double percentage) {
	this.name = name;
	this.id = id;
	this.subject = subject;
	this.percentage = percentage;
}

public String getName() {
	return name;
}

public int getId() {
	return id;
}

public String getSubject() {
	return subject;
}

public double getPercentage() {
	return percentage;
}

@Override
public String toString() {
	return name + "-" + id + "-" + subject + "-" + percentage;
}

}

public class StudentsDetails {

public static void main(String args[]) {

	Student student1 = new Student("Dinesh", 1, "Algorithms", 75);
	Student student2 = new Student("Arnav", 2, "Automata", 55);
	Student student3 = new Student("Anamika", 3, "Databases", 80);
	Student student4 = new Student("Vishal", 4, "Networking", 40);

	List<Student> stdList = new ArrayList<>();
	stdList.add(student1);
	stdList.add(student2);
	stdList.add(student3);
	stdList.add(student4);

	// 1
	List<Student> above = new ArrayList<>();
	List<Student> below = new ArrayList<>();
	stdList.forEach(s -> {
		if (s.percentage >= 60) {
			above.add(s);
		} else {
			below.add(s);
		}
	});
	System.out.println("{false=" + below + ",true=" + above);

	// 2
	List<Student> top3 = stdList.stream()
			.sorted(Comparator.comparing(Student::getPercentage, Comparator.reverseOrder())).limit(3)
			.collect(Collectors.toList());
	System.out.println(top3);

	// 3
	Map<String, Double> map2 = stdList.stream().collect(Collectors.toMap(Student::getName, Student::getPercentage));
	System.out.println(map2);

	// 4
	Set<String> subjectSet = stdList.stream().map(Student::getSubject).collect(Collectors.toSet());
	System.out.println(subjectSet);

	// 5
	Double highest = stdList.stream().mapToDouble(Student::getPercentage).max()
			.orElseThrow(NoSuchElementException::new);

	Double lowest = stdList.stream().mapToDouble(Student::getPercentage).min()
			.orElseThrow(NoSuchElementException::new);

	Double average = stdList.stream().mapToDouble(Student::getPercentage).average()
			.orElseThrow(NoSuchElementException::new);

	System.out.println("Highest Marks: " + highest);
	System.out.println("Lowest Marks: " + lowest);
	System.out.println("Average: " + average);

	// 6
	System.out.println(stdList.size());

	// 7
	Map<String, List<Student>> subjectGroup = stdList.stream().collect(Collectors.groupingBy(Student::getSubject));
	System.out.println(subjectGroup);

}

}

0 replies

nmokariya25 · 2023-09-28T18:40:53Z

nmokariya25
Sep 28, 2023

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Optional;
import java.util.OptionalDouble;
import java.util.Set;
import java.util.stream.Collectors;

class Student {
private String name;
private int id;
private String subject;

double percentage;

public Student(String name, int id, String subject, double percentage) {
    this.name = name;
    this.id = id;
    this.subject = subject;
    this.percentage = percentage;
}

public String getName() {
    return name;
}

public int getId() {
    return id;
}

public String getSubject() {
    return subject;
}

public double getPercentage() {
    return percentage;
}

@Override
public String toString() {
    return name + "-" + id + "-" + subject + "-" + percentage;
}

}

public class Studentstats {
public static void main(String[] args) {
Student student1 = new Student("Dinesh", 1, "Algorithms", 75);
Student student2 = new Student("Arnav", 2, "Automata", 55);
Student student3 = new Student("Anamika", 3, "Databases", 80);
Student student4 = new Student("Vishal", 4, "Networking", 40);
List studentList = Arrays.asList(student1, student2, student3, student4);

    Map<Boolean, List<Student>> map = studentList.stream()
            .collect(Collectors.partitioningBy(stu -> stu.getPercentage() > 60));
    System.out.println(map);

    List<Student> topPerformer = studentList.stream()
            .sorted(Comparator.comparing(Student::getPercentage, Comparator.reverseOrder())).limit(3)
            .collect(Collectors.toList());

    System.out.println(topPerformer);

    Map<String, Double> map2 = studentList.stream()
            .collect(Collectors.toMap(Student::getName, Student::getPercentage));
    System.out.println(map2);

    Set<String> subjectSet = studentList.stream().map(Student::getSubject).collect(Collectors.toSet());
    System.out.println(subjectSet);

    OptionalDouble highest = studentList.stream().mapToDouble(Student::getPercentage).max();
    System.out.println("Highest Percentage :" + highest.getAsDouble());

    OptionalDouble lowest = studentList.stream().mapToDouble(Student::getPercentage).min();
    System.out.println("Lowest Percentage :" + lowest.getAsDouble());

    OptionalDouble average = studentList.stream().mapToDouble(Student::getPercentage).average();

    System.out.println("Average Percentage :" + average.getAsDouble());
    System.out.println("Total students: " + studentList.size());

    Map<String, List<Student>> groupBySubject = studentList.stream()
            .collect(Collectors.groupingBy(Student::getSubject));
    System.out.println(groupBySubject);
}

}

0 replies

prasetha21-max · 2025-06-02T04:53:37Z

prasetha21-max
Jun 2, 2025

import java.util.*;

class Student {
    private String name;
    private int id;
    private String subject;
    double percentage;

    public Student(String name, int id, String subject, double percentage) {
        this.name = name;
        this.id = id;
        this.subject = subject;
        this.percentage = percentage;
    }

    public String getName() {
        return name;
    }

    public int getId() {
        return id;
    }

    public String getSubject() {
        return subject;
    }

    public double getPercentage() {
        return percentage;
    }

    @Override
    public String toString() {
        return name + "-" + id + "-" + subject + "-" + percentage;
    }
}

public class StudentAnalyticsNoStream {
    public static void main(String[] args) {
        Student student1 = new Student("Dinesh", 1, "Algorithms", 75);
        Student student2 = new Student("Arnav", 2, "Automata", 55);
        Student student3 = new Student("Anamika", 3, "Databases", 80);
        Student student4 = new Student("Vishal", 4, "Networking", 40);

        List<Student> studentList = new ArrayList<>();
        studentList.add(student1);
        studentList.add(student2);
        studentList.add(student3);
        studentList.add(student4);

        Map<Boolean, List<Student>> partitioned = new HashMap<>();
        partitioned.put(true, new ArrayList<>());
        partitioned.put(false, new ArrayList<>());
        for (Student student : studentList) {
            if (student.getPercentage() > 60) {
                partitioned.get(true).add(student);
            } else {
                partitioned.get(false).add(student);
            }
        }
        System.out.println("Partitioned Students (Above 60% vs 60% or Below):");
        System.out.println(partitioned);
        System.out.println();

        List<Student> sortedByPerformance = new ArrayList<>(studentList);
        sortedByPerformance.sort((s1, s2) -> Double.compare(s2.getPercentage(), s1.getPercentage()));
        System.out.println("Top 3 Performing Students:");
        for (int i = 0; i < Math.min(3, sortedByPerformance.size()); i++) {
            System.out.println(sortedByPerformance.get(i));
        }
        System.out.println();

        System.out.println("Name and Percentage of Each Student:");
        Map<String, Double> nameToPercentage = new LinkedHashMap<>();
        for (Student s : studentList) {
            nameToPercentage.put(s.getName(), s.getPercentage());
        }
        for (String name : nameToPercentage.keySet()) {
            System.out.println(name + ": " + nameToPercentage.get(name) + "%");
        }
        System.out.println();

        Set<String> subjects = new LinkedHashSet<>();
        for (Student s : studentList) {
            subjects.add(s.getSubject());
        }
        System.out.println("Subjects Offered in the College:");
        for (String subject : subjects) {
            System.out.println(subject);
        }
        System.out.println();

        double highest = Double.MIN_VALUE;
        double lowest = Double.MAX_VALUE;
        double total = 0;
        for (Student s : studentList) {
            double perc = s.getPercentage();
            if (perc > highest) highest = perc;
            if (perc < lowest) lowest = perc;
            total += perc;
        }
        double average = total / studentList.size();
        System.out.println("Performance Statistics:");
        System.out.println("Highest Percentage: " + highest + "%");
        System.out.println("Lowest Percentage: " + lowest + "%");
        System.out.println("Average Percentage: " + average + "%");
        System.out.println();

        System.out.println("Total Number of Students: " + studentList.size());
        System.out.println();

        Map<String, List<Student>> subjectMap = new LinkedHashMap<>();
        for (Student s : studentList) {
            String subject = s.getSubject();
            subjectMap.putIfAbsent(subject, new ArrayList<>());
            subjectMap.get(subject).add(s);
        }
        System.out.println("Students Grouped by Subject:");
        for (String subject : subjectMap.keySet()) {
            System.out.println(subject + ": " + subjectMap.get(subject));
        }
    }
}

0 replies

Sdey0907 · 2025-06-02T12:06:08Z

Sdey0907
Jun 2, 2025

**

Task - Collections _Sayan Dey_Completed
**

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

class Student {
private String name;
private int id;
private String subject;
double percentage;

public Student(String name, int id, String subject, double percentage) {
    this.name = name;
    this.id = id;
    this.subject = subject;
    this.percentage = percentage;
}

public String getName() {
    return name;
}

public int getId() {
    return id;
}

public String getSubject() {
    return subject;
}

public double getPercentage() {
    return percentage;
}

@Override
public String toString() {
    return name + "-" + id + "-" + subject + "-" + percentage;
}

}

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

    // Create student list
    List<Student> studentList = Arrays.asList(
        new Student("Dinesh", 1, "Algorithms", 75),
        new Student("Arnav", 2, "Automata", 55),
        new Student("Anamika", 3, "Databases", 80),
        new Student("Vishal", 4, "Networking", 40)
    );

    // 1. Partition students by percentage > 60
    Map<Boolean, List<Student>> partitioned = studentList.stream()
        .collect(Collectors.partitioningBy(s -> s.getPercentage() > 60));
    System.out.println("1. Partitioned Students (Above 60% vs 60% or Below):");
    System.out.println(partitioned);
    System.out.println();

    // 2. Top 3 performing students
    List<Student> top3 = studentList.stream()
        .sorted(Comparator.comparingDouble(Student::getPercentage).reversed())
        .limit(3)
        .collect(Collectors.toList());
    System.out.println("2. Top 3 Students:");
    System.out.println(top3);
    System.out.println();

    // 3. Name and percentage of each student
    Map<String, Double> namePercentageMap = studentList.stream()
        .collect(Collectors.toMap(Student::getName, Student::getPercentage));
    System.out.println("3. Name and Percentage of Each Student:");
    System.out.println(namePercentageMap);
    System.out.println();

    // 4. Set of subjects offered in the college
    Set<String> subjects = studentList.stream()
        .map(Student::getSubject)
        .collect(Collectors.toSet());
    System.out.println("4. Subjects Offered in the College:");
    System.out.println(subjects);
    System.out.println();

    // 5. Highest, lowest, and average percentage
    DoubleSummaryStatistics stats = studentList.stream()
        .mapToDouble(Student::getPercentage)
        .summaryStatistics();
    System.out.println("5. Statistics:");
    System.out.println("Highest Percentage: " + stats.getMax());
    System.out.println("Lowest Percentage: " + stats.getMin());
    System.out.println("Average Percentage: " + stats.getAverage());
    System.out.println();

    // 6. Total number of students
    System.out.println("6. Total Number of Students:");
    System.out.println(studentList.size());
    System.out.println();

    // 7. Group students by subject
    Map<String, List<Student>> groupedBySubject = studentList.stream()
        .collect(Collectors.groupingBy(Student::getSubject));
    System.out.println("7. Students Grouped By Subject:");
    System.out.println(groupedBySubject);
}

}

0 replies

vbhavana1 · 2025-06-02T14:56:03Z

vbhavana1
Jun 2, 2025

Bhavana
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Optional;
import java.util.OptionalDouble;
import java.util.Set;
import java.util.stream.Collectors;

class Student {
private String name;
private int id;
private String subject;

double percentage;

public Student(String name, int id, String subject, double percentage) {
    this.name = name;
    this.id = id;
    this.subject = subject;
    this.percentage = percentage;
}

public String getName() {
    return name;
}

public int getId() {
    return id;
}

public String getSubject() {
    return subject;
}

public double getPercentage() {
    return percentage;
}

@Override
public String toString() {
    return name + "-" + id + "-" + subject + "-" + percentage;
}

}

public class StudentDriver {
public static void main(String[] args) {
Student student1 = new Student("Dinesh", 1, "Algorithms", 75);
Student student2 = new Student("Arnav", 2, "Automata", 55);
Student student3 = new Student("Anamika", 3, "Databases", 80);
Student student4 = new Student("Vishal", 4, "Networking", 40);
List studentList = Arrays.asList(student1, student2, student3, student4);

    Map<Boolean, List<Student>> map = studentList.stream()
            .collect(Collectors.partitioningBy(stu -> stu.getPercentage() > 60));
    System.out.println(map);

    List<Student> topPerformer = studentList.stream()
            .sorted(Comparator.comparing(Student::getPercentage, Comparator.reverseOrder())).limit(3)
            .collect(Collectors.toList());

    System.out.println(topPerformer);

    Map<String, Double> map2 = studentList.stream()
            .collect(Collectors.toMap(Student::getName, Student::getPercentage));
    System.out.println(map2);

    Set<String> subjectSet = studentList.stream().map(Student::getSubject).collect(Collectors.toSet());
    System.out.println(subjectSet);

    OptionalDouble highest = studentList.stream().mapToDouble(Student::getPercentage).max();
    System.out.println("Highest Percentage :" + highest.getAsDouble());

    OptionalDouble lowest = studentList.stream().mapToDouble(Student::getPercentage).min();
    System.out.println("Lowest Percentage :" + lowest.getAsDouble());

    OptionalDouble average = studentList.stream().mapToDouble(Student::getPercentage).average();

    System.out.println("Average Percentage :" + average.getAsDouble());
    System.out.println("Total students: " + studentList.size());

    Map<String, List<Student>> groupBySubject = studentList.stream()
            .collect(Collectors.groupingBy(Student::getSubject));
    System.out.println(groupBySubject);
}

}

0 replies

Task - Collections - Student Statistics #56

Uh oh!

Uh oh!

akash-coded Mar 10, 2022 Maintainer

Replies: 53 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!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

**

Uh oh!

akash-coded
Mar 10, 2022
Maintainer