Scribd
Upload
174 views10 pages

CRUD Operations Implementation in Java

Crud operations in Java

Uploaded by

patansayyada
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
174 views10 pages

CRUD Operations Implementation in Java

Crud operations in Java

Uploaded by

patansayyada
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd

What are CRUD Operations in Java?

In this article, we are going to learn about the CRUD operations in Java with
implementation. CRUD is an acronym for the four
operations Create, Read, Update and Delete. The four CRUD operations can
be called by users to perform different types of operations on selected data within
the database. This could be accomplished on the command line or through a
graphical user interface. Let’s review each of the four components in-depth with
implementation in Java.

Create in CRUD Operations


The Create function allows users to create a new record in the database. In
the SQL relational database application, the Create function is
called INSERT. For example, in a restaurant, the details of the menu are stored
with the attributes, such as dish, cooking time, and price. If the chef decides to add a
new dish to the menu, a new record will be created in the database.
Read or Retrieve in CRUD Operations
The Read function is similar to a SEARCH function. It allows users to search
and retrieve specific records in the table and read their values. For example, in
the restaurant, from the menu stored the staff wants to look for the price of a dish.
Then he/she might retrieve and look for the price of the dish from the stored data.
Update in CRUD Operations
The Update function is used to modify existing records that exist in the
database. Users may have to modify information in multiple fields to fully change a
record. For example, in a restaurant, the manager decides to replace the price of a
dish. As a result, the existing record in the database must be changed.
Delete in CRUD Operations
The Delete function allows users to remove records from a database that are no
longer needed. For example, in a restaurant, the manager decides to delete a dish
permanently from the data. As a result, the existing record in the database will be
deleted.
To know more about what are crud operations in a database, click here.
Applications of CRUD Operations in Java
CRUD operations in Java are widely used in many applications supported by
relational databases. CRUD is used to describe user interface conventions that
allow to view, search, and change information. Most applications we use let us add
or create new entries, search for existing ones, make changes to them or delete
them. A very common application of the CRUD operations is the Contact list in
Smartphones.
 Filling up the Sign-UP form on any website is a CREATE operation of CRUD
 Checking bank balances is an example of the READ operation in CRUD.
 Whenever you make transactions in the bank, your balance gets updated which is an
example of an UPDATE operation in CRUD.
 Deleting a contact from your contact list is an example of the DELETE operation of
CRUD.

Example of CRUD operations


Let’s look at an example of how CRUD is implemented. When a new employee is
hired, the HR department creates a record for the employee. If the company
needs to send a letter to one or more employees, the read function might be used
to find the correct mailing address for the employee. If an employee’s salary or
contact information changes, the HR department may need to update the existing
record of the employee. If an employee leaves the company, the company may
choose to delete their information in the database.
Implementation of CRUD operations in Java
To start with the implementation part, we have to create a class crudOperation.
Then create a list Employee to store the information about the employee.

// Implementation of CRUD operations in Java

