Assignment 1

Set A :
1.
import java.io.*;

public class MultiplicationTable {

public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
System.out.print("Enter a number: ");
int num = Integer.parseInt(br.readLine());
for (int i = 1; i <= 10; i++) {
System.out.println(num + " x " + i + " = " + (num * i));
}
}
}

2.

public class ReverseNumber {

public static void main(String[] args) {
int num = Integer.parseInt(args[0]);
int rev = 0;
while (num != 0) {
rev = rev * 10 + num % 10;
num /= 10;
}
System.out.println("Reversed Number: " + rev);
}
}

3.

import java.util.*;

public class ArraySumSort {

public static void main(String[] args) {
int[] arr = {5, 2, 9, 1, 7};
int sum = 0;

for (int val : arr) {

sum += val;
}
 Arrays.sort(arr);
System.out.println("Sum = " + sum);
System.out.println("Sorted Array: " + Arrays.toString(arr));
}
}

----------------------OR------------------------

public class ArraySumAndSort {

public static void main(String[] args) {
int[] arr = {7, 3, 9, 1, 5};
int sum = 0;

// Calculate sum
for (int i = 0; i < arr.length; i++) {
sum += arr[i];
}

// Sort manually using simple bubble sort

for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
// swap arr[j] and arr[j+1]
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}

// Display results
System.out.println("Sum of array elements: " + sum);
System.out.print("Array in ascending order: ");
for (int val : arr) {
System.out.print(val + " ");
}
}
}

----------------------------------------------------------------------------------------------------------
4.

public class MyDate {

 private int dd, mm, yy;

public MyDate() {
this(1, 1, 2000);
}

public MyDate(int dd, int mm, int yy) {

this.dd = dd;
this.mm = mm;
this.yy = yy;
}

public void display() {

System.out.println("Date: " + dd + "-" + mm + "-" + yy);
}
}

Set B
1.

public class MyNumber {

private int num;

public MyNumber() {
this.num = 0;
}

public MyNumber(int num) {

this.num = num;
}

public boolean isPositive() {

return num > 0;
}

public boolean isNegative() {

return num < 0;
}

public boolean isEven() {

return num % 2 == 0;
}
 public boolean isOdd() {
return num % 2 != 0;
}

public static void main(String[] args) {

int val = Integer.parseInt(args[0]);
MyNumber obj = new MyNumber(val);

System.out.println("Positive? " + obj.isPositive());

System.out.println("Negative? " + obj.isNegative());
System.out.println("Even? " + obj.isEven());
System.out.println("Odd? " + obj.isOdd());
}
}

2.

import java.util.Scanner;

class Employee {
String name;
double salary;

void acceptDetails() {
Scanner sc = new Scanner(System.in);
System.out.print("Enter employee name: ");
name = sc.nextLine();
System.out.print("Enter employee salary: ");
salary = sc.nextDouble();
sc.nextLine();

void displayDetails() {
System.out.println("Name: " + name + ", Salary: " + salary);
}
}

public class EmployeeMain {

public static void main(String[] args) {
Employee[] empArr = new Employee[5]; // Array of 5 Employee objects
 // Accept details of 5 employees
for (int i = 0; i < empArr.length; i++) {
System.out.println("\nEnter details for Employee " + (i + 1));
empArr[i] = new Employee(); // Create new Employee object
empArr[i].acceptDetails();
}

// Display all employee details

System.out.println("\n--- Employee Details ---");
for (int i = 0; i < empArr.length; i++) {
System.out.print("Employee " + (i + 1) + ": ");
empArr[i].displayDetails();
}
}
}

3.

import java.util.*;

class Account {
int accno;
String accname;
double balance;

Account(int accno, String accname, double balance) {

this.accno = accno;
this.accname = accname;
this.balance = balance;
}

static void sortAccount(Account[] acc) {

Arrays.sort(acc, Comparator.comparingDouble(a -> a.balance));
}

void display() {
System.out.println(accno + " " + accname + " " + balance);
}

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);
System.out.print("Enter number of accounts: ");
int n = sc.nextInt();
 Account[] acc = new Account[n];

for (int i = 0; i < n; i++) {

System.out.print("Enter accno, accname, balance: ");
int no = sc.nextInt();
String name = sc.next();
double bal = sc.nextDouble();
acc[i] = new Account(no, name, bal);
}

sortAccount(acc);

System.out.println("\nSorted Account Details:");

for (Account a : acc) {
a.display();
}
}
}
--------------OR--------------

import java.util.Scanner;

