Random number generator

package RandomNumberGenerator;

//public class RandomNumberGenerator.RandomNumberGenerator {

//}
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class RandomNumberGenerator extends JFrame implements

ActionListener {

private JTextField textField;

private JButton button;
private JButton resetButton;

public RandomNumberGenerator() {

setTitle("Random Number Generator");

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setSize(350, 200);
setLayout(new FlowLayout());

JPanel panel = new JPanel();

panel.setLayout(new BoxLayout(panel,
BoxLayout.Y_AXIS));

JLabel titleLabel = new JLabel("Click the button below

to generate a random number.");
titleLabel.setHorizontalAlignment(JLabel.CENTER);
add(titleLabel);

button = new JButton("Click here");

button.setBackground(Color.YELLOW);
button.setForeground(Color.CYAN);
button.addActionListener(this);
add(button);

textField = new JTextField(20);

textField.setEditable(false);
textField.setHorizontalAlignment(JTextField.RIGHT);
textField.setBackground(Color.CYAN);
textField.setForeground(Color.BLUE);
add(textField);

resetButton = new JButton("Reset");

resetButton.addActionListener(this);
add(resetButton);
 }

public void actionPerformed(ActionEvent e) {

if (e.getSource() == button) {
textField.setText(String.valueOf((int)
(Math.random() * 1000000)));
} else if (e.getSource() == resetButton) {
textField.setText("");
}
}

public static void main(String[] args) {

RandomNumberGenerator randomNumberGenerator = new

RandomNumberGenerator();
randomNumberGenerator.setVisible(true);
}
}

Table
package Table;

import javax.swing.*;
import javax.swing.table.DefaultTableModel;
import java.io.BufferedReader;
import java.io.FileReader;
import java.util.ArrayList;
import java.util.List;

public class CSVTable {

public static void main(String[] args) {
String fileName = "Data.txt";

List<String> headings = new ArrayList<>();

List<List<String>> data = new ArrayList<>();

try {
BufferedReader br = new BufferedReader(new
FileReader(fileName));
String line;
while ((line = br.readLine()) != null) {
String[] values = line.split("\\|");
if (headings.isEmpty()) {
for (String value : values) {
headings.add(value.trim());
}
} else {
 List<String> row = new ArrayList<>();
for (String value : values) {
row.add(value.trim());
}
data.add(row);
}
}
br.close();
} catch (Exception e) {
e.printStackTrace();
}

SwingUtilities.invokeLater(() -> {
try {

UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassNa
me());
} catch (Exception e) {
e.printStackTrace();
}

String[] columnNames = headings.toArray(new

String[0]);
Object[][] rowData = new Object[data.size()][];
for (int i = 0; i < data.size(); i++) {
rowData[i] = data.get(i).toArray();
}

DefaultTableModel model = new

DefaultTableModel(rowData, columnNames);
JTable table = new JTable(model);
JScrollPane scrollPane = new JScrollPane(table);

JFrame frame = new JFrame("CSV Table");

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.getContentPane().add(scrollPane);
frame.pack();
frame.setLocationRelativeTo(null);
frame.setVisible(true);
});
}
}

Data.txt
Name|Gender|Age|Preference
mrit Kumar|M|20|Veg
Arit Kumari|F|21|Non-Veg
Amit Kum|M|20|Veg
Amrt Kuma|M|10|Non-Veg

Sum of numbers in line

package PresentTheSum;

import java.util.Scanner;

