public class Main {
static int entries = 100000000;
static byte[] barr = new byte[entries];

static {
System.err.println(Runtime.getRuntime().totalMemory());
for (int i = 0; i < entries; i++) {
barr[i] = new Byte("1");
}
System.err.println(barr.length);
System.err.println(Runtime.getRuntime().totalMemory());
}

public static void main(String[] args) {

}
}

class Animal {
static final int DOG=-1, CAT=1, MOUSE = 0;
String saySomething(int kind) {
if (kind 0) return “meow”;
return “squeak”;
}
}

this also allows you to do DOG | CAT is != 0
CAT | MOUSE >= 0 etc

If you have a lot of cases then by grouping related ones into negative / positive you can use 0. The Java compiler is like the old C compilers back in the ’80s before any of the optimizations that were made (some C++ compilers can generate code that is almost as good as assembly, but since Java is already slow on Mobiles and size limited it is worth optimizing the code rather than letting the compiler, although a tool such as proguard means you can use more maintainable code, but it won’t solve all your problems since it doesn’t refactor the logic, just the generated code).

public final static int X = 0;
public final static int Y = 1;
public final static int z = 2;
public final static int IMAGE_INDEX = 3;
public final static int SPRITE_SIZE = 4;

So that you can do draw(sprites[index + X],sprites[index + Y],sprites[index + IMAGE_INDEX])

However, Javac is very bad compiler and actually generates code index + 0 (rather than saying +0 is not actually much use and removing it).

So I removed that code, and some other optimizations and one of them I did was to replace code like
static final byte B[] = {10, 20, 30, 40, 50, 60, 70, 80, …};

with static final byte B[] = Bytecode::ArrayFromString(“encodedString”,offset), the encoded string was generated via the optimizer and occurred once in the class pool and had simple run length encoding as well (the other option would have been to load the data from a resource, but the string encoding was the simplest since I didn’t need to worry about it not being available).

Nope. Most sensitive to green (around the 530 – 550 nm mark). Considerably less sensitive to red and green by about 1-2 orders of magnitude (See: http://www.yorku.ca/eye/lambdas.htm and look at the dotted line; that is your colour vision. The scale is logarithmic, so a plus or minus one on the relative sensitivity axis is a difference of ten times the sensitivity). So the relative pixel size makes sense.

>” I guess this may be due to red being a danger colour for humans.”

I’m sure I read somewhere that this is purely cultural – that in some cultures red stands for purity, joy, good luck, happiness, prosperity, etc., but I’m not sure. I will have to Google it.