从完成《JAVA编程思想》第四版 流程控制 练习10的过程中学到的

      最近在学习《JAVA编程思想》第四版，做练习是必须的，而在流程控制这一章的练习10的完成过程中，不觉学到了一些东东，值得我记录下来。也许这些东西在后续的章节中会出现，所解决的问题也不成为问题，但毕竟这个过程是我学习的经历，需要我记录。

 

练习10： A vampire number has an even number of digits and is formed by multiplying a pair of numbers containing half the number of digits of the result. The digits are taken from the original number in any order. Pairs of trailing zeroes are not allowed. Examples include: 1260 = 21 * 60, 1827 = 21 * 87, 2187 = 27  * 81. Write a program that finds all the 4-digit vampire numbers. (Suggested by Dan Forhan.)

 

一个实现方法：

     public class VampireNumbers { static int a(int i) { return i/1000; } static int b(int i) { return (i%1000)/100; } static int c(int i) { return ((i%1000)%100)/10; } static int d(int i) { return ((i%1000)%100)%10; } static int com(int i, int j) { return (i * 10) + j; } static void productTest (int i, int m, int n) { if(m * n == i) System.out.println(i + " = " + m + " * " + n); } public static void main(String[] args) { for(int i = 1001; i < 9999; i++){ productTest(i, com(a(i), b(i)), com(c(i), d(i))); productTest(i, com(a(i), b(i)), com(d(i), c(i))); productTest(i, com(a(i), c(i)), com(b(i), d(i))); productTest(i, com(a(i), c(i)), com(d(i), b(i))); productTest(i, com(a(i), d(i)), com(b(i), c(i))); productTest(i, com(a(i), d(i)), com(c(i), b(i))); productTest(i, com(b(i), a(i)), com(c(i), d(i))); productTest(i, com(b(i), a(i)), com(d(i), c(i))); productTest(i, com(b(i), c(i)), com(d(i), a(i))); productTest(i, com(b(i), d(i)), com(c(i), a(i))); productTest(i, com(c(i), a(i)), com(d(i), b(i))); productTest(i, com(c(i), b(i)), com(d(i), a(i))); } } }

 

这个代码不是我写的，不过我最初的实现思想与此类似。运行结果

        1260 = 21 * 60
        1395 = 15 * 93
        1435 = 41 * 35
        1530 = 51 * 30
        1827 = 87 * 21
        2187 = 27 * 81
        6880 = 86 * 80
        6880 = 80 * 86

 

       最后两个6880，虽然算不上是错误，但心里总觉得不爽。原因很简单，显然是程序没有识别86*80和80*86是一码事。我想到的解决办法也有两种，一是保存结果，看到相同的数，如6880，删除相关数据，另一个就是在源头识别86*80==80*86。水平有限，或者是为了学习（美其名曰），我选择了后者，具体想法是对于1001~9999中的每个数，将所有可能参与乘法的两个操作数对放到一个Set中，这个过程消除所有重复的可能，包括a*b和b*a这种。方法很笨，却让我学到了一些东东。

 

        实际过程中我用泛化的ArrayList，之所以没用Set，是因为我还没搞懂（^-^）。我自定义了一个类OpPair，用来存储两个乘法操作数，准备override equals()方法，用来使用ArrayList的contains方法判断对象是否已存在与arraylist中，象这样：

 static void addOpPair(ArrayList<OpPair> opArray, OpPair opPair) { if ((!opArray.contains(opPair)) && (!opArray.contains(new OpPair(opPair.op2,opPair.op1)))) opArray.add(opPair); }

主程序通过调用这个函数将操作数对加入到arraylist中，确保没有重复的。没想到却出现了不少错误，也让我学到了（赚到了：））

 

一. 方法调用object传递的是引用，Arraylist中保留的也只是引用

       其实这在前面已经学过了，在我的另一个笔记中也着重强调了一下，到了实际问题中还是会忘记啊！再次加强一下！

       原因是我在调用的时候只定义了一个OpPair对象，而后通过改变里面的具体值实现不同操作数对，再调用addOpPair，象这样

  OpPair opPair = new OpPair(com(result[0],result[1]), com(result[2],result[3])); opArraylist.add(opPair); opPair.op1 = com(result[0],result[1]); opPair.op2 = com(result[3],result[2]); addOpPair(opArraylist,opPair);

结果显然是不对的。原来得这样

  OpPair opPair = new OpPair(com(result[0],result[1]), com(result[2],result[3])); opArraylist.add(opPair); addOpPair(opArraylist,new OpPair(com(result[0],result[1]), com(result[3],result[2])));

出了错误才恍然大悟，哎。。。看来还得加强学习和实践

 