class Account {
int accno;
String accname;
double balance;

// Constructor to initialize Account object

Account(int accno, String accname, double balance) {
this.accno = accno;
this.accname = accname;
this.balance = balance;
}

// Method to display account details

void display() {
System.out.println("Account No: " + accno);
System.out.println("Account Name: " + accname);
System.out.println("Balance: " + balance);
System.out.println("------------------------");
}

// Static method to sort account array by balance (using bubble sort)

public static void sortAccount(Account[] accounts, int n) {
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - 1 - i; j++) {
if (accounts[j].balance > accounts[j + 1].balance) {
// Swap accounts[j] and accounts[j+1]
Account temp = accounts[j];
accounts[j] = accounts[j + 1];
accounts[j + 1] = temp;
}
}
}
}

// Main method
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);

System.out.print("Enter number of accounts: ");

int n = sc.nextInt();

Account[] accounts = new Account[n];

// Input account details

for (int i = 0; i < n; i++) {
System.out.println("Enter details for account " + (i + 1));
System.out.print("Account Number: ");
int accno = sc.nextInt();
sc.nextLine(); // Consume newline
System.out.print("Account Name: ");
String accname = sc.nextLine();
System.out.print("Balance: ");
double balance = sc.nextDouble();

accounts[i] = new Account(accno, accname, balance);

}

// Sort accounts based on balance

sortAccount(accounts, n);

// Display sorted accounts

System.out.println("\nAccounts sorted by balance:");
for (int i = 0; i < n; i++) {
accounts[i].display();
}
 sc.close();
}
}

C
1.

import java.util.Scanner;

// MyDate class
class MyDate {
int dd, mm, yyyy;

// Default constructor
MyDate() {
dd = 1;
mm = 1;
yyyy = 2000;
}

// Parameterized constructor
MyDate(int d, int m, int y) {
dd = d;
mm = m;
yyyy = y;
}

// Accept date
void accept() {
Scanner sc = new Scanner(System.in);
System.out.print("Enter day: ");
dd = sc.nextInt();
System.out.print("Enter month: ");
mm = sc.nextInt();
System.out.print("Enter year: ");
yyyy = sc.nextInt();
}

// Display date
void display() {
System.out.println("Date of Birth: " + dd + "/" + mm + "/" + yyyy);
}
}

// Person class
class Person {
private int id;
private String name;
private MyDate dob;
private static int cnt = 1;

// Default constructor
Person() {
id = cnt++;
name = "";
dob = new MyDate();
}

// Parameterized constructor
Person(String n, MyDate d) {
id = cnt++;
name = n;
dob = d;
}

// Accept method
void accept() {
Scanner sc = new Scanner(System.in);
System.out.print("Enter name: ");
name = sc.nextLine();
dob = new MyDate();
dob.accept();
}

// Display method
void display() {
System.out.println("ID: " + id);
System.out.println("Name: " + name);
dob.display();
}
}

// Main class
public class PersonMain {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
 System.out.print("Enter number of persons: ");
int n = sc.nextInt();
sc.nextLine();

Person[] persons = new Person[n];

// Accept details
for (int i = 0; i < n; i++) {
System.out.println("\nEnter details for Person " + (i + 1));
persons[i] = new Person();
persons[i].accept();
}

// Display details
System.out.println("\n--- Person Details ---");
for (int i = 0; i < n; i++) {
System.out.println("\nPerson " + (i + 1));
persons[i].display();
}

sc.close();
}
}

Assignment 2
Set A

1.

class Point {
protected int x, y;

public Point() {
this.x = 0;
this.y = 0;
}

public Point(int x, int y) {

this.x = x;
this.y = y;
 }

public void display() {

System.out.println("Point Coordinates: (" + x + ", " + y + ")");
}
}

class ColorPoint extends Point {

private String color;

public ColorPoint() {
super();
this.color = "undefined";
}

public ColorPoint(int x, int y, String color) {

super(x, y);
this.color = color;
}

public void display() {

System.out.println("ColorPoint Coordinates: (" + x + ", " + y + "), Color: " + color);
}
}

// Subclass Point3D with additional member z

class Point3D extends Point {
protected int z;

public Point3D() {
super();
this.z = 0;
}

public Point3D(int x, int y, int z) {

super(x, y);
this.z = z;
}
 public void display() {
System.out.println("Point3D Coordinates: (" + x + ", " + y + ", " + z + ")");
}
}

public class PointTest {

public static void main(String[] args) {

Point p = new Point(2, 3);

ColorPoint cp = new ColorPoint(5, 6, "Red");
Point3D p3d = new Point3D(1, 4, 7);

p.display();
cp.display();
p3d.display();
}
}

-------------------------------------------------------------------------------------------------------------------------------
----------------------

2.

class Fibonacci
{

public void printFibonacci(int n)

{
int a = 0, b = 1;
System.out.print("Fibonacci Series: " + a + " " + b);
for (int i = 2; i < n; i++) {
int next = a + b;
System.out.print(" " + next);
a = b;
b = next;
}
System.out.println();
}
}
class Cube {

public void printCubes(int n) {

System.out.print("Cubes: ");
for (int i = 1; i <= n; i++) {
System.out.print((i * i * i) + " ");
}
System.out.println();
}
}

