How to find First and Second biggest number from the given array of Integers ?

package pack1;

public interface FirstAndSecondBiggestNumsInAnArrayInft {

	/* Define the functional interface with SAM 'ParseEachWord' */
	public String ParseAnArrayInput(int arrVal[]);

	/* Define the static method 'displayMsg' */
	static void displayMsg(String pairBigs) {
		System.out
				.println("First Biggest = " + pairBigs.split("#")[0] + "\nSecond Biggest = " + pairBigs.split("#")[1]);
	}

	/* Define the static method 'displayMsg' */
	static void displayAnArray(int[] arrVals) {

		int sizeOfArr = arrVals.length;
		System.out.println("The given input Array values are");
		/* Traversing an array to display the values */
		System.out.print("[ ");
		for (int i = 0; i < sizeOfArr; i++)
			System.out.print(arrVals[i] + " ");
		System.out.println("]");
	}
}

package pack1;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Optional;
import java.util.logging.Logger;
import java.util.stream.Collectors;

class ArrayNumsInput {

	private int[] arrIntVals;

	/* Declare the logger object for the class to display the log messages */
	static Logger logger = Logger.getLogger(ArrayNumsInput.class.getName());

	public boolean validateInputs(int[] inputAnIntegerArray) {

		/* Fetch the class object's name from which this method is called */
		String cName = Thread.currentThread().getStackTrace()[2].getClassName();
		String mName = "validateInputs()";
		logger.info("This method '" + mName + "' called from the Class '" + cName + "'");

		/* Validating the function parameters using Optional Integer Array data type */
		Optional<int[]> arrInput = Optional.ofNullable(inputAnIntegerArray);

		/*
		 * Fetch the value of the Optional Integer Array parameters using 'isPresent'
		 * condition check. If the value is available use 'get' method otherwise simply
		 * return 'false' to stop the program execution without proceeding further.
		 */
		if (arrInput.isPresent()) {
			if (arrInput.get().length != 0)
				setArrIntVals(arrInput.get());
			else
				return false;
		} else
			return false;

		logger.info("The provided Input validated Successfully");
		return true;
	}

	/* Define getter and setters for arrIntVals Array variable */

	public int[] getArrIntVals() {
		return arrIntVals;
	}

	public void setArrIntVals(int[] integers) {
		this.arrIntVals = integers;
	}
}

class FirstandSecondBigNums_without_Sort extends ArrayNumsInput implements FirstAndSecondBiggestNumsInAnArrayInft {

	public String ParseAnArrayInput(int[] inpArr) {

		/* Fetch the class object's name from which this method is called */
		String cName = Thread.currentThread().getStackTrace()[2].getClassName();
		String mName = "ParseAnArrayInput";
		logger.info("This method '" + mName + "' called from the Class '" + cName + "'");
		/*
		 * Define an immutable String variable which can Store First big and second big
		 * numbers with # as a delimiter.
		 */
		String pairOfNums = null;
		int bigNum = 0, secBignum = 0;

		if (validateInputs(inpArr)) {

			FirstAndSecondBiggestNumsInAnArrayInft.displayAnArray(inpArr);

			/* Assign inpArr[0] by default to the variables first big and second big */
			bigNum = secBignum = getArrIntVals()[0];
			/* Find the first big and second big numbers from this array of integers */
			for (int i = 1; i < getArrIntVals().length; i++) {
				if (getArrIntVals()[i] > bigNum) {
					secBignum = bigNum;
					bigNum = inpArr[i];
				} else if (getArrIntVals()[i] < bigNum && getArrIntVals()[i] > secBignum) {
					secBignum = getArrIntVals()[i];
				}
			}
			pairOfNums = String.valueOf(bigNum) + "#" + String.valueOf(secBignum);

		} else {
			logger.info("The given Input Array is null");
			pairOfNums = "None#None";
		}
		FirstAndSecondBiggestNumsInAnArrayInft.displayMsg(pairOfNums);
		return pairOfNums;
	}
}

class FirstandSecondBigNums_Using_Sort extends ArrayNumsInput implements FirstAndSecondBiggestNumsInAnArrayInft {

	public String ParseAnArrayInput(int[] inpArr) {

		/* Fetch the class object's name from which this method is called */
		String cName = Thread.currentThread().getStackTrace()[2].getClassName();
		String mName = "ParseAnArrayInput";
		logger.info("This method '" + mName + "' called from the Class '" + cName + "'");
		/*
		 * Define an immutable String variable which can Store First big and second big
		 * numbers with # as a delimiter.
		 */
		String pairOfNums = null;
		if (validateInputs(inpArr)) {

			FirstAndSecondBiggestNumsInAnArrayInft.displayAnArray(inpArr);

			/* use the built in sort method available in Arrays class */
			Arrays.sort(getArrIntVals());
			/*
			 * Extract first big from the last index position, and second big from the last
			 * but one index position of the array
			 */
			pairOfNums = String.valueOf(getArrIntVals()[getArrIntVals().length - 1]) + "#"
					+ String.valueOf(getArrIntVals()[getArrIntVals().length - 2]);
		} else {
			logger.info("The given Input Array is null");
			pairOfNums = "None#None";
		}
		FirstAndSecondBiggestNumsInAnArrayInft.displayMsg(pairOfNums);
		return pairOfNums;
	}
}

