热门标签 | HotTags
当前位置:  开发笔记 > 编程语言 > 正文

java散列与散列码探讨,简单HashMap实现散列映射表执行各种操作示列

java散列与散列码探讨,简单HashMap实现散列映射表执行各种操作示列packageorg.rui.collection2.maps;***散列与散列码*将土拔鼠对象与预报对象联系

java 散列与散列码探讨 ,简单HashMap实现散列映射表执行各种操作示列

package org.rui.collection2.maps;
/**
* 散列与散列码
* 将土拔鼠对象与预报对象联系起来,
* @author lenovo
*
*/
//土拨鼠
public class Groundhog {
protected int number;
public Groundhog(int n)
{
number=n;
}
@Override
public String toString() {
return "Groundhog #" + number;
}
}

package org.rui.collection2.maps;

import java.util.Random;

//预测
public class Prediction {
private static Random rand=new Random(47);
private boolean shadow=rand.nextDouble()>0.5;

@Override
public String toString() {
if(shadow)
return "六周后是冬天";//六个周的冬天six more weeks of winter
else
return "早春";//早春Early spring!
}
}

package org.rui.collection2.maps;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;
import java.util.Map;
/**
* 散列与散列码
* 将土拔鼠对象与预报对象联系起来,
* 每个Groundhog被 予一个标识 数字,于是可以在hasmmap中这样查找Prediction:
* 给我与Groundhog #3相关的prediction
* prediction类包含一个boolean 和toString
* 布尔 值用random来初始化;而Tostring方法则解释结果。
* detecSpring方法使用反射机制来实例化例用Groundhog类或任何从GroundHog派生出来的类.
*
* @author lenovo
*
*/
public class SpringDetector {
//发现
public static void detectSpring(Class type) throws Exception
{
Constructor ghog=type.getConstructor(int.class);
Map map=new HashMap();

//初始化map
for(int i=0;i<10;i++)
{
map.put(ghog.newInstance(i), new Prediction());
}
System.out.println("map:="+map);

//生成一个number=3的士拔鼠
Groundhog gh=ghog.newInstance(3);
//查找预测
System.out.println("looking up prediction for:"+gh);

//在初始化中的map中查找
if(map.containsKey(gh))
System.out.println(map.get(gh));
else
System.out.println("key not found "+gh);
//看起来很简单,但是他不工作,无法找到 需要实现hacode 和equals 下章讲解
}

public static void main(String[] args) throws Exception {
detectSpring(Groundhog.class);
}
}
/**output:
map:={Groundhog #5=早春, Groundhog #7=早春, Groundhog #8=六周后是冬天, Groundhog #0=六周后是冬天, Groundhog #9=六周后是冬天, Groundhog #2=早春, Groundhog #1=六周后是冬天, Groundhog #4=六周后是冬天, Groundhog #3=早春, Groundhog #6=早春}
looking up prediction for:Groundhog #3
key not found Groundhog #3
*/

package org.rui.collection2.maps;
/**
* 如果要使用自已的类作为HashMap的健,必须同时重载hashCode和equlas
* 示列
* @author lenovo
*
*/
//土拨鼠2
public class Groundhog2 extends Groundhog{
//public int number;
public Groundhog2(int n){ super(n);}
@Override
public int hashCode() {
return number;
}
@Override
public boolean equals(Object obj) {
return obj instanceof Groundhog2 &&
(number==((Groundhog2)obj).number);
}



}

package org.rui.collection2.maps;
/**
* Groundhog2.hashCode返回Groundhog的标识数字(编号)作为散列码。
* 在此例中,程序员负责确保不同的groundhog具有不同的编号。hashCode并不需要总是能够返回唯一的标识 码
* 但equals必须严格判断对象是否相同
* @author lenovo
*
*/
public class SpringDetector2 {
public static void main(String[] args) throws Exception {
SpringDetector.detectSpring(Groundhog2.class);
}

}
/**
map:={Groundhog #0=六周后是冬天, Groundhog #1=六周后是冬天, Groundhog #2=早春, Groundhog #3=早春, Groundhog #4=六周后是冬天, Groundhog #5=早春, Groundhog #6=早春, Groundhog #7=早春, Groundhog #8=六周后是冬天, Groundhog #9=六周后是冬天}
looking up prediction for:Groundhog #3
早春
*/

package org.rui.collection2.maps;

import java.util.*;

