======>1@:数组
10月12日
JAVA数组
java语言中，数组是一种最简单的复合数据类型。数组是有序数据的集合，数组中的每个元素具有相同的数据类型，可以用一个统一的数组名和下标来唯一地确定数组中的元素。数组有一维数组和多维数组。
★ 一维数组
1． 一维数组的定义
type arrayName[ ]；
类型(type)可以为Java中任意的数据类型，包括简单类型和复合类型。
例如：
int intArray[ ]；
Date dateArray[];
2．一维数组的初始化
◇ 静态初始化
int intArray[]={1,2,3,4};
String stringArray[]={"abc", "How", "you"};
◇ 动态初始化
1）简单类型的数组
int intArray[];
intArray = new int[5];
2）复合类型的数组
String stringArray[ ];
String stringArray = new String[3];/*为数组中每个元素开辟引用 空间(32位) */
stringArray[0]= new String("How");//为第一个数组元素开辟空间
stringArray[1]= new String("are");//为第二个数组元素开辟空间
stringArray[2]= new String("you");// 为第三个数组元素开辟空间
3．一维数组元素的引用
数组元素的引用方式为：
arrayName[index]
index为数组下标，它可以为整型常数或表达式，下标从0开始。每个数组都有一个属性length指明它的长度，例如：intArray.length指明数组intArray的长度。
★多维数组
Java语言中，多维数组被看作数组的数组。
1．二维数组的定义
type arrayName[ ][ ]；
type [ ][ ]arrayName;
2．二维数组的初始化
◇ 静态初始化
int intArray[ ][ ]={{1,2},{2,3},{3,4,5}};
Java语言中，由于把二维数组看作是数组的数组，数组空间不是连续分配的，所以不要求二维数组每一维的大小相同。
◇ 动态初始化
1) 直接为每一维分配空间，格式如下：
arrayName = new type[arrayLength1][arrayLength2];
int a[ ][ ] = new int[2][3]；
2) 从最高维开始，分别为每一维分配空间：
arrayName = new type[arrayLength1][ ];
arrayName[0] = new type[arrayLength20];
arrayName[1] = new type[arrayLength21];
…
arrayName[arrayLength1-1] = new type[arrayLength2n];
3) 例：
二维简单数据类型数组的动态初始化如下,
int a[ ][ ] = new int[2][ ]；
a[0] = new int[3];
a[1] = new int[5];
对二维复合数据类型的数组，必须首先为最高维分配引用空间，然后再顺次为低维分配空间。
而且，必须为每个数组元素单独分配空间。
例如：
String s[ ][ ] = new String[2][ ];
s[0]= new String[2];//为最高维分配引用空间
s[1]= new String[2]; //为最高维分配引用空间
s[0][0]= new String("Good");// 为每个数组元素单独分配空间
s[0][1]= new String("Luck");// 为每个数组元素单独分配空间
s[1][0]= new String("to");// 为每个数组元素单独分配空间
s[1][1]= new String("You");// 为每个数组元素单独分配空间
3．二维数组元素的引用
对二维数组中的每个元素，引用方式为：arrayName[index1][index2]
例如： num[1][0];
4．二维数组举例：
【例2．2】两个矩阵相乘
public class MatrixMultiply{
public static void main(String args[]){
int i,j,k;
int a[][]=new int [2][3]; //动态初始化一个二维数组
int b[][]={{1,5,2,8},{5,9,10,-3},{2,7,-5,-18}};//静态初始化
一个二维数组
int c[][]=new int[2][4]; //动态初始化一个二维数组
for (i=0;i<2;i++)
for (j=0; j<3 ;j++)
a[i][j]=(i+1)*(j+2);
for (i=0;i<2;i++){
for (j=0;j<4;j++){
c[i][j]=0;
for(k=0;k<3;k++)
c[i][j]+=a[i][k]*b[k][j];
}
}
System.out.println("*******Matrix C********");//打印Matrix C标记
for(i=0;i<2;i++){
for (j=0;j<4;j++)
System.out.println(c[i][j]+" ");
System.out.println();
}
}
}
2．5 字符串的处理
★ 字符串的表示
Java语言中，把字符串作为对象来处理，类String和StringBuffer都可以用来表示一个字符串。(类名都是大写字母打头)
1．字符串常量
字符串常量是用双引号括住的一串字符。
"Hello World!"
2．String表示字符串常量
用String表示字符串：
String( char chars[ ] );
String( char chars[ ], int startIndex, int numChars );
String( byte ascii[ ], int hiByte );
String( byte ascii[ ], int hiByte, int startIndex, int numChars );
String使用示例：
String s=new String() ; 生成一个空串
下面用不同方法生成字符串"abc"：
char chars1[]={'a','b','c'};
char chars2[]={'a','b','c','d','e'};
String s1=new String(chars1);
String s2=new String(chars2,0,3);
byte ascii1[]={97,98,99};
byte ascii2[]={97,98,99,100,101};
String s3=new String(ascii1,0);
String s4=new String(ascii2,0,0,3);
3．用StringBuffer表示字符串
StringBuffer( ); /*分配16个字符的缓冲区*/
StringBuffer( int len ); /*分配len个字符的缓冲区*/
StringBuffer( String s ); /*除了按照s的大小分配空间外,再分配16个
字符的缓冲区*/
★访问字符串
1．类String中提供了length( )、charAt( )、indexOf( )、lastIndexOf( )、getChars( )、getBytes( )、toCharArray( )等方法。
◇ public int length() 此方法返回字符串的字符个数
◇ public char charAt(int index) 此方法返回字符串中index位置上的字符，其中index 值的 范围是0~length-1
◇ public int indexOf(int ch)
public lastIndexOf(in ch)
返回字符ch在字符串中出现的第一个和最后一个的位置
◇ public int indexOf(String str)
public int lastIndexOf(String str)
返回子串str中第一个字符在字符串中出现的第一个和最后一个的位置
◇ public int indexOf(int ch,int fromIndex)
public lastIndexOf(in ch ,int fromIndex)
返回字符ch在字符串中位置fromIndex以后出现的第一个和最后一个的位置
◇ public int indexOf(String str,int fromIndex)
public int lastIndexOf(String str,int fromIndex)
返回子串str中的第一个字符在字符串中位置fromIndex后出现的第一个和最后一个的位置。
◇ public void getchars(int srcbegin,int end ,char buf[],int dstbegin)
srcbegin 为要提取的第一个字符在源串中的位置， end为要提取的最后一个字符在源串中的位置，字符数组buf[]存放目的字符串， dstbegin 为提取的字符串在目的串中的起始位置。
◇public void getBytes(int srcBegin, int srcEnd,byte[] dst, int dstBegin)
参数及用法同上，只是串中的字符均用8位表示。
2．类StringBuffer提供了 length( )、charAt( )、getChars( )、capacity()等方法。
方法capacity()用来得到字符串缓冲区的容量，它与方法length()所返回的值通常是不同的。
★修改字符串
修改字符串的目的是为了得到新的字符串，类String和类StringBuffer都提供了相应的方法。有关各个方法的使用，参考java 2 API。
1．String类提供的方法：
concat( )
replace( )
substring( )
toLowerCase( )
toUpperCase( )
◇ public String contat(String str);
用来将当前字符串对象与给定字符串str连接起来。
◇ public String replace(char oldChar,char newChar);
用来把串中出现的所有特定字符替换成指定字符以生成新串。
◇ public String substring(int beginIndex)；
public String substring(int beginIndex,int endIndex);
用来得到字符串中指定范围内的子串。
◇ public String toLowerCase();
把串中所有的字符变成小写。
◇ public String toUpperCase();
把串中所有的字符变成大写。
2．StringBuffer类提供的方法：
append( )
insert( )
setCharAt( )
如果操作后的字符超出已分配的缓冲区,则系统会自动为它分配额外的空间。
◇ public synchronized StringBuffer append(String str);
用来在已有字符串末尾添加一个字符串str。
◇ public synchronized StringBuffer insert(int offset, String str);
用来在字符串的索引offset位置处插入字符串str。
◇ public synchronized void setCharAt(int index,char ch);
用来设置指定索引index位置的字符值。
注意：String中对字符串的操作不是对源操作串对象本身进行的，而是对新生成的一个源操作串对象的拷贝进行的，其操作的结果不影响源串。
相反，StringBuffer中对字符串的连接操作是对源串本身进行的，操作之后源串的值发生了变化，变成连接后的串。
★ 其它操作
1．字符串的比较
String中提供的方法：
equals( )和equalsIgnoreCase( )
它们与运算符'= ='实现的比较是不同的。运算符'= ='比较两个对象是否引用同一个实例，而equals( )和equalsIgnoreCase( )则比较 两个字符串中对应的每个字符值是否相同。
2．字符串的转化
java.lang.Object中提供了方法toString( )把对象转化为字符串。
3．字符串"+"操作
运算符'+'可用来实现字符串的连接：
String s = "He is "+age+" years old.";
其他类型的数据与字符串进行"+"运算时，将自动转换成字符串。具体过程如下：
String s=new StringBuffer("he is").append(age).append("years old").toString();
注意：除了对运算符"+"进行了重载外，java不支持其它运算符的重载。
====>2@:java 中的覆盖
初次见到这两个单词并没有什么特别的感觉，但是时间长了，却发现书上一会儿用override，一会儿又用overload，搞得我的迷迷糊。于是就做了个总结，希望能对和我一样对这两个概念模糊不清的网友有一个帮助。
override可以翻译为覆盖，从字面就可以知道，它是覆盖了一个方法并且对其重写，以求达到不同的作用。对我们来说最熟悉的覆盖就是对接口方法的实现，在接口中一般只是对方法进行了声明，而我们在实现时，就需要实现接口声明的所有方法。除了这个典型的用法以外，我们在继承中也可能会在子类覆盖父类中的方法。在覆盖要注意以下的几点：
1、覆盖的方法的标志必须要和被覆盖的方法的标志完全匹配，才能达到覆盖的效果；
2、覆盖的方法的返回值必须和被覆盖的方法的返回一致；
3、覆盖的方法所抛出的异常必须和被覆盖方法的所抛出的异常一致，或者是其子类；
4、被覆盖的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。
overload对我们来说可能比较熟悉，可以翻译为重载，它是指我们可以定义一些名称相同的方法，通过定义不同的输入参数来区分这些方法，然后再调用时，VM就会根据不同的参数样式，来选择合适的方法执行。在使用重载要注意以下的几点：
1、在使用重载时只能通过不同的参数样式。例如，不同的参数类型，不同的参数个数，不同的参数顺序（当然，同一方法内的几个参数类型必须不一样，例如可以是fun(int, float)， 但是不能为fun(int, int)）；
2、不能通过访问权限、返回类型、抛出的异常进行重载；
3、方法的异常类型和数目不会对重载造成影响；
4、对于继承来说，如果某一方法在父类中是访问权限是priavte，那么就不能在子类对其进行重载，如果定义的话，也只是定义了一个新方法，而不会达到重载的效果。
下面是对override和overload的测试程序，其中注释中的内容都是会产生编译错误的代码，我们将注释去掉，看看在编译时会产生什么效果。
// 对overload测试的文件：OverloadTest.java
public class OverloadTest {
// 下面几个方法用来验证可以通过定义不同的参数类型和参数的数目进行方法重载。
public void fun(){
System.out.println("method fun in OverloadTest, no parameter");
}
public void fun(float f) {
System.out.println("method fun in OverloadTest, parameter type: float");
}
public void fun(int i){
System.out.println("method fun in OverloadTest, parameter type: int");
}
public void fun(int i1, int i2) {
System.out.println("method fun in OverloadTest, parameter type: int, int");
}
// 下面的两个方法用来验证可以通过定义不同的参数顺序进行方法重载。
// 需要注意：这里的参数肯定不是相同的类型，否则的顺序的先后就毫无意义。
public void fun1(int i, float f) {
System.out.println("method fun1 in OverloadTest, sequence of parameters is: int, float");
}
public void fun1(float f, int i) {
System.out.println("method fun1 in OverloadTest, sequence of parameters is: float, int");
}
// 下面的两个方法用来验证方法抛出的异常对于重载的影响.
// 无论是异常的类型还是异常的个数都不会对重载造成任何的影响。
public void fun2() throws TestException {
System.out.println("fun2 in OverloadTest, exception: TestException");
}
public void fun2(int i) throws TestException, TestException1 {
System.out.println("fun2 in OverloadTest, exception: TestException, TestException1");
}
public void fun2(float f) throws Exception {
System.out.println("fun2 in OverloadTest, exception: Exception");
}
// 不能通过抛出的异常类型来重载fun方法。
//public void fun(int i) throws Exception {
// System.out.println("method fun in OverloadTest, parameter type: int, exception: Exception");
//}
// 不能通过返回值重载fun方法。
//public boolean fun(int i) throws Exception {
// System.out.println("method fun in OverloadTest, parameter type: int, exception: Exception, return: boolean");
// return true;
//}
private void fun3() { }
// 不能通过不同的访问权限进行重载
public void fun3() { }
public static void main(String[] args) {
// 这里只是定义了OverloadTest的实例，所以test不会调用
// OverloadTest1中的方法。
OverloadTest test = new OverloadTest1();
// 这里定义了OverloadTest1的实例，因为OverloadTest1是OverloadTest
// 的子类，所以test1会调用OverloadTest中的方法。
OverloadTest1 test1 = new OverloadTest1();
try {
int i = 1, j = 2, m = 3;
// 这里不会调用OverloadTest1的fun方法
// test.fun(i, m, j);
test1.fun(i, j, m);
test1.fun();
// 这个调用不会执行，因为fun3()在OverloadTest中访问权限是priavte
//test1.fun3();
test1.fun3(i);
} catch(Exception e) { }
}
}
class OverloadTest1 extends OverloadTest{
// 在子类中重载fun
public void fun(int i, int m, int n) {
System.out.println("Overload fun1 in OverloadTest1, parameter type: int, int, int");
}
// 这个不是对父类中方法的重载，只是一个新的方法。
public void fun3(int i) {
System.out.println("fun2 in OverloadTest1");
}
}
// 对override测试的文件：OverrideTest.java
public class OverrideTest {
public void fun() throws TestException {
System.out.println("method fun in OverrideTest");
}
private void fun1() {
System.out.println("method fun1 in OverrideTest");
}
public static void main(String[] args) {
OverrideTest test = new OverrideTest1();
try {
test.fun();
test.fun1();
} catch(Exception e) { }
}
}
class OverrideTest1 extends OverrideTest{
// 以下正常Override
public void fun() throws TestException2 {
System.out.println("fun in OverrideTest1");
}
// 不能Override父类中的方法，因为它定义了不同的异常类型和
// 返回值。
//public int fun() throws TestException1 {
// System.out.println("method fun in Test");
// return 1;
//}
// 不能Override父类中的方法，因为它抛出了比父类中非法范围
// 更大的异常。
//public void fun() throws Exception {
// System.out.println("fun in OverrideTest1");
//}
// 这个方法并没有Override父类中的fun1方法，因为这个方法在
// 父类是private类型，所以这里只是相当于定义了一个新方法。
public void fun1() {
System.out.println("method fun1 in Test");
}
}
class TestException extends Exception{
public TestException(String msg) {
super(msg);
}
}
class TestException1 extends TestException {
public TestException1(String msg) {
super(msg);
}
}
class TestException2 extends TestException {
public TestException2(String msg) {
super(msg);
}
}
====>3@java 重写
====>4@Map
Java Map 集合类简介
本文相关下载：
· Jack 的 HashMap 测试
· Oracle JDeveloper 10g
java.util 中的集合类包含 Java 中某些最常用的类。 最常用的集合类是 List 和 Map。 List 的具体实现包括 ArrayList 和 Vector，它们是可变大小的列表，比较适合构建、存储和操作任何类型对象元素列表。 List 适用于按数值索引访问元素的情形。
Map 提供了一个更通用的元素存储方法。 Map 集合类用于存储元素对（称作“键”和“值”），其中每个键映射到一个值。 从概念上而言，您可以将 List 看作是具有数值键的 Map。 而实际上，除了 List 和 Map 都在定义 java.util 中外，两者并没有直接的联系。本文将着重介绍核心 Java 发行套件中附带的 Map，同时还将介绍如何采用或实现更适用于您应用程序特定数据的专用 Map。
了解 Map 接口和方法
Java 核心类中有很多预定义的 Map 类。 在介绍具体实现之前，我们先介绍一下 Map 接口本身，以便了解所有实现的共同点。 Map 接口定义了四种类型的方法，每个 Map 都包含这些方法。 下面，我们从两个普通的方法（表 1）开始对这些方法加以介绍。
表 1： 覆盖的方法。 我们将这 Object 的这两个方法覆盖，以正确比较 Map 对象的等价性。 equals(Object o) 比较指定对象与此 Map 的等价性
hashCode() 返回此 Map 的哈希码
Map 构建
Map 定义了几个用于插入和删除元素的变换方法（表 2）。
表 2： Map 更新方法： 可以更改 Map 内容。 clear() 从 Map 中删除所有映射
remove(Object key) 从 Map 中删除键和关联的值
put(Object key, Object value) 将指定值与指定键相关联
clear() 从 Map 中删除所有映射
putAll(Map t) 将指定 Map 中的所有映射复制到此 map
尽管您可能注意到，纵然假设忽略构建一个需要传递给 putAll() 的 Map 的开销，使用 putAll() 通常也并不比使用大量的 put() 调用更有效率，但 putAll() 的存在一点也不稀奇。 这是因为，putAll() 除了迭代 put() 所执行的将每个键值对添加到 Map 的算法以外，还需要迭代所传递的 Map 的元素。 但应注意，putAll() 在添加所有元素之前可以正确调整 Map 的大小，因此如果您未亲自调整 Map 的大小（我们将对此进行简单介绍），则 putAll() 可能比预期的更有效。
查看 Map
迭代 Map 中的元素不存在直接了当的方法。 如果要查询某个 Map 以了解其哪些元素满足特定查询，或如果要迭代其所有元素（无论原因如何），则您首先需要获取该 Map 的“视图”。 有三种可能的视图（参见表 3）
所有键值对 — 参见 entrySet()
所有键 — 参见 keySet()
有值 — 参见 values()
前两个视图均返回 Set 对象，第三个视图返回 Collection 对象。 就这两种情况而言，问题到这里并没有结束，这是因为您无法直接迭代 Collection 对象或 Set 对象。要进行迭代，您必须获得一个 Iterator 对象。 因此，要迭代 Map 的元素，必须进行比较烦琐的编码
Iterator keyValuePairs = aMap.entrySet().iterator();
Iterator keys = aMap.keySet().iterator();
Iterator values = aMap.values().iterator();
值得注意的是，这些对象（Set、Collection 和 Iterator）实际上是基础 Map 的视图，而不是包含所有元素的副本。 这使它们的使用效率很高。 另一方面，Collection 或 Set 对象的 toArray() 方法却创建包含 Map 所有元素的数组对象，因此除了确实需要使用数组中元素的情形外，其效率并不高。
我运行了一个小测试（随附文件中的 Test1），该测试使用了 HashMap，并使用以下两种方法对迭代 Map 元素的开销进行了比较：
int mapsize = aMap.size();
Iterator keyValuePairs1 = aMap.entrySet().iterator();
for (int i = 0; i < mapsize; i++)
{
Map.Entry entry = (Map.Entry) keyValuePairs1.next();
Object key = entry.getKey();
Object value = entry.getValue();
...
}
Object[] keyValuePairs2 = aMap.entrySet().toArray();
for (int i = 0; i < rem; i++) {
{
Map.Entry entry = (Map.Entry) keyValuePairs2[i];
Object key = entry.getKey();
Profilers in Oracle JDeveloperOracle JDeveloper 包含一嵌入的监测器，它测量内存和执行时间，使您能够快速识别代码中的瓶颈。 我曾使用 Jdeveloper 的执行监测器监测 HashMap 的 containsKey() 和 containsValue() 方法，并很快发现 containsKey() 方法的速度比 containsValue() 方法慢很多（实际上要慢几个数量级！）。 （参见图 1 和图 2，以及随附文件中的 Test2 类）。
Object value = entry.getValue();
...
}
此测试使用了两种测量方法： 一种是测量迭代元素的时间，另一种测量使用 toArray 调用创建数组的其他开销。 第一种方法（忽略创建数组所需的时间）表明，使用已从 toArray 调用中创建的数组迭代元素的速度要比使用 Iterator 的速度大约快 30%-60%。 但如果将使用 toArray 方法创建数组的开销包含在内，则使用 Iterator 实际上要快 10%-20%。 因此，如果由于某种原因要创建一个集合元素的数组而非迭代这些元素，则应使用该数组迭代元素。 但如果您不需要此中间数组，则不要创建它，而是使用 Iterator 迭代元素。
表 3： 返回视图的 Map 方法： 使用这些方法返回的对象，您可以遍历 Map 的元素，还可以删除 Map 中的元素。 entrySet() 返回 Map 中所包含映射的 Set 视图。 Set 中的每个元素都是一个 Map.Entry 对象，可以使用 getKey() 和 getValue() 方法（还有一个 setValue() 方法）访问后者的键元素和值元素
keySet() 返回 Map 中所包含键的 Set 视图。 删除 Set 中的元素还将删除 Map 中相应的映射（键和值）
values() 返回 map 中所包含值的 Collection 视图。 删除 Collection 中的元素还将删除 Map 中相应的映射（键和值）
访问元素
表 4 中列出了 Map 访问方法。Map 通常适合按键（而非按值）进行访问。 Map 定义中没有规定这肯定是真的，但通常您可以期望这是真的。 例如，您可以期望 containsKey() 方法与 get() 方法一样快。 另一方面，containsValue() 方法很可能需要扫描 Map 中的值，因此它的速度可能比较慢。
表 4： Map 访问和测试方法： 这些方法检索有关 Map 内容的信息但不更改 Map 内容。 get(Object key) 返回与指定键关联的值
containsKey(Object key) 如果 Map 包含指定键的映射，则返回 true
containsValue(Object value) 如果此 Map 将一个或多个键映射到指定值，则返回 true
isEmpty() 如果 Map 不包含键-值映射，则返回 true
size() 返回 Map 中的键-值映射的数目
对使用 containsKey() 和 containsValue() 遍历 HashMap 中所有元素所需时间的测试表明，containsValue() 所需的时间要长很多。 实际上要长几个数量级！ （参见图 1 和图 2，以及随附文件中的 Test2）。 因此，如果 containsValue() 是应用程序中的性能问题，它将很快显现出来，并可以通过监测您的应用程序轻松地将其识别。 这种情况下，我相信您能够想出一个有效的替换方法来实现 containsValue() 提供的等效功能。 但如果想不出办法，则一个可行的解决方案是再创建一个 Map，并将第一个 Map 的所有值作为键。 这样，第一个 Map 上的 containsValue() 将成为第二个 Map 上更有效的 containsKey()。
核心 Map
Java 自带了各种 Map 类。 这些 Map 类可归为三种类型：
通用 Map，用于在应用程序中管理映射，通常在 java.util 程序包中实现
HashMap
Hashtable
Properties
LinkedHashMap
IdentityHashMap
TreeMap
WeakHashMap
ConcurrentHashMap
专用 Map，您通常不必亲自创建此类 Map，而是通过某些其他类对其进行访问
java.util.jar.Attributes
javax.print.attribute.standard.PrinterStateReasons
java.security.Provider
java.awt.RenderingHints
javax.swing.UIDefaults
一个用于帮助实现您自己的 Map 类的抽象类
AbstractMap
内部哈希： 哈希映射技术
几乎所有通用 Map 都使用哈希映射。 这是一种将元素映射到数组的非常简单的机制，您应了解哈希映射的工作原理，以便充分利用 Map。
哈希映射结构由一个存储元素的内部数组组成。 由于内部采用数组存储，因此必然存在一个用于确定任意键访问数组的索引机制。 实际上，该机制需要提供一个小于数组大小的整数索引值。 该机制称作哈希函数。 在 Java 基于哈希的 Map 中，哈希函数将对象转换为一个适合内部数组的整数。 您不必为寻找一个易于使用的哈希函数而大伤脑筋： 每个对象都包含一个返回整数值的 hashCode() 方法。 要将该值映射到数组，只需将其转换为一个正值，然后在将该值除以数组大小后取余数即可。 以下是一个简单的、适用于任何对象的 Java 哈希函数
int hashvalue = Maths.abs(key.hashCode()) % table.length;
（% 二进制运算符（称作模）将左侧的值除以右侧的值，然后返回整数形式的余数。）
实际上，在 1.4 版发布之前，这就是各种基于哈希的 Map 类所使用的哈希函数。 但如果您查看一下代码，您将看到
int hashvalue = (key.hashCode() & 0x7FFFFFFF) % table.length;
它实际上是使用更快机制获取正值的同一函数。 在 1.4 版中，HashMap 类实现使用一个不同且更复杂的哈希函数，该函数基于 Doug Lea 的 util.concurrent 程序包（稍后我将更详细地再次介绍 Doug Lea 的类）。
图 3： 哈希工作原理
该图介绍了哈希映射的基本原理，但我们还没有对其进行详细介绍。 我们的哈希函数将任意对象映射到一个数组位置，但如果两个不同的键映射到相同的位置，情况将会如何？ 这是一种必然发生的情况。 在哈希映射的术语中，这称作冲突。 Map 处理这些冲突的方法是在索引位置处插入一个链接列表，并简单地将元素添加到此链接列表。 因此，一个基于哈希的 Map 的基本 put() 方法可能如下所示
public Object put(Object key, Object value) {
//我们的内部数组是一个 Entry 对象数组
//Entry[] table;
//获取哈希码，并映射到一个索引
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % table.length;
//循环遍历位于 table[index] 处的链接列表，以查明
//我们是否拥有此键项 — 如果拥有，则覆盖它
for (Entry e = table[index] ; e != null ; e = e.next) {
//必须检查键是否相等，原因是不同的键对象
//可能拥有相同的哈希
if ((e.hash == hash) && e.key.equals(key)) {
//这是相同键，覆盖该值
//并从该方法返回 old 值
Object old = e.value;
e.value = value;
return old;
}
}
//仍然在此处，因此它是一个新键，只需添加一个新 Entry
//Entry 对象包含 key 对象、 value 对象、一个整型的 hash、
//和一个指向列表中的下一个 Entry 的 next Entry
//创建一个指向上一个列表开头的新 Entry，
//并将此新 Entry 插入表中
Entry e = new Entry(hash, key, value, table[index]);
table[index] = e;
return null;
}
如果看一下各种基于哈希的 Map 的源代码，您将发现这基本上就是它们的工作原理。 此外，还有一些需要进一步考虑的事项，如处理空键和值以及调整内部数组。 此处定义的 put() 方法还包含相应 get() 的算法，这是因为插入包括搜索映射索引处的项以查明该键是否已经存在。 （即 get() 方法与 put() 方法具有相同的算法，但 get() 不包含插入和覆盖代码。） 使用链接列表并不是解决冲突的唯一方法，某些哈希映射使用另一种“开放式寻址”方案，本文对其不予介绍。
优化 Hasmap
如果哈希映射的内部数组只包含一个元素，则所有项将映射到此数组位置，从而构成一个较长的链接列表。 由于我们的更新和访问使用了对链接列表的线性搜索，而这要比 Map 中的每个数组索引只包含一个对象的情形要慢得多，因此这样做的效率很低。 访问或更新链接列表的时间与列表的大小线性相关，而使用哈希函数问或更新数组中的单个元素则与数组大小无关 — 就渐进性质（Big-O 表示法）而言，前者为 O(n)，而后者为 O(1)。 因此，使用一个较大的数组而不是让太多的项聚集在太少的数组位置中是有意义的。
调整 Map 实现的大小
在哈希术语中，内部数组中的每个位置称作“存储桶”(bucket)，而可用的存储桶数（即内部数组的大小）称作容量 (capacity)。 为使 Map 对象有效地处理任意数目的项，Map 实现可以调整自身的大小。 但调整大小的开销很大。 调整大小需要将所有元素重新插入到新数组中，这是因为不同的数组大小意味着对象现在映射到不同的索引值。 先前冲突的键可能不再冲突，而先前不冲突的其他键现在可能冲突。 这显然表明，如果将 Map 调整得足够大，则可以减少甚至不再需要重新调整大小，这很有可能显著提高速度。
使用 1.4.2 JVM 运行一个简单的测试，即用大量的项（数目超过一百万）填充 HashMap。 表 5 显示了结果，并将所有时间标准化为已预先设置大小的服务器模式（关联文件中的 Test3）。 对于已预先设置大小的 JVM，客户端和服务器模式 JVM 运行时间几乎相同（在放弃 JIT 编译阶段后）。 但使用 Map 的默认大小将引发多次调整大小操作，开销很大，在服务器模式下要多用 50% 的时间，而在客户端模式下几乎要多用两倍的时间！
表 5： 填充已预先设置大小的 HashMap 与填充默认大小的 HashMap 所需时间的比较 客户端模式 服务器模式
预先设置的大小 100% 100%
默认大小 294% 157%
使用负载因子
为确定何时调整大小，而不是对每个存储桶中的链接列表的深度进行记数，基于哈希的 Map 使用一个额外参数并粗略计算存储桶的密度。 Map 在调整大小之前，使用名为“负载因子”的参数指示 Map 将承担的“负载”量，即它的负载程度。 负载因子、项数（Map 大小）与容量之间的关系简单明了：
如果（负载因子）x（容量）>（Map 大小），则调整 Map 大小
例如，如果默认负载因子为 0.75，默认容量为 11，则 11 x 0.75 = 8.25，该值向下取整为 8 个元素。 因此，如果将第 8 个项添加到此 Map，则该 Map 将自身的大小调整为一个更大的值。 相反，要计算避免调整大小所需的初始容量，用将要添加的项数除以负载因子，并向上取整，例如，
对于负载因子为 0.75 的 100 个项，应将容量设置为 100/0.75 = 133.33，并将结果向上取整为 134（或取整为 135 以使用奇数）
奇数个存储桶使 map 能够通过减少冲突数来提高执行效率。 虽然我所做的测试（关联文件中的Test4）并未表明质数可以始终获得更好的效率，但理想情形是容量取质数。 1.4 版后的某些 Map（如 HashMap 和 LinkedHashMap，而非 Hashtable 或 IdentityHashMap）使用需要 2 的幂容量的哈希函数，但下一个最高 2 的幂容量由这些 Map 计算，因此您不必亲自计算。
负载因子本身是空间和时间之间的调整折衷。 较小的负载因子将占用更多的空间，但将降低冲突的可能性，从而将加快访问和更新的速度。 使用大于 0.75 的负载因子可能是不明智的，而使用大于 1.0 的负载因子肯定是不明知的，这是因为这必定会引发一次冲突。 使用小于 0.50 的负载因子好处并不大，但只要您有效地调整 Map 的大小，应不会对小负载因子造成性能开销，而只会造成内存开销。 但较小的负载因子将意味着如果您未预先调整 Map 的大小，则导致更频繁的调整大小，从而降低性能，因此在调整负载因子时一定要注意这个问题。
选择适当的 Map
应使用哪种 Map？ 它是否需要同步？ 要获得应用程序的最佳性能，这可能是所面临的两个最重要的问题。 当使用通用 Map 时，调整 Map 大小和选择负载因子涵盖了 Map 调整选项。
以下是一个用于获得最佳 Map 性能的简单方法
将您的所有 Map 变量声明为 Map，而不是任何具体实现，即不要声明为 HashMap 或 Hashtable，或任何其他 Map 类实现。
Map criticalMap = new HashMap(); //好
HashMap criticalMap = new HashMap(); //差
这使您能够只更改一行代码即可非常轻松地替换任何特定的 Map 实例。
下载 Doug Lea 的 util.concurrent 程序包 (http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/intro.html)。 将 ConcurrentHashMap 用作默认 Map。 当移植到 1.5 版时，将 java.util.concurrent.ConcurrentHashMap 用作您的默认 Map。 不要将 ConcurrentHashMap 包装在同步的包装器中，即使它将用于多个线程。 使用默认大小和负载因子。
监测您的应用程序。 如果发现某个 Map 造成瓶颈，则分析造成瓶颈的原因，并部分或全部更改该 Map 的以下内容： Map 类；Map 大小；负载因子；关键对象 equals() 方法实现。 专用的 Map 的基本上都需要特殊用途的定制 Map 实现，否则通用 Map 将实现您所需的性能目标。
Map 选择
也许您曾期望更复杂的考量，而这实际上是否显得太容易？ 好的，让我们慢慢来。 首先，您应使用哪种 Map？ 答案很简单： 不要为您的设计选择任何特定的 Map，除非实际的设计需要指定一个特殊类型的 Map。 设计时通常不需要选择具体的 Map 实现。 您可能知道自己需要一个 Map，但不知道使用哪种。 而这恰恰就是使用 Map 接口的意义所在。 直到需要时再选择 Map 实现 — 如果随处使用“Map”声明的变量，则更改应用程序中任何特殊 Map 的 Map 实现只需要更改一行，这是一种开销很少的调整选择。 是否要使用默认的 Map 实现？ 我很快将谈到这个问题。
同步 Map
同步与否有何差别？ （对于同步，您既可以使用同步的 Map，也可以使用 Collections.synchronizedMap() 将未同步的 Map 转换为同步的 Map。 后者使用“同步的包装器”）这是一个异常复杂的选择，完全取决于您如何根据多线程并发访问和更新使用 Map，同时还需要进行维护方面的考虑。 例如，如果您开始时未并发更新特定 Map，但它后来更改为并发更新，情况将如何？ 在这种情况下，很容易在开始时使用一个未同步的 Map，并在后来向应用程序中添加并发更新线程时忘记将此未同步的 Map 更改为同步的 Map。 这将使您的应用程序容易崩溃（一种要确定和跟踪的最糟糕的错误）。 但如果默认为同步，则将因随之而来的可怕性能而序列化执行多线程应用程序。 看起来，我们需要某种决策树来帮助我们正确选择。
Doug Lea 是纽约州立大学奥斯威戈分校计算机科学系的教授。 他创建了一组公共领域的程序包（统称 util.concurrent），该程序包包含许多可以简化高性能并行编程的实用程序类。 这些类中包含两个 Map，即 ConcurrentReaderHashMap 和 ConcurrentHashMap。 这些 Map 实现是线程安全的，并且不需要对并发访问或更新进行同步，同时还适用于大多数需要 Map 的情况。 它们还远比同步的 Map（如 Hashtable）或使用同步的包装器更具伸缩性，并且与 HashMap 相比，它们对性能的破坏很小。 util.concurrent 程序包构成了 JSR166 的基础；JSR166 已经开发了一个包含在 Java 1.5 版中的并发实用程序，而 Java 1.5 版将把这些 Map 包含在一个新的 java.util.concurrent 程序包中。
后续步骤
下载 Oracle JDeveloper 10g：改变您对 Java 开发的看法
Oracle JDeveloper 10g 中的监测器： 该监测器利用 Java 虚拟机中的某些特性，使您能够发现应用程序代码中的编程缺陷、性能问题以及内存泄漏。 可以将监测器与调试器和 CodeCoach 一起使用来进行功能强大且有效的应用程序代码故障排除。 了解更多有关事件监测、执行监测以及内存监测的信息。
所有这一切意味着您不需要一个决策树来决定是使用同步的 Map 还是使用非同步的 Map， 而只需使用 ConcurrentHashMap。 当然，在某些情况下，使用 ConcurrentHashMap 并不合适。 但这些情况很少见，并且应具体情况具体处理。 这就是监测的用途。
结束语
--------------------------------------------------------------------------------
====> HashMap使用方法 大 | 中 | 小 [ 2006/08/29 17:19 | by fubin ]
===>
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class MainClass {
public static void main(String args[]) {
HashMap hm = new HashMap();
hm.put("A", new Double(3434.34));
hm.put("B", new Double(123.22));
hm.put("C", new Double(1378.00));
hm.put("D", new Double(99.22));
hm.put("E", new Double(-19.08));
Set> set = hm.entrySet();
for (Map.Entry me : set) {
System.out.print(me.getKey() + ": ");
System.out.println(me.getValue());
}
System.out.println();
double balance = hm.get("B");
hm.put("B", balance + 1000);
System.out.println("B's new balance: " + hm.get("B"));
}
}
Eclipse 配置环境的jdk的一个小问题：[]表示注释。
1、如果jdk是：jdk1.42 java的编译环境是 1.4 [在Eclipse 中Project =>Properties=>java compiler=>configure workspace setting 下设置需要的jdk版本]
注意：环境是1.42时候、那么 [在Eclipse 中project=>properties=>java build path=>libraries==>在系统jre system library=选择需要的jdk版本]
2、如果jdk是：jdk1.5 java的编译环境是 1.5
==================================*******************************
利用 Java 的 Properties 类读取配置文件信息（转）
利用 Java 的 Properties 类读取配置文件信息
在我们平时写程序的时候，有些参数是经常改变的，而这种改变不是我们预知的。比如说我们开发了一个操作数据库的模块，在开发的时候我们连接本地的数据库那么 IP ，数据库名称，表名称，数据库主机等信息是我们本地的，要使得这个操作数据的模块具有通用性，那么以上信息就不能写死在程序里。通常我们的做法是用配置文件来解决。
各种语言都有自己所支持的配置文件类型。比如 Python ，他支持 .ini 文件。因为他内部有一个 ConfigParser 类来支持 .ini 文件的读写，根据该类提供的方法程序员可以自由的来操作 .ini 文件。而在 Java 中， Java 支持的是 .properties 文件的读写。 JDK 内置的 java.util.Properties 类为我们操作 .properties 文件提供了便利。
一． .properties 文件的形式
==========================================================
# 以下为服务器、数据库信息
dbPort = localhost
databaseName = mydb
dbUserName = root
dbPassword = root
# 以下为数据库表信息
dbTable = mytable
# 以下为服务器信息
ip = 192.168.0.9
在上面的文件中我们假设该文件名为： test.properties 文件。其中 # 开始的一行为注释信息；在等号“ = ”左边的我们称之为 key ；等号“ = ”右边的我们称之为 value 。（其实就是我们常说的键 - 值对） key 应该是我们程序中的变量。而 value 是我们根据实际情况配置的。
二． JDK 中的 Properties 类
Properties 类存在于胞 Java.util 中，该类继承自 Hashtable ，它提供了几个主要的方法：
1． getProperty ( String key) ， 用指定的键在此属性列表中搜索属性。也就是通过参数 key ，得到 key 所对应的 value 。
2． load ( InputStream inStream) ，从输入流中读取属性列表（键和元素对）。通过对指定的文件（比如说上面的 test.properties 文件）进行装载来获取该文件中的所有键 - 值对。以供 getProperty ( String key) 来搜索。
3． setProperty ( String key, String value) ，调用 Hashtable 的方法 put 。他通过调用基类的put方法来设置 键 - 值对。
4． store ( OutputStream out, String comments) ， 以适合使用 load 方法加载到 Properties 表中的格式，将此 Properties 表中的属性列表（键和元素对）写入输出流。与 load 方法相反，该方法将键 - 值对写入到指定的文件中去。
5． clear () ，清除所有装载的 键 - 值对。该方法在基类中提供。
有了以上几个方法我们就可以对 .properties 文件进行操作了！
三．代码实例
package configuration;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;
/** *//** *//** *//**
* 读取properties文件
* @author Qutr
*
*/
public class Configuration
{
private Properties propertie;
private FileInputStream inputFile;
private FileOutputStream outputFile;
/** *//** *//** *//**
* 初始化Configuration类
*/
public Configuration()
{
propertie = new Properties();
}
/** *//** *//** *//**
* 初始化Configuration类
* @param filePath 要读取的配置文件的路径+名称
*/
public Configuration(String filePath)
{
propertie = new Properties();
try {
inputFile = new FileInputStream(filePath);
propertie.load(inputFile);
inputFile.close();
} catch (FileNotFoundException ex) {
System.out.println("读取属性文件--->失败！- 原因：文件路径错误或者文件不存在");
ex.printStackTrace();
} catch (IOException ex) {
System.out.println("装载文件--->失败!");
ex.printStackTrace();
}
}//end ReadConfigInfo()
/** *//** *//** *//**
* 重载函数，得到key的值
* @param key 取得其值的键
* @return key的值
*/
public String getValue(String key)
{
if(propertie.containsKey(key)){
String value = propertie.getProperty(key);//得到某一属性的值
return value;
}
else
return "";
}//end getValue()
/** *//** *//** *//**
* 重载函数，得到key的值
* @param fileName properties文件的路径+文件名
* @param key 取得其值的键
* @return key的值
*/
public String getValue(String fileName, String key)
{
try {
String value = "";
inputFile = new FileInputStream(fileName);
propertie.load(inputFile);
inputFile.close();
if(propertie.containsKey(key)){
value = propertie.getProperty(key);
return value;
}else
return value;
} catch (FileNotFoundException e) {
e.printStackTrace();
return "";
} catch (IOException e) {
e.printStackTrace();
return "";
} catch (Exception ex) {
ex.printStackTrace();
return "";
}
}//end getValue()
/** *//** *//** *//**
* 清除properties文件中所有的key和其值
*/
public void clear()
{
propertie.clear();
}//end clear();
/** *//** *//** *//**
* 改变或添加一个key的值，当key存在于properties文件中时该key的值被value所代替，
* 当key不存在时，该key的值是value
* @param key 要存入的键
* @param value 要存入的值
*/
public void setValue(String key, String value)
{
propertie.setProperty(key, value);
}//end setValue()
/** *//** *//** *//**
* 将更改后的文件数据存入指定的文件中，该文件可以事先不存在。
* @param fileName 文件路径+文件名称
* @param description 对该文件的描述
*/
public void saveFile(String fileName, String description)
{
try {
outputFile = new FileOutputStream(fileName);
propertie.store(outputFile, description);
outputFile.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException ioe){
ioe.printStackTrace();
}
}//end saveFile()
public static void main(String[] args)
{
Configuration rc = new Configuration("./config/test.properties");//相对路径
String ip = rc.getValue("ipp");//以下读取properties文件的值
String host = rc.getValue("host");
String tab = rc.getValue("tab");
System.out.println("ip = " + ip + "ip-test leng = " + "ip-test".length());//以下输出properties读出的值
System.out.println("ip's length = " + ip.length());
System.out.println("host = " + host);
System.out.println("tab = " + tab);
Configuration cf = new Configuration();
String ipp = cf.getValue("./config/test.properties", "ip");
System.out.println("ipp = " + ipp);
// cf.clear();
cf.setValue("min", "999");
cf.setValue("max", "1000");
cf.saveFile("./config/save.perperties", "test");
// Configuration saveCf = new Configuration();
// saveCf.setValue("min", "10");
// saveCf.setValue("max", "1000");
// saveCf.saveFile("./config/save.perperties");
}//end main()
}//end class ReadConfigInfo
四．小结
通过上面的例子不难看出，在Java中操作配置文件是非常简单的。在一个需要用到大量配置信息的模块或系统里，我们有必要封装一个专门的类来共使用。通过最后的main函数调用，相信大家可以看出该类的用法。不足指出希望大家多多指点。
==========================>Map
==========================>list
==========================>set
扫一扫
5445
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