class Square {

public void printSquares(int n) {

System.out.print("Squares: ");
for (int i = 1; i <= n; i++) {
System.out.print((i * i) + " ");
}
System.out.println();
}
}

public class TestSeries {

public static void main(String[] args) {
int n = 5; // Example input

Fibonacci fib = new Fibonacci();

Cube cube = new Cube();
Square square = new Square();

fib.printFibonacci(n);
cube.printCubes(n);
square.printSquares(n);
}
}
-------------------------------------------------------------------------------------------------------------------------------
-----------

3.

import java.util.Scanner;

class Employee {
protected int id;
protected String name;
protected double salary;

public Employee() {
this.id = 0;
this.name = "";
this.salary = 0.0;
}

public void accept() {

Scanner scanner = new Scanner(System.in);
System.out.print("Enter Employee ID: ");
id = scanner.nextInt();
scanner.nextLine(); // Consume newline
System.out.print("Enter Employee Name: ");
name = scanner.nextLine();
System.out.print("Enter Employee Salary: ");
salary = scanner.nextDouble();
}

public void display() {

System.out.println("ID: " + id + ", Name: " + name + ", Salary: " + salary);
}
}

class Manager extends Employee {

private double bonus;

public Manager() {
 super(); // Call the base class (Employee) constructor
this.bonus = 0.0;
}

public void accept() {

super.accept(); // Call the accept method of Employee class
Scanner scanner = new Scanner(System.in);
System.out.print("Enter Manager Bonus: ");
bonus = scanner.nextDouble();
}

public void display() {

double totalSalary = salary + bonus;
System.out.println("ID: " + id + ", Name: " + name + ", Salary: " + salary + ", Bonus: " +
bonus + ", Total Salary: " + totalSalary);
}

public double getTotalSalary() {

return salary + bonus;
}
}

public class ManagerProgram {

public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Enter the number of managers: ");
int n = scanner.nextInt();

Manager[] managers = new Manager[n];

for (int i = 0; i < n; i++) {

System.out.println("\nEnter details for Manager " + (i + 1) + ":");
managers[i] = new Manager();
managers[i].accept();
}

Manager maxManager = managers[0];

 for (int i = 1; i < n; i++) {
if (managers[i].getTotalSalary() > maxManager.getTotalSalary()) {
maxManager = managers[i];
}
}

System.out.println("\nManager with the maximum total salary:");

maxManager.display();

}
}

-------------------------------------------------------------------------------------------------------------------------------
-------------

4.

class CapitalString {

public static String capitalizeFirstLetter(String str) {

if (str == null || str.isEmpty()) {
return str;
}

return str.substring(0, 1).toUpperCase() + str.substring(1).toLowerCase();

}
}

class Person {
private String name;
private String city;

public Person(String name, String city) {

this.name = name;
this.city = city;
}

public void display() {

 String capitalizedName = CapitalString.capitalizeFirstLetter(name);
System.out.println("Person Name: " + capitalizedName + ", City: " + city);
}
}

public class Main {

public static void main(String[] args) {

Person person = new Person("abc", "new york");

person.display();
}
}

-----------------------------------------------------------------------------------------------------------------------------

SET B :

1.Define an interface “Operation” which has methods area(),volume(). Define a constant PI

having a value 3.142.
Create a class circle (member – radius), cylinder (members – radius, height) which implements
this interface.
Calculate and display the area and volume

->

interface Operation {
double PI = 3.142;

double area();

double volume();
}

class Circle implements Operation {

private double radius;

public Circle(double radius) {

this.radius = radius;
}
 public double area() {
return PI * radius * radius;
}

public double volume() {

return 0;
}
}

class Cylinder implements Operation {

private double radius;
private double height;

public Cylinder(double radius, double height) {

this.radius = radius;
this.height = height;
}

public double area() {

return 2 * PI * radius * (radius + height);
}

public double volume() {

return PI * radius * radius * height;
}
}

public class Main {

public static void main(String[] args) {
Circle circle = new Circle(5);

System.out.println("Circle Area: " + circle.area());

System.out.println("Circle Volume: " + circle.volume());

Cylinder cylinder = new Cylinder(5, 10);

System.out.println("Cylinder Area: " + cylinder.area());

System.out.println("Cylinder Volume: " + cylinder.volume());
}
}
2. Write a Java program to create a super class Employee (members – name, salary). Derive a
sub-class as
Developer (member – projectname). Derive a sub-class Programmer (member – proglanguage)
from Developer.
Create object of Developer and display the details of it. Implement this multilevel inheritance
with appropriate constructor and methods.s

->

