Primitives competition (1)

Java has byte, short, int, char and long integral primitive types and Java language specification describes them very well:

The integral types are byte, short, int, and long, whose values are 8-bit, 16-bit, 32-bit and 64-bit signed two’s-complement integers, respectively, and char, whose values are 16-bit unsigned integers representing UTF-16 code units

I found these types mentioned in all java materials that I read but I saw in practice int and long most of the time. The logical question is if we really need all of them. Common sense tells me that I should check from two perspectives: storage usage and operations speed. I need more time to prepare a test for storage usage so I started with operations speed.

I selected the following operations based on how often I saw them in code

The multiplicative operators *, /, and % (§15.17)

The additive operators + and – (§15.18)

The increment operator ++, both prefix (§15.15.1) and postfix (§15.14.2)

The decrement operator –, both prefix (§15.15.2) and postfix (§15.14.3)

and I prepared a jmh benchmark:

@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@State(Scope.Thread)
public class IntegralPrimitivesOperations {

    byte bOp1 = 64;
    byte bOp2 = 21;

    @Benchmark
    public void baseline() {
    }

    /*
     * Addition
     */

    @Benchmark
    public byte measureAddByte() {
        return (byte) (bOp1 + bOp2);
    }

    //... similar code for short, int, char and long

    /*
     * Subtraction
     */

    @Benchmark
    public byte measureSubByte() {
        return (byte) (bOp1 - bOp2);
    }

    //... similar code for short, int, char and long

    /*
     * Multiplication
     */

    @Benchmark
    public byte measureMultByte() {
        return (byte) (bOp1 * bOp2);
    }

    //... similar code for short, int, char and long

    /*
     * Division
     */

    @Benchmark
    public byte measureDivByte() {
        return (byte) (bOp1 / bOp2);
    }

    //... similar code for short, int, char and long

    /*
     * Modulo
     */

    @Benchmark
    public byte measureModByte() {
        return (byte) (bOp1 % bOp2);
    }

    //... similar code for short, int, char and long

    /*
     * Increment
     */

    @Benchmark
    public byte measureIncByte() {
        return ++bOp1;
    }

    //... similar code for short, int, char and long

    /*
     * Decrement
     */

    @Benchmark
    public byte measureDecByte() {
        return --bOp1;
    }

    //... similar code for short, int, char and long

    /*
     * All
     */

    @Benchmark
    public byte measureAllByte() {
        return (byte) (++bOp1 * bOp2 + bOp1 / --bOp2 - --bOp1 % bOp2 + bOp2 * ++bOp1 - ++bOp2 / bOp1 + bOp2 % --bOp1);
    }

    //... similar code for short, int, char and long
}

100

101

@BenchmarkMode(Mode.AverageTime)

@OutputTimeUnit(TimeUnit.NANOSECONDS)

@State(Scope.Thread)

public class IntegralPrimitivesOperations {

byte bOp1 = 64;

byte bOp2 = 21;

@Benchmark

public void baseline() {

}

* Addition

@Benchmark

public byte measureAddByte() {

return (byte) (bOp1 + bOp2);

}