Theoretical Java Array Questions and Answers
1.Q. What is an Array in Java?
Ans: An Array in Java is a container object which is dynamically allocated that holds a fixed number of values of a single data type in contiguous memory locations. Array allows you to store multiple elements either primitive type like int or object references like String under a single variable name instead of declaring separate variables for each value.
Key Characteristics of Array are:
- Fixed Size: The length of an array must be specified when it is created and cannot be changed at runtime.
- Zero-Indexed: In Array the first element is always accessed at index 0 and the last element is at index (length-1).
- Homogeneous: Array can store only elements of the same data type.
- Object Behavior: In Java, arrays are considered as objects, which means they are stored in heap memory and have built in properties like .length.
2.Q. Why do java arrays use 0-based indexing?
Ans: In java , Arrays use 0-based indexing because the index acts as a memory offset rather than a counting number which makes address calculations simple and efficient.
The math behind Memory location in Arrays:
Target Address= Base Address+(Index*Element Size)
If you want to access the very first element , it sits exactly at the base address. Therefore, it is 0 elements away from the start.
First Element: Base Address+(0*Element Size)=Base Address
Second Element: Base Address+(1*Element size)
The main advantages of zero-based indexing are :
- Hardware Efficiency : If indexing started at 1 , the computer would have to calculate Base Adress+(Index-1)*(Element size). which would have force a subtraction operation (-1) for every single array access and it would have waste millions of CPU cycles over time.
- Pointer Arithmetic : In lower-level languages like C, writing array[i] is equivalent to writing *(array+i) . A 0-index aligns perfectly with how hardware points natively work.
- Historical Legacy: Early programming languages like BCPL and B used 0-based indexing to optimize compiler speeds on old mainframe hardware. After that, popular language C adopted this design and almost every modern programming languages(like Java, Python, JavaScript, C++) followed this convention to remain familiar to developers.
3.Q. What is the time complexity of accessing an element in an Array?
Ans: In an Array, accesing an element by a known index is highly efficient, while finding an array element when you don’t know its index is less efficient.
Time Complexity Of an Element while accessing by index : O(1)
Time Complexity Of an Element while Search by value : O(n)
Time Complexity Of an Array Element while inserting and deleting at the end : O(1)
The Time Complexity of an array element while inserting/deleting element at the beginning/middle : O(n) due to shifting of elements.
4.Q. How do you declare an Array?
Ans: In Java, You can declare an array by specifying the data type followed by square brackets [ ] and the array name with size.
data_type array-name[array_size];
int arr[6];
5.Q. Is it possible to declare an Array without specifying its size?
Ans: Yes, an array can be declared without specifying its size if it is initialized at the time of declaration. The Java compiler automatically determines the array size based on the number of elements present in the array.
6.Q. What are the default values of array elements when initialized without data?
Ans : When array is declared without data using new keyword (e.g., int arr[] = new int[6] ), Java automatically consider it with default values based on the data type.
The default values based on the data type are as follows:
- int, byte , short , long : 0
- float , double : 0.0
- boolean : false
- char : \u0000
- Object references : null
7. Q. What is the difference between an Array and an ArrayList in Java?
Ans: The difference between Array and ArrayList are as follows:
| Feature | Java Array | Java ArrayList |
|---|---|---|
| Size | The size of the array is always fixed which cannot be changed after creation. | ArrayList is dynamic in size which grows automatically. |
| Data Types | Array holds both primitive data types and objects. | ArrayList holds only objects |
| Performance | Array is faster in access and less memory overhead. | ArrayList is slightly slower due to resizing and boxing/unboxing |
| Length Query | Array uses .length property | ArrayList uses the .size() method |
| Generics | Array doesn’t support generics | ArrayList supports generics for type safety. |
8.Q. Where are arrays stored in Java memory and what does the array variable hold?
Ans: In Java, Arrays are considered as objects which means they are always allocated in the heap memory.
The Array variable is a local variable stored on the stack which doesnot hold the actual values ; instead it holds a reference (memory address) pointing to the array object on the heap.
9.Q. Why are arrays stored in contiguous memory?
Ans: Arrays are stored in contiguous memory locations basically due to enable O(1) constant-time random access and to maximize CPU cache efficiency through spatial locality.
- Instant Mathematical Address Calculation
- Improves CPU Cache performance.
- Faster travel due to spatial locality.
- Lower Memory Overhead
10.Q. What is a Multi-dimensional Array?
Ans: A multi-dimensional array is an array with more than one dimension. It is an array of arrays , which store data in a grid , table or multi-layered structure instead of a single straight line. In real world, multi-dimensional array is used in doing algebra,math calculations , in storing digital pictures made of pixels with color values etc.
Syntax:
data_type [dim1][dim2][dim3]…..[dimN] array_name= new data_type[size1][size2]….[sizeN];
Parameters:
- data_type: Type of elements to be stored in the array
- dim : Number of Dimension such as 1D , 2D ,3D etc
- array_name: Identifier for the array
- size1,sizeN: Size of each dimension
Examples:
//Two dimensional array:
int[][] arr2d=new int[4][5];
//Three dimensional array:
int[][][] arr3d=new int[3][6][8];
11.Q. What happens when an array is accessed out of bounds?
Ans: When an array is accessed out of bounds or outside its valid index range, results in invalid or undefined behavior, depending on the programming language. This can lead to runtime errors , unexpected program behavior or exceptions .
- In Java, accessing an invalid index throws an ArrayIndexOutOfBoundsException.
- In languages like C and C++, out of bounds access results in undefined behavior, which may produce incorrect values or cause the program to crash.
12.Q. What is Jagged Array?
Ans: In Java, a Jagged Array is a multi-dimendional array where each row can have a different number of columns .
- Each row in jagged array can have different number of elements.
- Jagged array is useful in representing irregular or uneven data.
- Jagged array helps reduce memory usage when row sizes vary.
Syntax: dataType[ ][ ] arrayName=new dataType[numberOfRows][ ] ;
arrayName[0]=new dataType[columnsForRow0];
arrayName[1]=new dataType[columnsForRow1];
Example:
int[ ] [ ] jagged=new int[3][ ];
jagged[0]=new int[2]; //Row 0 has 2 columns
jagged[1]=new int[5]; //Row 1 has 5 columns.
jagged[2]=new int[3]; //Row 2 has 3 columns
13.Q. What are the advantages and disadvantages of Arrays?
Ans: Advantages of Arrays are:
- Accessing is fast: One can find any element instantly using its index number with O(1) time complexity.
- Good Memory use: Elements in array are sit next to each other in memory, which helps the CPU to load them faster.
- Low extra space: Array requires low extra space as arrays do not need extra room for pointers or links between items.
- Simple Design : Arrays are easy to set up and use in almost every programming language.
Disadvantages of Array :
- Fixed size : Array size is fixed, one must choose the size when you create the array , and it cannot be changed later.
- Slow Adding and removal of elements : Inserting and deleting elements in the middle of the array forces to shift all neighboring items over, which takes extra time.
- Array allows same type only : Array can store elements of one single data type in a single array.
- Space wasted: If you set the array larger than needed, extra unused space remains wasted.
14.Q. What is the difference between an array and Linked List ?
Ans :
| Feature | Array | Linked List |
|---|---|---|
| Memory Allocation | Contiguous blocks | Memory allocation of Linked list occurs in scattered nodes. |
| Size flexibility | Fixed Size | Dynamically shrinks or grows |
| Allocation Timing | Compile time(static) | Runtime(Dynamic) |
| Access time | Fast O(1) via index | Slow O(n) as sequential search |
| Memory efficiency | Low overhead ; risk of wasted space | High overhead due to pointer storage. |
| Insert/Delete | Slow O(n) due to shifting of elements | Fast O(1) at known positions |
| Cache Performance | Excellent(highly optimal for CPU cache) | Poor(frequent cache misses) |
15.Q. What is sparse array?
Ans: Sparse array or sparse matrix is a data structure where the majority of the elements are empty , zero or null . In sparse array, instead of allocating memory to store every single index sequentially ,they are optimized to only record the values of the data that actually exists and the coordinates. The opposite of sparse array is called dense array where almost every slot is packed with active data.
Pingback: Java Arrays - learncodingforfree.com