Compare int to character constant in Java

Question

I have a binary file that uses sets of 4 chars to form integers that have "meaning". For example, the 4 bytes '0005', which equals 808464437 in integer form.

I'd rather represent these in my Java code as '0005' rather than 808464437. I also don't want to set constants like final int V0005 = 808464437.

In C++, I can do the following:

fileStream->read((byte*) &version, 4); //Get the next bytes and stuff them into the uint32 version

switch (version) {
    case '0005':
        //do something
    case '0006':
        //do something
    case '0007':
        //do something
}

In Java, my problem isn't reading the 4 bytes and putting them into some data type. My problem is comparing some data type to the const char array '0005'.

How do I compare an int, or whatever form, to a const character array like '0005' in Java? I need to do this as efficiently as possible!

Answer 1

Thanks for explaining your answer.

Here's how to convert from 4 bytes to an int, which you can then compare to the int in question:

    int v0005 = ByteBuffer.wrap("0005".getBytes()).asIntBuffer().get();

This is unfortunately the only way I can see to do it... probably not as efficient as you want, but perhaps it's what you need nonetheless.

I would suggest setting up some of these as 'constants' in one of your classes like so:

public static final int V0005 = ByteBuffer.wrap("0005".getBytes()).asIntBuffer().get();
public static final int V0006 = ByteBuffer.wrap("0006".getBytes()).asIntBuffer().get();
public static final int V0007 = ByteBuffer.wrap("0007".getBytes()).asIntBuffer().get();
public static final int V0008 = ByteBuffer.wrap("0008".getBytes()).asIntBuffer().get();

And then switch on V0005, etc, since switching on a primitive type (int) is efficient.

Answer 2

A char array in java is nothing more than a String in java. You can use string in switch-cases in Java7, but I don't know the efficiency of the comparisions.

Because only the last element of you char array seems to have a meaning, you could do a switch case with it. Something like

private static final int VERSION_INDEX = 3;

...
    char[] version = // get it somehow

    switch (version[VERSION_INDEX]) {
         case '5': 
            break;
         // etc
    }
...

EDIT More object oriented version.

  public interface Command {
       void execute();
  }

  public class Version {
       private final Integer versionRepresentation;

       private Version (Integer versionRep) {
            this.versionRepresentation = versionRep;
       }

       public static Version get(char[] version) {
            return new Version(Integer.valueOf(new String(version, "US-ASCII")));
       }

       @Override
       public int hashCode() {
            return this.versionRepresentation.hashCode();
       }
       @Override
       public boolean equals(Object obj) {
            if (obj instanceof Version) {
                Version that = (Version) obj;

                return that.versionRepresentation.equals(this.versionRepresentation);
            }
            return false;
       }
  }

  public class VersionOrientedCommandSet {
       private final Command EMPTY_COMMAND = new Command() { public void execute() {}};
       private final Map<Version, Command> versionOrientedCommands;

       private class VersionOrientedCommandSet() {
           this.versionOrientedCommands = new HashMap<Version, Command>();
       }

       public void add(Version version, Command  command) {
           this.versionOrientedCommands.put(version, command);
       }

       public void execute(Version version) throw CommandNotFoundException {
           Command command = this.versionOrientedCommands.get(version);

           if (command != null)  {
               command.execute();
           } else {
               throw new CommandNotFoundException("No command registered for version " + version);
           }

       }
  }

  // register you commands to VersionOrientedCommandSet
  char[] versionChar = // got it from somewhere
  Version version = Version.get(versionChar);
  versionOrientedCommandSet.execute(version);

lots of code hehe You will have a little cost of warm-up, but if you program is executed multiple times, you will gain efficiency with the map :P

Answer 3

Getting a little from some of the other answers (@marvo and @vikingsteve), I came out with this :

public enum Version {

  V0005 {

    @Override
    public void doStuff() {
      // do something
    }
  },
  V0006 {
  @Override
    public void doStuff() {
    // do something else
    }

  };

private final int value;
private static final Map<Integer, Version> versions = new HashMap<>();

private Version() {
    final byte[] bytes = name().substring(1).getBytes(); //remove the initial 'V'
    this.value = ByteBuffer.wrap(bytes).asIntBuffer().get();
}

static {
    for (Version v : values()) {
        versions.put(v.value, v);
    }
}

public abstract void doStuff();


public Version valueOf(int i){
    return versions.get(i);
}
}

This offers a good object-oriented approach, since the action is encapsulated with the data representation .Each Constant decides what to do when doStuff is called, avoiding the switch on client code. The usage would be :

int code = readFromSomewhere();
Version.valueOf(i).doStuff();

The valueOf method finds the Version in a map which is populated when loading the class. I don't know if this is as efficient as you need, since the int gets boxed to an Integer but you'll only find out when you profile, everything else is pure speculation. Also note that the integer values are calculated for you in the constructor, so you just have to define the enums with the right name and it'll be done automatically.

Answer 4

Are you looking for something like value1.intValue() == value2.intValue()? Or you could just type cast.

char myChar = 'A';
int myInt = (int) myChar;

The same cane go for the other way around.

int myInt = 6;
char myChar = (char) myInt;

Answer 5

The only way would be a very inefficient byte[] to String conversion.

switch (new String(version, "US-ASCII")) {
case "0005":
    break;
...
}

Using a (Hash-)Map instead would make it faster again.

But I think you will not be satisfied by this solution.

Answer 6

The most efficient way would be to work with integers - something like final int V0005 = 0x30303035 (a combination of a couple of different ideas seen here) would be manageable. Java just doesn't have the kind of integer literals you are looking for.

If you really want to work with strings, you need to read the characters in a byte array first, then convert that to a String (the default charset normally works as it is a superset of ASCII). However, it would be less efficient.

You could write a function to calculate the constant values from the simple numbers (like 5) for better readability, but that's probably overkill.

Answer 7

Given that this appears to be a version string in a packet or something, then the number of values are finite and of a reasonable amount. So they can be encapsulated in an enum. The enum can encapsulate efficient code for converting from the four bytes in the input data to the representative enum. (My code for performing that conversion isn't necessarily the most efficient. Maybe, given a small number of versions, a nice internal array or mapping of ints to enums would work.)

class enum Version {

    UNKNOWN(0),
    V0005(0x30303035),  // whatever the int value is
    V0006(0x30303036);

    private int id;
    private Version(int value) {
        id = value;
    }

    public static Version valueOf(int id) {
        for (Version version : values()) {
            if (version.getId() == id) {
                return version;
            }
        }
        return UNKNOWN;
    }

    public static Version valueOf(String sId) {
        return valueOf(computeId(sId));
    }

    public static int computeId(String sId) {
        // efficiently convert from your string to its int value
    }
}

Then in my switch :

String s = methodThatReadsFourChars(...);
switch (Version.valueOf(s)) {
case V0005 : doV0005Stuff(); break;
case V0006 : doV0006Stuff(); break;
default :
    throw new UnknownVersionException();