Java Array

Scanner
1
Scanner
• It is one of the utility class located in the
java.util package
• Using Scanner class, we can take inputs from the
keyboard
• Provides methods for scanning
– int
– float
– double
– line etc.
2
Scanner
3
Array
4
Array
s
• A group of variables containing values that all have
the same type
• Arrays are fixed‐length entities
• In Java, arrays are objects, so they are considered
reference types
• But the elements of an array can be either primitive
types or reference types
5
Array
• We
s
access the element of an array using
the following syntax
– name[index]
– “index” must be a nonnegative integer
• “index” can be int/byte/short/char but not
long
• In Java, every array knows its own length
• The length information is maintained in a public final
int member variable called length
6
Declaring and Creating Arrays
• int c[ ] = new int [12]
– Here, “c” is a reference to an integer array
– “c” is now pointing to an array object holding 12 integers
– Like other objects arrays are created using “new” and are
created in the heap
– “int c[ ]” represents both the data type and the variable
name.
Placing number here is a syntax error-
– int c[12]; // compiler error
7
• int[ ] c = new int [12]
– Here, the data type is more evident i.e. “int[ ]”
– But does the same work as
• int c[ ] = new int [12]
• Is there any difference between the above two
approaches?
8
int c[ ], x int[ ] c, x;
Here, ‘c’ is a reference to an Here, ‘c’ is a reference to an
integer array integer array (same as before)
‘x’ is just a normal integer But, now ‘x’ is also a reference