二. equals的override得这样：public boolean equals(Object o)，参数得用Object

      原以为解决了上面那个问题就万事大吉了，结果还是不行。查找原因，是在调用contains出现了问题。翻看API，contains的签名是 public boolean contains(Object o)。一切皆对象，应该没有问题啊，通过o.equals()和多态，肯定能调用到我自己的类的equals()啊。我的类初始定义：

 class OpPair { int op1; int op2; public OpPair(int i1,int i2) { op1 = i1; op2 = i2; } public boolean equals(OpPair o) { return ((op1==o.op1)&&(op2 == o.op2)); } public String toString() { return (""+op1+" "+op2); } }

以为没有问题，细想才发现override不成功，签名不一致，变成重载了，而contains调用的是Object的equals方法。Object的equals方法参数自然是Object，看来得这样

 public boolean equals(Object o) { return ((op1==((OpPair)o).op1)&&(op2 == ((OpPair)o).op2)); }

一试，果不其然。

 

      问题解决了，有点疑问：Arraylist既然泛化了，为什么这个方法泛化呢？或者是我调用错了，没调用到泛化过的类似函数？

 

我的代码

// control/VampireNumbers.java // TIJ4 Chapter Control, Exercise 10, page 154 /* A vampire number has an even number of digits and is formed by multiplying a * pair of numbers containing half the number of digits of the result. The * digits are taken from the original number in any order. Pairs of trailing * zeroes are not allowed. Examples include: 1260 = 21 * 60, 1827 = 21 * 87, * 2187 = 27 * 81. Write a program that finds all the 4-digit vampire numbers. * (Suggested by Dan Forhan.) */ import java.util.*; public class VampireNumbers { public static void main(String[] args) { int[] result = new int[4]; for (int i = 1001; i < 9999; i++) { getDigits(i, result); ArrayList<OpPair> opArraylist = new ArrayList<OpPair>(); OpPair opPair = new OpPair(com(result[0],result[1]), com(result[2],result[3])); opArraylist.add(opPair); addOpPair(opArraylist,new OpPair(com(result[0],result[1]), com(result[3],result[2]))); addOpPair(opArraylist,new OpPair(com(result[0],result[2]), com(result[1],result[3]))); addOpPair(opArraylist,new OpPair(com(result[0],result[2]), com(result[3],result[1]))); addOpPair(opArraylist,new OpPair(com(result[0],result[3]), com(result[1],result[2]))); addOpPair(opArraylist,new OpPair(com(result[0],result[3]), com(result[2],result[1]))); addOpPair(opArraylist,new OpPair(com(result[1],result[0]), com(result[2],result[3]))); addOpPair(opArraylist,new OpPair(com(result[1],result[0]), com(result[3],result[2]))); addOpPair(opArraylist,new OpPair(com(result[1],result[2]), com(result[3],result[0]))); addOpPair(opArraylist,new OpPair(com(result[1],result[3]), com(result[2],result[0]))); addOpPair(opArraylist,new OpPair(com(result[2],result[0]), com(result[3],result[1]))); addOpPair(opArraylist,new OpPair(com(result[2],result[1]), com(result[3],result[0]))); for ( OpPair o : opArraylist) productTest(o,i); } } static void addOpPair(ArrayList<OpPair> opArray, OpPair opPair) { if ((!opArray.contains(opPair)) && (!opArray.contains(new OpPair(opPair.op2,opPair.op1)))) opArray.add(opPair); } static void getDigits(int src, int[] result) { result[0] = src/1000; src %= 1000; result[1] = src/100; src %= 100; result[2] = src/10; src %= 10; result[3] = src; } static int com(int i, int j) { return (i*10 + j); } static void productTest(OpPair o, int product) { if (o.op1 * o.op2 == product) System.out.println(product +" = " + o.op1 +" * " + o.op2); } } class OpPair { int op1; int op2; public OpPair(int i1,int i2) { op1 = i1; op2 = i2; } public boolean equals(Object o) { return ((op1==((OpPair)o).op1)&&(op2 == ((OpPair)o).op2)); } public String toString() { return (""+op1+" "+op2); } }

 

运行结果

 1260 = 21 * 60
1395 = 15 * 93
1435 = 41 * 35
1530 = 51 * 30
1827 = 87 * 21
2187 = 27 * 81
6880 = 86 * 80

突然发现自己的方法原来是那么的笨、重，哈哈，管它呢，暂时学到了就行，慢慢的就好了！结束了~~

 

简单改了下，不妨在OpPair中把两个操作数排个序，小的在op1，大的在op2，addOpPair就可以这样

static void addOpPair(ArrayList<OpPair> opArray, OpPair opPair) { if (!opArray.contains(opPair)) opArray.add(opPair); }

运行结果

1260 = 21 * 60
1395 = 15 * 93
1435 = 35 * 41
1530 = 30 * 51
1827 = 21 * 87
2187 = 27 * 81
6880 = 80 * 86