class Employee {
protected String name;
protected double salary;

public Employee(String name, double salary) {

this.name = name;
this.salary = salary;
}

public void displayDetails() {

System.out.println("Name: " + name);
System.out.println("Salary: $" + salary);
}
}

class Developer extends Employee {

protected String projectName;

public Developer(String name, double salary, String projectName) {

super(name, salary);
this.projectName = projectName;
}

public void displayDetails() {

super.displayDetails();
System.out.println("Project Name: " + projectName);
}
}

class Programmer extends Developer {

private String progLanguage;
 public Programmer(String name, double salary, String projectName, String progLanguage) {
super(name, salary, projectName);
this.progLanguage = progLanguage;
}

public void displayDetails() {

super.displayDetails();
System.out.println("Programming Language: " + progLanguage);
}
}

public class Main {

public static void main(String[] args) {
Developer developer = new Developer("Alice", 80000, "AI Project");

developer.displayDetails();
}
}

3 . Define an abstract class Staff with members name and address. Define two sub-classes of
this class –
FullTimeStaff (members - department, salary, hra - 8% of salary, da – 5% of salary) and
PartTimeStaff (members - number-of-hours, rate-per-hour). Define appropriate constructors.
Write abstract method as calculateSalary() in Staff class. Implement this method in subclasses.
Create n objects which could be of either FullTimeStaff or PartTimeStaff class by asking the
user‘s choice.
Display details of all FullTimeStaff objects and all PartTimeStaff objects along with their salary.

->

import java.util.Scanner;

abstract class Staff {

protected String name;
protected String address;

public Staff(String name, String address) {

this.name = name;
this.address = address;
}
 public abstract double calculateSalary();

public abstract void displayDetails();

}

class FullTimeStaff extends Staff {

private String department;
private double salary;
private double hra;
private double da;

public FullTimeStaff(String name, String address, String department, double salary) {

super(name, address);
this.department = department;
this.salary = salary;
this.hra = 0.08 * salary; // 8% of salary
this.da = 0.05 * salary; // 5% of salary
}

public double calculateSalary() {

return salary + hra + da;
}

public void displayDetails() {

System.out.println("Full-Time Staff:");
System.out.println("Name: " + name);
System.out.println("Address: " + address);
System.out.println("Department: " + department);
System.out.println("Basic Salary: $" + salary);
System.out.println("HRA: $" + hra);
System.out.println("DA: $" + da);
System.out.println("Total Salary: $" + calculateSalary());
System.out.println();
}
}

class PartTimeStaff extends Staff {

private int numberOfHours;
private double ratePerHour;

public PartTimeStaff(String name, String address, int numberOfHours, double ratePerHour) {

super(name, address);
this.numberOfHours = numberOfHours;
 this.ratePerHour = ratePerHour;
}

public double calculateSalary() {

return numberOfHours * ratePerHour;
}

public void displayDetails() {

System.out.println("Part-Time Staff:");
System.out.println("Name: " + name);
System.out.println("Address: " + address);
System.out.println("Number of Hours: " + numberOfHours);
System.out.println("Rate per Hour: $" + ratePerHour);
System.out.println("Total Salary: $" + calculateSalary());
System.out.println();
}
}

public class Main {

public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);

System.out.println("Enter the number of staff members:");

int n = scanner.nextInt();
scanner.nextLine(); // Consume newline

Staff[] staffArray = new Staff[n];

for (int i = 0; i < n; i++) {

System.out.println("Enter details for staff member " + (i + 1));
System.out.println("Is this staff member Full-Time (enter 'f') or Part-Time (enter 'p')?");
char type = scanner.nextLine().charAt(0);

if (type == 'f') {
// Input details for FullTimeStaff
System.out.println("Enter name:");
String name = scanner.nextLine();
System.out.println("Enter address:");
String address = scanner.nextLine();
System.out.println("Enter department:");
String department = scanner.nextLine();
System.out.println("Enter basic salary:");
double salary = scanner.nextDouble();
 scanner.nextLine(); // Consume newline

staffArray[i] = new FullTimeStaff(name, address, department, salary);

} else if (type == 'p') {
System.out.println("Enter name:");
String name = scanner.nextLine();
System.out.println("Enter address:");
String address = scanner.nextLine();
System.out.println("Enter number of hours:");
int numberOfHours = scanner.nextInt();
System.out.println("Enter rate per hour:");
double ratePerHour = scanner.nextDouble();
scanner.nextLine();

staffArray[i] = new PartTimeStaff(name, address, numberOfHours, ratePerHour);

} else {
System.out.println("Invalid type entered. Please enter 'f' for Full-Time or 'p' for
Part-Time.");
i--;
}
}

System.out.println("\nStaff Details:");
for (int i = 0; i < staffArray.length; i++) {
if (staffArray[i] != null) {
staffArray[i].displayDetails();
}
}

}
}