/**
* 理解hashCode
* 使用散列的目地在于 :你要使用一个对象来查找另一个对象.
* 不过使用TreeMap或者你自已实现的Map也可以达到此目地 下面的示例用
* 一对ArrayList实现了一个Map
*
* @author lenovo
*
*/
public class SlowMap extends AbstractMap {
private List keys = new ArrayList();
private List values = new ArrayList();

public V put(K key, V value) {
V oldValue = get(key);
if (!keys.contains(key)) {
keys.add(key);
values.add(value);// 添加新的
} else
// 它将被用来查找表示它在keys列表中的位置的数值型索引 并且这个数字被用作索引来产生与values列表相关联的值
values.set(keys.indexOf(key), value);
return oldValue;
}

public V get(Object key) {
if (!keys.contains(key))
return null;
return values.get(keys.indexOf(key));
}

public Set> entrySet() {
Set> set = new HashSet>();
Iterator ki = keys.iterator();
Iterator vi = values.iterator();
while (ki.hasNext()) {
set.add(new MapEntry(ki.next(), vi.next()));

}
return set;
}

public static void main(String[] args) {
// 慢的
SlowMap map = new SlowMap();
map.put("CAMEROON", "yaounde");
map.put("A", "aa");
map.put("B", "bb");
map.put("C", "cc");
System.out.println(map);
System.out.println(map.get("A"));
System.out.println(map.entrySet());
}

}
/**output:
{CAMEROON=yaounde, C=cc, B=bb, A=aa}
aa
[CAMEROON=yaounde, C=cc, B=bb, A=aa]
*/

package org.rui.collection2.maps;

import java.util.Map;

/**
* 想要创建自已的map类型,就必须同时定义Map.Entry的实现
*
* @author lenovo
*
*/
public class MapEntry implements Map.Entry {

private K key;
private V value;

public MapEntry(K key, V value) {
this.key = key;
this.value = value;
}

@Override
public K getKey() {
return key;
}

@Override
public V getValue() {
return value;
}

@Override
public V setValue(V v) {
V result = value;
value = v;
return result;
}

public int hashCode() {
// 异或 不同为1 相同的为0
return (key == null ? 0 : key.hashCode())
^ (value == null ? 0 : value.hashCode());
}

public boolean equals(Object o) {
if (!(o instanceof MapEntry))return false;
MapEntry me = (MapEntry) o;
return (key == null ?
me.getKey() == null : key.equals(me.getKey()))
&& (value == null ? me.getValue() == null : value.equals(me
.getValue()));
}

public String toString() {
return key + "=" + value;
}

}

package org.rui.collection2.maps;

import java.util.AbstractMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.ListIterator;
import java.util.Map;
import java.util.Set;

/**
* 为速度而散列
*
* 散列的价值在于速度,解决方案之一就是保持健的排序状态,然后使用Collections.binarySearch()查询
* 数组并不保存健本身。而是通过健对象生成一个数字,将其作为数组的下标。这个数字就是散列码,
* 注意:这个 实现并不意味着对性能进行了调化,它只是想要展示散列映射表执行的各种操作,
* @author lenovo
*
*/
public class SimpleHashMap extends AbstractMap {


static final int SIZE=997;
//你不可能拥有一个物理geerics数组
//you can't have a physical array of geerics
//but you can upcast to one 但是你可以向上抛
LinkedList>[] buckets=new LinkedList[SIZE];//bucket桶 位
/***
* 对于put方法 hasCode将针对健而被调用,并且其结果被强制转换为正数。
* 为了使产生的数字适合bucket数组的大小 取模操作符将按照该数组的尺寸取模,
* 如果数组的某个位置是null,这表示还没有元素被散列至此,所以,为了保存刚散列到该定位的对象
* 需要创建一个新的LinkedList
*
*/
public V put(K key,V value)
{
V oldValue=null;
int index=Math.abs(key.hashCode())%SIZE;
if(buckets[index]==null)
{
buckets[index]=new LinkedList>();
}
LinkedList> bucket=buckets[index];
MapEntry pair=new MapEntry(key,value);
boolean found=false;
ListIterator> it=bucket.listIterator();
while(it.hasNext())
{
MapEntry itM=it.next();
if(itM.getKey().equals(key))
{
oldValue=itM.getValue();
it.set(itM);//replace old with new
found=true;
break;
}
}
if(!found)
{
buckets[index].add(pair);
}
return oldValue;
}

/**
* get 按照put相同的方式计算在buckets数组中的索引,
* 这个很重要,因为这样可以保证两个方法可以计算相同的位置
*/

@Override
public V get(Object key)
{
int index=Math.abs(key.hashCode())%SIZE;
if(buckets[index]==null)return null;
for(MapEntry ipair:buckets[index])
if(ipair.getKey().equals(key))
return ipair.getValue();
return null;
}

@Override
public Set> entrySet() {
Set> set=new HashSet>();
for(LinkedList> bucket:buckets)
{
if(bucket==null)continue;
for(MapEntry mpair:bucket)
set.add(mpair);
}
return set;
}
////////////////////////////////////////////////////////
public static void main(String[] args) {
SimpleHashMap simple=new SimpleHashMap();
simple.put("CAMEROON", "yaounde");
simple.put("A", "aa");
simple.put("B", "bb");
simple.put("C", "cc");
System.out.println(simple);
System.out.println(simple.get("B"));
System.out.println(simple.entrySet());
}
}
/***output:
{CAMEROON=yaounde, C=cc, B=bb, A=aa}
bb
[CAMEROON=yaounde, C=cc, B=bb, A=aa]
*/




