Fixed-Size Reference Data Types

Java also has non-primitive data types, which are called reference types. These include:

  1. Arrays: A collection of elements of the same type.
  2. Classes: User-defined data types that can have fields, methods, and constructors.
  3. Interfaces: Similar to classes but with only method signatures and no implementation.
  4. Enums: A special type that defines a set of constants.
  5. Strings: A sequence of characters.

Reference types store references (memory addresses) to objects rather than the objects themselves. This allows Java to manage memory more efficiently and handle complex data structures.

Arrays

  • An array is a collection of elements of the same type stored in contiguous memory locations.

  • Arrays in Java are fixed in size, meaning the number of elements in an array is determined when the array is created and cannot be changed.

  • Arrays are indexed starting from 0. The index represents the position of an element in the array.

  • To access an element in an array, you use the index enclosed in square brackets after the array name (e.g., arr[0]).

An example of creating and accessing elements in an array:

int[] arr = new int[5]; // Create an array of 5 integers
arr[0] = 10; // Assign 10 to the first element
arr[1] = 20; // Assign 20 to the second element
System.out.println(arr[0]); // Output: 10
System.out.println(arr[1]); // Output: 20

Note that arrays are different from Python lists, which can grow or shrink dynamically and don’t need to have length specified at the time of creation. Also, Python lists can contain elements of different types, while Java arrays are homogeneous (contain elements of the same type).

To modify the values of an array, you can assign new values to individual elements using their indices.

To access subarrays or slices of an array, you can use the Arrays.copyOfRange() method or loop through the array and copy elements to a new array.

An array is a fixed-size collection of elements of the same type stored in contiguous memory locations. Arrays in Java are indexed starting from 0, and the index represents the position of an element in the array. The size of an array is determined when the array is created and cannot be changed.

Declaring and Initializing Arrays

To declare an array in Java, you specify the type of elements the array will hold, followed by square brackets [] and the array name. You can initialize the array with values using an array initializer enclosed in curly braces {}.

Here is an example of declaring and initializing an array of integers:

// Declare and initialize an array of integers
int[] numbers = {10, 20, 30, 40, 50};

In the above example, we declared an array numbers of integers and initialized it with five elements.

Accessing Array Elements

You can access elements in an array using the index enclosed in square brackets [] after the array name. The index starts from 0 for the first element and increments by 1 for each subsequent element.

Here is an example of accessing elements in an array:

int[] numbers = {10, 20, 30, 40, 50};

// Access the first element
int firstElement = numbers[0]; // firstElement = 10

// Access the third element
int thirdElement = numbers[2]; // thirdElement = 30

Array Length

You can get the length of an array using the length property of the array. The length property returns the number of elements in the array.

Here is an example of getting the length of an array:

int[] numbers = {10, 20, 30, 40, 50};

// Get the length of the array
int length = numbers.length; // length = 5

Iterating Over Arrays

You can iterate over the elements of an array using a loop, such as a for loop or a foreach loop. By iterating over the array, you can access and process each element in the array.

Here is an example of iterating over an array using a for loop:


int[] numbers = {10, 20, 30, 40, 50};

// Iterate over the array using a for loop

for (int i = 0; i < numbers.length; i++) {
    System.out.println(numbers[i]); // Output each element
}

In the above example, we used a for loop to iterate over the numbers array and print each element to the console.

Strings

In Java, strings are objects of the String class that represent sequences of characters. Strings in Java are immutable, meaning their values cannot be changed once they are created. Java provides a rich set of methods for working with strings, such as concatenation, substring extraction, searching, and more.

Strings are part of the Java standard library and do not need to be imported explicitly. You can create strings using string literals or the String class constructor.

Creating Strings

You can create strings in Java using string literals or the String class constructor

Here is an example of creating strings:

// Using string literals
String str1 = "Hello, World!";
String str2 = "Java Programming";

// Using the String class constructor
String str3 = new String("Welcome to Java!");

In the above example, we created strings using string literals and the String class constructor.

Read String Length

You can get the length of a string using the length() method of the String class. The length() method returns the number of characters in the string.

Here is an example of getting the length of a string:

String str = "Hello, World!";
int length = str.length(); // length = 13

Accessing Characters

In order to read an individual character from a string, you can use the charAt() method. The charAt() method returns the character at a specified index in the string.

Here is an example of accessing characters in a string:

String str = "Java Programming";
char firstChar = str.charAt(0); // firstChar = 'J'
char lastChar = str.charAt(str.length() - 1); // lastChar = 'g'

Substring Extraction

You can extract a substring from a string using the substring() method. The substring() method takes the starting index and optionally the ending index of the substring to be extracted.

Here is an example of extracting a substring from a string:

String str = "Hello, World!";
String subStr = str.substring(7); // subStr = "World!"

String Concatenation

You can concatenate strings in Java using the + operator or the concat() method of the String class.

Here is an example of concatenating strings:

String str1 = "Hello, ";
String str2 = "World!";
String result = str1 + str2; // result = "Hello, World!"

String Comparison

You can compare strings in Java using the equals() method or the compareTo() method of the String class. The equals() method checks if two strings have the same content, while the compareTo() method compares two strings lexicographically.

Here is an example of comparing strings:

String str1 = "Hello";
String str2 = "Hello";
boolean isEqual = str1.equals(str2); // isEqual = true
int result = str1.compareTo("World"); // result = -15

Converting to Numeric Types

You can convert strings to numeric types such as integers and doubles using the parseInt() and parseDouble() methods of the Integer and Double classes, respectively.

Here is an example of converting a string to an integer:

String str = "123";
int number = Integer.parseInt(str); // number = 123

In the above example, we converted the string "123" to an integer using the parseInt() method of the Integer class.

String Formatting

You can format strings in Java using the String.format() method, which allows you to create formatted strings with placeholders for variables.

Here is an example of formatting a string:

String name = "Alice";
int age = 30;
String message = String.format("Hello, %s! You are %d years old.", name, age);
// message = "Hello, Alice! You are 30 years old."

Enums

An enum in Java is a special data type that defines a set of constants. Enums are used to represent fixed values that are known at compile time. Enum constants are implicitly static and final, meaning they cannot be changed once they are defined.

Enums are defined using the enum keyword, followed by the enum name and a list of constants enclosed in curly braces {}. Each constant is separated by a comma.

Here is an example of defining an enum:

enum Day {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

In the above example, we defined an enum Day with constants representing the days of the week.

Enums can have fields, constructors, and methods like classes. You can also define custom fields and methods for each enum constant.

Here is an example of an enum with custom fields and methods:


enum Day {
    MONDAY("Monday", 1),
    TUESDAY("Tuesday", 2),
    WEDNESDAY("Wednesday", 3),
    THURSDAY("Thursday", 4),
    FRIDAY("Friday", 5),
    SATURDAY("Saturday", 6),
    SUNDAY("Sunday", 7);

    private final String name;
    private final int value;

    Day(String name, int value) {
        this.name = name;
        this.value = value;
    }

    public String getName() {
        return name;
    }

    public int getValue() {
        return value;
    }
}

In the above example, we defined an enum Day with custom fields name and value for each constant. We also defined a constructor to initialize the fields and methods to access the fields.

Enums are useful for representing a fixed set of values and can improve code readability and maintainability by providing meaningful names for constants.