-------------------------------------------------------------------------------------------------------------------------------
--------------
ASSIGNMENT 3
SET A :

1.

Accept n integers from the user and store them in a collection. Display them in the sorted order.
The collection should not accept duplicate elements. (Use a suitable collection). Search for a
particular element using predefined search method in the Collection framework.
->

import java.util.Scanner;
import java.util.TreeSet;

public class Collection

{
public static void main(String[] args)
{
TreeSet<Integer> numbers = new TreeSet<>();
Scanner scanner = new Scanner(System.in);

System.out.print("Enter the number of integers you want to input: ");

int n = scanner.nextInt();

System.out.println("Enter " + n + " integers:");

for (int i = 0; i < n; i++) {
int number = scanner.nextInt();
numbers.add(number);
}

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

System.out.print("Enter the element to search for: ");

int searchElement = scanner.nextInt();

if (numbers.contains(searchElement))
{
System.out.println("Element " + searchElement + " is found in the collection.");
}
else
{
System.out.println("Element " + searchElement + " is not found in the collection.");
}

}
}

----------------------------------------------------------

2.
Create a Hash table containing Employee name and Salary. Display the details of the hash
table. Also search for a specific Employee and display Salary of that Employee.

=>

import java.util.HashMap;
import java.util.Scanner;

public class Collection1

{
public static void main(String[] args)
{
HashMap<String, Double> employeeSalaries = new HashMap<>();
Scanner scanner = new Scanner(System.in);

employeeSalaries.put("John", 50000.0);
employeeSalaries.put("Jane", 60000.0);
employeeSalaries.put("Emily", 70000.0);
employeeSalaries.put("Michael", 80000.0);
employeeSalaries.put("Sophia", 75000.0);

System.out.println("Employee Salaries:");
for (String employee : employeeSalaries.keySet())
{
System.out.println("Employee: " + employee + ", Salary: $" +
employeeSalaries.get(employee));
}

System.out.print("\nEnter the name of the employee to search for their salary: ");
String searchName = scanner.nextLine();

if (employeeSalaries.containsKey(searchName))
{
double salary = employeeSalaries.get(searchName);
System.out.println("Salary of " + searchName + " is: $" + salary);
}
else
{
System.out.println("Employee " + searchName + " is not found in the record.");
}
}
}
-----------------------------

3.
Write a java program to accept a number from the user, if number is zero then throw
userdefined exception ―Number is 0, otherwise check whether no is prime or not.

=>

import java.util.Scanner;

class ZeroNumberException extends Exception

{
public ZeroNumberException(String message)
{
super(message);
}
}

public class Main

{
public static void main(String[] args)
{
Scanner scanner = new Scanner(System.in);

try
{
System.out.print("Enter a number: ");
int number = scanner.nextInt();

if (number == 0)
{
throw new ZeroNumberException("Number is 0");
}

if (isPrime(number))
{
System.out.println(number + " is a prime number.");
} else {
System.out.println(number + " is not a prime number.");
}

}
catch (ZeroNumberException e)
 {
System.out.println("Exception: " + e.getMessage());
}
catch (Exception e)
{
System.out.println("An error occurred: " + e.getMessage());
}
finally
{
scanner.close();
}
}

public static boolean isPrime(int num)

{
if (num <= 1) {
return false;
}

for (int i = 2; i * i <= num; i++)

{
if (num % i == 0)
{
return false;
}
}

return true;
}
}

-------------------

4.Write a java program that displays the number of characters, lines and words of a file.

->

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class FileInfo {

public static void main(String[] args) {

String fileName = "info.txt";
int charCount = 0;
int wordCount = 0;
int lineCount = 0;

try (BufferedReader br = new BufferedReader(new FileReader(fileName)))

{
String line;

while ((line = br.readLine()) != null) {

lineCount++;
charCount += line.length(); // Count characters in the current line
String[] words = line.split("\\s+"); // Split the line into words
wordCount += words.length; // Increment word count by the number of words in the
current line
}
} catch (IOException e)
{
System.out.println("An error occurred while reading the file.");
e.printStackTrace();
}

System.out.println("Number of characters: " + charCount);

System.out.println("Number of words: " + wordCount);
System.out.println("Number of lines: " + lineCount);
}
}

--------------------------------------

-----------------------------------------------------------------------------

SET B :

1. Construct a linked List containing names of colours: red, blue, yellow and orange. Then
extend your program to do the following:
i. Display the contents of the List using an Iterator
ii. Display the contents of the List in reverse order using a ListIterator
iii. Create another list containing pink and green. Insert the elements of this list
between blue and yellow.

—>

import java.util.LinkedList;
import java.util.Iterator;
import java.util.ListIterator;

