几个谜题，深入的了解java

在2009年的JavaOne大会上，Joshua Bloch和Neal Gafter又为我们带来的7道谜题，挺有意思的。大家不妨看看。
摘自：
Return of the Puzzlers: Schlock and Awe
Joshua Bloch, Google, Inc.; Neal Gafter, Microsoft
http://developers.sun.com/learning/javaoneonline/sessions/2009/pdf/TS-5186.pdf

 

分析可以参考上面链接，或者参考我的分析http://zangxt.iteye.com/admin/blogs/436133
1.Life's Persistent Questions

public class SimpleQuestion {

    static boolean yesOrNo(String s) {
        s = s.toLowerCase();
        if (s.equals("yes") || s.equals("y") || s.equals("t")) {
            s = "true";
        }
        return Boolean.getBoolean(s);
    }

    public static void main(String[] args) {
        System.out.println(yesOrNo("true") + " " + yesOrNo("Yes"));
    }
}

问题：程序打印什么？
如果熟悉Boolean.getBoolean（）这个方法的话，应该不会出错。方法的功能参考文档。

2.Instruments of Tortue

import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;

public class InstrumentedHashSet<E> extends HashSet<E> {
    private int addCount = 0;
    @Override
    public boolean add(E e){
        addCount++;
        return super.add(e);
    }

    @Override
    public boolean addAll(Collection<? extends E> c){
        addCount += c.size();
        return super.addAll(c);
    }

    public static void main(String[] args) {
        InstrumentedHashSet<String> s = new InstrumentedHashSet<String>();
        s.addAll(Arrays.asList("Accordion","Banjo","Kazoo"));
        System.out.println(s.addCount);
    }
}

问题：打印结果是什么？

这个看第一遍可能会出错，不过也算容易理解。

3.Iterator Titillator

import java.util.Iterator;
import java.util.NoSuchElementException;

public abstract class AbstractIterator<T> implements Iterator<T> {

    T next = nextElement();

    public boolean hasNext() {
        return next != null;
    }

    public T next() {
        if (next == null) {
            throw new NoSuchElementException();
        }
        T result = next;
        next = nextElement();
        return result;
    }

    public void remove() {
        throw new UnsupportedOperationException();
    }

    protected abstract T nextElement();

    private static Iterator<Character> test(final String s) {
        return new AbstractIterator<Character>() {

            private int cursor = 0;

            protected Character nextElement() {
                return cursor == s.length() ? null : s.charAt(cursor++);
            }
        };
    }

    public static void main(String[] args) {
        for (Iterator<Character> i = test("OPS"); i.hasNext();) {
            System.out.print(i.next());
        }
    }
}

问题：输出结果是什么？

理解如何正确的设计Iterator。

4.Search for the One

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;


public class Searching {
    public static void main(String[] args) {
        String[] strings = { "0", "1", "2", "3", "4", "5"};

        List<Integer> integers = new ArrayList<Integer>();
        for(String s : strings){
            integers.add(Integer.valueOf(s));
        }

        System.out.println(Collections.binarySearch(integers, 1,cmp));
    }

    static Comparator<Integer> cmp = new Comparator<Integer>(){
        public int compare(Integer i,Integer j){
            return i<j?-1:(i==j?0:1);
        }
    };
}

问题：打印结果是什么？

如果看过《Java Puzzlers》这本书的话应该容易发现问题。

5.Cogito Ergo Sum

import java.util.LinkedHashMap;
import java.util.Map;

public enum RomanNumeral {

    I(1), V(5), X(10), L(50), C(100), D(500), M(1000);
    private static Map<Integer, RomanNumeral> map = new LinkedHashMap<Integer, RomanNumeral>();
    public final int val;

    RomanNumeral(int val) {
        this.val = val;
        storeInMap();
    }

    private void storeInMap() {
        map.put(val, this);
    }

    public static RomanNumeral fromInt(int val) {
        return map.get(val);
    }

    public static void main(String[] args) {
        int sum = 0;
        for (int i = 0; i < 1000; i++) {
            if (fromInt(i) != null) {
                sum += i;
            }
        }
        System.out.println(sum);
    }
}

问题：打印结果是什么？

如果理解java加载类和创建对象的顺序的话这个问题容易理解。

6.Thread Friendly

public class ThreadFriendly {
    ThreadLocal<Value> threadLocalPart = new ThreadLocal<Value>();
    class Value{
        final int i;
        Value(int i){
            this.i = i;
        }
    }
    
    ThreadFriendly setThreadVal(int i){
        threadLocalPart.set(new Value(i));
        return this;
    }
    
    int getThreadVal(){
        return threadLocalPart.get().i;
    }
    
