小编alf*_*alf的帖子

我正在尝试从Scala中的Okasaki的书中实现一些结构,并且在测试中尝试将实际测试保留在基类中,仅使用子类来提供测试中的实例.

例如,对不平衡(树)集的测试如下所示:

class UnbalancedSetSpec
  extends SetSpec(new UnbalancedSet[Int])
  with IntElements

哪里

abstract class SetSpec[E, S](val set: Set[E, S]) extends Specification with ScalaCheck {

  implicit def elements: Arbitrary[E]

  // ...

  private def setFrom(es: Seq[E]): S = es.foldRight(set.empty)(set.insert)
}

现在有时我想专门研究儿童规范,例如

class RedBlackSetSpec
  extends SetSpec(new RedBlackSet[Int])
  with IntElements {

  "fromOrdList" should {
    "be balanced" ! prop { (a: List[Int]) =>
      val s = RedBlackSet.fromOrdList(a.sorted)

      set.isValid(s) should beTrue
    }
  }
}

它失败,因为没有方法isValid上Set[E, S]-它的定义RedBlackSet[E].但是,如果我继续前进,改变SetSpec[E, S](val set: Set[E, S])到 …

需要一个字符串集合,其中插入的元素需要排序,也可以非重复,可以通过索引检索.

• 我可以使用TreeSet它删除重复项并按顺序排序所有内容但无法通过索引检索.通过索引检索,我可以制作ArrayList和addAll元素,但这 addAll需要很多时间.

要么

• 我可以使用an ArrayList,insert required,然后通过其他方法删除重复项,然后使用Collections.sort方法对元素进行排序.

但问题是,所有这些都需要时间,是否有任何直接的方法来实现这一点,一个集合 - 排序,非重复,通过索引进行O(1)随机访问.

我有一个界面,

trait Heap[E, H <: Heap[E, H]] {
  implicit def ord: Ordering[E]

  def empty: H

  def isEmpty: Boolean

  def insert(x: E): H

  def merge(b: H): H

  def findMin: E

  def deleteMin: H

  def toList: List[E] =
    if (isEmpty) Nil else findMin :: deleteMin.toList
}

它是通用的,因为我们需要H定义" Heap相同类型的a ",def merge(b: H): H这通常是根据合并相同内部结构的堆来定义的.

这对于"正常"堆很合适,即自己管理内部结构的堆:

class LazyPairingHeap[E](val h: Repr[E] = Empty)
                        (implicit val ord: Ordering[E])
  extends Heap[E, LazyPairingHeap[E]] {

  import okasaki.heaps.LazyPairingHeap._

  override def empty = new LazyPairingHeap[E](Empty)

  override def …

我有一个程序,我试图从一个用逗号分隔的字符串中取一组数字并将它们放入一个ArrayList; 但是,我不太清楚该怎么做.到目前为止,我所做的是将String转换为一个字符数组,然后使用以下方法将字符转换为整数:

Character.digit(temp[i], 10)

此示例在for循环中迭代字符串.让我们说在这种情况下"1,2,3,4".获取新char数组的第一个元素并将其转换为int.

我的问题是,

• 答:必须有更好的方法来做到这一点.
• B:如果您获得2位或3位数字会发生什么,例如,"34,2,3,65,125".当我需要它作为一个元素时,这些将作为数组的单独元素存储.
• C:如果数字是负数,会发生什么,如果负数是2或3位数呢？例如,"-123,45,3,4,-6".

请记住,这对于任何String争论都是有意义的.

这里有很多条件,我不知道如何解决它们.

ConcurrentHashMap与依赖于其线程安全但不依赖于其同步细节的程序中的Hashtable完全可互操作.

我对线程安全与同步细节感到困惑,任何人都能告诉我一个例子吗？

public class F {
    int test(int e) {
        System.out.println("ok");
        return e;
    }

    public static void main(String[] args) {
        int y = 8;
        F f = new F();
        int i = f.test(y++);
        System.out.println(i);
    }
}

这个程序的输出8是我所期望的.

public class Sa {
    public static void main(String[] args) {
        int i = 8;
        i++;
        System.out.println(i);
    }
}

对于这个程序,输出是9令人惊讶的:为什么我们在两个程序中使用相同的值和相同的增量运算符得到不同的值？

有考试的程序.任何人都可以解释"-434"是如何回答的:

class A {}
class B extends A {}
public class ComingThru {
    static String s = "-";
    public static void main (String[] args) {
        A[] aa = new A[2];
        B[] ba = new B[2];
        sifter(aa);
        sifter(ba);
        sifter(7);
        System.out.print(s);
    }
    static void sifter(A[]... a2) { s += "1";}
    static void sifter(B[]... b1) { s += "2";}
    static void sifter(B[] b1)    { s += "3";}
    static void sifter(Object o)  { s += "4";}
}

谢谢!