public class ColorList {

public static void main(String[] args) {

LinkedList<String> colors = new LinkedList<>();

colors.add("red");
colors.add("blue");
colors.add("yellow");
colors.add("orange");

System.out.println("Displaying colors using Iterator:");

Iterator<String> iterator = colors.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}

// ii. Display the contents of the List in reverse order using a ListIterator
System.out.println("\nDisplaying colors in reverse order using ListIterator:");
ListIterator<String> listIterator = colors.listIterator(colors.size()); // Start at the end of the
list
while (listIterator.hasPrevious()) {
System.out.println(listIterator.previous());
}

// iii. Create another list containing pink and green, insert between blue and yellow
LinkedList<String> newColors = new LinkedList<>();
newColors.add("pink");
newColors.add("green");

// Insert the new list between blue and yellow

int index = colors.indexOf("yellow"); // Find the position of yellow
 colors.addAll(index, newColors); // Add newColors before yellow

// Display the modified list

System.out.println("\nModified color list:");
for (String color : colors) {
System.out.println(color);
}
}
}

----------------------------

2.Write a java program to accept Doctor Name from the user and check whether it is valid
or not. (It should not contain digits and special symbol) If it is not valid then throw user
defined Exception - Name is Invalid -- otherwise display it.

->

import java.util.Scanner;

// User-defined exception class

class InvalidNameException extends Exception
{
public InvalidNameException(String message)
{
super(message);
}
}

public class DoctorNameValidation

{

public static void validateName(String name) throws InvalidNameException

{

if (!name.matches("[a-zA-Z\\s]+")) {
throw new InvalidNameException("Name is Invalid");
}
}
 public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);

System.out.print("Enter Doctor's Name: ");

String doctorName = scanner.nextLine();

try {

validateName(doctorName);

System.out.println("Doctor's Name is valid: " + doctorName);

} catch (InvalidNameException e) {
// If invalid, display the custom exception message
System.out.println(e.getMessage());
}
}
}

--------------------------

3.Write a java program to accept details of n customers (c_id, cname, address, mobile_no)
from user and store it in a file (Use DataOutputStream class). Display the details of
customers by reading it from file.(Use DataInputStream class)

->

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.Scanner;

public class CustomerDetails

{

public static void main(String[] args)

{
Scanner scanner = new Scanner(System.in);

try {

FileOutputStream fos = new FileOutputStream("customers.txt");

DataOutputStream dos = new DataOutputStream(fos);

// Accept the number of customers

System.out.print("Enter the number of customers: ");
int n = scanner.nextInt();
scanner.nextLine(); // Consume newline

// Loop to accept customer details and write them to the file

for (int i = 1; i <= n; i++) {
System.out.println("Enter details for customer " + i + ":");

System.out.print("Customer ID: ");

int c_id = scanner.nextInt();
scanner.nextLine(); // Consume newline

System.out.print("Customer Name: ");

String cname = scanner.nextLine();

System.out.print("Address: ");
String address = scanner.nextLine();

System.out.print("Mobile Number: ");

String mobile_no = scanner.nextLine();

// Write the details to the file

dos.writeInt(c_id);
dos.writeUTF(cname);
dos.writeUTF(address);
dos.writeUTF(mobile_no);
}

dos.close();

FileInputStream fis = new FileInputStream("customers.txt");

DataInputStream dis = new DataInputStream(fis);

System.out.println("\nCustomer Details from the file:");

for (int i = 1; i <= n; i++) {

int c_id = dis.readInt();
String cname = dis.readUTF();
 String address = dis.readUTF();
String mobile_no = dis.readUTF();

System.out.println("\nCustomer " + i + ":");

System.out.println("Customer ID: " + c_id);
System.out.println("Customer Name: " + cname);
System.out.println("Address: " + address);
System.out.println("Mobile Number: " + mobile_no);
}

dis.close();

} catch (Exception e) {
System.out.println("An error occurred: " + e.getMessage());
}

scanner.close();
}
}

-------------------------------------------------------------------------------------------------------------------------------
-------------------------

Assignment 4 :
Set A :

1.

