Pros and Cons of Arrays in Java

Ben L — Tue, 20 Feb 2024 14:29:17 +0000

Arrays are a fundamental data structure in Java, and they provide a convenient way to store and manage elements.

While arrays are useful, they also have disadvantages. Here's a breakdown of the pros and cons of using arrays in Java.

Pros of Arrays

Speedy Element Access: Arrays allow for quick access to any element. This is because elements in an array are stored in contiguous memory locations, enabling direct access via each element's index.
Versatile Storage: An array can store various types of data, including strings, primitive data types (like int), and objects from any class you create.
Built-in Java Support: Being a core part of the Java language, arrays do not require imports to be used. This built-in support simplifies coding and reduces the need for external dependencies.

Cons of Arrays

Despite their advantages, arrays have certain drawbacks that can limit their usefulness in many scenarios.

Fixed Size: Perhaps the most significant limitation of arrays is their fixed size. Once an array is created, its size cannot be altered. If you need to store more elements than the array can hold, you'll need to create a new, larger array and copy the elements from the old array to the new one, which can be an inefficient way to handle your program.
Inefficient Resizing: Related to the fixed size issue, resizing an array to accommodate more elements or to shrink its size is cumbersome and resource-intensive. This resizing process involves creating a new array and manually copying elements, which can be time-consuming and waste resources.
Wasted Memory Space: If an array is allocated more space than it needs, it can lead to inefficient use of memory. This is particularly problematic when memory usage is a critical concern.
Difficulty in Removing Elements: Arrays do not provide a straightforward way to remove elements. To delete an element from the middle of an array, you typically have to shift all subsequent elements one position to the left.

Using == vs the equals() Method in Java

Ben L — Tue, 20 Feb 2024 14:05:53 +0000

The == operator is used to compare the identities of reference data types (not the contents of primitive data types).

It basically checks if the references point to the same object. Even if the actual values in those two objects are identical, it will return a false value if they are separate objects.

Using the Equals() Method

If you want to compare the contents of reference data types, then you should use the Equals() method, which is available via the Object class, although must override it in the classes you create.

For example, let’s say we would like to compare two student IDs to check if they are the same. We can use the equals() method.

Here’s a walkthrough:

Let’s say we created a studentID in the class Student:

private int studentID;

Now, we want to create a method to compare two student IDs.

To start with, you have to declare the method and pass an Object as the parameter:

public boolean equals(Object obj);

The next line will use the == operator, already discussed, to check if the objects we will be comparing are the same object in the memory. If they are, there will be no more need to continue with the code.

if (this == obj) return true;

If they are not the same object, we must check if the Object passed as a parameter is of the class Student so we can compare the IDs:

if (obj instanceof Student){

If it is, we can proceed with casting the object as a Student object, after which we can compare it:

Student a = (Student) obj;

Now we can compare the values of current student ID and that belonging to the Object typecast to a Student object “a”:

return studentID == a.studentID;

Remember to include an else block, which specifies that if the passed object was not an object of the class Student, we simply call the equals() method of the superclass:

else{
return super.equals(obj)
}

Let’s see the entire code again:

@Override
public boolean equals(Object obj){
if (this == obj) return true;
if (obj instanceof Student){
Student a == (Student) obj;
return studentID = a.studentID;
}
else{
return super.equals(obj)
}
}
_

DEV Community: Ben L

Pros and Cons of Arrays in Java

Pros of Arrays

Cons of Arrays

Using == vs the equals() Method in Java