    public static void main(String[] args) {
        int sum = 0;
        for(int i = -500000;i<=500000;i++){
            sum+= new ThreadFriendly().setThreadVal(i).getThreadVal();
        }
        System.out.println(sum);
    }
}

问题：打印结果是什么？

理解内部类和ThreadLocal。

7.When Words Collide

public class PrintWords {
    public static void main(String[] args) {
        System.out.println(
            Words.FIRST + " " + Words.SECOND + " " + Words.THIRD
        );
    }
}

public class Words{
    public static final String FIRST = "the";
    public static final String SECOND = null;
    public static final String THIRD = "set";
}

编译PrintWords.java文件。
修改Words.java文件为

public class Words{
    public static final String FIRST = "physics";
    public static final String SECOND = "chemistry";
    public static final String THIRD = "biology";
}

      编译Words.java文件。针对这个版本运行PrintWords。

     请问，输出结果是什么？

需要了解常量折叠现象，注意null。

评论

14 楼 banshaotang 2012-08-21  

第四题，
4.Search for the One
因为现在的jdk有了改变，所以结果与当初的值 不一样了吧？？
我用的jdk1.6输出的为1（这个应该是正确的吧?

13 楼 lianxianghui 2009-08-06  

ZangXT 写道

whitesock 写道

不看看ThreadLocal的源码， 很难分析出6为啥OutOfMemory

的确，我也是跟踪了半天

到底是因为啥呢?

12 楼 sucker 2009-08-04  

最后一个应该是
1：编译PrintWords.java,生成PrintWords.class,Words.class
2:修改Words.java.编译Words.java 覆盖了Words.class
3:运行PrintWords.class 试试。

把final 去掉，再按上面步骤试试。

11 楼 sucker 2009-08-04  

ZangXT 写道

teasp 写道

3.Iterator Titillator. 这个比较怪异， 我的解释是父类AbstractIterator初始化的时候匿名子类的cursor还没初始化，但是int型没初始化的时候是被当作0的，所以父类的next获得了第一个字符。当父类初始化完成后子类开始初始化然后将cursor设为0。

基本正确，可以参考我另一篇的分析。

能不能讲讲这个执行顺序？Iterator<Character> i = test("OPS") 执行后是什么结果。

10 楼 kage 2009-08-03  

xuwenjin666 写道

第一题答案应该是true true 吧！

xuwenjin666 写

superwind 写道

第一题应该是false false

API的定义是：当且仅当以参数命名的系统属性存在，且等于 "true" 字符串时，才返回 true。
理解了这句话就明白了

9 楼 ZangXT 2009-08-02  

找到原因了，问题在于Integer的valueOf(String s)这个方法，这个方法每次都返回一个新的Integer对象，

wcf1987 写道

teasp 写道

找到原因了，问题在于Integer的valueOf(String s)这个方法，这个方法每次都返回一个新的Integer对象，结果导致i==j始终不成立。

就是，java这个地方设计的很有问题啊，integer的运算符重载做了<>但是没有=实在是容易犯错啊

这不能算什么问题，>,<,>=,<=本类对Integer类型是没有定义的，我在语言角度增加它们是没有问题的。但是!=和==在出现自动装箱和拆箱之前就有了，它们的语义是不能轻易改变了。

8 楼 wcf1987 2009-08-02  

teasp 写道

找到原因了，问题在于Integer的valueOf(String s)这个方法，这个方法每次都返回一个新的Integer对象，结果导致i==j始终不成立。

就是，java这个地方设计的很有问题啊，integer的运算符重载做了<>但是没有=实在是容易犯错啊

7 楼 superwind 2009-08-01  

第一题应该是false false

6 楼 ZangXT 2009-08-01  

teasp 写道

3.Iterator Titillator. 这个比较怪异， 我的解释是父类AbstractIterator初始化的时候匿名子类的cursor还没初始化，但是int型没初始化的时候是被当作0的，所以父类的next获得了第一个字符。当父类初始化完成后子类开始初始化然后将cursor设为0。

基本正确，可以参考我另一篇的分析。

5 楼 ZangXT 2009-08-01  

xuwenjin666 写道

第一题答案应该是true true 吧！

亲自动手实验一下才好

4 楼 ZangXT 2009-08-01  

whitesock 写道

不看看ThreadLocal的源码， 很难分析出6为啥OutOfMemory

的确，我也是跟踪了半天

3 楼 whitesock 2009-08-01  

不看看ThreadLocal的源码， 很难分析出6为啥OutOfMemory

2 楼 youngmaster 2009-07-31  

的确有些容易错...

1 楼 xuwenjin666 2009-07-31  

第一题答案应该是true true 吧！