小编Nar*_*hai的帖子

我正在探索Java 8源代码,发现代码的这一特定部分非常令人惊讶:

//defined in IntPipeline.java
@Override
public final OptionalInt reduce(IntBinaryOperator op) {
    return evaluate(ReduceOps.makeInt(op));
}

@Override
public final OptionalInt max() {
    return reduce(Math::max); //this is the gotcha line
}

//defined in Math.java
public static int max(int a, int b) {
    return (a >= b) ? a : b;
}

是Math::max什么样的方法指针？普通static方法如何转换为IntBinaryOperator？

由于Java 8允许在名为Default Methods的接口中默认实现方法,因此在何时使用a之间似乎存在混淆abstract class.

那么什么时候应该使用与默认方法的接口,何时应该使用抽象类？抽象类在这种情况下仍然有用吗？

我试图弄清楚当我们使用nio FileChannel与普通FileInputStream/FileOuputStream文件读取和写入文件系统时,性能(或优势)是否有任何差异.我观察到,在我的机器上,两者都在同一级别执行,也很多次FileChannel都是慢一些.我可以了解比较这两种方法的更多细节.这是我使用的代码,我正在测试的文件是350MB.如果我不是在查看随机访问或其他此类高级功能,那么对文件I/O使用基于NIO的类是一个不错的选择吗？

package trialjavaprograms;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class JavaNIOTest {
    public static void main(String[] args) throws Exception {
        useNormalIO();
        useFileChannel();
    }

    private static void useNormalIO() throws Exception {
        File file = new File("/home/developer/test.iso");
        File oFile = new File("/home/developer/test2");

        long time1 = System.currentTimeMillis();
        InputStream is = new FileInputStream(file);
        FileOutputStream fos = new FileOutputStream(oFile);
        byte[] buf = new byte[64 * 1024];
        int len = 0; …

我知道复合操作i++不是线程安全的,因为它们涉及多个操作.

但是检查引用本身是一个线程安全的操作？

a != a //is this thread-safe

我尝试编程并使用多个线程,但它没有失败.我想我无法在我的机器上模拟比赛.

编辑:

public class TestThreadSafety {
    private Object a = new Object();

    public static void main(String[] args) {

        final TestThreadSafety instance = new TestThreadSafety();

        Thread testingReferenceThread = new Thread(new Runnable() {

            @Override
            public void run() {
                long countOfIterations = 0L;
                while(true){
                    boolean flag = instance.a != instance.a;
                    if(flag)
                        System.out.println(countOfIterations + ":" + flag);

                    countOfIterations++;
                }
            }
        });

        Thread updatingReferenceThread = new Thread(new Runnable() {

            @Override
            public void run() …

Java 8包含了一个名为Defender方法的新功能,它允许在接口中创建默认方法实现.

首先,对于Java中所有精简程序员来说,这是一个巨大的范式转换.我查看了Brain Goetz给出的JavaOne 13演示文稿,他正在讨论集合库中的新内容stream()和parallelStream()实现.

为了在Collection界面中添加新方法,他们不能在不破坏以前版本的情况下添加新方法.所以他说,为了迎合这一点,我们增加了Default方法的新功能.

public interface SimpleInterface {
  public void doSomeWork();

  //A default method in the interface created using "default" keyword
  default public void doSomeOtherWork(){
    System.out.println("DoSomeOtherWork implementation in the interface");
  }
}

现在我的问题基本上是默认方法只是在需要向接口添加新方法而不破坏客户端代码时才有用吗？或者它也有一些其他用途吗？

Liskov替换原则是SOLID的原则之一.我现在已经多次阅读过这个原则,并试图理解它.

这是我用它做的,

这一原则与阶级等级之间强烈的行为契约有关.子类型应该能够在不违反合同的情况下用超类型替换.

我也读过其他一些文章,我有点想不起这个问题.千万Collections.unmodifiableXXX()方法不违反LSP？

以上链接文章的摘录:

换句话说,当通过其基类接口使用对象时,用户只知道基类的前提条件和后置条件.因此,派生对象不能指望这样的用户遵守比基类所要求的更强的前提条件

为什么我这么认为？

之前

class SomeClass{
      public List<Integer> list(){
           return new ArrayList<Integer>(); //this is dumb but works
      }
}

后

class SomeClass{
     public List<Integer> list(){
           return Collections.unmodifiableList(new ArrayList<Integer>()); //change in implementation
     }
}

我SomeClass将来无法改变返回不可修改列表的实现.编译将工作,但如果客户端以某种方式尝试更改List返回,那么它将在运行时失败.

这就是为什么Guava 为集合创建了单独的ImmutableXXX接口？

这不是直接违反LSP或我完全弄错了吗？

Java 7支持切换,Strings如下面的代码

switch (month.toLowerCase()) {
case "january":
    monthNumber = 1;
    break;
case "february":
    monthNumber = 2;
    break;
default: 
    monthNumber = 0;
    break;
}

Java是否equals()在每种String情况下调用该方法？或者,它依赖于==或intern()？

这简单地等同于:

String month = month.toLowerCase();
if("january".equals(month)){
monthNumber = 1;
}else if("february".equals(month)){
monthNumber = 1;
}..

更新:

将switch表达式中的String与每个case标签关联的表达式进行比较,就好像String.equals正在使用该方法一样.

正如文档所指出的那样,行为就像equals()被调用一样.

我正在查看一些代码并看到以下表示法.我有点不确定这三个点是什么意思,你称之为什么.

void doAction(Object...o);

谢谢.

<xs:element name="age">
  <xs:simpleType>
    <xs:restriction base="xs:integer">
      <xs:minInclusive value="0"/>
      <xs:maxInclusive value="120"/>
    </xs:restriction>
  </xs:simpleType>
</xs:element>

所以我希望它像这样转换为Java代码:

public void setAge(int age){
    if(age < 0 || age > 120){
         //throw some exception
    }
     //setting the age as it is a valid value
}

在JAXB中可以吗？

曾经看过一些WebService Client存根生成器这样做可能是axis2 webservice但不确定.

我在许多图书馆见过像Spring它使用了大量的接口,与单一的方法在他们像BeanNameAware等.

实现者类将使用单个方法实现许多接口.

在什么情况下保持单个方法接口是有意义的？这样做是为了避免使一个单一界面变得笨重ResultSet吗？或者是否有一些设计标准主张使用这些类型的接口？