How to check whether the given strings or sentences are Anagram or not?

package pack1;

import java.util.HashMap;

public interface Anagram {

	/* Define the functional interface with SAM 'AnagramCheck' */
	boolean AnagramCheck(String str1, String str2);

	/* Define the default method 'getMapOfSentence' */
	default HashMap<Character, Integer> getMapOfSentence(String inpSentence) {
		return null;
	}

	/* Define the static method 'displayMsg' */
	static void displayMsg(boolean trueOrFalse,String strOne,String strTwo) {

		if (trueOrFalse)
			System.out.println("Both Line of Strings '"+strOne+"' and '"+strTwo+"' are Anagram\n");
		else
			System.out.println("Both Line of Strings '"+strOne+"' and '"+strTwo+"' are Not Anagram\n");
	}
}

package pack1;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Optional;
import java.util.logging.Logger;

class AnagramInputs {

	private String strParam1;
	private String strParam2;

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

	public boolean validateInputs(String str1, String str2) {

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

		/* Validating the function parameters using Optional String data type methods */
		Optional<String> strInput1 = Optional.ofNullable(str1);
		Optional<String> strInput2 = Optional.ofNullable(str2);

		/*
		 * Fetch the value of the Optional String 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 (strInput1.isPresent())
			setStrParam1(strInput1.get());
		else
			return false;

		if (strInput2.isPresent())
			setStrParam2(strInput2.get());
		else
			return false;

		logger.info("Both the inputs are validated Successfully");
		return true;
	}

	public String getStrParam1() {
		return strParam1;
	}

	public void setStrParam1(String strParam1) {
		this.strParam1 = strParam1;
	}

	public String getStrParam2() {
		return strParam2;
	}

	public void setStrParam2(String strParam2) {
		this.strParam2 = strParam2;
	}
}

class AnagramChk_Using_Strings extends AnagramInputs implements Anagram {

	@Override
	public boolean AnagramCheck(String str1, String str2) {

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

		if (validateInputs(str1, str2)) {

			char[] str1Chars = getStrParam1().toLowerCase().toCharArray();

			System.out.println("First input after converted to Lower case character Array");
			System.out.println(str1);
			/* Sorting the characters array including with spaces, if any available */
			Arrays.sort(str1Chars);
			System.out.println("First input after Sorting the characters in the array");
			System.out.println(str1);

			/*
			 * Converting the input sentence to sequence of characters array in the same
			 * order
			 */
			char[] str2Chars = getStrParam2().toLowerCase().toCharArray();
			System.out.println("Second input after converted to Lower case character Array");
			System.out.println(str2Chars);

			/* Sorting the characters array including with spaces, if any available */
			Arrays.sort(str2Chars);
			System.out.println("Second input after Sorting the characters in the array");
			System.out.println(str2Chars);

			/*
			 * Compare the two sorted character array strings, excluding the spaces after
			 * converting into lower case for Anagram check
			 */
			if (String.valueOf(str1Chars).trim().contentEquals(String.valueOf(str2Chars).trim()))
				isAnagram = true;
			else
				isAnagram = false;
		} else {
			isAnagram = false;
			logger.warning("Either first Input or the Second Input is null");
		}
		Anagram.displayMsg(isAnagram, str1, str2);
		return isAnagram;
	}
}

class AnagramChk_Using_Hashmap extends AnagramInputs implements Anagram {

	@Override
	public boolean AnagramCheck(String str1, String str2) {

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

		HashMap<Character, Integer> charCntOfStr1, charCntOfStr2 = new HashMap<>();

		if (validateInputs(str1, str2)) {
			charCntOfStr1 = getMapOfSentence(getStrParam1());
			System.out.println("First input after after generation of Hashmap");
			System.out.println(charCntOfStr1);
			charCntOfStr2 = getMapOfSentence(getStrParam2());
			System.out.println("Second input after after generation of Hashmap");
			System.out.println(charCntOfStr2);
			System.out.println("Comparing both the generated Hashmaps");
			if (charCntOfStr1.equals(charCntOfStr2)) {
				isAnagram = true;
			} else {
				isAnagram = false;
			}
		} else{
			isAnagram = false;
			logger.warning("Either first Input or the Second Input is null");
		}
		Anagram.displayMsg(isAnagram, str1, str2);
		return isAnagram;
	}

