I am working on a plugin for a Minecraft server. In it, I have a function that returns a ChatColor depending on what permission level you are.

Whenever I need reference the user with proper colors, I always get a color from the below function.

 * ChatColor
 * @param Player
 * @return ChatColor
public ChatColor getColor(Player p) {
    // By default the color is Guest. The color will stay at guest otherwise.
    ChatColor color = ChatColor.GRAY;
    if (p.hasPermission("level.owner")) {
        // Owner
        color = ChatColor.RED;
    } else if (p.hasPermission("level.staff")) {
        // Admin / Mod
        color = ChatColor.AQUA;
    } else if (p.hasPermission("level.builder")) {
        // Builder
        color = ChatColor.DARK_AQUA;
    } else if (p.hasPermission("level.member")) {
        // Member
        color = ChatColor.GOLD;
    } else if (p.hasPermission("level.guest")) {
        // Guest
        // We don't need to change the color, since the color defaults to gray.
    return color;

One might call this function as below:

p.sendMessage("Welcome back, " + getColor(p) + p.getName() + gold + "!");

And it would send a message to the player like "Welcome back, (playerName)!" with playerName the level's color.

What I have found is that if you have the first permission level (level.owner) it can take a much longer time. After putting in some debugging (e.g getting a NanoTime, running my function, and subtracting the difference) I've found the following:

  • With level.owner it takes about 4580ns to run
  • With level.staff it takes about 6340ns to run
  • With level.builder it takes about 8000ns to run
  • With level.member it takes about 7630ns (sometimes going as high as 10240ns) to run
  • With level.guest it takes about 10000ns+ to run

Is there any way to improve my function run at nearly the same speed for all of my checks?

(I am a beginner at Java, but know many other languages, so this is somewhat new to me.)

  • 1
    \$\begingroup\$ Sounds like the performance issue has to do with p.hasPermission. \$\endgroup\$ Jan 20, 2016 at 0:45

2 Answers 2


I'm guessing that you call this method frequently. If so, you might consider memoizing the result. Something like

private Map<Player, ChatColor> playerChatColors = new HashMap<>();

in the class. Possibly make this static. And then at the beginning of the method, replace

    ChatColor color = ChatColor.GRAY;


    ChatColor color = playerChatColors.get(p);
    if (color != null) {
        return color;
    color = ChatColor.GRAY;

And then before the return at the end, add something like

    playerChatColors.put(p, color);

I don't know if this is faster or not. In the typical case, it will just do a single hash access. If that is fast, then it's faster. If that's slow, then it might not be.

There's also the problem that if the permissions change, this won't adjust. I'm assuming that this will be rare enough not to matter. If that's not so, you might need to find a way to invalidate the caching when permissions change. Of course, if you invalidate too often, you lose the benefits of caching. The first call to this method will be slower. It's the subsequent calls that this might help.

  • \$\begingroup\$ Thank you extremely much for your answer! While it won't completely remove the slowness of .hasPermission(), it will speed up subsequent calls. \$\endgroup\$
    – Spotlight
    Jan 20, 2016 at 1:41

Nice code! It was fun to review. Note that I do not know how this API you are using works, so I've made quite a few assumptions about it. Also, I've some assumptions about your knowledge of Java (despite your post) because you said you were familiar with other programming languages, so if you have any questions you can ask me in a comment.

Different times

The reason why you have different times for each level is because of these else ifs. Since this is a chain of else ifs, when one passes, the entire rest of the chain is skipped.

That means, the player is level.owner, as soon as that first check passes, the rest of the checks are completely skipped and the color is returned. However, if the user is a level.guest, the execution has to go through the entire chain before checking for level.guest.

A way you could possibly even these out would be to remove the else part of each conditional. That way, each conditional has to be at least checked before the return statement is reached.

However, I don't see why you would want to do that because if it's possible to keep your function fast like it is now, then there is no point in trying to make it slower so the speeds are even.

In fact, you could make this function even a bit faster by returning the color as soon as the correct conditional is met.

Converting to switch

Now, I don't know exactly how this API that you are using works, so this next part may not work.

You could try to speed up your code even more/make it more cleaner than it is right now by storing the player's permission level in the player object itself. Then, you could easily use a switch to re-write your code:

switch(p.permissionLevel) {
    case "level.owner":
    case "level.staff":

This permissionLevel field would most likely be set to the right level in the constructor of this player object.

Now, your code is faster because you don't have to keep calling that hasPermission method. Also, it looks much cleaner in the form of a loop.

Permission enum

Right now, you are checking what permission a player has by using this hasPermission method with these arbitrary strings. While this is okay, it could be made much more cleaner and idiomatic using an enum.

Say you had this enum:

public enum PermissionLevel {

Now, the different levels of permission are stored in one convenient place. Instead of using strings to represent the different levels, you should now use something like this.

But wait, there's more:

With this, you could also make this getColor method more efficient, along with future methods by storing the corresponding chat color with each enum. Here is what I mean:

public enum PermissionLevel {
    OWNER(ChatColor.RED), STAFF(ChatColor.AQUA)...

    ... etc methods etc...

Using that, you could now make this getColor method have O(1) speed:

public ChatColor getColor(Player p) {
    return p.permission.chatColor;

This completely eliminates the need for any conditionals and function calls, thus speeding up your code by a lot.

  • 1
    \$\begingroup\$ The switch won't work. There are a set of permission levels, not a single one. See Player and click through to Permissible. \$\endgroup\$
    – mdfst13
    Jan 20, 2016 at 1:03
  • \$\begingroup\$ @mdfst13 You could fix that with removing the break in a few places, right? \$\endgroup\$
    – SirPython
    Jan 20, 2016 at 1:07
  • \$\begingroup\$ No. You can't switch on a Collection in Java. You need it to return a String, but you will actually get a Set from getPermissibles. I.e. the problem is in what you call and can't be fixed from this method. \$\endgroup\$
    – mdfst13
    Jan 20, 2016 at 1:11
  • \$\begingroup\$ Thank you for your review! It's extremely informative. As @mdfst13 said, there is a set of permission levels. My example was with "level.staff", however the player could also have the permission "minecraft.toggledownfall", and an infinite quanity more. \$\endgroup\$
    – Spotlight
    Jan 20, 2016 at 1:12
  • 1
    \$\begingroup\$ @awesomebing1 Sure thing! \$\endgroup\$
    – SirPython
    Jan 20, 2016 at 1:44

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.