​ Q1. ComboBox Example (Programming Language)

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class ComboBoxExample {

public static void main(String[] args)
{
// Create a new JFrame (window)
 JFrame frame = new JFrame("ComboBox Example"); // This creates a new window
titled "ComboBox Example."

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // This ensures that the

program will terminate when the user closes the window.

frame.setSize(400, 200); // Sets the size of the window to 400 pixels wide and 200 pixels
high.

frame.setLayout(new FlowLayout()); // The FlowLayout manager arranges components in

a left-to-right flow, much like words on a page. It ensures the components (combo box, button,
label) are positioned in a simple layou

// Create components (label, combo box, button)

JLabel label = new JLabel("Programming language Selected: "); // Creates a label to
display the selected programming language. Initially, it just displays the text "Programming
language Selected: ".

String[] languages = {"C", "C++", "C#", "Java", "PHP"}; // Defines an array of strings
representing the options (programming languages) to be shown in the combo box.

JComboBox<String> comboBox = new JComboBox<>(languages); // Creates a combo

box using the languages array. The user can select one of these languages.

JButton showButton = new JButton("Show"); // Creates a button labeled "Show." When

clicked, it will display the selected language.

// Add action listener to the button . Adds an ActionListener to the "Show" button. This
allows the button to respond to clicks.

showButton.addActionListener(new ActionListener()
{

​ // This method is executed when the button is clicked. The ActionEvent e contains
information about the button click.
public void actionPerformed(ActionEvent e)
{
String selectedLanguage = (String) comboBox.getSelectedItem();
label.setText("Programming language Selected: " + selectedLanguage); // Updates
the text of the label to display the selected programming language. For example, if "Java" is
selected, the label will show "Programming language Selected: Java."
}
});
 // Add components to the frame. These lines add the combo box, button, and label to the
frame (window). Swing components are typically added to a container like JFrame.

frame.add(comboBox);
frame.add(showButton);
frame.add(label);

// Set frame to be visible . This makes the window visible to the user. Without this, the
window would not appear on the screen.

frame.setVisible(true);
}
}

—-------++++++++++-------

Q2.New User Register

import javax.swing.*;
import java.awt.*;

public class RegisterGUI {

public static void main(String[] args) {
// Create a new JFrame (window)
JFrame frame = new JFrame("New User Register");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(500, 300);
frame.setLayout(new GridBagLayout()); // Using GridBagLayout for flexible positioning

// Create GridBagConstraints for setting component positions

GridBagConstraints gbc = new GridBagConstraints();
gbc.insets = new Insets(5, 5, 5, 5); // Spacing between components
gbc.fill = GridBagConstraints.HORIZONTAL; // Fill components horizontally

// Create components (labels, text fields, buttons)

JLabel titleLabel = new JLabel("New User Register", JLabel.CENTER);
titleLabel.setFont(new Font("Serif", Font.BOLD, 20));

JLabel firstNameLabel = new JLabel("First name:");

JTextField firstNameText = new JTextField(10);

JLabel lastNameLabel = new JLabel("Last name:");

JTextField lastNameText = new JTextField(10);

JLabel emailLabel = new JLabel("Email address:");

JTextField emailText = new JTextField(10);

JLabel usernameLabel = new JLabel("Username:");

JTextField usernameText = new JTextField(10);

JLabel passwordLabel = new JLabel("Password:");

JPasswordField passwordText = new JPasswordField(10);

JLabel mobileLabel = new JLabel("Mobile number:");

JTextField mobileText = new JTextField(10);

JButton registerButton = new JButton("Register");

// Add components to frame with positions

gbc.gridwidth = 2; // Title spans two columns
gbc.gridx = 0;
gbc.gridy = 0;
frame.add(titleLabel, gbc);

gbc.gridwidth = 1; // Reset for labels and fields

gbc.gridx = 0;
gbc.gridy = 1;
frame.add(firstNameLabel, gbc);
gbc.gridx = 1;
frame.add(firstNameText, gbc);

gbc.gridx = 0;
gbc.gridy = 2;
frame.add(lastNameLabel, gbc);
gbc.gridx = 1;
frame.add(lastNameText, gbc);

gbc.gridx = 0;
gbc.gridy = 3;
frame.add(emailLabel, gbc);
gbc.gridx = 1;
frame.add(emailText, gbc);

gbc.gridx = 2;
gbc.gridy = 1;
frame.add(usernameLabel, gbc);
 gbc.gridx = 3;
frame.add(usernameText, gbc);

gbc.gridx = 2;
gbc.gridy = 2;
frame.add(passwordLabel, gbc);
gbc.gridx = 3;
frame.add(passwordText, gbc);

gbc.gridx = 2;
gbc.gridy = 3;
frame.add(mobileLabel, gbc);
gbc.gridx = 3;
frame.add(mobileText, gbc);

gbc.gridwidth = 4; // Register button spans all columns

gbc.gridx = 0;
gbc.gridy = 4;
frame.add(registerButton, gbc);

// Set frame to be visible

frame.setVisible(true);
}
}

—--------------++++++++++++++------------

