标签: ocpjp

我只是在研究OCPJP问题,我发现了这个奇怪的代码:

public static void main(String a[]) {
    System.out.println(Double.NaN==Double.NaN);
    System.out.println(Double.NaN!=Double.NaN);
}

当我运行代码时,我得到了:

false
true

false当我们比较两个看起来彼此相同的东西时,输出结果如何？什么NaN意思？

我正在攻读OCPJP考试,因此我必须了解Java的每一个奇怪的细节.这包括增量前和增量后运算符应用于变量的顺序.以下代码给出了奇怪的结果:

int a = 3;

a = (a++) * (a++);

System.out.println(a); // 12

答案不应该是11吗？或者13？但不是12!

跟进:

以下代码的结果是什么？

int a = 3;

a += (a++) * (a++);

System.out.println(a);

在以下程序中

class ZiggyTest2 {

    public static void main(String[] args){     

        double x = 123.456;
        char c = 65;
        int i = 65;

        System.out.printf("%s",x);
        System.out.printf("%b",x);
        System.out.printf("%c",c);
        System.out.printf("%5.0f",x);
        System.out.printf("%d",i);
    }       
}

输出是

123.456trueA  12365

有人可以解释一个双值(即123.456)如何转换为布尔值(即.true)

我问的原因是因为我知道java不允许数字用于布尔值.例如,Java中不允许以下内容

if (5) {
 //do something
}

谢谢

public class Java{
    public static void main(String[] args){
        final byte x = 1;
        final byte y = 2;
        byte z = x + y;//ok
        System.out.println(z);

        byte a = 1;
        byte b = 2;
        byte c = a + b; //Compiler error
        System.out.println(c);
    }
}

如果涉及任何int-sized或者更小的表达式的结果总是为int,即使两个字节的总和适合一个字节.

当我们添加两个适合字节的最终字节时,为什么会这样？ 没有编译器错误.

如果枚举实现了Comparable,为什么无法与<或>进行比较？

public class Dream    
{
    public static void main(String... args)
    {
        System.out.println(PinSize.BIG == PinSize.BIGGER); //false
        System.out.println(PinSize.BIG == PinSize.BIG); //true
        System.out.println(PinSize.BIG.equals(PinSize.BIGGER));//false
        System.out.println(PinSize.BIG > PinSize.BIGGERER);// compilation error
        //can't be compared
        System.out.println(PinSize.BIG.toString().equals(PinSize.BIGGER));// #4
        PinSize b = PinSize.BIG ;
        System.out.println( b instanceof Comparable);// true
    }  
}
enum PinSize { BIG, BIGGER, BIGGERER };

为什么此示例中的输出为1？

public static void main(String[] args){
 int[] a = { 1, 2, 3, 4 };   
 int[] b = { 2, 3, 1, 0 };   
 System.out.println( a [ (a = b)[3] ] );   
}

我以为会是2.即,表达式评估为:

a[(a=b)[3]]
a[b[3]]    //because a is now pointing to b
a[0]   

不应该[0]为2,因为a指向b？

提前致谢.

有人可以解释这段代码吗？

public class SneakyThrow {


  public static void sneakyThrow(Throwable ex) {
    SneakyThrow.<RuntimeException>sneakyThrowInner(ex);
  }

  private static <T extends Throwable> T sneakyThrowInner(Throwable ex) throws T {
    throw (T) ex;
  }



  public static void main(String[] args) {
    SneakyThrow.sneakyThrow(new Exception());
  }


}

它可能看起来很奇怪,但这不会产生强制转换异常,并且允许抛出已检查的异常而不必在签名中声明它,或者将其包装在未经检查的异常中.

请注意,两者都没有sneakyThrow(...)或主要声明任何已检查的异常,但输出为:

Exception in thread "main" java.lang.Exception
    at com.xxx.SneakyThrow.main(SneakyThrow.java:20)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:601)
    at com.intellij.rt.execution.application.AppMain.main(AppMain.java:120)

本hack在龙目岛的使用,注释@SneakyThrow,允许抛出checked异常没有声明.

我知道它与类型擦除有关,但我不确定理解黑客的每个部分.

编辑: 我知道我们可以插入一个Integera List<String>和那个checked/unchecked异常区别是编译时功能.

从非泛型类型List转换为类似于List<XXX>编译器的泛型类型时会产生警告.但是直接转换为泛型类型并不像(T) ex上面的代码那样常见.

如果你愿意,对我来说似乎很奇怪的部分是我理解JVM中的内容List<Dog>并且List<Cat> …

OCP Java SE 6程序员实践考试的正确答案之一是:

您可以通过编程方式测试已启用的断言,而不会抛出AssertionError.

我怎样才能做到这一点？

我准备在接下来的2个月进行OCPJP 8考试,目前我这个考试得到了我的注意,因为我不明白为什么

public class BiPredicateTest {
    public static void main(String[] args) {
        BiPredicate<List<Integer>, Integer> containsInt = List::contains;
        List<Integer> ints = java.util.Arrays.asList(1,20,20);
        ints.add(1);
        ints.add(20);
        ints.add(20);
        System.out.println(containsInt.test(ints, 20));

        BiConsumer<List<Integer>, Integer> listInt = BiPredicateTest::consumeMe;
        listInt.accept(ints, 15);

    }

    public static void consumeMe(List<Integer> ints, int num) {
        ints.removeIf(i -> i>num);
        ints.forEach(System.out::println);
    }
}

这显然是编译好的!但是当你运行它时,你会看到这样的异常

C:\Users\user\Documents>javac BiPredicateTest.java

C:\Users\user\Documents>java BiPredicateTest
true
Exception in thread "main" java.lang.UnsupportedOperationException
        at java.util.AbstractList.remove(AbstractList.java:161)
        at java.util.AbstractList$Itr.remove(AbstractList.java:374)
        at java.util.Collection.removeIf(Collection.java:415)
        at BiPredicateTest.consumeMe(BiPredicateTest.java:22)
        at BiPredicateTest.main(BiPredicateTest.java:17)

我需要一些帮助来理解为什么asList方法不能与removeIf一起使用？我假设它将返回一个实现removeIf方法!的ArrayList实例.

任何答案将不胜感激.

干杯!

我在Ganesh和Sharma的书中提出了一个问题:oracle_certified_professional_java_se_7_programmer_exams_1z0-804_and_1z0-805.

一个问题是:

80. 考虑以下程序并预测输出:

      class Test {
    
        public static void main(String args[]) {
          String test = "I am preparing for OCPJP";
          String[] tokens = test.split("\\S");
          System.out.println(tokens.length);
        }
      }
    

    Run Code Online (Sandbox Code Playgroud)

    a)0

    b)5

    c)12

    d)16

现在我明白\ S是正则表达式意味着将非空格字符视为分隔符.但我很困惑的是正则表达式如何进行匹配以及split产生的实际标记是什么.

我添加了代码来打印令牌,如下所示

for (String str: tokens){
  System.out.println("<" + str + ">");
}

我得到了以下输出

16

<>

< >

<>

< >

<>

<>

<>

<>

<>

<>

<>

<>

< >

<>

<>

< >

所以很多空字符串令牌.我只是不明白这一点.

我会想到,如果分隔符是非空格字符,那么在上面的文本中,所有字母字符都可以作为分隔符,所以如果我们匹配导致空字符串的标记,也许应该有21个标记.我只是不明白Java的正则表达式引擎如何解决这个问题.是否有任何正则表达的大师可以为我阐明这些代码？