public class SumOfNumbers {

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

System.out.println("Enter a line containing

numbers:");
String inputLine = scanner.nextLine();

try {
int sum = calculateSumOfNumbers(inputLine);
System.out.println("Sum of numbers in the input
line: " + sum);
} catch (NumberFormatException e) {
System.out.println("Error: Non-numeric characters
encountered. Ignoring them.");
}
}

private static int calculateSumOfNumbers(String inputLine)

throws NumberFormatException {
Scanner lineScanner = new Scanner(inputLine);
int sum = 0;

while (lineScanner.hasNext()) {
if (lineScanner.hasNextInt()) {
sum += lineScanner.nextInt();
} else {
// If the next token is not an integer, ignore
it
lineScanner.next();
}
}

return sum;
}
}

Name Validator
package NameValidator;

import java.awt.*;
import java.awt.event.*;

class InvalidNameFormatException extends Exception {

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

public class NameValidator extends Frame implements

ActionListener {
TextField tf;
Button btn;
Label label;

public NameValidator() {
tf = new TextField(20);
btn = new Button("Validate");
label = new Label("");

setLayout(new FlowLayout());
add(tf);
add(btn);
add(label);

btn.addActionListener(this);
}

public void actionPerformed(ActionEvent e) {

String name = tf.getText();

try {
validateName(name);
label.setText("OK");
} catch (InvalidNameFormatException ex) {
label.setText("Invalid name");
}
}

public void validateName(String name) throws

InvalidNameFormatException {
if (name.matches(".*\\d.*")) {
throw new InvalidNameFormatException("Invalid
name. It should not contain numbers.");
}
}

public static void main(String[] args) {

NameValidator frame = new NameValidator();
 frame.setTitle("Name Validator");
frame.setSize(300, 100);
frame.setVisible(true);
frame.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
}
}

Coffeemaker

AbstractCoffeeMaker
package CoffeeMaker;

import java.util.Map;
import java.util.HashMap;
public abstract class AbstractCoffeeMaker implements
CoffeeMaker {
private Map<String, Integer> ingredients;

public AbstractCoffeeMaker() {
ingredients = new HashMap<>();
}

protected void addIngredient(String name, int quantity) {

ingredients.put(name, quantity);
}

protected boolean checkIngredients(String name, int

quantity) {
return ingredients.getOrDefault(name, 0) >= quantity;
}

public void brew() {

// default brewing process
}

public void serve() {

// default serving process
}
}
BlackCoffee
package CoffeeMaker;

public class BlackCoffee extends AbstractCoffeeMaker {

public BlackCoffee() {
addIngredient("coffee", 10);
}

@Override
public void brew() {
// brew black coffee recipe
}

@Override
public void serve() {
// serve black coffee
}
}

Cappuccino
package CoffeeMaker;

public class Cappuccino extends AbstractCoffeeMaker {

public Cappuccino() {
addIngredient("coffee", 10);
addIngredient("milk", 150);
addIngredient("foamed milk", 10);
}

@Override
public void brew() {
// brew cappuccino recipe
}

@Override
public void serve() {
// serve cappuccino
}
}

Interface Coffeemaker
package CoffeeMaker;

public interface CoffeeMaker {

void brew();
 void serve();
}

Lattee
package CoffeeMaker;

public class Latte extends AbstractCoffeeMaker {

public Latte() {
addIngredient("coffee", 10);
addIngredient("milk", 150);
}

@Override
public void brew() {
// brew latte recipe
}

@Override
public void serve() {
// serve latte
}
}

Scientific calculator

AbstractScientificCalculator
package ScientificCalculator;

import java.util.HashMap;
import java.util.Map;

public abstract class AbstractScientificCalculator implements

ScientificCalculator {

protected Map<Integer, Double> factorialMap = new

HashMap<>();

@Override
public double logarithm(double number, double base) {
return Math.log(number) / Math.log(base);
}

@Override
public double exponential(double number, double power) {
return Math.pow(number, power);
}
 @Override
public double root(double number, double degree) {
return Math.pow(number, 1.0 / degree);
}

@Override
public double factorial(int number) {
if (number == 0 || number == 1) {
return 1;
}

if (factorialMap.containsKey(number)) {
return factorialMap.get(number);
}

double factorial = number * factorial(number - 1);

factorialMap.put(number, factorial);

return factorial;
}
}

BasicScientificCalculator
package ScientificCalculator;

public class BasicScientificCalculator extends

AbstractScientificCalculator {

public static void main(String[] args) {

BasicScientificCalculator calculator = new
BasicScientificCalculator();

double logarithm = calculator.logarithm(100, 10);

double exponential = calculator.exponential(2, 3);
double root = calculator.root(8, 2);
double factorial = calculator.factorial(5);

System.out.println("Logarithm: " + logarithm);

System.out.println("Exponential: " + exponential);
System.out.println("Root: " + root);
System.out.println("Factorial: " + factorial);
}
}

Interface ScientificCalculator
package ScientificCalculator;

public interface ScientificCalculator {

double logarithm(double number, double base);
double exponential(double number, double power);
double root(double number, double degree);
double factorial(int number);
}

Shape

Circle
package Shape;

public class Circle extends Shape {

private double radius;

public Circle(double radius) {

this.radius = radius;
}

@Override
void draw() {
System.out.println("Drawing a circle with radius " +
radius);
}

@Override
double calculateArea() {
return Math.PI * radius * radius;
}
}

Main
package Shape;

public class Main {

public static void main(String[] args) {
Shape circle = new Circle(5);
Shape square = new Square(4);
Shape triangle = new Triangle(3, 2);

circle.draw();
square.draw();
triangle.draw();
 System.out.println("Area of circle: " +
circle.calculateArea());
System.out.println("Area of square: " +
square.calculateArea());
System.out.println("Area of triangle: " +
triangle.calculateArea());
}
}

Abstract class Shape

package Shape;

public abstract class Shape {

abstract void draw();
abstract double calculateArea();
}

Square
package Shape;

public class Square extends Shape {

private double side;

public Square(double side) {

this.side = side;
}

@Override
void draw() {
System.out.println("Drawing a square with side length
" + side);
}

@Override
double calculateArea() {
return side * side;
}
}

Triangle
package Shape;

public class Triangle extends Shape {

private double base;
 private double height;

public Triangle(double base, double height) {

this.base = base;
this.height = height;
}

@Override
void draw() {
System.out.println("Drawing a triangle with base " +
base + " and height " + height);
}

@Override
double calculateArea() {
return 0.5 * base * height;
}
}

String manipulation
package StringManipulation;

import java.util.Scanner;

import java.util.Scanner;

public class StringManipulationProgram {

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

do {
System.out.println("Select an option:");
System.out.println("a. String compare");
System.out.println("b. String compare ignoring
case");
System.out.println("c. String reverse");
System.out.println("d. Change to uppercase");
System.out.println("e. Change to lowercase");
System.out.println("f. END");

char choice = scanner.next().charAt(0);

scanner.nextLine(); // Consume the newline
character

switch (choice) {
case 'a':
System.out.println("Enter the first
string:");
String str1 = scanner.nextLine();
System.out.println("Enter the second
string:");
String str2 = scanner.nextLine();
compareStrings(str1, str2);
break;

case 'b':
System.out.println("Enter the first
string:");
String str3 = scanner.nextLine();
System.out.println("Enter the second
string:");
String str4 = scanner.nextLine();
compareStringsIgnoreCase(str3, str4);
break;

case 'c':
System.out.println("Enter the string to
reverse:");
input = scanner.nextLine();
reverseString(input);
break;

case 'd':
System.out.println("Enter the string to
convert to uppercase:");
input = scanner.nextLine();
toUpperCase(input);
break;

case 'e':
System.out.println("Enter the string to
convert to lowercase:");
input = scanner.nextLine();
toLowerCase(input);
break;

case 'f':
System.out.println("Program ended.
Goodbye!");
break;

default:
System.out.println("Invalid option. Please
try again.");
}

} while (scanner.hasNext() && scanner.next().charAt(0)

!= 'f');
 scanner.close();
}

private static void compareStrings(String str1, String

str2) {
if (str1.equals(str2)) {
System.out.println("The strings are equal.");
} else {
System.out.println("The strings are not equal.");
}
}

private static void compareStringsIgnoreCase(String str1,

String str2) {
if (str1.equalsIgnoreCase(str2)) {
System.out.println("The strings are equal
(ignoring case).");
} else {
System.out.println("The strings are not equal
(ignoring case).");
}
}

private static void reverseString(String str) {

StringBuilder reversed = new
StringBuilder(str).reverse();
System.out.println("Reversed string: " + reversed);
}

private static void toUpperCase(String str) {

System.out.println("Uppercase: " + str.toUpperCase());
}

private static void toLowerCase(String str) {

System.out.println("Lowercase: " + str.toLowerCase());
}
}

Employee Salary

PayrollProcessor
package salary.accounts;

import salary.emp.*;

public class PayrollProcessor {

public static void printEmployeeDetails(Employee employee)
{
 System.out.println("Employee Details:");
System.out.println("Name: " + employee.getName());
System.out.println("Employee ID: " +
employee.getEmployeeId());
System.out.println("Category: " +
employee.getCategory());
System.out.println("Basic Pay: " +
employee.getBasicPay());
System.out.println("HRA: " + employee.calculateHRA());
System.out.println("DA: " + employee.calculateDA());
System.out.println("Gross Pay: " +
employee.calculateGrossPay());
System.out.println("Income Tax: " +
employee.calculateIncomeTax());
System.out.println("Allowance: " +
employee.calculateAllowance());
}

public static void main(String[] args) {

// Example usage
Employee employee = new Employee("John Doe", 101,
"Permanent", 50000.0);
printEmployeeDetails(employee);
}
}

Employee

package salary.emp;

public class Employee {

private String name;
private int employeeId;
private String category;
private double basicPay;

public Employee(String name, int employeeId, String

category, double basicPay) {
this.name = name;
this.employeeId = employeeId;
this.category = category;
this.basicPay = basicPay;
}

public double calculateHRA() {

return 0.1 * basicPay;
}

public double calculateDA() {

 return 0.05 * basicPay;
}

public double calculateGrossPay() {

return basicPay + calculateHRA() + calculateDA();
}

public double calculateIncomeTax() {

return 0.4 * calculateGrossPay();
}

public double calculateAllowance() {

return 0.02 * basicPay;
}

public String getName() {

return name;
}

public int getEmployeeId() {

return employeeId;
}

public String getCategory() {

return category;
}

public double getBasicPay() {

return basicPay;
}
}

Inner Class
package Innerclass;

// Outer class
class OuterClass {

// Member Inner class

class MemberInner {
void display() {
System.out.println("Member Inner class");
}
}

// Anonymous Inner class

void anonymousInnerMethod() {
// Anonymous Inner class inside a method
Runnable runnable = new Runnable() {
 @Override
public void run() {
System.out.println("Anonymous Inner class");
}
};
new Thread(runnable).start();
}

// Local Inner class

void localInnerMethod() {
class LocalInner {
void display() {
System.out.println("Local Inner class");
}
}
LocalInner localInner = new LocalInner();
localInner.display();
}

// Static Nested class

static class StaticNested {
void display() {
System.out.println("Static Nested class");
}
}

// Nested Interface
interface NestedInterface {
void show();
}
}

public class InnerClassExample {

public static void main(String[] args) {
// Creating an instance of the outer class
OuterClass outer = new OuterClass();

// Member Inner class

OuterClass.MemberInner memberInner = outer.new
MemberInner();
memberInner.display();

// Anonymous Inner class

outer.anonymousInnerMethod();

// Local Inner class

outer.localInnerMethod();

// Static Nested class

OuterClass.StaticNested staticNested = new
OuterClass.StaticNested();
 staticNested.display();

// Nested Interface
OuterClass.NestedInterface nestedInterface = new
OuterClass.NestedInterface() {
@Override
public void show() {
System.out.println("Nested Interface");
}
};
nestedInterface.show();
}
}

Relative Date of Birth

package RelativeLatest;

import java.util.*;

public class SortDates {

static Map<String, Integer> monthsMap = new HashMap<>();

// Function which initializes the monthsMap

static void sortMonths() {
monthsMap.put("Jan", 1);
monthsMap.put("Feb", 2);
monthsMap.put("Mar", 3);
monthsMap.put("Apr", 4);
monthsMap.put("May", 5);
monthsMap.put("Jun", 6);
monthsMap.put("Jul", 7);
monthsMap.put("Aug", 8);
monthsMap.put("Sep", 9);
monthsMap.put("Oct", 10);
monthsMap.put("Nov", 11);
monthsMap.put("Dec", 12);
}

static int cmp(String date) {

String[] dateParts = date.split(" ");
int day = Integer.parseInt(dateParts[0]);
int month = monthsMap.get(dateParts[1]);
int year = Integer.parseInt(dateParts[2]);

return year * 10000 + month * 100 + day;

}

// Utility function to print the contents

// of the array
 static void printDates(String[] dates, int n) {
for (int i = 0; i < n; i++) {
System.out.println(dates[i]);
}
}

public static void main(String[] args) {

String[] dates = { "24 Jul 2017", "25 Jul 2017", "11
Jun 1996",
"01 Jan 2019", "12 Aug 2005", "01 Jan 1997" };
int n = dates.length;

// Order the months

sortMonths();

// Sort the dates

Arrays.sort(dates, (a, b) -> cmp(a) - cmp(b));

// Print the sorted dates

printDates(dates, n);
}
}

// This code is contributed by Prince Kumar