推荐阅读
  • 本文详细介绍了Java反射机制的基本概念、获取Class对象的方法、反射的主要功能及其在实际开发中的应用。通过具体示例,帮助读者更好地理解和使用Java反射。 ... [详细]
  • 2020年9月15日,Oracle正式发布了最新的JDK 15版本。本次更新带来了许多新特性,包括隐藏类、EdDSA签名算法、模式匹配、记录类、封闭类和文本块等。 ... [详细]
  • Spring – Bean Life Cycle
    Spring – Bean Life Cycle ... [详细]
  • DAO(Data Access Object)模式是一种用于抽象和封装所有对数据库或其他持久化机制访问的方法,它通过提供一个统一的接口来隐藏底层数据访问的复杂性。 ... [详细]
  • Spring Boot 中配置全局文件上传路径并实现文件上传功能
    本文介绍如何在 Spring Boot 项目中配置全局文件上传路径,并通过读取配置项实现文件上传功能。通过这种方式,可以更好地管理和维护文件路径。 ... [详细]
  • 本文介绍了在 Java 编程中遇到的一个常见错误:对象无法转换为 long 类型,并提供了详细的解决方案。 ... [详细]
  • 深入解析 Lifecycle 的实现原理
    本文将详细介绍 Android Jetpack 中 Lifecycle 组件的实现原理,帮助开发者更好地理解和使用 Lifecycle,避免常见的内存泄漏问题。 ... [详细]
  • 本文详细介绍了 PHP 中对象的生命周期、内存管理和魔术方法的使用,包括对象的自动销毁、析构函数的作用以及各种魔术方法的具体应用场景。 ... [详细]
  • 属性类 `Properties` 是 `Hashtable` 类的子类,用于存储键值对形式的数据。该类在 Java 中广泛应用于配置文件的读取与写入,支持字符串类型的键和值。通过 `Properties` 类,开发者可以方便地进行配置信息的管理,确保应用程序的灵活性和可维护性。此外,`Properties` 类还提供了加载和保存属性文件的方法,使其在实际开发中具有较高的实用价值。 ... [详细]
  • Android 自定义 RecycleView 左滑上下分层示例代码
    为了满足项目需求,需要在多个场景中实现左滑删除功能,并且后续可能在列表项中增加其他功能。虽然网络上有很多左滑删除的示例,但大多数封装不够完善。因此,我们尝试自己封装一个更加灵活和通用的解决方案。 ... [详细]
  • 本文介绍了如何使用Java和PDFBox库根据坐标值对PDF文件进行局部切割的方法。 ... [详细]
  • 在多线程并发环境中,普通变量的操作往往是线程不安全的。本文通过一个简单的例子,展示了如何使用 AtomicInteger 类及其核心的 CAS 无锁算法来保证线程安全。 ... [详细]
  • 重要知识点有:函数参数默许值、盈余参数、扩大运算符、new.target属性、块级函数、箭头函数以及尾挪用优化《深切明白ES6》笔记目次函数的默许参数在ES5中,我们给函数传参数, ... [详细]
  • 原文网址:https:www.cnblogs.comysoceanp7476379.html目录1、AOP什么?2、需求3、解决办法1:使用静态代理4 ... [详细]
  • 本文是Java并发编程系列的开篇之作,将详细解析Java 1.5及以上版本中提供的并发工具。文章假设读者已经具备同步和易失性关键字的基本知识,重点介绍信号量机制的内部工作原理及其在实际开发中的应用。 ... [详细]
author-avatar
流年时光云
这个家伙很懒,什么也没留下!
PHP1.CN | 中国最专业的PHP中文社区 | DevBox开发工具箱 | json解析格式化 |PHP资讯 | PHP教程 | 数据库技术 | 服务器技术 | 前端开发技术 | PHP框架 | 开发工具 | 在线工具
Copyright © 1998 - 2020 PHP1.CN. All Rights Reserved | 京公网安备 11010802041100号 | 京ICP备19059560号-4 | PHP1.CN 第一PHP社区 版权所有