Finding the most common character in a string with a hash map

Since you are on Java 8, this will be an ideal exercise for getting familiarized with the new stream-based processing approach. For example, instead of using an explicit for-loop:

for (int i = 0; i < s.length(); i++) {
    if (map.containsKey(s.charAt(i))) {
        // ...
    }
}

You can call String.chars() to give you an IntStream of 'int zero-extending the char values', or in other words a stream of characters.

Then, you only need to call Stream.collect() with a combination of Collectors.groupingBy() and Collectors.counting() to give you the resulting Map instance with the count-per-character:

Map<Character, Long> result = input.chars().boxed().collect(Collectors.groupingBy(
                                c -> Character.valueOf((char) c.intValue()),
                                Collectors.counting()));

For the first argument of Collectors.groupingBy(), we are mapping our Integer objects (which have been boxed() from the IntStream) to Character instances.

Again, instead of looping on result.entrySet(), we can apply another set of stream operations on it. First, we can define a Comparator that will compare an Entry object by the value:

private static final Comparator<Entry<? extends Object, Long>> RANK_BY_VALUE = Comparator
        .comparingLong(Entry::getValue);

Then, we will sort the stream of map entries with the reverse of this Comparator so that the characters with the most occurrences are ranked first:

Entry<Character, Long> entry = result.entrySet().stream()
                                .sorted(RANK_BY_VALUE.reversed()).findFirst().get();

Putting all these together into its own method:

private static Entry<Character, Long> getMaxOccurrenceCharacter(String input) {
    return input.chars().boxed().collect(
                    Collectors.groupingBy(
                            c -> Character.valueOf((char) c.intValue()),
                            Collectors.counting())).entrySet().stream()
            .sorted(RANK_BY_VALUE.reversed()).findFirst().get();
}

And here's an example of how you can make use of this method:

public static void main(String[] args) {
    Entry<Character, Long> result = getMaxOccurrenceCharacter("abc");
    System.out.printf("The character \"%s\" is repeated %d time(s).\n",
            result.getKey(), result.getValue());
}

// result
The character "a" is repeated 1 time(s).

Other pointers from your code:

• Java's bracing convention is to put the opening brace on the same line, instead of what you have used (mostly). More importantly, have a consistent convention in your codebase. :) If you are more inclined to your current way, then do so throughout.
• HashMap<Character, Integer> map should be declared using the Map interface, for simplification.
• The method name getMaxViaHashmap() can be improved upon, as there should not be a need to tell callers how the derivation is done (ViaHashmap).
• If your method is meant to be used solely for the derivation, it should not print output to System.out. From my example above, I get the results out first, then display it to the user.

• Even if you want to do the equivalent of this manually:

  if (map.containsKey(key)) {
      map.put(key, map.get(key) + newValue);
  } else {
      map.put(key, newValue);
  }
  

  There are the newer Map.compute() or Map.merge() methods to help you. For example:

  // input being the String
  Map<Character, Long> result = new HashMap<>();
  for (int i = 0; i < input.length(); i++) {
      result.merge(Character.valueOf(input.charAt(i)), 1L, (a, b) -> a + b);
  }
  

edit: @Misha's answer is a welcome improvement to mine, do take a look at that too.

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

You'd normally declare this as the interface. That way if you want to change the implementation, you only have to do so in one place.

         Map<Character, Integer> map = new HashMap<>(); 

Also, you don't need to repeat the types in the map in the latest Java. The <> tells the compiler to figure it out for you.

         char maxappearchar = ' ';

You don't need to declare this at the beginning of the method. You can move it between the two for loops, since it's only used in the second loop. And you can do without it entirely if you prefer (see below).

         for (int i = 0; i < s.length(); i++)

You don't have to manually maintain an index variable. You can just say

         for (char c : s.toCharArray())

It's also easier to write c than s.charAt(i).

              if ( map.containsKey(s.charAt(i)))
              {
                    map.put (s.charAt(i), map.get(s.charAt(i)) + 1 );
              }       
              else
              {
                map.put (s.charAt(i), 1);
              }

It's not necessary to do both containsKey and get. You can just say

              Integer count = map.get(c);
              if ( count == null )
              {
                  count = 0;
              }       

              map.put(c, count + 1);

This also simplifies to just one put line.

          int maxValueInMap=(Collections.max(map.values()));  // This will return max value in the Hashmap    
            for (Entry<Character, Integer> entry : map.entrySet())
            {  
                if (entry.getValue()==maxValueInMap)
                {
                    System.out.println("the max char is : " + entry.getKey() + "  and displayed  " +maxValueInMap+ "  times");     // Print the key with max value
                    maxappearchar = entry.getKey();
                }

            }
            return maxappearchar;

As previously mentioned you can write this without maxappearchar.

            int maxValueInMap = Collections.max(map.values());
            for (Entry<Character, Integer> entry : map.entrySet())
            {  
                if (entry.getValue() == maxValueInMap)
                {
                    System.out.println("the max char is : " + entry.getKey() + "  and displayed  " +maxValueInMap+ "  times");
                    return entry.getKey();
                }
            }

            return ' ';

This also does fewer iterations of the loop, as it will exit early. This won't help you in big O terms, but it may cut the actual run time slightly. I'm not sure whether getting the maximum value manually would beat that or not. You'd have to iterate through the entire loop and do a comparison on each iteration, but getting the maximum requires that already.

It also may be important to you to print all the characters with the maximum number of appearances. This only prints the first one encountered. Both versions only return one character.

Consider having the method return a Character instead of a char. That would allow you to return null on an empty string. As it is, you have it returning a space in that case, which is also a possible answer.

There is already a Java 8 answer (http://codereview.stackexchange.com/a/101202/70389) but I think there are a number of improvements that can be made to it (more than can fit in a comment)

import static java.util.stream.Collectors.counting;
import static java.util.stream.Collectors.groupingBy;
import static java.util.Map.Entry.comparingByValue;

char mostFrequent = s.chars()
        .mapToObj(x -> (char) x)                  // box to Character
        .collect(groupingBy(x -> x, counting()))  // collect to Map<Character, Long>
        .entrySet().stream()
        .max(comparingByValue())                  // find entry with largest count
        .get()                                    // or throw if source string is empty
        .getKey();                                // get Character key of the selected entry

If you want to throw a different exception or supply a message, replace .get() with something like .orElseThrow(() -> new NoSuchElementException("input string empty")). x -> x can be also expressed as Function.identity() if you find that more readable.

Relative to the other answer, I made the following changes:

• It is unnecessary to first box to Integer with boxed() and then rebox to Character inside the collector. Better box to Character right away with mapToObj(x -> (char) x)
• It is customary to statically import collectors for brevity
• It is better for both CPU and memory to use .max(...) rather than .sorted(...).findFirst().
• Map.Entry has static methods for comparators by value and by key.

Additionally, it's important to keep in mind that processing a String as a sequence of char will not work for certain Unicode characters as some of them take up 2 chars. To be fully Unicode-friendly, you will need to use .codePoints() and operate on ints rather than chars