class crudOperation {

public static void main(String args[]) {

List < Employee > c = new ArrayList < Employee > ();

Scanner s = new Scanner([Link]);

Scanner s1 = new Scanner([Link]);

int ch;

do {

[Link]("[Link]");

[Link]("[Link]");

[Link]("[Link]");
[Link]("[Link]");

[Link]("[Link]");

[Link]("Enter your choice : ");

ch = [Link]();

Insert in CRUD operations in Java


For implementing the INSERT operation, get the Employee details from the user
such as Employee no, Employee name, and Employee Salary. Once the user gives
the details, insert the details to the Employee list using add function in the
Collections.

switch (ch) {//Insert Operation

case 1:

[Link]("Enter Empno : ");

int eno = [Link]();

[Link]("Enter Empname : ");

String ename = [Link]();

[Link]("Enter Salary : ");

int salary = [Link]();

[Link](new Employee(eno, ename, salary));

[Link]("---------------------");

[Link]("Record Inserted Sucessfully");

[Link]("---------------------");

break;

Output for Insert Operation:


Display in CRUD operations in Java
To display the Employee details we have to iterate through the details of the
employee stored in the list. For this operation, we are using Iterator in Collections.

//Display Operation

case 2:

[Link]("---------------------");

Iterator < Employee > i = [Link]();

while ([Link]()) {

Employee e = [Link]();

[Link](e);

[Link]("---------------------");

break;

Read in CRUD operations in Java


For Search or Read Operation, we use the same iterator object and traverse
through each record to find the details we want. After finding the details we require it
is displayed in the output console to the user.

//Search Operation

case 3:

boolean found = false;

[Link]("Enter Empno to Search : ");


int empno = [Link]();

[Link]("---------------------");

i = [Link]();

while ([Link]()) {

Employee e = [Link]();

if ([Link]() == empno) {

[Link](e);

found = true;

if (!found) {

[Link]("Record Not Found");

[Link]("---------------------");

break;

Here is the complete code to execute the CRUD operations in Java.

import [Link].*;

class Employee {

private int empno;

private String ename;

private int salary;

Employee(int empno, String ename, int salary) {

[Link] = empno;

[Link] = ename;
[Link] = salary;

public int getEmpno() {

return empno;

public int getSalary() {

return salary;

public String getEname() {

return ename;

public String toString() {

return empno + " " + ename + " " + salary;

class crudOperation {

public static void main(String args[]) {

List < Employee > c = new ArrayList < Employee > ();

Scanner s = new Scanner([Link]);

Scanner s1 = new Scanner([Link]);

int ch;

do {

[Link]("[Link]");

[Link]("[Link]");

[Link]("[Link]");
[Link]("[Link]");

[Link]("[Link]");

[Link]("Enter your choice : ");

ch = [Link]();

switch (ch) {

//Insert Operation

case 1:

[Link]("Enter Empno : ");

int eno = [Link]();

[Link]("Enter Empname : ");

String ename = [Link]();

[Link]("Enter Salary : ");

int salary = [Link]();

[Link](new Employee(eno, ename, salary));

[Link]("---------------------");

[Link]("Record Inserted Sucessfully");

[Link]("---------------------");

break;

//Display Operation

case 2:

[Link]("---------------------");

Iterator < Employee > i = [Link]();

while ([Link]()) {

Employee e = [Link]();

[Link](e);
}

[Link]("---------------------");

break;

//Search Opeartion

case 3:

boolean found = false;

[Link]("Enter Empno to Search : ");

int empno = [Link]();

[Link]("---------------------");

i = [Link]();

while ([Link]()) {

Employee e = [Link]();

if ([Link]() == empno) {

[Link](e);

found = true;

if (!found) {

[Link]("Record Not Found");

[Link]("---------------------");

break;

//Delete Operation

case 4:

found = false;
[Link]("Enter Empno to Delete : ");

empno = [Link]();

[Link]("---------------------");

i = [Link]();

while ([Link]()) {

Employee e = [Link]();

if ([Link]() == empno) {

[Link]();

found = true;

if (!found) {

[Link]("Record Not Found");

} else {

[Link]("Record is Deleted Sucessfully");

[Link]("---------------------");

break;

//Update Opeartion

case 5:

found = false;

[Link]("Enter Empno to Update : ");

empno = [Link]();

ListIterator < Employee > li = [Link]();

while ([Link]()) {
Employee e = [Link]();

if ([Link]() == empno) {

[Link]("Enter new Name : ");

ename = [Link]();

[Link]("Enter new Salary : ");

salary = [Link]();

[Link](new Employee(empno, ename, salary));

found = true;

[Link]("---------------------");

if (!found) {

[Link]("Record Not Found");

else {

[Link]("Record is Updated Sucessfully");

[Link]("---------------------");

break;

while (ch != 0);} }

Common questions

Powered by AI

CRUD operations exemplify data flow and management by providing foundational operations for data handling within applications. They represent how data is created, accessed, modified, and deleted, forming the backbone for interactions in applications such as contact lists, banking systems, and enterprise resource planning. This structured approach supports data integrity and consistency across various levels of application functionality.

Collections in Java manage CRUD operations efficiently due to their dynamic nature and robust APIs that support the addition, access, update, and removal of elements across data structures. They provide coherent methodologies through interfaces like List and Iterator, making it simple to implement CRUD functionality such as inserting employees, retrieving information, or updating records seamlessly. Their ability to scale with demand and use diverse data structures caters to varied CRUD requirements.

Implementing a 'Search' operation in Java involves using an Iterator to traverse a list of records, checking each record against a search criterion (like employee number) for a match, and fetching details once found. This ensures data retrieval accuracy by sequentially comparing all entries, leading to precise and efficient search outputs that mirror user enquiries.

The 'Read' function is vital for retrieving and displaying specified records. In Java, 'Read' operations utilize iterators to traverse through a collection of records. For instance, searching for an employee number in a database involves iterating over a list to find and print the matching employee's details. This function provides essential data visibility and accessibility in software applications.

Understanding CRUD operations provides insight into fundamental software development practices by establishing core principles for data management. They are essential for interacting with databases, encompassing a lifecycle of data handling that supports application functionalities. Grasping these operations enhances comprehension of relational database operations, enabling developers to build applications that manage data efficiently, perform transactions smoothly, and maintain data integrity.

The 'Update' function is crucial for maintaining relevant and current data integrity within a database. It allows modifications to existing records, such as altering a dish price in a restaurant database, or updating employee salaries and contact information in a company. This reflection ensures systems remain accurate and functional, mirroring everyday tasks where information continuously evolves.

The 'Delete' operation allows for the removal of records from a database that are no longer needed, thereby freeing up storage and maintaining a clean and efficient database. In Java, this is achieved by iterating over the records and using a remove method on the iterator upon finding the specific record. Its implication on data management is significant, as it involves decisions regarding data retention and record lifecycle.

CRUD operations in software reflect real-world processes such as adding new entries to a system, reading data, updating existing records, and deleting outdated information. For example, filling out a signup form online corresponds to creating a record, checking a bank balance is reading, updating a contact detail is akin to an update, and removing a contact is a delete operation.

In Java, the CREATE operation is implemented through an 'INSERT' function where user input is collected for attributes such as Employee number, name, and salary. This information is then added to a list of Employee objects using the 'add' method of the Java Collection framework.

Potential pitfalls in implementing the CRUD Delete operation include accidentally removing crucial records if criteria aren't valid or misappropriating removal logic. This can significantly impact data integrity, leading to data loss and inconsistencies within the system. Correct implementation requires robust validation and safeguard mechanisms to ensure only intended records are deleted and that the procedure doesn't affect related data structures.

You might also like