package hashMap;
import java.util.*;
import java.util.Map.Entry;
//map 是一种键值对 ，不能有重复的键 因此用set 作为其key最适合了
public class HashMapTest
{
public static <K, V> void main(String[] args)
{
// HashMap hm=new HashMap();
// hm.put(1,"123");
// hm.put(2,"456");
// hm.put(3,"123");
// hm.put(4,"456");
// hm.put(5,"123");
// hm.put(6,"456");
// System.out.println(hm.get(1));
// System.out.println(hm);
// //键试图操作
// Set s=hm.keySet();
// s.remove(1);
// System.out.println(hm);
// //值视图操作
// Collection col=hm.values();
// //col.add("789");
// col.remove("456");
// System.out.println(hm);
// //映射集合
// Set keyvalue=hm.entrySet();
// for(Object o:key_value)
// {
// Entry e=(Entry) o;
// e.setValue("test");
// System.out.println(e.getKey()+"------"+e.getValue());
// }
//hashMap与hashtable得区别:1.hashMap可以有空键，空值，hashtabe不可以有
//2.hashmap是线程不安全的，hashitable是线程安全的(单线程使用hashMap多线程使用hashtable)
//3.hashMap的效率高
HashMap<Integer, Manager> hm=new HashMap<Integer, Manager>();
Manager m1=new Manager(123,"郑云飞",22);
Manager m2=new Manager(456,"xuanzi",18);
hm.put(123, m1);
hm.put(456, m2);
if(hm.containsKey(123))
{
System.out.println("有此人");
Manager mm=m1;
System.out.println(mm);
}
else
{
System.out.println("无此人");
}
//遍历HashMap中的key何value的值
Iterator<Integer> it=hm.keySet().iterator();
while(it.hasNext())
{
//取出key
Integer key=it.next();
//通过key取出value
Manager mm=hm.get(key);
//输出信息
System.out.println("编号:"+mm.getId());
System.out.println("姓名:"+mm.getName());
System.out.println("年龄:"+mm.getAge());
}
}
}
package hashMap;
class Manager
{
private int id;
private String name;
private int age;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Manager(int id, String name, int age) {
super();
this.id = id;
this.name = name;
this.age = age;
}
public Manager(int id, String name)
{
super();
this.id = id;
this.name = name;
}
@Override
public String toString() {
// TODO Auto-generated method stub
return "编号:"+id+"姓名:"+name+"年龄："+age;
}
public static int test(int id,String name,int age)
{
System.out.println("编号:"+id+"姓名:"+name+"年龄："+age);
return age;
}
}
package hashMap;
import java.io.FileInputStream;
import java.lang.reflect.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Enumeration;
import java.util.Properties;
class MyReflect
{
//依据参数返回类对象 参数:
public static Object getObject(String[] args,Class cl) throws Exception
{
int con_Args_Count = Integer.parseInt(args[1]);//构造函数参数个数
Class[] con_Class = new Class[con_Args_Count];//形参列表
Object[] con_Object = new Object[con_Args_Count];//实参列表
Object o = null;//获取对象的实例
for(int i=0;i<con_Class.length;i++)
{
if(args[2+i].equals("int"))
{
con_Class[i] = int.class;
con_Object[i] = Integer.parseInt(args[2+con_Args_Count+i]);
}
if(args[2+i].equals("String"))
{
con_Class[i] = String.class;
con_Object[i] = args[2+con_Args_Count+i];
}
if(args[2+i].equals("char"))
{
con_Class[i] = char.class;
con_Object[i] = args[2+con_Args_Count+i].charAt(0);
}
if(args[2+i].equals("float"))
{
con_Class[i] = float.class;
con_Object[i] = Float.parseFloat(args[2+con_Args_Count+i]);
}
if(args[2+i].equals("boolean"))
{
con_Class[i] = boolean.class;
con_Object[i] = Boolean.parseBoolean(args[2+con_Args_Count+i]);
}
}
Constructor con = cl.getDeclaredConstructor(con_Class);//获取class对象所表示的类或接口的指定构造方法
o = con.newInstance(con_Object);//创建对象
return o;
}
//依据参数执行方法 并返回结果 参数:
public static Object invokeMethod(String[] args,Object o,Class cl) throws Exception
{
int con_Args_Count = Integer.parseInt(args[1]);
int me_Args_Count = Integer.parseInt(args[3+2*con_Args_Count]);
Class[] me_Class = new Class[me_Args_Count];
Object[] me_Object = new Object[me_Args_Count];
String me_Name = args[2+2*con_Args_Count];
for(int i=0;i<me_Class.length;i++)
{
Object[] oo = turn(args[4+2*con_Args_Count+i],args[4+2*con_Args_Count+me_Args_Count+i]);
me_Class[i] = (Class)oo[0];
me_Object[i] = oo[1];
}
Method m = cl.getDeclaredMethod(me_Name,me_Class);
Object result = m.invoke(o,me_Object);
return result;
}
public static void main(String[] args) throws Exception
{
Properties p=new Properties();
p.load(new FileInputStream("test.ini"));
Enumeration e=p.propertyNames();
ArrayList al=new ArrayList();
while(e.hasMoreElements())
{
String key=(String) e.nextElement();
al.add(key);
}
Collections.sort(al);
}
public static Object[] turn(String cs,String os)
{
Object[] o = new Object[2];
if(cs.equals("int"))
{
o[0] = int.class;
o[1] = Integer.parseInt(os);
}
if(cs.equals("String"))
{
o[0] = String.class;
o[1] = os;
}
if(cs.equals("char"))
{
o[0] = char.class;
package hashMap;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.Enumeration;
import java.util.Properties;
public class PropertiesTest
{
public static void main(String[] args) throws FileNotFoundException, IOException
{
Properties p=new Properties();
//Properties p=System.getProperties();
// System.out.println("当前系统:"+p.getProperty("os.name"));
// System.out.println("当前系统版本:"+p.getProperty("os.version"));
// System.out.println("当前java版本:"+p.getProperty("java.version"));
// System.out.println("用户名:"+p.getProperty("user.name"));
//
p.load(new FileInputStream("test.ini"));
//枚举器
Enumeration e=p.propertyNames();
while(e.hasMoreElements())
{
String key=(String) e.nextElement();
//为了能读中文()
System.out.println(key+"=="+new String(p.getProperty(key).getBytes("latin1"),"gbk"));
}
}
}
package hashMap;
import java.lang.reflect.*;
import java.io.*;
class ReflectTest
{
public static void main(String[] args) throws Exception
{
//BankCard bc=new BankCard("12","123456","zhangsan",123);
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
//获取待产生对象的类的名称
System.out.println("请输入类名:");
String className = br.readLine();
//加载该类至内存 并获得该类的自描述Class对象
Class cl = Class.forName(className);
//通过自描述对象产生对象（假如该类有无参构造）
Object o = cl.newInstance();
System.out.println(o.getClass().getName());
//获得待执行方法名
System.out.println("请输入方法名:");
String methodName = br.readLine();
//通过类的自描述对象获得方法的描述对象
if(methodName.equals("welcome"))
{
Method m = cl.getMethod(methodName);
m.invoke(o);
}
//通过方法的自描述对象执行该方法
//System.out.println("对象m："+m);
else if(methodName.equals("insertCard"))
{
Method m=cl.getMethod(methodName,BankCard.class);
m.invoke(o,bc);
}
/**
*调用主函数
*
**/
else if (methodName.equals("main"))
{
Method m = cl.getMethod(methodName,new Class[]{String[].class});
m.invoke(o,(Object)new String[]{"",""});
}
else if(methodName.equals("test"))
{
Method m=cl.getMethod(methodName,new Class[]{int.class,int.class});
m.invoke(o,5,6);
}
//获得一个类的所有公共非构造方法
System.out.println("All public method");
Method[] mo = cl.getMethods();
for(Method mm:mo)
{
System.out.println(mm);
}
System.out.println("All method:");
//获得一个类中所有非构造方法
Method[] me = cl.getDeclaredMethods();
for(Method mm:me)
{
System.out.println(mm);
}
//所有的公共构造
System.out.println("公共构造:");
Constructor[] c = cl.getConstructors();
for(Constructor cc:c)
{
System.out.println(cc);
}
//所有构造
System.out.println("所有构造:");
Constructor[] cs = cl.getDeclaredConstructors();
for(Constructor cs1:cs)
{
System.out.println(cs1);
}
}
};
class Test
{
int a,b;
Test(int a,int b)
{
this.a=a;
this.b=b;
}
public void test(int a,int b)
{
a=9;b=8;
System.out.println("a="+a+"b="+b);
//System.exit(0);
}
public void test(int a)
{
a=10;
System.out.println(a);
System.exit(0);
}
};
o[1] = os.charAt(0);
}
if(cs.equals("float"))
{
o[0] = float.class;
o[1] = Float.parseFloat(os);
}
if(cs.equals("boolean"))
{
o[0] = boolean.class;
o[1] = Boolean.parseBoolean(os);
}
return o;
}
}
分享到：
相关推荐
HashMap之resize()方法源码解读 HashMap的resize()方法是HashMap中最核心的方法之一，该方法负责扩容HashMap的容量，以便存储更多的键值对。下面我们将对HashMap的resize()方法进行源码解读，了解其扩容机制和原理...
《HashMap面试题详解》 HashMap作为Java集合框架中的重要成员，是面试中常见的知识点，尤其在数据结构与算法、并发编程以及JVM内存管理等领域，HashMap的深入理解至关重要。本篇将围绕HashMap的相关面试题，从基础...
### hashMap和hashTable的区别 #### 一、简介与基本概念 `HashMap` 和 `HashTable` 都是 Java 集合框架中非常重要的数据结构，它们都实现了 `Map` 接口，用于存储键值对。尽管它们在功能上有很多相似之处，但在...
在Java编程中，HashMap是一个非常常用的集合类，用于存储键值对数据。然而，它存在一个重要的特性，那就是线程不安全。理解这个问题并找到解决方案是每个Java开发者必须掌握的知识。 HashMap线程不安全的原因主要...
### HashMap与HashTable的区别详解 #### 引言 在Java编程中，`HashMap`与`HashTable`作为两种常用的数据结构，经常被用来存储键值对数据。尽管它们在功能上相似，但在实现细节、性能表现以及使用场景方面存在显著...
### HashMap介绍和使用详解 #### 一、HashMap的数据结构 HashMap是Java集合框架的一个重要组成部分，它实现了Map接口，能够存储键值对映射。在Java编程语言中，最基本的数据结构有两种：数组和引用（模拟指针）。...
在这个主题中，我们将深入探讨如何使用JNI处理HashMap、String等对象。 首先，让我们来理解JNI的基本结构。JNI接口提供了大量的函数，让本地方法（C/C++代码）能够创建、访问和修改Java对象。要使用JNI，你需要定义...
### 使用HashMap模拟网上购物车 #### 一、项目背景与目标 在本实验中，我们通过使用Java语言中的`HashMap`来模拟一个简单的网上购物车系统。该项目的主要目的是熟悉Java集合框架中的`HashMap`类，并了解如何利用它...
HashMap是Java编程语言中一个非常重要的数据结构，它属于集合框架的一部分，主要用于存储键值对（Key-Value）数据。HashMap在内部实现上基于哈希表，也称为散列表，它提供了一种快速查找、插入和删除数据的方法，...
### ibatis 使用 HashMap 解决 resultClass 映射 在日常的软件开发过程中，尤其是在处理数据库查询时，我们经常面临一个问题：如何优雅地处理那些未知或动态变化的列名及列数的情况？在这种情况下，传统的实体类...
在IT行业中，哈希表（HashMap）是一种高效的数据结构，它使用哈希函数将键（Key）映射到数组的特定位置，以便快速存取数据。Delphi是一种强大的Object Pascal编程语言，它提供了多种实现哈希表的方式。在这个特定的...
Java HashMap 类详解 本资源详细介绍了 Java 中的 HashMap 类，包括其实现机制、Hash 存储机制、集合存储机制等方面的知识点。 1. HashMap 和 HashSet 的关系 HashMap 和 HashSet 是 Java Collection Framework ...
Java中的HashMap是一个非常重要的数据结构，它实现了Map接口，提供了键值对的高效存储和访问。HashMap基于哈希表（也称为散列表）原理工作，它允许用户通过键（Key）快速查找对应的值（Value）。在HashMap中，键和值...
哈希映射（HashMap）是Java编程语言中广泛使用的数据结构之一，主要提供键值对的存储和查找功能。HashMap的实现基于哈希表的概念，它通过计算对象的哈希码来快速定位数据，从而实现了O(1)的平均时间复杂度。在深入...
HashMap类在Java编程语言中是集合框架的一部分，它是一个基于哈希表的Map接口实现。HashMap提供了快速的插入、删除和查找操作，平均时间复杂度为O(1)。在这个压缩包“HashMap类.rar”中，包含的是易语言版本的...
### Java中HashMap, LinkedHashMap, TreeMap，HashTable的区别 在Java编程语言中，`Map`接口是集合框架中的一个重要组成部分，用于存储键值对。本文将详细分析四种常用的`Map`实现类：`HashMap`, `LinkedHashMap`, ...
HashMap是Java编程语言中常用的集合类之一，它属于哈希表数据结构，提供key-value的存储方式，并且具有快速查询的特性。然而，HashMap本身并不保证元素的顺序，特别是当涉及到遍历或输出HashMap的内容时，顺序可能会...
哈希映射（HashMap）是Java编程语言中一个非常重要的数据结构，它在《简单的key value hashmap》中被提及，通常用于存储键值对（key-value pairs）。HashMap是Java集合框架的一部分，它提供了高效的查找、插入和删除...
《马士兵老师HashMap学习笔记详解》 HashMap是Java编程语言中常用的一种数据结构，它提供了键值对（key-value pair）的存储功能，是基于哈希表实现的。马士兵老师的HashMap学习笔记深入剖析了这一核心组件的工作...