	public HashMap<Character, Integer> getMapOfSentence(String inpSentence) {

		HashMap<Character, Integer> charCntOfStr = new HashMap<>();

		for (int i = 0; i < inpSentence.length(); i++) {
			char eachChar = Character.toLowerCase(inpSentence.charAt(i));
			if (Character.isWhitespace(eachChar))
				continue;
			else if (!charCntOfStr.containsKey(eachChar))
				charCntOfStr.put(eachChar, 1);
			else
				charCntOfStr.put(eachChar, charCntOfStr.get(eachChar) + 1);
		}
		return charCntOfStr;
	}
}

class AnagramChk_Using_StringBuilder extends AnagramInputs implements Anagram {

	@Override
	public boolean AnagramCheck(String str1, String str2) {

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

		if (validateInputs(str1, str2)) {

			// Converting the first input line to lower case by excluding spaces
			StringBuilder str1B = new StringBuilder(getStrParam1().replaceAll("\\s", "").toLowerCase());
			System.out.println("First input after converted to Lower case character Array");
			System.out.println(str1B);

			// Converting the second input line to lower case by excluding spaces
			str2 = getStrParam2().replaceAll("\\s", "").toLowerCase();
			System.out.println("Second input after converted to Lower case character Array");
			System.out.println(str2);

			/*
			 * Check the availability of each character from the firstLine (StringBuilder)
			 * in the secondLine, if available delete the same from firstLine
			 */
			if (str1B.length() == str2.length()) {
				while (str1B.length() > 0) {
					if (str2.contains(String.valueOf(str1B.charAt(0))) == true)
						str1B.deleteCharAt(0);
					else {
						isAnagram = false;
						break;
					}
				}
			} else
				isAnagram = false;

		} else{
			isAnagram = false;
			logger.warning("Either first Input or the Second Input is null");
		}
		Anagram.displayMsg(isAnagram, str1, str2);
		return isAnagram;
	}
}

class AnagramChk_Using_LambdaExpression extends AnagramInputs implements Anagram {

	/* Define the Lambda expression for the user defined functional interface */
	Anagram Ag = ((strVal1, strVal2) -> {

		// Converting the both input strings to sequence of characters array
		char[] str1Chars = strVal1.toLowerCase().toCharArray();
		char[] str2Chars = strVal2.toLowerCase().toCharArray();

		// Sorting the characters of two arrays including with spaces, if any
		Arrays.sort(str1Chars);
		Arrays.sort(str2Chars);

		/*
		 * Compare the two sorted character array strings, excluding the spaces, after
		 * converting into lower case for Anagram check
		 */
		if (String.valueOf(str1Chars).trim().contentEquals(String.valueOf(str2Chars).trim()))
			return true;
		else
			return false;
	});

	@Override
	public boolean AnagramCheck(String str1, String str2) {

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

		boolean status = false;
		if (validateInputs(str1, str2))
			// Calling the functional interface with String arguments
			status = Ag.AnagramCheck(getStrParam1(), getStrParam2());
		else {
			status = false;
			logger.warning("Either first Input or the Second Input is null");
		}
		Anagram.displayMsg(status, str1, str2);
		return status;
	}
}

class AnagramJ8v1 {

	public static void main(String[] args) {

		/*
		 * create the class object AnagramChk_Using_Strings, and call the method
		 * AnagramCheck
		 */
		AnagramChk_Using_Strings AUStr = new AnagramChk_Using_Strings();
		AUStr.AnagramCheck("Happyness", "ss en Happy");

		/*
		 * create the class object AnagramChk_Using_Hashmap, and call the method
		 * AnagramCheck
		 */
		AnagramChk_Using_Hashmap AUHashmap = new AnagramChk_Using_Hashmap();
		AUHashmap.AnagramCheck("Creative Learning", "Creating Learnive");

		/*
		 * create the class object AnagramChk_Using_StringBuilder, and call the method
		 * AnagramCheck
		 */
		AnagramChk_Using_StringBuilder AUStrB = new AnagramChk_Using_StringBuilder();
		AUStrB.AnagramCheck("All Incorrect", "Allinone errect");
		AUStrB.AnagramCheck("All Incorrect", "All incre ctor");

		/*
		 * create the class object AnagramChk_Using_LambdaExpression, and call the
		 * method AnagramCheck
		 */
		AnagramChk_Using_LambdaExpression AUStrL = new AnagramChk_Using_LambdaExpression();
		AUStrL.AnagramCheck("sample", "amples");
		AUStrL.AnagramCheck("Clears", "Pearls");
		AUStrL.AnagramCheck("Clears", null);
	}
}