// String.hashCode

    /** The value is used for character storage. */
    private final char value[];

    /** The offset is the first index of the storage that is used. */
    private final int offset;

    /** The count is the number of characters in the String. */
    private final int count;

    /** Cache the hash code for the string */
    private int hash; // Default to 0

    /**
     * Returns a hash code for this string. The hash code for a
     * <code>String</code> object is computed as
     * <blockquote><pre>
     * s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]
     * </pre></blockquote>
     * using <code>int</code> arithmetic, where <code>s[i]</code> is the
     * <i>i</i>th character of the string, <code>n</code> is the length of
     * the string, and <code>^</code> indicates exponentiation.
     * (The hash value of the empty string is zero.)
     *
     * @return a hash code value for this object.
     */
    public int hashCode()
        {
        int h = hash;
        if ( h == 0 )
            {
            int off = offset;
            char val[] = value;
            int len = count;

            for ( int i = 0; i < len; i++ )
                {
                h = 31 * h + val[ off++ ];
                }
            hash = h;
            }
        return h;
        }

import java.awt.Color;
/**
 * Class to describe a fruit.
 */
public class Fruit
   {
   /**
    * Flavour of the fruit.
    */
   private String flavour;

   /**
    * Colour of the fruit.
    */
   private Color colour;

   /**
    * Compare this Fruit object with another
    * fruit object.
    *
    * @param other Object, usually a Fruit, to compare with.
    *
    * @return true if the objects are of identical flavour.
    */
   public boolean equals ( Object other )
      {
      if ( other == null )
         {
         return false;
         }
      else if ( other instanceof Fruit )
         {
         return this.flavour.equals ( ((Fruit)other ).flavour );
         }
      else return false;
      }

   /**
    * Calculate the hashcode of this object, based
    * only on its flavour.
    *
    * @return the hashcode for the Fruit object
    */
   public int hashCode()
      {
      return flavour.hashCode();
      }
   }

// simple packed hashCode algorithm
final int low1 = 0;
final int high1 = 99;

final int low2 = -10;
final int high2 = 10;

final int low3 = 100;
final int high3 = 1000;

int hashCode = ( field1 - low1 );
hashCode *= ( high2 - low2 + 1 );
hashCode += ( field2 - low2 );
hashCode *= ( high3 - low3 + 1 );
hashCode += ( field3 - low3 );

// object1 has
o1.string1 = "apple";
o1.string2 = "orange";
// and object2 has
o2.string1 = "orange";
o2.string2 = "apple";

/**
 * hashCode that combines two strings
 * @return a hash code value on the pair of strings.
 */
public int hashCode()
   {
   int result = string1.hashCode();
   result = 37 * result + string2.hashCode();
   result = 37 * result + string3.hashCode();
   // etc for all fields in the object
   // This will only work for 5 fields before you overflow and lose input from the first field.
   // The optimal prime multiplier is near Math.exp( Math.log( Integer.MAX_VALUE ) / numberOfFields) )
   // This technique samples output from all the component Objects but mushes it together with information form the other fields.
   return result;
   }

/**
 * hashCode that combines three strings using xor.
 * @return a hash code value on the entire object.
 */
public int hashCode()
   {
   // this will not work well if some of the strings are equal.
   int result = string1.hashCode();
   result ^= string2.hashCode();
   result ^= string3.hashCode();
   // etc for all fields in the object
   return result;
   }

/**
 * simplified version of how String.hashCode works.
 * For the actual version see src.jar java/lang/String.java
 * @return a hash code value for this String.
 */
public int hashCode()
   {
   // inside the String is a char[] val that holds the characters.
   int hash = 0;
   int len = char.length();
   for ( int i=0; i<len; i++ )
      {
      hash = 31 * hash + val[ i ];
      }
   return hash;
   }

/**
 * Java version of the assembler hashCode used in the BBL Forth compiler.
 * Because of the 1-bit shift you don't lose data completely on long keys.
 * The shift breaks up patterns in the data.
 * @return a hash code value for the byte[] val byte array in this object.
 */
public int hashCode()
   {
   //  byte[] val  holds the data.
   int hash = 0;
   int len = val.length();
   for ( int i=0; i<len; i++ )
      {
      // rotate left and xor (very fast in assembler, a bit clumsy to specify in Java, but a smart compiler might collapse it to two machine instructions)
      hash <<= 1;
      if ( hash < 0 )
         {
         hash |= 1;
         }
      hash ^= val[ i ];
      }
   return hash;
   }

/**
 * A vanilla XOR hashCode of all the bytes in an array. This gives only a signed 8-bit result.
 * @param val array of bytes to hash
 * @return a hash code value for the byte[] val byte array.
 */
public static int hashCode( byte[] val )
   {
   //  byte[] val  holds the data.
   int hash = 0;
   final int len = val.length();
   for ( int i=0; i<len; i++ )
      {
      hash ^= val[ i ];
      }
   return hash;
   }