The document discusses arrays and their features in Java. It explains that arrays can hold primitives or references, and are the most efficient way to store sequences of objects. The key array operations covered are traversing, searching, inserting, deleting, sorting, and merging. It also discusses how to compare, copy, and clone arrays using methods like equals(), toString(), copyOf(), arraycopy(), and clone().

1. Data Structure Lecture 2
Following operations can be performed on the data structures:
1. Traversing
2. Searching
3. Inserting
4. Deleting
5. Sorting
6. Merging
1. Traversing- It is used to access each data item exactly once so
that it can be processed.
2. Searching- It is used to find out the location of the data item if it
exists in the given collection of data items.
3. Inserting- It is used to add a new data item in the given
collection of data items.
4. Deleting- It is used to delete an existing data item from the given
collection of data items.
5. Sorting- It is used to arrange the data items in some order i.e. in
ascending or descending order in case of numerical data and in
dictionary order in case of alphanumeric data.
6. Merging- It is used to combine the data items of two sorted files
into single file in the sorted form.
1

2. Array Data Structure
Introduction
An array is an aggregate data structure that is designed to store a
group of objects of the same or different types. Arrays can hold
primitives as well as references. The array is the most efficient data
structure for storing and accessing a sequence of objects.
Here is the list of most important array features you must know
(i.e. be able to program)
• copying and cloning
• insertion and deletion
• searching and sorting
You already know that the Java language has only two data types,
primitives and references. Which one is an array? Is it primitive?
An array is not a primitive data type - it has a field (and only one),
called length. Formally speaking, an array is a reference type,
though you cannot find such a class in the Java APIs. Therefore,
you deal with arrays as you deal with references. One of the major
diffeences between refeences and primituives is that you cannot
copy arrays by assigning one to another:
int[] a = {9, 5, 4};
int[] b = a;
The assignment operator creates an alias to the object, like in the
picture below
2

3. Since these two references a and b refer to the same object,
comparing them with the double equal sign "==" will always return
true. In the next code example,
int [] a = {1,2,3};
int [] b = {1,2,3};
a and b refer to two different objects (though with identical
contents). Comparing them with the double equal sign will return
false. How would you compare two objects with identical
contents? In short, using the equals method. For array
comparison, the Java APIs provides the Arrays class.
The Arrays class
The java.util.Arrays class is a convenience class for various array
manipulations, like comparison, searching, printing, sorting and
others. Basically, this class is a set of static methods that are all
useful for working with arrays. The code below demonstrates a
proper invocation ofequals:
int[] a = {1,2,3};
int[] b = {1,2,3};
if( Arrays.equals(a, b) )
System.out.println("arrays with
identical contents");
3

4. Another commonly used method is toString() which takes
care of of printing
int[] a = {1,2,3};
System.out.println(Arrays.toString(a));
Here is the example of sorting
int[] a = {3,2,1};
Arrays.sort(a);
System.out.println(Arrays.toString(a));
In addition to that, the class has other utility methods for
supporting operations over multidimensional arrays.
Copying arrays
There are four ways to copy arrays
1. using a loop structure
2. using Arrays.copyOf()
3. using System.arraycopy()
4. using clone()
The first way is very well known to you
int[] a = {1, 2, 3};
int[] b = new int[a.length];
for(int i = 0; i ‹ a.length; i++) b[i] =
a[i];
The next choice is to use Arrays.copyOf()
int[] a = {1, 2, 3};
int[] b = Arrays.copyOf(a, a.length);
4

5. The second parameter specifies the length of the new array, which
could either less or equal or bigger than the original length.
The most efficient copying data between arrays is provided
by System.arraycopy() method. The method requires five arguments.
Here is its signature
public static void arraycopy(Object source,
int srcIndex,
Object
destination,
int destIndex,
int length)
The method copies length elements from a source array
starting with the index srcIndex to a new
array destination at the indexdestIndex.The above code
example can be rewritten as it follows
int[] a = {1, 2, 3};
int[] b = new int[a.length];
System.arraycopy(a, 0, b, 0, 3)
And the last copying choice is the use of cloning. Cloning involves
creating a new array of the same size and type and copying all the
old elements into the new array. The clone() method is defined
in the Object class and its invocation is demonstrated by this
code segment
int[] a = {1, 2, 3};
int[] b = (int[]) a.clone();
5

6. The second parameter specifies the length of the new array, which
could either less or equal or bigger than the original length.
The most efficient copying data between arrays is provided
by System.arraycopy() method. The method requires five arguments.
Here is its signature
public static void arraycopy(Object source,
int srcIndex,
Object
destination,
int destIndex,
int length)
The method copies length elements from a source array
starting with the index srcIndex to a new
array destination at the indexdestIndex.The above code
example can be rewritten as it follows
int[] a = {1, 2, 3};
int[] b = new int[a.length];
System.arraycopy(a, 0, b, 0, 3)
And the last copying choice is the use of cloning. Cloning involves
creating a new array of the same size and type and copying all the
old elements into the new array. The clone() method is defined
in the Object class and its invocation is demonstrated by this
code segment
int[] a = {1, 2, 3};
int[] b = (int[]) a.clone();
5