hashCode()

state = f(state);

key.hashCode() % arraySize

public static Character createCharacter(String characterName, String worldId)
{
  // Seed RNG by NPC name
  Rng rng = new Rng(characterName.hashCode());
  Character c = new Character(characterName);

  // Set basic characteristics of NPC
  c.setHairColor(rng.nextInt(0, MaxHairColorId));
  c.setShirtColor(rng.nextInt(0, MaxShirtColorId));
  c.setPantsColor(rng.nextInt(0, MaxPantsColorId));
  c.setShoeColor(rng.nextInt(0, MaxShoeColorId));
  c.setGlasses(rng.nextBoolean);
  c.setGlassesColor(rng.nextInt(0, MaxGlassesColorId));

  // Reseed RNG
  rng.reset((characterName + ":" + worldId).hashCode());
  // Modifiy character slightly in this alternate reality
  switch(rng.nextInt(0, 5)
  {
    case 0:
      c.setHairColor(rng.nextInt(0, MaxHairColorId));
      break;
    case 1:
      c.setShirtColor(rng.nextInt(0, MaxShirtColorId));
      break;
    case 2:
      c.setPantsColor(rng.nextInt(0, MaxPantsColorId));
      break;
    case 3:
      c.setShoeColor(rng.nextInt(0, MaxShoeColorId));
      break;
    case 4:
      c.setGlasses(!c.hasGlasses());
      break;
    case 5:
      c.setGlassesColor(rng.nextInt(0, MaxGlassesColorId));
      break;
  }
  return c;
}

(x + ", " + y).hashCode()

(playerName + "..." + x + ", " + y).hashCode()

float rand(vec2 co){
    return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
}

// repeated for other type
vec2 mod289(vec2 x)     { return x - floor(x * (1.0 / 289.0)) * 289.0; }
vec2 permute(vec2 x)    { return mod289(((x*34.0)+1.0)*x); }
vec2 rng(vec2 x)        { return fract(x*1.0/41.0); }

// minimal example: take a 2D coordinate and convert into a hash value, then
// generate multiple random numbers by rehashing the hash.
float bar(vec2 x)
{
  float h, r;
  vec2 m = mod289(x);             // values must be bound to (-289,289) for precision

  h = permute(permute(m.x)+m.y);  // hash the coordinates together
  r = rng(h);                     // first random number
  ...
  h = permute(h);                 // hash the hash
  r = rng(h);                     // second random number
}

dot(v1, v2) = v1.x*v2.x + v1.y*v2.y + v1.z*v2.z

vec3 p1;
vec3 p2;

//...

vec3 delta = p1-p2;
float distSqrd = dot(delta, delta); //Distance^2, can be useful for lighting which saves you the square root
float dist = sqrt(distSqrd); 

vec3 color;

//...

float grayscale = dot(color, vec3(0.21, 0.71, 0.07));

uniform sampler2D shadowMap;

float shadow(){
    vec3 wDivShadowCoord = shadowCoord.xyz / shadowCoord.w; //z-divide

    float distanceFromLight = texture(shadowMap, wDivShadowCoord.xy).z;
    
    return distanceFromLight < wDivShadowCoord.z ? 0.0 : 1.0;
}

return step(wDivShadowCoord.z, distanceFromLight);

GL11.glTexParameteri(GL_TEXTURE_2D, GL14.GL_TEXTURE_COMPARE_MODE, GL14.GL_COMPARE_R_TO_TEXTURE);

textureProj()

float shadow(){
    return textureProj(sampler, shadowCoord);
}

rng.setSeed(someValue);

for(int i=0; i<100*100*2; i++) {
  float x = 100*rng.nextFloat();
  float y = 100*rng.nextFloat();
  doMyFlower(x,y);
}

// From Knuth, reasonable on modern machines for smallish
// means.  There are many ways this can be computed.
// eMean = exp(-mean)
public static final int poisson(float eMean)
{
  int   r = 1;
  float t = rng.nextFloat();
  
  while (t > eMean) {
    r++;
    t *= rng.nextFloat();
  }
  return r-1;
}

// Sketch below this point
private static final float FLOWER_POWER = (float)Math.exp(-2);

private void doSomeCellFlowerThing(...)
{
  rng.setSeed(hashOfThisCell); 

  int num = poisson(FLOWER_POWER);

  for(int i=0; i<num; i++) {
    // coordinates local to the square meter in this example
    float x = rng.nextFloat();
    float y = rng.nextFloat();
    ...
  }
}

  vec3 weyli(vec3 s, vec3 a)  { return fract(s+a); }            // simple incremental
  vec3 weyl(vec3 n, vec3 a)   { return fract(n*a); }            // simple explict
  vec3 weyln(vec3 n, vec3 a)  { return fract(n*fract(n*a)); }   // nested
  vec3 weylns(vec3 n, vec3 a)                                   // shuffled nested
  {
    n = m*fract(n*fract(n*a))+0.5;
    return fract(n*fract(n*a));
  }

float eval(float x, float y)
{
  long seed = mix(x,y);         // map the input coordinate to a seed value
  prng.setSeed(seed);           // set the PRNGs seed to the mix
  return prng.nextFloat();      // return the result
}

float eval(float x, float y)
{
  // lower left hand corner of cell containing (x,y)
  int ix   = (int)Math.floor(x);
  int iy   = (int)Math.floor(y);

  // offset into 'cell' of (x,y). dx & dy are on [0,1)
  float dx = x - ix;
  float dy = y - iy;

  // generate a random value for each vertex of the cell
  // based on its integer coordinate.
  float r00 = mix(ix,   iy);
  float r10 = mix(ix+1, iy);
  float r01 = mix(ix,   iy+1);
  float r11 = mix(ix+1, iy+1);

  // use some interpolation technique to get the sample value.
  return blend(r00,r10,r01,r11,dx,dy);
}

float eval(float x, float y) 
{
  // lower left hand corner of cell containing (x,y)
  int ix = (int)Math.floor(x);
  int iy = (int)Math.floor(y);

  // offset into 'cell' of (x,y). dx & dy are on [0,1)
  x -= ix;
  y -= iy;

  // generate a random value for each vertex of the cell
  // based on its integer coordinate.
  int   h00 = mix(ix,   iy);
  int   h10 = mix(ix+1, iy);
  int   h01 = mix(ix,   iy+1);
  int   h11 = mix(ix+1, iy+1);

  // some function that uses the random number to 'dot'
  // against a random vector. Not the '-1' compared to the '+1'
  // above.
  float r00 = dotRandVect(h00, x,   y);
  float r10 = dotRandVect(h10, x-1, y);
  float r01 = dotRandVect(h01, x,   y-1);
  float r11 = dotRandVect(h11, x-1, y-1);

  // convert the offest into the cell into a weighting factor
  // so-called ease or s-curve    
  x = weight(x);
  y = weight(y);

  // blend to get the final result
  float xb = lerp(x, r00, r10);
  float xt = lerp(x, r01, r11);

  return lerp(y, xb, xt);
}

ArrayList<GameObject> currentList, nextList;

//Lists created at load time


//Example game loop:

while(true){

    update(); //Updates all objects
    render(); //Draws all objects

}

private void update(){
    for(int i = 0; i < currentList.size(); i++){
        GameObject go = currentList.get(i);
        go.update();
        if(go.isAlive()){
            nextList.add(go);
        }
    }
    
    //Alive objects are now in nextList. Clear currentList.
    currentList.clear();
    
    //Swap current and next list
    ArrayList<GameObject> temp = nextList;
    nextList = currentList;
    currentList = temp;
}

java.lang.Object.hashCode();
java.lang.Object.getClass();
java.lang.Object.clone();

java.lang.Math.abs(double);
java.lang.Math.sin(double);
java.lang.Math.cos(double);
java.lang.Math.tan(double);
java.lang.Math.atan2(double, double);
java.lang.Math.sqrt(double);
java.lang.Math.log(double);
java.lang.Math.log10(double);
java.lang.Math.pow(double, double);
java.lang.Math.exp(double)
java.lang.Math.min(int, int);
java.lang.Math.max(int, int);

java.lang.Float.floatToRawIntBits(float);
java.lang.Float.floatToIntBits(float);
java.lang.Float.intBitsToFloat(int);

java.lang.Double.doubleToRawLongBits(double);
java.lang.Double.doubleToLongBits(double);
java.lang.Double.longBitsToDouble(long);

java.lang.Integer.numberOfLeadingZeros(int);
java.lang.Long.numberOfLeadingZeros(long);

java.lang.Integer.numberOfTrailingZeros(int);
java.lang.Long.numberOfTrailingZeros(long);

java.lang.Integer.bitCount(int);
java.lang.Long.bitCount(long);

java.lang.Integer.reverseBytes(int);
java.lang.Long.reverseBytes(long);
java.lang.Character.reverseBytes(char);
java.lang.Short.reverseBytes(short);

java.lang.System.identityHashCode(Object);
java.lang.System.currentTimeMillis();
java.lang.System.nanoTime();
java.lang.System.arraycopy(....);
java.lang.Thread.isInterrupted(....);
java.lang.Thread.currentThread();

java.lang.Class.isAssignableFrom(Class)
java.lang.Class.isInstance(Object)
java.lang.Class.getModifiers()
java.lang.Class.isInterface()
java.lang.Class.isArray()
java.lang.Class.isPrimitive()
java.lang.Class.getSuperclass()
java.lang.Class.getComponentType()

sun.reflect.Reflection.getClassAccessFlags(Class)
java.lang.reflect.Array.getLength(Object)

sun.reflect.Reflection.getCallerClass()

java.lang.reflect.Array.newArray

java.util.Arrays.copyOf

java.util.Arrays.copyOfRange
java.util.Arrays.equals
java.lang.String.compareTo(String)
java.lang.String.indexOf
java.lang.String.equals(Object)
java.nio.Buffer.checkIndex(int)

java.lang.ref.Reference.get()

sun.misc.AtomicLongCSImpl.get()
sun.misc.AtomicLongCSImpl.attemptUpdate

sun.misc.Unsafe.allocateInstance
sun.misc.Unsafe.copyMemory
sun.misc.Unsafe.park
sun.misc.Unsafe.unpark

sun.misc.Unsafe.getObject
sun.misc.Unsafe.getBoolean
sun.misc.Unsafe.getByte
sun.misc.Unsafe.getShort
sun.misc.Unsafe.getChar
sun.misc.Unsafe.getInt
sun.misc.Unsafe.getLong
sun.misc.Unsafe.getFloat
sun.misc.Unsafe.getDouble
sun.misc.Unsafe.putObject
sun.misc.Unsafe.putBoolean
sun.misc.Unsafe.putByte
sun.misc.Unsafe.putShort
sun.misc.Unsafe.putChar
sun.misc.Unsafe.putInt
sun.misc.Unsafe.putLong
sun.misc.Unsafe.putFloat
sun.misc.Unsafe.putDouble
sun.misc.Unsafe.getObjectVolatile
sun.misc.Unsafe.getBooleanVolatile
sun.misc.Unsafe.getByteVolatile
sun.misc.Unsafe.getShortVolatile
sun.misc.Unsafe.getCharVolatile
sun.misc.Unsafe.getIntVolatile
sun.misc.Unsafe.getLongVolatile
sun.misc.Unsafe.getFloatVolatile
sun.misc.Unsafe.getDoubleVolatile
sun.misc.Unsafe.putObjectVolatile
sun.misc.Unsafe.putBooleanVolatile
sun.misc.Unsafe.putByteVolatile
sun.misc.Unsafe.putShortVolatile
sun.misc.Unsafe.putCharVolatile
sun.misc.Unsafe.putIntVolatile
sun.misc.Unsafe.putLongVolatile
sun.misc.Unsafe.putFloatVolatile
sun.misc.Unsafe.putDoubleVolatile
sun.misc.Unsafe.getByte
sun.misc.Unsafe.getShort
sun.misc.Unsafe.getChar
sun.misc.Unsafe.getInt
sun.misc.Unsafe.getLong
sun.misc.Unsafe.getFloat
sun.misc.Unsafe.getDouble
sun.misc.Unsafe.getAddress
sun.misc.Unsafe.putByte
sun.misc.Unsafe.putShort
sun.misc.Unsafe.putChar
sun.misc.Unsafe.putInt
sun.misc.Unsafe.putLong
sun.misc.Unsafe.putFloat
sun.misc.Unsafe.putDouble
sun.misc.Unsafe.putAddress
sun.misc.Unsafe.compareAndSwapObject
sun.misc.Unsafe.compareAndSwapLong
sun.misc.Unsafe.compareAndSwapInt
sun.misc.Unsafe.putOrderedObject
sun.misc.Unsafe.putOrderedLong
sun.misc.Unsafe.putOrderedInt
sun.misc.Unsafe.prefetchRead
sun.misc.Unsafe.prefetchWrite
sun.misc.Unsafe.prefetchReadStatic
sun.misc.Unsafe.prefetchWriteStatic

java.lang.Throwable.fillInStackTrace

java.lang.StringBuilder, object.initializer, void.method.signature
java.lang.StringBuilder, object.initializer, int.void.signature
java.lang.StringBuilder, object.initializer, string.void.signature

java.lang.StringBuilder.append(char)
java.lang.StringBuilder.append(int)
java.lang.StringBuilder.append(String)
java.lang.StringBuilder.toString()

java.lang.StringBuffer, object.initializer, void.method.signature
java.lang.StringBuffer, object.initializer, int.void.signature
java.lang.StringBuffer, object.initializer, string.void.signature
java.lang.StringBuffer.append(char)
java.lang.StringBuffer.append(int)
java.lang.StringBuffer.append(String)
java.lang.StringBuffer.toString()

java.lang.Integer.toString(int)

java.lang.String, object.initializer, string.void.signature
java.lang.Object, object.initializer, void.method.signature

java.lang.reflect.Method.invoke, object.object.array.object.signature

java.lang.invoke.MethodHandleNatives, checkSpreadArgument, checkSpreadArgument.signature
java.lang.invoke.MethodHandle, invokeExact,   object.array.object.signature
java.lang.invoke.MethodHandle, invokeGeneric, object.array.object.signature
java.lang.invoke.MethodHandle, invokeVarargs, object.array.object.signature
java.lang.invoke.InvokeDynamic, star,         object.array.object.signature

java.lang.invoke.MethodHandleImpl.selectAlternative, selectAlternative.signature

/* unboxing methods: */
java.lang.Boolean.booleanValue
java.lang.Byte.byteValue
java.lang.Character.charValue
java.lang.Short.shortValue
java.lang.Integer.intValue
java.lang.Long.longValue
java.lang.Float.floatValue
java.lang.Double.doubleValue

/* boxing methods: */ 
java.lang.Boolean.valueOf
java.lang.Byte.valueOf
java.lang.Character.valueOf
java.lang.Short.valueOf
java.lang.Integer.valueOf
java.lang.Long.valueOf
java.lang.Float.valueOf
java.lang.Double.valueOf

import java.io.Serializable;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.RandomAccess;

public class UnrolledLinkedList implements Cloneable, Collection, List, RandomAccess, Serializable {

   @Override
   public void add(int arg0, Object arg1) {
      // TODO Auto-generated method stub
      
   }

   @Override
   public boolean addAll(int arg0, Collection arg1) {
      // TODO Auto-generated method stub
      return false;
   }

   @Override
   public Object get(int arg0) {
      // TODO Auto-generated method stub
      return null;
   }

   @Override
   public int indexOf(Object arg0) {
      // TODO Auto-generated method stub
      return 0;
   }

   @Override
   public int lastIndexOf(Object arg0) {
      // TODO Auto-generated method stub
      return 0;
   }

   @Override
   public ListIterator listIterator() {
      // TODO Auto-generated method stub
      return null;
   }

   @Override
   public ListIterator listIterator(int arg0) {
      // TODO Auto-generated method stub
      return null;
   }

   @Override
   public Object remove(int arg0) {
      // TODO Auto-generated method stub
      return null;
   }

   @Override
   public Object set(int arg0, Object arg1) {
      // TODO Auto-generated method stub
      return null;
   }

   @Override
   public List subList(int arg0, int arg1) {
      // TODO Auto-generated method stub
      return null;
   }

   @Override
   public boolean add(Object arg0) {
      // TODO Auto-generated method stub
      return false;
   }

   @Override
   public boolean addAll(Collection arg0) {
      // TODO Auto-generated method stub
      return false;
   }

   @Override
   public void clear() {
      // TODO Auto-generated method stub
      
   }

   @Override
   public boolean contains(Object arg0) {
      // TODO Auto-generated method stub
      return false;
   }

   @Override
   public boolean containsAll(Collection arg0) {
      // TODO Auto-generated method stub
      return false;
   }

   @Override
   public boolean isEmpty() {
      // TODO Auto-generated method stub
      return false;
   }

   @Override
   public Iterator iterator() {
      // TODO Auto-generated method stub
      return null;
   }

   @Override
   public boolean remove(Object arg0) {
      // TODO Auto-generated method stub
      return false;
   }

   @Override
   public boolean removeAll(Collection arg0) {
      // TODO Auto-generated method stub
      return false;
   }

   @Override
   public boolean retainAll(Collection arg0) {
      // TODO Auto-generated method stub
      return false;
   }

   @Override
   public int size() {
      // TODO Auto-generated method stub
      return 0;
   }

   @Override
   public Object[] toArray() {
      // TODO Auto-generated method stub
      return null;
   }

   @Override
   public Object[] toArray(Object[] arg0) {
      // TODO Auto-generated method stub
      return null;
   }

}

// Don't do this!
ArrayList<Foo> foos = new ArrayList<Foo>(); 
HashMap<Foo,Bar> foobar = new HashMap<Foo,Bar>(); 

// Do this instead
List<Foo> foos = new ArrayList<Foo>(); 
Map<Foo,Bar> foobar = new HashMap<Foo,Bar>();    

public class GameLoopExperiment implements Runnable {

    private boolean running = true;
    private final int  framerate = 60;
    private final long frameIntervalNanos = 1_000_000_000L / framerate;

    public void logic(int deltaTime) {
        for(int i=0; i<entities.size(); i++) {
             entities[i].processTick(deltaTime);
        }
    }

    public void render() {
        for(int i=0; i<entities.size(); i++) {
             entities[i].draw();
        }
    }

    public boolean isRunning() {
        return running;
    }
 
    public void exit() {
        running = false;
    }

    public void run() { 
        long lastFrameNanos = System.nanoTime(); //Initialize it for the first time
        
        while ( this.isRunning() ) {
           long now = System.nanoTime(); // TODO wrap in a method that fixes negative nanoTimes
           long deltaTime = now - lastFrameNanos;
           lastFrameNanos = now;
           logic((int)deltaTime);
           render();
        }
    }
}

 public static void main(String[] args) {
        SampleApplet applet = new SampleApplet();
        Frame frame = new Frame();
        frame.addWindowListener(new WindowAdapter()
        {
          public void windowClosing(WindowEvent e)
          {
            System.exit(0);
          }
        });

        frame.add(applet);
        frame.setSize(800,600);
        frame.show();
        applet.init();
        applet.start();
    }

<applet code="SampleApplet.class" width="800" height="600"></applet>

<applet code="SampleApplet.class" archive="SampleJar.jar" width="800" height="600"></applet>