variable to an integer array
9
Using an Array Initializer
• We can also use an array initializer to create an array
– int n[ ] = {10, 20, 30, 40, 50}
• The length of the above array is 5
• n[0] is initialized to 10, n[1] is initialized to 20, and so
on
• The compiler automatically performs a “new”
operation taking the count information from the list
and initializes the elements properly
10
Arrays of Primitive Types
• When created by “new”, all the elements are
initialized with default values
– byte, short, char, int, long, float and double are initialized
to zero
– boolean is initialized to false
• This happens for both member arrays and local
arrays
11
Arrays of Reference Types
• String [] str = new String[3]
– Only 3 String references are created
– Those references are initialized to null by default
– Need to explicitly create and assign actual String objects in
the above three positions.
• str[0] = new String(“Hello”);
• str[1] = “World”;
• str[2] = “I” + “ Like” + “ Java”;
12
Example Program 1:
class Array {
public static void main(String args[]) {
int month_days[];
month_days = new int[12];
month_days[0] = 31;
month_days[1] = 28;
month_days[2] = 31;
month_days[3] = 30;
month_days[4] = 31;
month_days[5] = 30;
month_days[6] = 31;
month_days[7] = 31;
month_days[8] = 30;
month_days[9] = 31;
month_days[10] = 30;
month_days[11] = 31;
System.out.println("April has " + month_days[3] + " days.");
}
}
https://www.programiz.com/java-programming/online-compiler/
13
Sample Program 2:
import java.util.Scanner;
public class DynamicArrayInput {
public static void main(String[] args) {
// Create a Scanner object for reading input
Scanner sc = new Scanner(System.in);
// Ask the user for the size of the array
System.out.print("Enter the number of elements in the array: ");
int size = sc.nextInt();
// Declare an array of the specified size
int[] array = new int[size];
// Prompt the user to enter each element of the array
System.out.println("Enter " + size + " elements:");
for (int i = 0; i < size; i++) {
System.out.print("Element " + (i + 1) + ": ");
array[i] = sc.nextInt();
} 14
Cont.. // Display the entered array elements
System.out.println("The entered array elements are:");
for (int i = 0; i < size; i++) {
System.out.print(array[i] + " ");
}
// Close the Scanner
sc.close();
}}
OUTPUT
Enter the number of elements in the array: 5
Enter 5 elements:
Element 1: 10
Element 2: 20
Element 3: 30
Element 4: 40
Element 5: 50
The entered array elements are:
10 20 30 40 50 15
Passing Arrays to Methods
void modifyArray(double d[ ]) {…} double
[] temperature = new double[24];
modifyArray(temperature);
• Changes made to the elements of ‘d’ inside
“modifyArray” is visible and reflected in the
“temperature” array
• But inside “modifyArray” if we create a new array and
assign it to ‘d’ then ‘d’ will point to the newly created
array and changing its elements will have no effect on
“temperature”
16
Passing Arrays to Methods
• Changing the elements is visible, but changing the
array reference itself is not visible
void modifyArray(double d[ ]) {
d[0] = 1.1; // visible to the caller
}
void modifyArray(double d[ ]) {
d = new double [10];
d[0] = 1.1; // not visible to the
caller
}
17
Multidimensional Arrays
• Can be termed as array of arrays.
• int b[ ][ ] = new int[3][4];
– Length of first dimension = 3
• b.length equals 3
– Length of second dimension = 4
• b[0].length equals 4
• int[ ][ ] b = new int[3][4];
– Here, the data type is more evident i.e. “int[ ][ ]”
18
• Can be termed as array of arrays.
• int b[ ][ ] = new int[3][4];
– Length of first dimension = 3
• b.length equals 3
– Length of second dimension = 4
• b[0].length equals 4
• int[ ][ ] b = new int[3][4];
– Here, the data type is more evident i.e. “int[ ][ ]”
19
• int b[ ][ ] = { { 1, 2, 3 }, { 4, 5, 6 } };
– b.length equals 2
– b[0].length and b[1].length equals 3
• All these examples represent rectangular two
dimensional arrays where every row has same
number of columns
• Java also supports jagged array where rows can have
different number of columns
20
Example – 1 Array
int b[ ][ ];
b = new int[2][ ]; ‘b’
b[0] = new int[2];
b[1] = new int[3]; Col Col Col
b[0][2] = 7; //will throw an exception 0 1 2
Row
0
Example – 2
int b[ ][ ] = { { 1, 2 }, { 3, 4, 5 } }; Row
b[0][2] = 8; //will throw an exception 1
In both cases
b.length equals 2
b[0][2] does not exist
b[0].length equals 2
b[1].length equals 3
21
Jagged Array Sample Program
import java.util.Scanner;
public class JaggedArrayExample {

public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// Input the number of rows
System.out.print("Enter the number of rows: ");
int rows = scanner.nextInt();
// Declare the jagged array
int[][] jaggedArray = new int[rows][];
// Input the elements of the jagged array
for (int i = 0; i < rows; i++) {
System.out.print("Enter the number of elements in row " + i + ": ");
int columns = scanner.nextInt();
jaggedArray[i] = new int[columns];
for (int j = 0; j < columns; j++) {

System.out.print("Element at [" + i + "][" + j + "]: ");
jaggedArray[i][j] = scanner.nextInt();
}
}
22
// Display the jagged array
System.out.println("The jagged array is:");
for (int i = 0; i < jaggedArray.length; i++) {
for (int j = 0; j < jaggedArray[i].length; j++) {
System.out.print(jaggedArray[i][j] + " ");
}
System.out.println();
} scanner.close();
}
}
OUTPUT:
Enter the number of rows: 3
Enter the number of elements in row 0: 2
Element at [0][0]: 1
The jagged array is:
12
345 23
Command Line Arguments
24
Using Command‐Line Arguments
• java MyClass arg1 arg2 … argN
– words after the class name are treated as command‐line
arguments by Java
– Java creates a separate String object containing each
command‐line argument, places them in a String array and
supplies that array to main
– That’s why we have to have a String array parameter
(String args[ ]) in main
– We do not need a “argc” type parameter (for parameter
counting) as we can easily use “args.length” to determine
the number of parameters supplied.
25
Using Command‐Line Arguments
3
Hello
java CommandLineTest Hello 2 You
2
You
26
For-Each
27
For‐Each version of the for loop
28
JOptionPane
29
Static
30
Static Variables
• When a member (both methods and variables) is
declared static, it can be accessed before any objects
of its class are created, and without reference to any
object
• Static variable
– Instance variables declared as static are like global
variables
– When objects of its class are declared, no copy of a static
variable is made
31
Static Methods & Blocks
• Static method
– They can only call other static methods
– They must only access static data
– They cannot refer to this or super in any way
• Static block
– Initialize static variables.
– Get executed exactly once, when the class is first loaded
32
Static
33
Final
• Declare a final variable, prevents its contents from
being modified
• final variable must initialize when it is declared
• It is common coding convention to choose all
uppercase identifiers for final variables
final int FILE_NEW = 1;
final int FILE_OPEN = 2;
final int FILE_SAVE = 3;
final int FILE_SAVEAS = 4;
final int FILE_QUIT = 5;
34
Unsigned right shift operator
• The >> operator automatically fills the high‐order bit
with its previous contents each time a shift occurs
• This preserves the sign of the value
• But if you want to shift something that doesn’t
represent a numeric value, you may not want the
sign extension
• Java’s >>> shifts zeros into the high‐order bit
int a= ‐1; a = a >>>24;
11111111 11111111 11111111 11111111 [‐1]
00000000 00000000 00000000 11111111 [255]
35
Nested and Inner Classes
36
Nested Classes
• It is possible to define a class within another classes,
such classes are known as nested classes
• The scope of nested class is bounded by the scope of
its enclosing class. That means if class B is defined
within class A, then B doesn’t exists without A
• The nested class has access to the members
(including private!) of the class in which it is nested
• The enclosing class doesn’t have access to the
members of the nested class
37
Static Nested Classes
• Two types of nested classes.
– Static
– Non‐Static
• A static nested class is one which has the static
modifier applied. Because it is static, it must access
the members of its enclosing class through an object
• That is, it cannot refer to members of its enclosing
class directly. Because of this restriction, static
nested classes are seldom used
38
Static Nested Classes
39
Inner Classes
• The most important type of nested class is the inner
class
• An inner class is a non‐static nested class
• It has access to all of the variables and methods of its
outer class and may refer to them directly in the
same way that other non‐static members of the
outer class do
• Thus, an inner class is fully within the scope of its
enclosing class
40
Inner Classes
41
Inner Classes
42
Variable Arguments
43
Variable Arguments Ambiguity
44
Local Variable Type Inference
45
• Recently added to the Java language (Java 10)
– all variables must be declared prior to their use
– a variable can be initialized with a value when it is declared
– when a variable is initialized, the type of the initializer
must be the same as the declared type of the variable
• In principle, it would not be necessary to specify an
explicit type for an initialized variable
– it could be inferred by the type of its initializer
46
• Compiler infer the type of a local variable based on
the type of its initializer without explicit specification
• Advantages:
– Streamline code by eliminating the need to redundantly
specify a variable’s type when it can be inferred
– Simplify declarations when the type name is quite lengthy,
such as can be the case with some class names
– Helpful when a type is difficult to determine
– Its inclusion helps keep Java up-to-date with evolving
trends in language design
47
• The context-sensitive identifier var was added to Java
as a reserved type name
• To use local variable type inference, the variable
must be declared with var as the type name and it
must include an initializer
– double avg = 10.0; // type is explicitly specified
– var avg = 10.0; // type is inferred as double because
initializer (10.0) is of type double
• var can still be used as user-defined identifier
– int var = 1; // valid
48
• var cannot be used as the name of a class
• var can be used to declare an array type, but cannot
be used with an array initializer
– var myArray = new int[10]; // valid
– var myArray = { 1, 2, 3 }; // invalid
• var is not allowed as an element type of an array
– var[] myArray = new int[10]; // invalid
– var myArray[] = new int[10]; // invalid
49
• var can be used to declare a variable only when that
variable is initialized
– var counter; // invalid
• var cannot be used to declare a variable with null as
the initializer
• var can be used only to declare local variables, it
cannot be used when declaring instance variables,
parameters, or return types
• var can be used in a for/for-each loop when declaring
and initializing the loop control/iteration variable
50
• Local variable type inference can also be used with
reference types
– var str = “This is a string”;
– Type inference is primarily used with reference types
• Local variable type inference is especially effective in
shortening declarations that involve long class names
• Local variable type inference can also be used with
user-defined classes
– var mc = new MyClass();
51

Java Array

Uploaded by

Java Array

Uploaded by

Scanner

‘x’ is just a normal integer But, now ‘x’ is also a reference

public class JaggedArrayExample {

for (int j = 0; j < columns; j++) {

You might also like