Bangladesh University of Business and Technology
Assisgement
Course Code:CSE 332
Course Title: Advanced Programming
Submitted By: Submitted To:
Name: Foysal Ahmad Name:Md.Mahbubur Rahman
ID: 21225103124 Assistant Professor,CSE.
Section: 03 Bangladesh University of
Intake: 49 Business and Technology
Date of Submission: 19-05-2024
1.
Code:
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
public class FileDataReader {
public static void main(String[] args)
{ try {
File file = new File("data.txt");
Scanner scanner = new Scanner(file);
while (scanner.hasNextLine()) {
String data = scanner.nextLine();
System.out.println(data);
scanner.close();
} catch (FileNotFoundException e) {
System.err.println("Error: File not found. Please make sure the file exists and is
accessible.");
e.printStackTrace();
Output:
2.
Code:
public class ArrayAccessExample {
public static void main(String[] args)
int[] array = {10, 20, 30, 40, 50};
int indexToAccess =
5; try {
int element = array[indexToAccess];
System.out.println("Element at index " + indexToAccess + ": " + element);
} catch (ArrayIndexOutOfBoundsException e) {
System.err.println("Error: Invalid index. Index " + indexToAccess + " is out of bounds.");
e.printStackTrace();
Output:
3
Code:
class InsufficientFundsException extends Exception {
public InsufficientFundsException(String message) {
super(message);
}
}
class NegativeAmountException extends Exception {
public NegativeAmountException(String message) {
super(message);
}
}
class BankAccount {
private double balance;
public BankAccount(double initialBalance) {
if (initialBalance < 0) {
throw new IllegalArgumentException("Initial balance cannot be negative");
}
this.balance = initialBalance;
}
public double getBalance() {
return balance;
}
public void deposit(double amount) throws NegativeAmountException {
if (amount < 0) {
throw new NegativeAmountException("Cannot deposit a negative amount");
}
balance += amount;
}
public void withdraw(double amount) throws InsufficientFundsException, NegativeAmountException {
if (amount < 0) {
throw new NegativeAmountException("Cannot withdraw a negative amount");
}
if (amount > balance) {
throw new InsufficientFundsException("Insufficient funds for withdrawal");
}
balance -= amount;
}
}
public class BankTransaction{
public static void main(String[] args) {
BankAccount account = new BankAccount(1000);
System.out.println("Initial Balance: " + account.getBalance());
try {
account.deposit(500);
System.out.println("Deposited 500. Current Balance: " + account.getBalance());
} catch (NegativeAmountException e) {
System.out.println("Deposit failed: " + e.getMessage());
}
finally {
System.out.println("Deposit operation completed.");
}
try {
account.withdraw(2000);
System.out.println("Withdrew 2000. Current Balance: " + account.getBalance());
} catch (InsufficientFundsException | NegativeAmountException e) {
System.out.println("Withdrawal failed: " + e.getMessage());
}
finally {
System.out.println("Withdrawal operation completed.");
}
try {
account.deposit(-100);
System.out.println("Deposited -100. Current Balance: " + account.getBalance());
}
catch (NegativeAmountException e)
{
System.out.println("Deposit failed: " + e.getMessage());
}
finally {
System.out.println("Deposit operation completed.");
}
try {
account.withdraw(300);
System.out.println("Withdrew 300. Current Balance: " + account.getBalance());
} catch (InsufficientFundsException | NegativeAmountException e)
{
System.out.println("Withdrawal failed: " + e.getMessage());
}
finally {
System.out.println("Withdrawal operation completed.");
}
}
}
Output:
4.
Code:
class InsufficientBalanceException extends Exception {
public InsufficientBalanceException(String message)
super(message);
class BankAccount {
private double balance;
public BankAccount(double initialBalance)
{if (initialBalance < 0) {
throw new IllegalArgumentException("Initial balance cannot be negative");
this.balance = initialBalance;
public void deposit(double amount) {
if (amount <= 0) {
throw new IllegalArgumentException("Deposit amount must be positive");
}
balance += amount;
System.out.println("Deposited: " + amount + ", New Balance: " + balance);
public void withdraw(double amount) throws InsufficientBalanceException
{if (amount <= 0) {
throw new IllegalArgumentException("Withdrawal amount must be positive");
if (amount > balance) {
throw new InsufficientBalanceException("Insufficient balance. Current balance: " +
balance);
balance -= amount;
System.out.println("Withdrew: " + amount + ", New Balance: " + balance);
public double getBalance()
{ return balance;
public static void main(String[] args)
{try {
BankAccount account = new
BankAccount(1000); account.deposit(500);
account.withdraw(300);
account.withdraw(1500); // This will throw an exception
} catch (InsufficientBalanceException e)
{ System.err.println(e.getMessage());
} catch (IllegalArgumentException e) {
System.err.println(e.getMessage());
Output:
5.
Code:
import java.util.Scanner;
import java.util.regex.Pattern;
import java.util.regex.Matcher;
class InvalidEmailFormatException extends IllegalArgumentException {
public InvalidEmailFormatException(String message) {
super(message);
}
}
public class EmailValidator{
private static final String EMAIL_REGEX = "^[A-Za-z0-9+_.-]+@(.+)$";
private static final Pattern EMAIL_PATTERN = Pattern.compile(EMAIL_REGEX);
public static void validateEmail(String email) throws InvalidEmailFormatException,
NullPointerException {
if (email == null) {
throw new NullPointerException("Email address cannot be null");
}
Matcher matcher = EMAIL_PATTERN.matcher(email
);
if (!matcher.matches()) {
throw new InvalidEmailFormatException("Invalid email format: " + email);
}
}
public static void main(String[] args) {
Scanner scanner = null;
try {
scanner = new Scanner(System.in);
System.out.print("Enter your email address: ");
String email = scanner.nextLine();
validateEmail(email);
System.out.println("Email address is valid.");
} catch (InvalidEmailFormatException e) {
System.out.println("Validation failed: " + e.getMessage());
} catch (NullPointerException e) {
System.out.println("Validation failed: " + e.getMessage());
}
}
}
Output:
6.
Code:
public class ThreadExample {
public static void main(String[] args) {
Thread deptThread = new Thread(new DeptThread());
Thread nameThread = new Thread(new NameThread());
Thread idThread = new Thread(new IDThread());
deptThread.start();
nameThread.start();
try {
nameThread.join();
} catch (InterruptedException e) {
idThread.start();
for (int i = 0; i < 10; i++) {
System.out.println("Main thread executing");
try {
Thread.sleep(1000); // Sleep for 1 second
} catch (InterruptedException e) {
class DeptThread implements Runnable {
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("Dept");
try {
Thread.sleep(2000); // Sleep for 2 seconds
} catch (InterruptedException e) {
class NameThread implements Runnable {
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println("Name");
class IDThread implements Runnable
{@Override
public void run() {
for (int i = 0; i < 30; i++) {
System.out.println("ID");
Output:
7
Code:
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class MatrixMultiplier {
public static int[][] multiplyMatrices(int[][] matrix1, int[][] matrix2) {
int row1 = matrix1.length;
int col1 = matrix1[0].length;
int col2 =
matrix2[0].length;
int[][] result = new int[row1][col2];
ExecutorService executor =
Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
for (int i = 0; i < row1; i++)
{final int row = i;
executor.submit(() -> {
for (int j = 0; j < col2;
j++) {int sum = 0;
for (int k = 0; k < col1; k++) {
sum += matrix1[row][k] * matrix2[k][j];
result[row][j] = sum;
});
executor.shutdown();
while (!executor.isTerminated())
{} return result;
public static void main(String[] args) {
int[][] matrix1 = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
int[][] matrix2 = {{9, 8, 7}, {6, 5, 4}, {3, 2, 1}};
int[][] result = multiplyMatrices(matrix1,
matrix2); for (int[] row : result) {
for (int num : row) {
System.out.print(num + " ");
System.out.println();
Output:
8.
Code:
public class FactorialCalculator {
static class FactorialThread extends Thread {
private int number;
private long factorial;
public FactorialThread(int number)
{this.number = number;
this.factorial = 1;
}public void run() {
factorial = calculateFactorial(number);
public long getFactorial()
{return factorial;
} private long calculateFactorial(int n)
{ long result = 1;
for (int i = 2; i <= n;
i++) {result *= i;
} return result;
} public static void main(String[] args)
{ int n = 6;
FactorialThread evenThread = new FactorialThread(n % 2 == 0 ? n : n - 1);
FactorialThread oddThread = new FactorialThread(n % 2 == 0 ? n - 1 :
n);evenThread.start();
oddThread.start();
try {
evenThread.join();
oddThread.join();
} catch (InterruptedException e)
{ e.printStackTrace();
} long factorial = evenThread.getFactorial() * oddThread.getFactorial();
System.out.println("Factorial of " + n + " is: " + factorial);
Output:
9.
Code:
public class LetterPrinter {
static class UppercaseThread extends Thread {
@Override
public void run() {
for (char c = 'A'; c <= 'Z'; c++) {
System.out.print(c + " ");
try {
Thread.sleep(100); // Sleep to allow lowercase thread to execute
} catch (InterruptedException e) {
static class LowercaseThread extends Thread {
@Override
public void run() {
for (char c = 'a'; c <= 'z'; c++) {
System.out.print(c + " ");
try {
Thread.sleep(100); // Sleep to allow uppercase thread to execute
} catch (InterruptedException e) {
}
} public static void main(String[] args) {
Thread uppercaseThread = new UppercaseThread();
Thread lowercaseThread = new LowercaseThread();
uppercaseThread.start();
lowercaseThread.start();
try {
uppercaseThread.join();
lowercaseThread.join();
} catch (InterruptedException e) {
Output:
10.
Code:
public class SumCalculator {
static class SumThread extends Thread {
private final int start;
private final int end;
private long sum;
public SumThread(int start, int end) {
this.start = start;
this.end = end;
this.sum = 0;
} @Override
public void run()
for (int i = start; i <= end; i++)
{sum += i;
} public long getSum()
{ return sum;
}public static void main(String[] args)
{final int N = 100;
final int numThreads = 5;
SumThread[] threads = new SumThread[numThreads];
int segmentSize = N / numThreads;
int start = 1;
int end = segmentSize;
for (int i = 0; i < numThreads; i++)
{if (i == numThreads - 1) {
end = N; // Last segment
threads[i] = new SumThread(start, end);
start = end + 1;
end += segmentSize;
for (SumThread thread : threads) {
thread.start();
for (SumThread thread : threads) {
try {
thread.join();
} catch (InterruptedException e) {
long totalSum = 0;
for (SumThread thread : threads) {
totalSum += thread.getSum();
} System.out.println("Sum of numbers from 1 to 100: " + totalSum);
}
}
Output:
11.
Code:
import java.util.*;
public class WordCounter {
public static void main(String[] args) {
String paragraph = "Write a program that takes a paragraph of text as input and counts the
occurrences of each word. Additionally, identify the five most common words and display them along
with their frequencies.";
String[] words = paragraph.replaceAll("[^a-zA-Z ]",
"").toLowerCase().split("\\s+"); Map<String, Integer> wordCounts = new
HashMap<>();
for (String word : words) {
wordCounts.put(word, wordCounts.getOrDefault(word, 0) + 1);
List<Map.Entry<String, Integer>> sortedWordCounts = new
ArrayList<>(wordCounts.entrySet());
sortedWordCounts.sort((a, b) -> b.getValue().compareTo(a.getValue()));
System.out.println("Word Counts:");
for (Map.Entry<String, Integer> entry : sortedWordCounts) {
System.out.println(entry.getKey() + ": " + entry.getValue());
System.out.println("\nTop 5 Most Common Words:"); int
count = 0;
for (Map.Entry<String, Integer> entry : sortedWordCounts)
{if (count >= 5) {
break;
System.out.println(entry.getKey() + ": " + entry.getValue());
count++;
Output:
12.
Code:
import java.util.Scanner;
public class SubStringChecker
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Enter a sentence: ");
String sentence = scanner.nextLine().toLowerCase();
System.out.print("Enter a word to check: ");
String word = scanner.nextLine().toLowerCase();
boolean isSubstringPresent = sentence.contains(word);
if (isSubstringPresent) {
System.out.println("The word \"" + word + "\" is present as a substring in the
sentence.");
} else {
System.out.println("The word \"" + word + "\" is not present as a substring in the
sentence.");
} scanner.close();
output:
13.
Code:
import java.util.Scanner;
public class CapitalizeWords
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Enter a sentence: ");
String sentence = scanner.nextLine();
String[] words = sentence.split("\\s+");
StringBuilder capitalizedSentence = new
StringBuilder(); for (String word : words) {
if (!word.isEmpty()) {
String capitalizedWord = word.substring(0, 1).toUpperCase() + word.substring(1);
capitalizedSentence.append(capitalizedWord).append(" ");
String result = capitalizedSentence.toString().trim
System.out.println("Original sentence: " + sentence);System.out.println("Capitalized sentence: " + result);
scanner.close();
Output:
14.
Code:
public class ReverseWords {
public static String reverseSentence(String sentence) {
String[] words = sentence.split("\\s+");
StringBuilder reversedSentence = new StringBuilder();
for (int i = words.length - 1; i >= 0; i--) {
reversedSentence.append(words[i]); if
(i > 0) {
reversedSentence.append(" ");
return reversedSentence.toString();
public static void main(String[] args)
{ String sentence = "Hello
world";
String reversedSentence = reverseSentence(sentence);
System.out.println("Original sentence: " + sentence);
System.out.println("Reversed sentence: " + reversedSentence);
}
Output:
15.
Code:
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
public class CharacterCounter {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Enter a string: ");
String input = scanner.nextLine();
Map<Character, Integer> charCountMap = new HashMap<>();
char[] chars = input.toCharArray();
for (char c : chars) {
if (charCountMap.containsKey(c)) {
charCountMap.put(c, charCountMap.get(c) + 1);
}
else {
charCountMap.put(c, 1);
}
}
System.out.println("Character counts:");
for (Map.Entry<Character, Integer> entry : charCountMap.entrySet()) {
System.out.println(entry.getKey() + ": " + entry.getValue());
}
scanner.close();
}
}
Output:
16.
Code:
import java.util.Scanner;
public class FullNameConcatenator {
public static void main(String[] args)
Scanner scanner = new Scanner(System.in);
System.out.print("Enter your first name: ");
String firstName = scanner.nextLine();
System.out.print("Enter your last name: ");
String lastName = scanner.nextLine();
String fullName = firstName + " " + lastName;
System.out.println("Your full name is: " + fullName);
scanner.close();
}
Output:
17.
Code:
public class StringManipulation {
public static void main(String[] args)
String A = "The early bird catches the
worm"; String B = "Patience is a virtue";
String wordFromA = A.substring(4,
9); String wordFromB =
B.substring(14);
String sentence = wordFromA + " " + wordFromB;
String capitalizedSentence = sentence.toUpperCase();
int lastIndexV = capitalizedSentence.lastIndexOf('V');
System.out.println("Extracted word from A: " + wordFromA);
System.out.println("Extracted word from B: " + wordFromB);
System.out.println("Concatenated sentence: " + sentence);
System.out.println("Capitalized sentence: " + capitalizedSentence);
System.out.println("Last occurrence of 'V': " + lastIndexV);
Ouput:
18.
Code
import java.util.LinkedList;
import java.util.Queue;
class TicketBookingSystem
private Queue<String> ticketRequests;
public TicketBookingSystem() {
ticketRequests = new LinkedList<>();
public void addBookingRequest(String customerName) {
ticketRequests.offer(customerName);
System.out.println("Booking request added for: " + customerName);
}
public void processBookings() {
System.out.println("\nProcessing bookings:");
while (!ticketRequests.isEmpty()) {
String customerName = ticketRequests.poll();
System.out.println("Booking confirmed for: " + customerName);
public void displayBookingStatus() {
System.out.println("\nTotal number of bookings: " + ticketRequests.size());
System.out.println("Pending bookings:");
for (String customerName : ticketRequests) {
System.out.println(customerName);
public class Mainn {
public static void main(String[] args) {
TicketBookingSystem bookingSystem = new
TicketBookingSystem();
bookingSystem.addBookingRequest("Alice");
bookingSystem.addBookingRequest("Bob");
bookingSystem.addBookingRequest("Charlie");
bookingSystem.processBookings();
bookingSystem.displayBookingStatus();
}
Output:
19.
Code:
import
java.util.ArrayList; class
Car {
private double price;
private String brand;
private double speed;
public Car(double price, String brand, double speed)
{this.price = price;
this.brand = brand;
this.speed = speed;
}public double getPrice()
{return price;
}public String getBrand()
{return brand;
}public double getSpeed()
{return speed; }
}public class Main1 {
public static void main(String[] args) {
ArrayList<Car> carList = new ArrayList<>();
carList.add(new Car(2500000, "Toyota", 180));
carList.add(new Car(1500000, "Honda", 200));
carList.add(new Car(3000000, "Ford", 220));
carList.add(new Car(1800000, "Nissan", 190));
carList.add(new Car(2200000, "Chevrolet",
210));
System.out.println("Cars with price over 2000000 takas:");
for (Car car : carList) {
if (car.getPrice() > 2000000) {
System.out.println("Brand: " + car.getBrand() + ", Price: " + car.getPrice() + " takas");
Output:
20.
Code:
import java.util.Arrays;
public class Gradebook
private String[] studentIDs;
private double[] grades;
public Gradebook(int capacity) {
studentIDs = new
String[capacity]; grades = new
double[capacity];
public void addStudent(String studentID, double grade) {
for (int i = 0; i < studentIDs.length; i++) {
if (studentIDs[i] == null) {
studentIDs[i] =
studentID; grades[i] =
grade;
return;
System.out.println("Gradebook is full. Cannot add more students.");
public void removeStudent(String studentID) {
for (int i = 0; i < studentIDs.length; i++) {
if (studentIDs[i] != null && studentIDs[i].equals(studentID)) {
studentIDs[i] = null;
grades[i] =
0.0; return;
System.out.println("Student ID not found.");
public void displayStudentIDs() {
System.out.println("Student IDs:");
for (String id : studentIDs) {
if (id != null) {
System.out.println(id);
public void displayGrades() {
System.out.println("Grades:");
for (int i = 0; i < studentIDs.length; i++)
{ if (studentIDs[i] != null) {
System.out.println("Student ID: " + studentIDs[i] + ", Grade: " + grades[i]);
public static void main(String[] args) {
Gradebook gradebook = new Gradebook(5);
gradebook.addStudent("1001", 85.5);
gradebook.addStudent("1002", 90.0);
gradebook.addStudent("1003", 75.0);
gradebook.displayStudentIDs();
gradebook.displayGrades();
gradebook.removeStudent("1002");
gradebook.displayStudentIDs();
gradebook.displayGrades();
Output:
21.
Code:
import java.util.Scanner;
import java.util.Stack;
class Student {
private String name;
private int id;
public Student(String name, int id)
{ this.name = name;
this.id = id;
public String getName()
{ return name;
public int getId()
{return id;
}@Override
public String toString() {
return "Student [name=" + name + ", id=" + id + "]";
public class Mainnnn {
public static void main(String[] args) {
Stack<Student> studentStack = new
Stack<>(); Scanner scanner = new
Scanner(System.in); for (int i = 1; i <= 10;
i++) {
studentStack.push(new Student("Student" + i, i));
int menu;
do {
System.out.println("\nMenu:");
System.out.println("1. Insert a Student object");
System.out.println("2. Delete the top Student object");
System.out.println("3. Display the top Student object");
System.out.println("4. Exit");
System.out.print("Enter your choice: ");
menu = scanner.nextInt();
switch (menu) {
case 1:
System.out.print("Enter student name: ");
String name = scanner.next();
System.out.print("Enter student id: ");
int id = scanner.nextInt();
studentStack.push(new Student(name, id));
System.out.println("Student object inserted successfully.");
break;
case 2:
if (!studentStack.isEmpty()) {
Student deletedStudent = studentStack.pop(); System.out.println("Top
Student object deleted: " + deletedStudent);
} else {
System.out.println("Stack is empty. No Student object to delete.");
break;
case 3:
if (!studentStack.isEmpty()) {
Student topStudent = studentStack.peek();
System.out.println("Top Student object: " + topStudent);
} else {
System.out.println("Stack is empty. No Student object to display.");
break;
case 4:
System.out.println("Exiting the program...");
break;
default:
System.out.println("Invalid menu choice. Please enter a valid menu option.");
} while (menu !=
4);scanner.close();
Output:
22.
Code:
import
java.util.ArrayList; import
java.util.List;
public class StringDuplicateRemover {
public static void main(String[] args) {
List<String> stringList = new
ArrayList<>(); stringList.add("apple");
stringList.add("banana");
stringList.add("apple");
stringList.add("orange");
stringList.add("banana");
stringList.add("grape");
stringList.add("banana");
System.out.println("List before removing duplicates:");
System.out.println(stringList);
removeDuplicates(stringList);
System.out.println("\nList after removing duplicates:");
System.out.println(stringList);
public static void removeDuplicates(List<String> stringList)
{ List<String> uniqueList = new ArrayList<>();
for (String str : stringList)
{ if
(!uniqueList.contains(str)) {
uniqueList.add(str);
stringList.clear();
stringList.addAll(uniqueList);
Output:
