小编Kev*_*ght的帖子

我有这个方法使用列表元素的一个属性List将a 转换为a Map:

简而言之,它看起来像这样:

private Map<String, List<Diagnostic<? extends JavaFileObject>>> toMap( List<Diagnostic<? extends JavaFileObject>> diagnostics ) {
    Map<String, List<Diagnostic<? extends JavaFileObject>>> result = new HashMap<String, List<Diagnostic<? extends JavaFileObject>>>();
    for ( Diagnostic<? extends JavaFileObject> d : diagnostics ) {
        List<Diagnostic<? extends JavaFileObject>> list = null;
        if ( !result.containsKey( d.getCode() ) ) {
            list = new ArrayList<Diagnostic<? extends JavaFileObject>>();
            result.put( d.getCode(), list );
        } else {
            list = result.get( d.getCode() );
        }
        assert list != null;
        list.add( d );
    } …

想象一下,我有以下表格可供我使用:

A: { x: int, y: int, z: int, ...99 other columns... }

我现在想要对此进行转换,将z其设置为NULLwhere x > y,将结果数据集存储为B.

我想这样做而不必明确提及所有其他列,因为这成为维护的噩梦.

有简单的解决方案吗？

我已经创建了一个pimp方法,collate可以从任何Traversable或任何可以被强制转换为可遍历的类型中使用,如下例所示:

val ints = List(0,9,4,5,-3,-5,6,5,-2,1,0,6,-3,-2)
val results = ints collate {
  case i: Int if(i < 0) => i.floatValue
} andThen {
  case i: Int if(i>5) => i.toString
} andThen {
  case i: Int if(i==0) => i
} toTuple

/*
results: (List[Float], List[java.lang.String], List[Int], List[Int]) =
(List(-3.0, -5.0, -2.0, -3.0, -2.0),List(9, 6, 6),List(0, 0),List(4, 5, 5, 1))
*/

把它看成是一个工会"变成往返的邪恶产卵collect和partition,如果你会...

它的定义如下:

import collection.generic.CanBuildFrom

class Collatable[Repr <% Traversable[T], T](xs: Repr) {

  // Results handling …

它在代码中更容易解释:

class Bippy {
  val x = 42

  class Boppy {
    val y = "hello world"
  }

  val bop = new Boppy
}

val bip = new Bippy
val bop: Bippy#Boppy = bip.bop

bop然后提供给另一个方法,该方法需要x从包含的实例中查找值Bippy.这样做有什么神奇的咒语？

该实例bop来自我无法控制的代码,因此添加新方法Boppy不是一个选项.

我有几个类都扩展了相同的特性,并且共享了应该改变其状态的相互功能.但是我想知道是否有更好的方法来实现相同的功能.

例如:

trait Breed
case object Pincher extends Breed
case object Haski extends Breed

trait Foox{
  def age: Int
  def addToAge(i: Int): Foox 
}

case class Dog(breed: Breed, age: Int) extends Foox
case class Person(name: String, age: Int) extends Foox

我希望addToAge它将返回与附加int相同的对象,当然我可以为每个类实现相同的,这与DRY规则相矛盾:

case class Dog(breed: Breed, age: Int) extends Foox{
  def addToAge(i: Int) = copy(age = age + i)
}
case class Person(name: String, age: Int) extends Foox{
  def addToAge(i:Int) = copy(age = age + i)
}

1. 有没有更好的方法来避免这种情况？

2. 是否有一个选项可以避免重新定义该年龄:在每个案例类中使用Int并保持其状态(年龄已经在特征中定义)？

我有两个scala类(当我javap -private用来读取类文件时它们的Java代码).

当我使用n,并d在toString方法,会产生类私有成员域.这是为什么？我有点困惑.

Scala#1:

class Rational(n: Int, d: Int) {

}

相当于javap:

public class com.zjffdu.tutorial.scala.Rational
extends java.lang.Object
implements scala.ScalaObject{
    public com.zjffdu.tutorial.scala.Rational(int, int);
}

Scala#2:

class Rational(n: Int, d: Int) {
  override def toString() = n + "/" + d
}

相当于javap:

public class com.zjffdu.tutorial.scala.Rational
extends java.lang.Object
implements scala.ScalaObject{
    private final int n;
    private final int d;
    public java.lang.String toString();
    public com.zjffdu.tutorial.scala.Rational(int, int);
}

好吧,这个问题可能不多说,但是这里是交易:我正在学习scala并决定使用一个方法来创建一个实用程序类"FuncThread",该方法接收一个名称参数函数(我想它之所以称之为因为它是一个函数但是没有参数列表)然后启动一个带有runable的线程,然后执行传递的函数,我写了这样一个类,如下所示:

class FuncThread
{
   def runInThread( func: => Unit)
   {
     val thread = new Thread(new Runnable()
     {
        def run()
        {
          func
        }
     }

     thread.start()
   }
}

然后我写了一个junit测试如下:

@Test
def weirdBehaivorTest()
{
  var executed = false
  val util = new FuncThread()
  util.runInThread
  {
    executed = true
  }

  //the next line makes the test pass....
  //val nonSense : () => Unit  = () => { Console println "???" }

  assertTrue(executed)
}

如果我取消注释第二个注释行,则测试通过,但如果它仍然被注释,则测试失败,这是正确的行为吗？by-name参数函数如何以及何时执行？

我知道Scala有actor库但我想尝试这个,因为我一直想用Java做这个

我有关于斯卡拉的问题Future.

目前我有一个程序通过一个目录运行并检查是否有文件.如果有文件,程序应将这些文件转换为".pdf"

我的代码看起来像这样(它是伪代码):

for(file <- directory) {
  if(timestamp > filetimestamp) {
    Future {
    // do a convert job that returns UNIT
    }
  }
}

这是有效的代码还是我需要等待返回值？

还有其他替代品和Futures一样轻量级吗？

我想检查字符串是否包含该字符.我正在写一个刽子手代码.例如,这里是猜词:"scala",但它看起来像"_ _ _ _ _"用户.假设用户输入字母'a',那么它必须看起来像"_ _ a _ a".

def checkGuess(){
if (result.contains(user_input)) {
    val comp = result.toCharArray
    for (i <- comp){
        if (user_input != comp(i))
            comp(i) = '_'
        comp(i)
        }
    val str = comp.toString
    }
}

这是正确的吗？

先感谢您.

谁能帮助我理解这段代码？我对Scala一无所知,也没有听说过.

def maxSubseq(l: List[Int]) = l.scanRight(Nil : List[Int]) {
    case (el, acc) if acc.sum + el < 0 => Nil
    case (el, acc) => el :: acc
} max Ordering.by((_: List[Int]).sum)

def biggestMaxSubseq(l: List[Int]) = l.scanRight(Nil : List[Int]) {
    case (el, acc) if acc.sum + el < 0 => Nil
    case (el, acc) => el :: acc
} max Ordering.by((ss: List[Int]) => (ss.sum, ss.length))

def biggestMaxSubseq[N](l: List[N])(implicit n: Numeric[N]) = {
    import n._
    l.scanRight(Nil : List[N]) {
        case (el, acc) …

class X extends Map[String, String] {
    def x(): X = { X() } // can't be compiled
}

无法编译,错误是:

<console>:6: error: not found: value X
def x(): X = { X() } // can't be compiled

为什么找不到X？我看不出如何纠正它.

更新:

我现在知道原因.我想要做的是创建一个扩展的类HashMap,因为Map()它将返回一个实例HashMap,所以我想我可以扩展Map.现在,正确的代码应该是:

import scala.collection.immutable.HashMap
class X extends HashMap[String, String] {
    def x(): X = { new X() }
}

如果我错了请纠正我

Scala引入了新的范例,如TypeTheory,Continuations,Monads和其他计算理论.Scala是否正在成为一种理论语言,因为大多数论文,博客都在谈论这一点,而我相对较少看到代码插图......