public int reverseW(char[] seq) {
		    int point =0, left = 0, right = 0;
		    char tmp = '\0';

		    while(point < seq.length) {
		      if(seq[point] == ' ' || point == seq.length-1) {
		        if(seq[point] == ' ') right = point-1;
		        else right = point;
		        while(left < right) {
		          tmp = seq[left];
		          seq[left] = seq[right];
		          seq[right] = tmp;
		          left++;
		          right--;
		        }        
		        left = point+1;        
		      }
		      point++;
		    }  

		    System.out.println(Arrays.toString(seq));
		    return 0;
	  }	  

///////////////////////////////////////////////////////
// Reverse Words

public class Example
{
   public void reverseWordInMyString(String str)
   {
	/* The split() method of String class splits
	 * a string in several strings based on the
	 * delimiter passed as an argument to it
	 */
	String[] words = str.split(" ");
	String reversedString = "";
	for (int i = 0; i < words.length; i++)
        {
           String word = words[i]; 
           String reverseWord = "";
           for (int j = word.length()-1; j >= 0; j--) 
	   {
		/* The charAt() function returns the character
		 * at the given position in a string
		 */
		reverseWord = reverseWord + word.charAt(j);
	   }
	   reversedString = reversedString + reverseWord + " ";
	}
	System.out.println(str);
	System.out.println(reversedString);
   }
   public static void main(String[] args) 
   {
	Example obj = new Example();
	obj.reverseWordInMyString("Welcome to BeginnersBook");
	obj.reverseWordInMyString("This is an easy Java Program");
   }
}

//////////////////////////
public class StringFormatter {  
public static String reverseWord(String str){  
    String words[]=str.split("\\s");  
    String reverseWord="";  
    for(String w:words){  
        StringBuilder sb=new StringBuilder(w);  
        sb.reverse();  
        reverseWord+=sb.toString()+" ";  
    }  
    return reverseWord.trim();  
}  
}


      public static boolean isPalindromeString(String originalString) 
      {
          String reverse = StringUtils.reverse(originalString);
          return originalString.equals(reverse);
      }

// Reverse WORDS solutions //////////////////////////////////////////
  
  public boolean isPunkt(String s) {	  
	  return s.equals(".") || s.equals(",") || s.equals("!");
  }

  public boolean isPunkt(char c) {	  
	  return c=='.' || c==',' || c=='!';
  }  
  
  public String reverseWords(String s) {
	  // Leetcode 151
	  // Given an input string s, reverse the order of the words.
	  
	  // Note that s may contain leading or trailing spaces or multiple spaces 
	  // between two words. The returned string should only have a single 
	  // space separating the words. Do not include any extra spaces.
	  
      String[] words = s.trim().replaceAll(" +", " ").split(" ");
      StringBuilder reverse = new StringBuilder("");
      for(int i=words.length-1; i>=0; i--){
           reverse.append(words[i] + " ");
      }  
      return reverse.toString().trim();
  }
  
  
  public String reverseWords2(String s) {
	  // Given an input string s, reverse the order of the words.
	  // Live punktuation as is
	  
      String[] words = s.trim().replaceAll(" +", " ").split(" ");
      StringBuilder reverse = new StringBuilder("");
      
      int left = 0, right = words.length-1;
      String tmp = "", rightP = "", leftP = "";
      
      while(left < right) {
    	  rightP = words[right].substring(words[right].length()-1);
    	  leftP = words[left].substring(words[left].length()-1);
    	  
    	  tmp = words[left];
    	  words[left] = words[right];
    	  words[right] = tmp;
    	  
    	  
   		  if(isPunkt(leftP)) 
    		  words[right] = tmp.substring(0, tmp.length()-1); 
   		  if(isPunkt(rightP)) {
    		  words[right] = words[right]+rightP; 
   		  	  words[left] = words[left].substring(0, words[left].length()-1); 
   		  }
   		  if(isPunkt(leftP)) {
    		  words[left] = words[left]+leftP;    	
   		  }    	  
    	  left++;
    	  right--;    	  
      }
      
      for(int i=0; i < words.length; i++){
    		  reverse.append(words[i]+" ");  	  
      }  
      return reverse.toString().trim();
  }  
  
  public String reverseWords3(String s) {
	  // Given an input string s, reverse the order of the words.
	  // Live punktuation as is using HashMap
  
      String[] words = s.trim().replaceAll(" +", " ").split(" ");
      StringBuilder reverse = new StringBuilder("");
      
      Map<Integer, String> punkt = new HashMap<Integer, String>();
      String tmp = "";      

      for(int i=0; i < words.length; i++){  
    	  tmp = words[i].substring(words[i].length()-1);
    	  if(isPunkt(tmp)) {
    		  words[i] = words[i].substring(0, words[i].length()-1);
    		  punkt.put(words.length-1-i, tmp);
    	  }
      }  
      
      for(int i=words.length-1; i>=0; i--){
    	  if(punkt.containsKey(i)) {
    		  reverse.append(words[i]+punkt.get(i)+" ");
    	  } else {
    		  reverse.append(words[i]+" ");
    	  }
      }  
      return reverse.toString().trim();
  }   
  
  
  
  
  public int reverseWStr(String s) {
	  // Given an input string s, reverse THE WORDS in it.
	  // Live punktuation as is using Char Array
	  	char[] seq = s.toCharArray();
	  
	    int point =0, left = 0, right = 0;
	    char tmp = '\0';

	    while(point < seq.length) {
	      if(seq[point] == ' ' || point == seq.length-1) {
	        if(seq[point] == ' ') right = point-1;
	        else right = point;
	        while(left < right) {
	          tmp = seq[right];
	          if(!isPunkt(tmp)) {
		          seq[right] = seq[left];
		          seq[left] = tmp;
		          left++;		          
	          }
	          right--;
	        }        
	        left = point+1;        
	      }
	      point++;
	    }  

	    //System.out.println(Arrays.toString(seq));
	    System.out.println(String.valueOf(seq));
	    return 0;
  }

Using Stack

String description = "Java technology blog for smart java concepts and coding practices";
 
// reverse string builder
StringBuilder reverseString = new StringBuilder();
 
// Put words from String in Stack
Stack<String> myStack = new Stack<>();
 
StringTokenizer tokenizer = new StringTokenizer(description, " ");
 
while (tokenizer.hasMoreTokens()) {
  myStack.push(tokenizer.nextToken());
}
 
//Pop each word from stack and append in builder
 
while (!myStack.empty()) {
  reverseString.append(myStack.pop() + " ");
}
 
System.out.println(reverseString.toString());