Custom middle Element of array

Finding the middle element of a list in Java

The middle element of a list in Java is well-structured. The logic you have used iterates over the list while keeping track of the list's length and dynamically adjusting the mid-point to capture the middle element. Below is a summary of the implementation:

Step 1: Main Method Implementation

Purpose:

The main method creates and initializes different types of lists (String, Integer, Double) and then calls the midElement method of the MidOfList class to find the middle element of each list.
After finding the middle element, it prints out the result.

Step 2: Implementation of MidOfList Class

Purpose:

The MidOfList class is a generic class that contains the midElement method, which takes a list as a parameter and returns the middle element of the list.

Key Method: midElement

Logic:

The method iterates through the list using a for-each loop.
It increments a counter (length) for each element in the list to keep track of the number of elements.
It calculates the mid-point index by dividing the current length by 2.
Depending on whether the length is odd or even, it adjusts the mid-point index to select the appropriate middle element.
The method returns the middle element once the loop completes.

Improvement and Considerations

Efficiency:

The current implementation calculates the middle index on each iteration, which is efficient for small lists. For very large lists, this could be optimized by calculating the middle index in a single traversal with two pointers (a slow and a fast pointer) instead of recalculating inside the loop.

Type Safety:

The method uses generics, which is excellent for maintaining type safety across different data types in the list.

Simplicity:

The method is simple and readable, making it easy to understand and maintain.

Code Example

Here is the code as provided:

java

package com.array;

import java.util.ArrayList;

import java.util.List;

public class MidOfListDemo {

@SuppressWarnings("rawtypes")

public static void main(String[] args) {

MidOfList midOfArray = new MidOfList();

List<String> list = new ArrayList<>();

list.add("Kartik");

list.add("Mandal");

list.add("WB");

list.add("MEDINIPUR");

list.add("BANGALORE");

list.add("KARNATAKA");

list.add("INDIA");

list.add("Pallav");

list.add("Chaturvedi");

list.add("Delhi");

@SuppressWarnings("unchecked")

String aa = (String) midOfArray.midElement(list);

System.out.println(aa);

List<Integer> listInt = new ArrayList<>();

listInt.add(1);

listInt.add(4);

listInt.add(5);

listInt.add(8);

listInt.add(6);

listInt.add(9);

listInt.add(2);

listInt.add(3);

listInt.add(7);

@SuppressWarnings("unchecked")

int i = (int) midOfArray.midElement(listInt);

System.out.println(i);

List<Double> listDouble = new ArrayList<>();

listDouble.add(1.0);

listDouble.add(4.0);

listDouble.add(5.0);

listDouble.add(8.0);

listDouble.add(6.0);

listDouble.add(9.0);

listDouble.add(2.0);

listDouble.add(3.0);

listDouble.add(7.0);

@SuppressWarnings("unchecked")

Double d = (Double) midOfArray.midElement(listDouble);

System.out.println(d);

}

java

package com.array;

import java.util.List;

public class MidOfList<T> {

/**

* This method returns the middle element of the list.

* @param pList

* @return T

public T midElement(List<T> pList) {

int length = 0;

int midLength = 0;

T middle = null;

for (T abc : pList) {

length++;

if (length % 2 == 0) {

midLength = length;

middle = pList.get(midLength / 2);

} else {

midLength = length;

if (midLength > 0)

midLength = midLength - 1;

middle = pList.get(midLength / 2);

}

return middle;

}

Output:

KARNATAKA

6.0

Conclusion

This solution correctly finds and returns the middle element of a list regardless of the type of elements in the list (String, Integer, Double). The use of generics and type safety makes this solution versatile. This is a simple and effective implementation for finding the middle element of an array.

Finding the middle element of a array in Java

To create a custom method for finding the middle element of an array in Java, you can follow a similar approach as you did with the list. Here’s how you can do it:

Custom Mid Element Method for Arrays

In this example, we'll create a method that works for arrays of different data types using Java generics. The method will find the middle element of an array by calculating the mid-point index.

Step 1: Create a Class for Mid Element Calculation

java

package com.array;

public class MidOfArray {

/**

* This method returns the middle element of the array.

* @param array

* @return T

public static <T> T midElement(T[] array) {

int length = array.length;

int midIndex = length / 2;

// If the length is odd, return the middle element.

// If the length is even, return the first of the two middle elements.

if (length % 2 == 0) {

return array[midIndex - 1];

} else {

return array[midIndex];

}

Step 2: Test the Method with Different Data Types

java

package com.array;

public class MidOfArrayDemo {

public static void main(String[] args) {

MidOfArray midOfArray = new MidOfArray();

// Test with String array

String[] stringArray = {"Kartik", "Mandal", "WB", "MEDINIPUR", "BANGALORE", "KARNATAKA", "INDIA", "Pallav", "Chaturvedi", "Delhi"};

String middleString = midOfArray.midElement(stringArray);

System.out.println("Middle element of String array: " + middleString);

// Test with Integer array

Integer[] intArray = {1, 4, 5, 8, 6, 9, 2, 3, 7};

Integer middleInt = midOfArray.midElement(intArray);

System.out.println("Middle element of Integer array: " + middleInt);

// Test with Double array

Double[] doubleArray = {1.0, 4.0, 5.0, 8.0, 6.0, 9.0, 2.0, 3.0, 7.0};

Double middleDouble = midOfArray.midElement(doubleArray);

System.out.println("Middle element of Double array: " + middleDouble);

}

Explanation

Generics Usage:

The midElement method is generic and can work with any type of array (T[]).

Calculation of Mid-Point Index:

The middle index is calculated by dividing the length of the array by 2 (length / 2).

Handling Even and Odd Lengths:

If the array length is even, the method returns the element just before the exact middle.
If the array length is odd, it returns the exact middle element.

Example Outputs:

For an array of strings: {"Kartik", "Mandal", "WB", "MEDINIPUR", "BANGALORE", "KARNATAKA", "INDIA", "Pallav", "Chaturvedi", "Delhi"}, the middle element would be "BANGALORE".
For an array of integers: {1, 4, 5, 8, 6, 9, 2, 3, 7}, the middle element would be 8.
For an array of doubles: {1.0, 4.0, 5.0, 8.0, 6.0, 9.0, 2.0, 3.0, 7.0}, the middle element would be 8.0.

Conclusion

This approach provides a simple and efficient way to find the middle element of an array in Java. The use of generics allows this method to work with arrays of any type, making it versatile and reusable across different data types.