Q3.LoginGUI

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class LoginGUI {

public static void main(String[] args) {
// Create a new JFrame (window)
JFrame frame = new JFrame("Login");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(300, 150);
frame.setLayout(new GridLayout(3, 2));

// Create components (labels, text fields, buttons)

 JLabel userLabel = new JLabel("Username:");
JTextField userText = new JTextField();
JLabel passLabel = new JLabel("Password:");
JPasswordField passText = new JPasswordField();
JButton loginButton = new JButton("Login");
JButton resetButton = new JButton("Reset");

// Add components to the frame

frame.add(userLabel);
frame.add(userText);
frame.add(passLabel);
frame.add(passText);
frame.add(loginButton);
frame.add(resetButton);

// Action listener for login button

loginButton.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

String username = userText.getText();
String password = new String(passText.getPassword());

// Check if username and password are "admin"

if (username.equals("admin") && password.equals("admin")) {
JOptionPane.showMessageDialog(frame, "Login Successful!");
} else {
JOptionPane.showMessageDialog(frame, "Invalid Username or Password");
}
}
});

// Action listener for reset button

resetButton.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

userText.setText("");
passText.setText("");
}
});

// Set frame to be visible

frame.setVisible(true);
}
}
—-------------++++++++++++++++=-----------

Q4.Customer Details

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class CustomerDetailsForm {

public static void main(String[] args) {
// Create the frame
JFrame frame = new JFrame("Customer Account Details");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(200, 100);

// Create a panel with a GridLayout to arrange labels and text fields

JPanel panel = new JPanel();
panel.setLayout(new GridLayout(5, 2, 10, 10)); // 5 rows, 2 columns, with 10px gaps

// Add labels and text fields

JLabel nameLabel = new JLabel("Name of Customer:");
JTextField nameField = new JTextField(20);

JLabel bankLabel = new JLabel("Name of Bank:");

JTextField bankField = new JTextField(20);

JLabel accountLabel = new JLabel("Account No.:");

JTextField accountField = new JTextField(20);

JLabel panLabel = new JLabel("Pan Number:");

JTextField panField = new JTextField(20);

// Add the components to the panel

panel.add(nameLabel);
panel.add(nameField);
panel.add(bankLabel);
panel.add(bankField);
panel.add(accountLabel);
panel.add(accountField);
panel.add(panLabel);
panel.add(panField);
 // Create a label for error messages
JLabel messageLabel = new JLabel("");
messageLabel.setForeground(Color.RED);

// Add a submit button

JButton submitButton = new JButton("Submit");
panel.add(submitButton);

// Add the message label below the submit button

panel.add(messageLabel);

// Add the panel to the frame

frame.add(panel);

// Set the frame visible

frame.setVisible(true);

// Add action listener to the submit button

submitButton.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

// Get the text from the fields
String name = nameField.getText();
String bank = bankField.getText();
String account = accountField.getText();
String pan = panField.getText();

// Check if any field is empty

if (name.isEmpty() || bank.isEmpty() || account.isEmpty() || pan.isEmpty()) {
messageLabel.setText("Please fill in all the details!");
} else {
messageLabel.setText("Details submitted successfully.");
messageLabel.setForeground(Color.GREEN);
}
}
});
}
}

—----------------+++++++++++++++======-----------

Q5. Simple Calculator

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

class SimpleCalculator{
public static void main(String[] args) {
// Create the frame
JFrame frame = new JFrame("Calculator with Search Bar");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(300, 500); // Increased size to accommodate the search bar

// Main panel with BorderLayout

JPanel mainPanel = new JPanel(new BorderLayout());

// Create the search bar

JTextField searchBar = new JTextField();
searchBar.setHorizontalAlignment(JTextField.CENTER);
searchBar.setText("Search..."); // Placeholder text
mainPanel.add(searchBar, BorderLayout.NORTH); // Search bar at the top

// Panel for the calculator display and buttons

JPanel calculatorPanel = new JPanel(new BorderLayout());

// Create the display field for calculator

JTextField displayField = new JTextField();
displayField.setEditable(false);
displayField.setHorizontalAlignment(JTextField.RIGHT);
calculatorPanel.add(displayField, BorderLayout.NORTH); // Display at the top

// Create a panel for buttons (4x3 grid layout)

JPanel buttonPanel = new JPanel(new GridLayout(4, 3, 10, 10)); // 4 rows, 3 columns,
10px gaps

// Array of button labels

String[] buttons = { "7", "8", "9", "4", "5", "6", "1", "2", "3", "0", "-", "Clear" };

// Add buttons to the panel

for (String text : buttons) {
JButton button = new JButton(text);
buttonPanel.add(button);

// Add action listener to each button

button.addActionListener(new ActionListener() {
 public void actionPerformed(ActionEvent e) {
if (text.equals("Clear")) {
displayField.setText(""); // Clear the display if "Clear" is clicked
} else {
displayField.setText(displayField.getText() + text); // Append the button text to
the display
}
}
});
}

// Add the button panel to the calculator panel

calculatorPanel.add(buttonPanel, BorderLayout.CENTER);

// Add calculator panel to the main panel

mainPanel.add(calculatorPanel, BorderLayout.CENTER);

// Set the layout and add the main panel to the frame
frame.add(mainPanel);

// Make the frame visible

frame.setVisible(true);
}
}