小编Rob*_*ert的帖子

返回Void类型的正确方法是什么,当它不是原始类型时？例如.我目前使用null如下.

interface B<E>{ E method(); }

class A implements B<Void>{

    public Void method(){
        // do something
        return null;
    }
}

今天我看到了一个带有java断言而不是JUnit断言的JUnit测试用例 - 是否有优势或缺点优先于另一个？

有没有一种简单的方法可以从命令行中充满文本文档的文件夹中删除相同的文本行？

我知道Java中的双重锁定已被破坏,那么在Java中使单例线程安全的最佳方法是什么？我想到的第一件事是:

class Singleton{
    private static Singleton instance;

    private Singleton(){}

    public static synchronized Singleton getInstance(){
        if(instance == null) instance = new Singleton();
        return instance;
    }
}

这有用吗？如果是这样,它是最好的方式(我想这取决于具体情况,所以说明特定技术最好的时候会有用)

我写了一个解析器如下:

class LogParser extends JavaTokenParsers {

  def invertedIndex: Parser[Array[Array[(Int, Int)]]] = {
    num ~> num ~> num ~> rep(postingsList) ^^ {
      _.toArray
    }
  }

  def postingsList: Parser[Array[(Int, Int)]] = {
    num ~> rep(entry) ^^ {
      _.toArray
    }
  }

  def entry = {
    num ~ "," ~ num ^^ {
      case docID ~ "," ~ count => (docID.toInt, count.toInt)
    }
  }

  def num = wholeNumber ^^ (_.toInt)

}

如果我使用FileReader从(270MB)文件解析如下:

val index = parseAll(invertedIndex, new FileReader("path/to/file")).get

我得到了Exception in thread "main" java.lang.StackOverflowError …

我正在尝试构建一个方法,在未加权的图形中返回从一个节点到另一个节点的最短路径.我考虑过使用Dijkstra,但这似乎有点矫枉过正,因为我只需要一对.相反,我已经实现了广度优先搜索,但问题是我的返回列表包含一些我不想要的节点 - 如何修改我的代码以实现我的目标？

public List<Node> getDirections(Node start, Node finish){
    List<Node> directions = new LinkedList<Node>();
    Queue<Node> q = new LinkedList<Node>();
    Node current = start;
    q.add(current);
    while(!q.isEmpty()){
        current = q.remove();
        directions.add(current);
        if (current.equals(finish)){
            break;
        }else{
            for(Node node : current.getOutNodes()){
                if(!q.contains(node)){
                    q.add(node);
                }
            }
        }
    }
    if (!current.equals(finish)){
        System.out.println("can't reach destination");
    }
    return directions;
}

我正在寻找一个java库或一些帮助来编写我自己的插值函数.那就是我有两个双打数组,这两个数组可能有不同的大小,但是是有序的.我需要能够估计中间值,并插入以使两个数组的大小相同.事实上,插值中出现的点总数是2个数组大小减去1的总和.但是,每个数组的范围必须保持不变,因此不需要外推.

例如.a1 = [1,4,9,16,25,36]和a2 = [6,9,14,30]

结果可能是例如.

a1 = [1,2.25,5,2.65,9,12.25,16,25,36]和a2 = [6,6.5625,7.25,9,10.2625,11.25,14,25.25,30]

f(x) = x^2 and g(x) = x^2 + 5然而,这些例子很容易就是任何多项式 - 关键是要能够很好地估计/近似数据集中的函数,以提供足够的插值.这里的x值只是输入数组的索引.在输出中,只有y值很重要.

我写了一个n-ary树ADT工作正常.但是,我需要将其序列化存储在变量调用类中.例如.

    DomTree<String> a = Data.createTreeInstance("very_large_file.xml");
    String x = a.toString();

我写的方法,该方法提供正是我需要它的目的,但在非常大的投入需要(在一个100MB的XML文件,20分钟)永远 - 我已经计时的方法,并从XML文件创建树快,但调用toString()如上所示非常慢.

@Override
public String toString(){
    return printTree(this);
}

public String printTree(AbstractTree<E> tree){
    if (tree.isLeaf()){
        return tree.getNodeName();
    }else{
        String tStr = tree.getNodeName() + "(";

        int i = 0;
        Iterator<AbstractTree<E>> child = tree.getChildren().iterator();
        while (i < tree.getChildren().size() - 1){

            tStr += printTree(child.next()) + ", ";
            i++;
        }
        tStr += printTree(child.next()) + ")";

        return tStr;    
    }
}

我猜它是用字符串构建的方式而不是遍历树的方式？有一个更好的方法吗？

更新:遵循Skaffman的示例,以下代码为非常大的输入提供outOfMemoryError.

@Override
public String toString(){
    StringBuilder buffer = new StringBuilder();
    printTree(this, buffer);
    return buffer.toString(); …

我正在Haskell中编写一个小函数式编程语言,但我找不到如何实现(==)的定义,因为这看起来很棘手？

我正在为一个Uni项目设计一个弹球游戏,其中应该有两种模式:运行模式和构建器模式,从而可以设计/重新设计机器的布局.

我最初的想法是状态模式 - 然而,我担心各州之间的共同界面可能会将它们收缩为实施不适合该州的方法.

例如.在构建器模式中,设置保险杠或其他任何位置是完全合适的.但是在运行模式下,它将被实现为什么都不做或抛出异常 - 这看起来很讨厌,特别是如果有很多这样的方法.

有更好的设计吗？