0% found this document useful (0 votes)
13 views

Java ASSIGNMENT

Java ASSIGNMENT

Uploaded by

manoj
Copyright
© © All Rights Reserved
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
13 views

Java ASSIGNMENT

Java ASSIGNMENT

Uploaded by

manoj
Copyright
© © All Rights Reserved
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 17

WEEK 9 ASSIGNMENT:

Q1.
import javax.swing.*;

import javax.swing.table.DefaultTableModel;

import java.awt.*;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.util.ArrayList;

public class SimpleLibrarySystem extends JFrame {

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

private DefaultTableModel tableModel;

public SimpleLibrarySystem() {

setTitle("Simple Library System");

setSize(400, 300);

setDefaultCloseOperation(EXIT_ON_CLOSE);

setLayout(new BorderLayout());

// Table for displaying books

tableModel = new DefaultTableModel(new String[]{"Title", "Author"}, 0);

JTable bookTable = new JTable(tableModel);

add(new JScrollPane(bookTable), BorderLayout.CENTER);

// Panel for adding books

JPanel panel = new JPanel();

JTextField titleField = new JTextField(10);

JTextField authorField = new JTextField(10);


JButton addButton = new JButton("Add Book");

panel.add(new JLabel("Title:"));

panel.add(titleField);

panel.add(new JLabel("Author:"));

panel.add(authorField);

panel.add(addButton);

add(panel, BorderLayout.SOUTH);

// Action listener for adding books

addButton.addActionListener(e -> {

String title = titleField.getText();

String author = authorField.getText();

if (!title.isEmpty() && !author.isEmpty()) {

books.add(new Book(title, author));

tableModel.addRow(new Object[]{title, author});

titleField.setText("");

authorField.setText("");

} else {

JOptionPane.showMessageDialog(this, "Please enter both title and author.", "Error",


JOptionPane.ERROR_MESSAGE);

});

setVisible(true);

public static void main(String[] args) {


SwingUtilities.invokeLater(SimpleLibrarySystem::new);

class Book {

private String title;

private String author;

public Book(String title, String author) {

this.title = title;

this.author = author;

public String getTitle() { return title; }

public String getAuthor() { return author; }

Q2:
import java.util.Scanner;

public class CircleArea {

// Pure function to calculate the area of a circle

public static double calculateArea(double radius) {

return Math.PI * radius * radius;

}
// Impure function to prompt user for radius and print the area

public static void promptUserAndPrintArea() {

Scanner scanner = new Scanner(System.in);

System.out.print("Enter the radius of the circle: ");

double radius = scanner.nextDouble(); // User input

double area = calculateArea(radius); // Calling the pure function

System.out.printf("The area of the circle with radius %.2f is: %.2f%n", radius, area);

public static void main(String[] args) {

// Call the impure function to execute the program

promptUserAndPrintArea();

OUTPUT:

Q3.
import java.util.Arrays;

public class NumberList {

// Pure function to find the maximum value in a list of numbers

public static int findMax(int[] numbers) {

int max = numbers[0];

for (int num : numbers) {


if (num > max) {

max = num;

return max;

// Impure function to sort a list of numbers in ascending order

public static void sortNumbers(int[] numbers) {

Arrays.sort(numbers); // This modifies the original array

public static void main(String[] args) {

int[] numbers = {34, 12, 5, 67, 23};

// Using the pure function

int max = findMax(numbers);

System.out.println("Maximum value: " + max);

// Using the impure function

sortNumbers(numbers);

System.out.println("Sorted numbers: " + Arrays.toString(numbers));

OUTPUT:
Q4.
import java.util.ArrayList;

import java.util.List;

class Student {

private String name;

private int age;

private double grade;

public Student(String name, int age, double grade) {

this.name = name;

this.age = age;

this.grade = grade;

public int getAge() {

return age;

// Additional getters can be added if needed

public class StudentRecords {

private List<Student> students;

public StudentRecords() {

students = new ArrayList<>();


}

// Mutable function to add a new student to the list

public void addStudent(String name, int age, double grade) {

Student newStudent = new Student(name, age, grade);

students.add(newStudent);

// Immutable function to calculate the average age of students

public double calculateAverageAge() {

if (students.isEmpty()) {

return 0; // Avoid division by zero

int totalAge = 0;

for (Student student : students) {

totalAge += student.getAge();

return (double) totalAge / students.size();

public static void main(String[] args) {

StudentRecords records = new StudentRecords();

// Adding students

records.addStudent("Alice", 20, 85.5);

records.addStudent("Bob", 22, 90.0);

records.addStudent("Charlie", 19, 78.5);

// Calculating average age


double averageAge = records.calculateAverageAge();

System.out.printf("Average age of students: %.2f%n", averageAge);

OUTPUT:

Q5.
class BankAccount {

private String accountHolder;

private double balance;

private double interestRate; // Annual interest rate as a percentage

public BankAccount(String accountHolder, double balance, double interestRate) {

this.accountHolder = accountHolder;

this.balance = balance;

this.interestRate = interestRate;

// Mutable function to update the balance of the bank account

public void updateBalance(double amount) {

this.balance += amount; // Add or subtract amount to the balance

// Immutable function to calculate the interest earned on the account

public double calculateInterest(int years) {

return (this.balance * this.interestRate / 100) * years; // Simple interest calculation


}

// Getter for balance

public double getBalance() {

return balance;

public static void main(String[] args) {

// Create a new bank account

BankAccount account = new BankAccount("John Doe", 1000.0, 5.0);

// Display initial balance

System.out.printf("Initial balance: $%.2f%n", account.getBalance());

// Update balance by depositing $500

account.updateBalance(500);

System.out.printf("Balance after deposit: $%.2f%n", account.getBalance());

// Update balance by withdrawing $200

account.updateBalance(-200);

System.out.printf("Balance after withdrawal: $%.2f%n", account.getBalance());

// Calculate interest earned over 3 years

double interestEarned = account.calculateInterest(3);

System.out.printf("Interest earned over 3 years: $%.2f%n", interestEarned);

OUTPUT:
Q6.
import java.util.function.BiFunction;

public class AnonymousFunctionExample {

public static void main(String[] args) {

// Anonymous function to add two numbers and immediately call it

int sum = ((a, b) -> a + b).apply(5, 3);

System.out.println("Sum of 5 and 3: " + sum);

// Anonymous function to multiply two numbers and assign it to a variable

BiFunction<Integer, Integer, Integer> multiply = (a, b) -> a * b;

int product = multiply.apply(4, 6);

System.out.println("Product of 4 and 6: " + product);

OUTPUT:

Q7.
import java.util.Arrays;
import java.util.List;

import java.util.stream.Collectors;

public class AnonymousFunctionExample {

public static void main(String[] args) {

// List of numbers

List<Integer> numbersToSquare = Arrays.asList(1, 2, 3, 4);

// Anonymous function to square each element in the list

List<Integer> squaredNumbers = numbersToSquare.stream()

.map(num -> num * num) // Squaring each number

.collect(Collectors.toList());

System.out.println("Squared Numbers: " + squaredNumbers);

// List of numbers to filter

List<Integer> numbersToFilter = Arrays.asList(1, 2, 3, 4, 5, 6);

// Anonymous function to filter even numbers from the list

List<Integer> evenNumbers = numbersToFilter.stream()

.filter(num -> num % 2 == 0) // Filtering even numbers

.collect(Collectors.toList());

System.out.println("Even Numbers: " + evenNumbers);

OUTPUT:
Q8.
import java.util.Arrays;

import java.util.List;

import java.util.Map;

import java.util.stream.Collectors;

class Employee {

private String name;

private double salary;

private String department;

public Employee(String name, double salary, String department) {

this.name = name;

this.salary = salary;

this.department = department;

public String getName() {

return name;

public double getSalary() {

return salary;

}
public String getDepartment() {

return department;

public class EmployeeExample {

public static void main(String[] args) {

// Sample list of employees

List<Employee> employees = Arrays.asList(

new Employee("Alice", 70000, "Engineering"),

new Employee("Bob", 60000, "Engineering"),

new Employee("Charlie", 80000, "Marketing"),

new Employee("David", 50000, "Marketing"),

new Employee("Eve", 90000, "HR")

);

// Map: Create a new list containing the employee names and their corresponding salaries

List<String> employeeNamesWithSalaries = employees.stream()

.map(e -> e.getName() + " - $" + e.getSalary())

.collect(Collectors.toList());

System.out.println("Employee Names and Salaries:");

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

// Filter: Filter employees who belong to a specific department

String targetDepartment = "Engineering";

List<Employee> filteredEmployees = employees.stream()

.filter(e -> e.getDepartment().equals(targetDepartment))

.collect(Collectors.toList());
System.out.println("\nEmployees in " + targetDepartment + " Department:");

filteredEmployees.forEach(e -> System.out.println(e.getName()));

// Reduce: Calculate the average salary for employees in each department

Map<String, Double> averageSalaryByDepartment = employees.stream()

.collect(Collectors.groupingBy(

Employee::getDepartment,

Collectors.averagingDouble(Employee::getSalary)

));

System.out.println("\nAverage Salary by Department:");

averageSalaryByDepartment.forEach((department, avgSalary) ->

System.out.println(department + ": $" + avgSalary));

OUTPUT:
Q9.
import java.util.Arrays;

import java.util.List;

import java.util.Map;

import java.util.stream.Collectors;

class Student {

private String name;

private int age;

private double grade;

public Student(String name, int age, double grade) {

this.name = name;

this.age = age;

this.grade = grade;

public String getName() {

return name;

public int getAge() {

return age;

public double getGrade() {

return grade;

}
}

public class StudentExample {

public static void main(String[] args) {

// Sample list of students

List<Student> students = Arrays.asList(

new Student("Alice", 20, 85.5),

new Student("Bob", 22, 90.0),

new Student("Charlie", 19, 78.0),

new Student("David", 21, 88.5),

new Student("Eve", 23, 92.0)

);

// Map: Create a new list containing only the names of the students

List<String> studentNames = students.stream()

.map(Student::getName)

.collect(Collectors.toList());

System.out.println("Student Names:");

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

// Filter: Filter the students who are above a certain age threshold

int ageThreshold = 21;

List<Student> filteredStudents = students.stream()

.filter(s -> s.getAge() > ageThreshold)

.collect(Collectors.toList());

System.out.println("\nStudents above age " + ageThreshold + ":");

filteredStudents.forEach(s -> System.out.println(s.getName()));


// Reduce: Calculate the average grade of all students

double averageGrade = students.stream()

.collect(Collectors.averagingDouble(Student::getGrade));

System.out.printf("\nAverage Grade of all students: %.2f%n", averageGrade);

OUTPUT:

You might also like