最新消息:最新信息可以到系统基本设置里填写,如果不想要这一栏可以修改head.htm,将第53行到55行删除即可

Java编程思想对象的容纳实例详解

创意新鲜 dedesos.com

java提供了容纳对象的多种方式,接下来我们具体看看都有哪些方式。



  对象数组容纳的是句柄,而基本数据类型数组容纳的是具体的数值。








2、stack



下面是一个简单的堆栈示例,它能读入数组的每一行,同时将其作为字串压入堆栈。

import java.util.*;
public class stacks {
 static string[] months = { 
 "january", "february", "march", "april",
 "may", "june", "july", "august", "september",
 "october", "november", "december" };
 public static void main {
 stack stk = new stack;
 for
 stk.push;
 system.out.println;
 // treating a stack as a vector:
 stk.addelement;
 system.out.println);
 system.out.println;
 while)
 system.out.println);
}




dictionary的实现过程并不麻烦。下面列出一种简单的方法,它使用了两个vector,一个用于容纳键,另一个用来容纳值:

import java.util.*;
public class assocarray extends dictionary {
 private vector keys = new vector;
 private vector values = new vector;
 public int size { return keys.size; }
 public boolean isempty {
 return keys.isempty;
 public object put {
 keys.addelement;
 values.addelement;
 return key;
 public object get {
 int index = keys.indexof;
 // indexof returns -1 if key not found:
 if return null;
 return values.elementat;
 public object remove {
 int index = keys.indexof;
 if return null;
 keys.removeelementat;
 object returnval = values.elementat;
 values.removeelementat;
 return returnval;
 public enumeration keys {
 return keys.elements;
 public enumeration elements {
 return values.elements;
 // test it:
 public static void main {
 assocarray aa = new assocarray;
 for
 aa.put,
 string.valueof
 .touppercase);
 char[] ca = { 'a', 'e', 'i', 'o', 'u' };
 for
 system.out.println));







作为应用散列表的一个例子,可考虑用一个程序来检验java的math.random方法的随机性到底如何。在理想情况下,它应该产生一系列完美的随机分布数字。但为了验证这一点,我们需要生成数量众多的随机数字,然后计算落在不同范围内的数字多少。散列表可以极大简化这一工作,因为它能将对象同对象关联起来。如下所示:

//: statistics.java
// simple demonstration of hashtable
import java.util.*;
class counter { 
 int i = 1; 
 public string tostring { 
 return integer.tostring; 
class statistics {
 public static void main {
 hashtable ht = new hashtable;
 for {
 // produce a number between 0 and 20:
 integer r = 
 new integer * 20));
 if)
 ht.get).i++;
 else
 ht.put);
 system.out.println;
}


为显示散列表,只需把它简单地打印出来即可。hashtable tostring方法能遍历所有键-值对,并为每一对都调用tostring。integer tostring是事先定义好的,可看到计数器使用的tostring。一次运行的结果如下:

{19=526, 18=533, 17=460, 16=513, 15=521, 14=495,
 13=512, 12=483, 11=488, 10=487, 9=514, 8=523,
 7=497, 6=487, 5=480, 4=489, 3=509, 2=503, 1=475,
 0=505}


在前面的例子里,我们用一个标准库的类作为hashtable的一个键使用。作为一个键,它能很好地工作,因为它已经具备正确运行的所有条件。但在使用散列表的时候,一旦我们创建自己的类作为键使用,就会遇到一个很常见的问题。例如,假设一套天气预报系统将groundhog对象匹配成prediction。这看起来非常直观:我们创建两个类,然后将groundhog作为键使用,而将prediction作为值使用。如下所示:

//: springdetector.java
// looks plausible, but doesn't work right.
import java.util.*;
class groundhog {
 int ghnumber;
 groundhog { ghnumber = n; }
class prediction {
 boolean shadow = math.random 0.5;
 public string tostring {
 if
 return "six more weeks of winter!";
 else
 return "early spring!";
public class springdetector {
 public static void main {
 hashtable ht = new hashtable;
 for
 ht.put, new prediction);
 system.out.println;
 system.out.println;
 groundhog gh = new groundhog;
 if)
 system.out.printlnht.get);
}



因此,为了在散列表中将自己的类作为键使用,必须同时覆盖hashcode和equals,就象下面展示的那样:

//: springdetector2.java
// if you create a class that's used as a key in
// a hashtable, you must override hashcode
// and equals.
import java.util.*;
class groundhog2 {
 int ghnumber;
 groundhog2 { ghnumber = n; }
 public int hashcode { return ghnumber; }
 public boolean equals {
 return 
 && o).ghnumber);
public class springdetector2 {
 public static void main {
 hashtable ht = new hashtable;
 for
 ht.put,new prediction);
 system.out.println;
 system.out.println;
 groundhog2 gh = new groundhog2;
 if)
 system.out.printlnht.get);
}

groundhog2.hashcode将土拔鼠号码作为一个标识符返回。为了返回一个独一无二的标识符,并不需要hashcode,equals方法必须能够严格判断两个对象是否相等。
equals方法要进行两种检查:检查对象是否为null;若不为null,则继续检查是否为groundhog2的一个实例。即使为了继续执行equals,它也应该是一个groundhog2。正如大家看到的那样,这种比较建立在实际ghnumber的基础上。这一次一旦我们运行程序,就会看到它终于产生了正确的输出。
 





properties p = system.getproperties;
p.list;





我们现在可以开始演示enumeration的真正威力:将穿越一个序列的操作与那个序列的基础结构分隔开。在下面的例子里,printdata类用一个enumeration在一个序列中移动,并为每个对象都调用tostring方法。此时创建了两个不同类型的集合:一个vector和一个hashtable。并且在它们里面分别填充mouse和hamster对象。由于enumeration隐藏了基层集合的结构,所以printdata不知道或者不关心enumeration来自于什么类型的集合:

//: enumerators2.java
// revisiting enumerations
import java.util.*;
class printdata {
 static void print {
 while)
 system.out.println.tostring);
class enumerators2 {
 public static void main {
 vector v = new vector;
 for
 v.addelement);
 hashtable h = new hashtable;
 for
 h.put, new hamster);
 system.out.println;
 printdata.print);
 system.out.println;
 printdata.print);
}




映射:一系列“键-值”对。从表面看,这似乎应该成为一个“键-值”对的“集合”,但假若试图按那种方式实现它,就会发现实现过程相当笨拙。这进一步证明了应该分离成单独的概念。另一方面,可以方便地查看map的某个部分。只需创建一个集合,然后用它表示那一部分即可。这样一来,map就可以返回自己键的一个set、一个包含自己值的list或者包含自己“键-值”对的一个list。和数组相似,map可方便扩充到多个“维”,毋需涉及任何新概念。只需简单地在一个map里包含其他map。


6、使用collections


























总结

以上就是本文关于java编程思想对象的容纳实例详解的全部内容,希望能对大家有所帮助,也希望大家对本站多多支持!

    与本文相关的文章

    网友最新评论