public class ArrayExample {
public static void main(String[] args) {
// Declare and initialize an array
int[] numbers = new int[5]; // Array of 5 integers
// Initializing array elements
numbers[0] = 10;
numbers[1] = 20;
numbers[2] = 30;
numbers[3] = 40;
numbers[4] = 50;
// Accessing and printing array elements
System.out.println("Element at index 0: " + numbers[0]);
System.out.println("Element at index 1: " + numbers[1]);
System.out.println("Element at index 2: " + numbers[2]);
System.out.println("Element at index 3: " + numbers[3]);
System.out.println("Element at index 4: " + numbers[4]);
// Using enhanced for loop to access all elements
System.out.println("\nArray elements using enhanced for loop:");
for (int num : numbers) {
System.out.println(num);
}
}
}
int[] numbers = new int[5]; declares an array of integers with 5 elements.numbers[0] = 10;).numbers[0] for the first element).for (int num : numbers)) is used to iterate through and print the array’s elements.
public class BubbleSortExample {
public static void main(String[] args) {
int[] arr = {64, 34, 25, 12, 22, 11, 90}; // Unsorted array
int n = arr.length;
// Bubble Sort Algorithm
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
// Swap the elements
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
// Display the sorted array
System.out.println("Sorted array:");
for (int num : arr) {
System.out.print(num + " ");
}
}
}
n-1 times, where n is the length of the array.
public class BubbleSortExample {
public static void main(String[] args) {
int[] arr = {64, 34, 25, 12, 22, 11, 90}; // Unsorted array
int n = arr.length;
// Bubble Sort Algorithm
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
// Swap the elements
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
// Display the sorted array
System.out.println("Sorted array:");
for (int num : arr) {
System.out.print(num + " ");
}
}
}
n-1 times, where n is the length of the array.In Java, you can create arrays where each row can have a different number of columns. These are called jagged arrays.
public class JaggedArrayExample {
public static void main(String[] args) {
// Declaration of a jagged array (array of arrays)
int[][] jaggedArray = new int[3][];
// Initializing each row with different lengths
jaggedArray[0] = new int[2]; // Row 0 has 2 elements
jaggedArray[1] = new int[4]; // Row 1 has 4 elements
jaggedArray[2] = new int[3]; // Row 2 has 3 elements
// Assigning values to the jagged array
jaggedArray[0][0] = 1;
jaggedArray[0][1] = 2;
jaggedArray[1][0] = 3;
jaggedArray[1][1] = 4;
jaggedArray[1][2] = 5;
jaggedArray[1][3] = 6;
jaggedArray[2][0] = 7;
jaggedArray[2][1] = 8;
jaggedArray[2][2] = 9;
// Accessing and displaying the jagged array
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();
}
}
}
int[][] jaggedArray = new int[3][]; declares a 2D array with 3 rows, but the number of columns varies for each row.jaggedArray[0] = new int[2];).Binary search is an efficient algorithm for finding an item from a sorted array. It works by repeatedly dividing the search interval in half.
import java.util.Arrays;
public class BinarySearchExample {
public static void main(String[] args) {
int[] arr = {12, 34, 54, 2, 3, 65, 90};
// Sort the array before applying binary search
Arrays.sort(arr);
int target = 34;
int result = binarySearch(arr, target);
if (result == -1) {
System.out.println("Element not found.");
} else {
System.out.println("Element found at index: " + result);
}
}
public static int binarySearch(int[] arr, int target) {
int left = 0;
int right = arr.length - 1;
while (left <= right) {
int mid = left + (right - left) / 2;
// Check if target is at mid
if (arr[mid] == target) {
return mid;
}
// If target is smaller, ignore the right half
if (arr[mid] > target) {
right = mid - 1;
}
// If target is larger, ignore the left half
else {
left = mid + 1;
}
}
// Target not found
return -1;
}
}
Arrays.sort() before binary search can be applied.binarySearch method iteratively compares the middle element with the target and adjusts the search range (left and right indices) until the target is found or the range is exhausted.Java does not support multiple inheritance with classes due to the ambiguity it may cause. However, interfaces provide a way for a class to implement multiple functionalities (via multiple interfaces).
interface Animal {
void eat();
}
interface AnimalSound {
void makeSound();
}
class Dog implements Animal, AnimalSound {
public void eat() {
System.out.println("Dog is eating.");
}
public void makeSound() {
System.out.println("Dog barks.");
}
}
public class MultipleInheritanceExample {
public static void main(String[] args) {
Dog dog = new Dog();
dog.eat();
dog.makeSound();
}
}
Animal and AnimalSound are interfaces that define behaviors.Dog class implements both interfaces, allowing it to inherit and implement methods from both.super Keyword:The super keyword is used to access the immediate parent class. It can be used to call parent class methods and constructors.
super Keyword Example Program:
class Animal {
String name;
Animal(String name) {
this.name = name;
}
void display() {
System.out.println("Animal name: " + name);
}
}
class Dog extends Animal {
Dog(String name) {
super(name); // Call the parent class constructor
}
void display() {
super.display(); // Call the parent class method
System.out.println("Dog is barking.");
}
}
public class SuperKeywordExample {
public static void main(String[] args) {
Dog dog = new Dog("Buddy");
dog.display();
}
}
super(name); is used to call the constructor of the parent class (Animal).super.display(); is used to call the display method of the parent class before adding additional behavior in the Dog class.