class FirstandSecondBigNums_Using_Streams extends ArrayNumsInput implements FirstAndSecondBiggestNumsInAnArrayInft {

	public String ParseAnArrayInput(int[] inpArr) {

		/* Fetch the class object's name from which this method is called */
		String cName = Thread.currentThread().getStackTrace()[2].getClassName();
		String mName = "ParseAnArrayInput";
		logger.info("This method '" + mName + "' called from the Class '" + cName + "'");
		/*
		 * Define an immutable String variable which can Store First big and second big
		 * numbers with # as a delimiter.
		 */
		String pairOfNums = null;
		int secondBig = 0;

		if (validateInputs(inpArr)) {

			FirstAndSecondBiggestNumsInAnArrayInft.displayAnArray(inpArr);

			/*
			 * Use the stream method of Arrays class to find the first, and the second
			 * biggest in the given array
			 */

			secondBig = Arrays.stream(inpArr).filter(e -> e != (Arrays.stream(inpArr).max().getAsInt())).max()
					.getAsInt();

			pairOfNums = String.valueOf(Arrays.stream(inpArr).max().getAsInt()) + "#" + String.valueOf(secondBig);
		} else {
			logger.info("The given Input Array is null");
			pairOfNums = "None#None";
		}
		FirstAndSecondBiggestNumsInAnArrayInft.displayMsg(pairOfNums);
		return pairOfNums;
	}
}

class FirstandSecondBigNums_Using_Collections extends ArrayNumsInput implements FirstAndSecondBiggestNumsInAnArrayInft {

	public String ParseAnArrayInput(int[] inpArr) {

		/* Fetch the class object's name from which this method is called */
		String cName = Thread.currentThread().getStackTrace()[2].getClassName();
		String mName = "ParseAnArrayInput";
		logger.info("This method '" + mName + "' called from the Class '" + cName + "'");
		/*
		 * Define an immutable String variable which can Store First big and second big
		 * numbers with # as a delimiter.
		 */
		String pairOfNums = null;
		int firstBig;

		if (validateInputs(inpArr)) {

			FirstAndSecondBiggestNumsInAnArrayInft.displayAnArray(inpArr);

			List<Integer> numList = Arrays.stream(inpArr).boxed().collect(Collectors.toList());

			/*
			 * Use the Collections class to find the biggest number from the above Array
			 * list of integers
			 */
			firstBig = Collections.max(numList);

			/* Remove the first biggest number from the above ArrayList */
			numList.remove(numList.indexOf(Collections.max(numList)));

			pairOfNums = String.valueOf(firstBig) + "#" + String.valueOf(Collections.max(numList));
		} else {
			logger.info("The given Input Array is null");
			pairOfNums = "None#None";
		}
		FirstAndSecondBiggestNumsInAnArrayInft.displayMsg(pairOfNums);
		return pairOfNums;
	}
}

public class FirstAndSecongdBiggestNumsInAnArrayJ8 {

	public static void main(String args[]) {

		/*
		 * create the class object FirstandSecondBigNums_without_Sort, and call the
		 * method ParseAnArrayInput
		 */

		FirstandSecondBigNums_without_Sort FSBNWS = new FirstandSecondBigNums_without_Sort();
		int[] intArr = { 14, 20, 11, 5, 29, 17, 58 };
		FSBNWS.ParseAnArrayInput(intArr);
		FSBNWS.ParseAnArrayInput(new int[] {});
		FSBNWS.ParseAnArrayInput(null);

		/*
		 * create the class object FirstandSecondBigNums_Using_Sort, and call the method
		 * ParseAnArrayInput
		 */

		FirstandSecondBigNums_Using_Sort FSBNUS = new FirstandSecondBigNums_Using_Sort();
		FSBNUS.ParseAnArrayInput(new int[] { 214, 520, 115, 35, 729, 317, 158 });
		FSBNUS.ParseAnArrayInput(null);

		/*
		 * create the class object FirstandSecondBigNums_Using_Streams, and call the
		 * method ParseAnArrayInput
		 */

		FirstandSecondBigNums_Using_Streams FSBNUST = new FirstandSecondBigNums_Using_Streams();
		FSBNUST.ParseAnArrayInput(new int[] { 24, 50, 15, 135, 79, 37, 18 });
		FSBNUST.ParseAnArrayInput(null);

		/*
		 * create the class object FirstandSecondBigNums_Using_Collections, and call the
		 * method ParseAnArrayInput
		 */

		FirstandSecondBigNums_Using_Collections FSBNUC = new FirstandSecondBigNums_Using_Collections();
		FSBNUC.ParseAnArrayInput(new int[] { 241, 505, 157, 13, 79, 373, 189 });
		FSBNUC.ParseAnArrayInput(null);
	}
}