Hachage avec java

//HackTrackHashDemo ht = new HackTrackHashDemo(HackTrackHashDemo.COLLISION_HANDLER_DOUBLE_HASH);

HackTrackHashDemo(HackTrackHashDemo.COLLISION_HANDLER_LINEAR);

import java.util.ArrayList;
import java.util.List;

/**
 * Created on Nov 3, 2005
 * 
 * @author HackTrack
 *
 */
public class HackTrackHashDemo {
	public static final int COLLISION_HANDLER_LINEAR = 0;
	public static final int COLLISION_HANDLER_DOUBLE_HASH = 1;
	private int collisionHandling;
	private int size;
	private List valueList;

	/**
	 * Create a new HackTrackHashMap
	 * @param size Size of the map
	 * @param collisionHandling The type of collisionHandling to be used
	 */
	public HackTrackHashDemo(int collisionHandling, int size) {
		super();
		this.collisionHandling = collisionHandling;
		this.size = size;
		valueList = new ArrayList(this.size);
		for (int i = 0; i < this.size; i++) {
			valueList.add(i, null);
		}
	}

	/**
	 * Creates a new HackTrackHashMap with default size
	 * @param collisionHandling The type of collisionHandling to be used 
	 */
	public HackTrackHashDemo(int collisionHandling) {
		this(collisionHandling, 10);
	}

	/**
	 * Creates a new HackTrackHashMap with default size (10) and default collision handling method (double hash)
	 */
	public HackTrackHashDemo() {
		this(COLLISION_HANDLER_DOUBLE_HASH, 10);
	}

	/**
	 * Add a new entry into the table
	 * @param item The item to store into the table
	 * @return The object added to the table (null if object hasn't been added)
	 */
	public Object put(String item) {
		Object result = null;
		int hashKey = hash(item);
		if (valueList.get(hashKey) != null) {
			System.out.println("!!!!! COLLISION adding " + item);
			if (this.collisionHandling == COLLISION_HANDLER_DOUBLE_HASH) {
				hashKey = collisionDoubleHash(item);
			} else {
				hashKey = collisionLinearHash(hashKey);
			}
		}
		if (hashKey != -1) {
			result = item;
			add(hashKey, item);
			System.out.println(valueList);
		}
		return result;
	}

	/**
	 * Add an item into table
	 */
	private void add(int hashKey, Object value) {
		valueList.remove(hashKey);
		valueList.add(hashKey, value);
	}

	/**
	 * Handle a collision using linear method
	 * @param key The key to be used later to find back this item
	 * @param initialHash The initial hash code value
	 * @return The hash code for the object (-1 if no more available place in table)
	 */
	private int collisionLinearHash(int initialHash) {
		int h = -1;
		int index = initialHash;
		for (int i = 0; i < this.size; i++) {
			index++;
			if (index >= this.size)
				index = 0;
			if (valueList.get(index) == null) {
				h = index;
				System.out.println("New linear hash generated = " + h);
				break;
			}
		}
		System.out.println("New linear hash is " + h);
		return h;
	}

	/**
	 * Handle a collision using double hash method
	 * @param key The key to be used later to find back this item
	 * @return The hash code for the object (-1 if no more available place in table)
	 */
	private int collisionDoubleHash(String key) {
		int h = -1;
		// TO DO
		//Must return the new HashValue for 'key'.
		//h value must be greater or equal to 0 and lower than table size.
		return h;
	}

	/**
	 * Get an item with a specified key
	 * @param key The key to be used to find an item in the table
	 * @return The item ifound, else return null
	 */
	public Object get(String key) {
		Object result = null;
		int hashKey = hash(key);
		result = valueList.get(hashKey);
		if (result != null && !result.equals(key)) {
			if (this.collisionHandling == COLLISION_HANDLER_DOUBLE_HASH) {
				result = getDoubleHash(key);
			} else {
				result = getLinearHash(hashKey, key);
			}
		}
		return result;
	}

	/**
	 *  Find an object using linear hash
	 * @param key Item to find
	 */
	private Object getLinearHash(int initialHash, String key) {
		Object result = null;
		int index = initialHash;
		for (int i = 0; i <= this.size; i++) {
			index++;
			if (index >= this.size)
				index = 0;
			if (valueList.get(index) != null && valueList.get(index).equals(key)) {
				result = valueList.get(index);
				break;
			}
		}
		return result;
	}

	/**
	 *  Find an object using double hash
	 * @param key Item to find
	 */
	private Object getDoubleHash(String key) {
		Object result = null;
		//TO DO
		//Must return the Object for 'key' using double hash
		//Null if not found
		return result;
	}

	/**
	 * Get hash code for a specified String
	 * @param str
	 * @return
	 */
	private int hash(String str) {
		int h = 0;
		for (int i = 0; i < str.length(); i++) {
			h = 31 * h + str.charAt(i);
		}
		h = Math.abs(h % this.size);
		return h;
	}

	public static void main(String[] args) {
		String[] keys =
			{
				"hello",
				"goodbye",
				"damn",
				"go on!",
				"hacktrack",
				"java",
				"hashcode",
				"yessss",
				"development",
				"doubleHash" };
		//HackTrackHashDemo ht = new HackTrackHashDemo(HackTrackHashDemo.COLLISION_HANDLER_DOUBLE_HASH);
		HackTrackHashDemo ht = new HackTrackHashDemo(HackTrackHashDemo.COLLISION_HANDLER_LINEAR);
		
		//Adding items to table
		for (int i = 0; i < keys.length; i++) {
			ht.put(keys[i]);
		}

		//Searching items into table
		for (int i = 0; i < keys.length; i++) {
			System.out.println("Get (" + keys[i] + ") = " + ht.get(keys[i]));
		}

	}
}