在这个参数化的Scala函数中,为什么需要强制转换？
在这个参数化的Scala函数中，需要强制转换的原因可能是因为类型不匹配或者泛型类型的擦除。Scala是一种强类型语言，这意味着它需要在编译时确定变量和表达式的类型。当您在编写代码时遇到类型不匹配的问题时，可能需要使用强制类型转换来解决。
例如，如果您有一个泛型类型的集合，例如ListT，在使用时，泛型类型参数T会被擦除，因此在运行时，集合中的元素类型将变为Object类型。在这种情况下，如果您需要将元素转换为特定类型，可能需要使用强制类型转换。
另一种可能的原因是，您可能在使用第三方库或API，这些库或API可能返回了一个Any类型的数据，而您需要将其转换为特定类型。在这种情况下，您可以使用强制类型转换来将Any类型的数据转换为所需的类型。
总之，需要强制转换的原因可能是类型不匹配或泛型类型擦除。在Scala中，强制类型转换可以通过使用.asInstanceOfT方法来实现，其中T是您要转换的目标类型。
相关·内容
我希望有一个带有类依赖类型的参数的类，就像我经常为方法所做的那样。然而，令我惊讶的是，这并没有奏效：
scala> trait Compiler { trait Config }
defined trait Compiler
// works fine, as expected
scala> def f(c: Compiler)(conf: c.Config) = {}
f: (c: Compiler)(conf: c.Config)Unit
scala> class F(val c: Compiler)(val conf: c.Config)
<console&g
浏览 1提问于2015-09-24得票数 4
回答已采纳
我很困惑为什么我不能从下面这行Scala代码中生成一个集合： val pairs = for( v <- vc; o <- oc) yield (v,o) 它在这个函数的内部，这个函数使用了不可变的向量。 private def recMergeVirtualAndReal(mCell: RCell, vc: Vector[Cell], oc: Vector[Cell]): Vector[Cell] = {
var temp_oc = oc
val pairs = for( v <- vc; o <- oc) yield (v,o)
浏览 35提问于2019-03-17得票数 0
回答已采纳
1回答
当我在写的时候，我也试着用更“函数式”的方式来解决这个问题，但还是坚持了下面的问题：
scala> "1".asInstanceOf[Int]
java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Integer
at scala.runtime.BoxesRunTime.unboxToInt(Unknown Source)
...
但
scala> Some("1".asInstanceOf[Int])
res29: Some[I
浏览 0提问于2011-08-03得票数 4
回答已采纳
我有一个包含map数据类型的类型安全配置对象。下面是conf文件中密钥的内容。 test_mapping = {
'15': [8000, 8002],
'5': [500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522],
....
} 这是我用来从配置中读取这个密钥的代码。 scala> val test = config.getObject("test_mapping&#
浏览 19提问于2019-06-21得票数 0
以下是REPL (Scala2.11)中的人为实验：
scala> class Foo[T] {
| def as(x: Any) = x.asInstanceOf[T]
| }
defined class Foo
scala> val foo = new Foo[String]
foo: Foo[String] = Foo@65ae6ba4
scala> val x: Any = 123
x: Any = 123
scala> foo.as(x) // expected
java.lang.ClassCastException: ja
浏览 2提问于2015-12-10得票数 4
回答已采纳
1回答
我试着使用conv函数，就像我在一些例子中看到的那样，但并不适合我。我不明白为什么这个函数在DF列中返回相同的值。我在Scala2.11.11中使用了spark2.1，然后我尝试使用SPART2.2和Scala2.11.11。但是，当我使用应用于我的SHA2的conv函数时，它并不像预期的那样工作。我的代码是：
val newDf = Df.withColumn("id",conv(sha2(col("id"),256),16,10).cast(IntegerType))
有什么建议吗？非常感谢!
浏览 4提问于2018-06-10得票数 3
回答已采纳
我使用Spark2.4已经有一段时间了，最近几天我刚刚开始使用Spark3.0。在切换到Spark3.0运行udf((x: Int) => x, IntegerType)后，我得到了这个错误
Caused by: org.apache.spark.sql.AnalysisException: You're using untyped Scala UDF, which does not have the input type information. Spark may blindly pass null to the Scala closure with primitive-ty
浏览 9提问于2020-12-03得票数 6
回答已采纳
我正在编写一个包装器，它接受一个Scala 并触发与框架兼容的事件。
在数据绑定框架中，有一个用来装饰普通列表的抽象Java。我想重用这个基类，但即使是这段简单的代码也失败了：
val list = new java.util.ArrayList[Int]
val obsList = new ObservableList(list, null) {}
有错误：
illegal inheritance; anonymous class $anon inherits different type instances of trait Collection: java.util.Collection
浏览 15提问于2011-02-14得票数 4
回答已采纳
对于Scala来说，它是个新手，为了澄清一些ScalaMock语法，搜索了很多地方。根据，我一直看到以下通用测试模式：
(myClass.myMethod _).expects()
这里到底发生了什么？类/方法/空格/下划线起什么作用？编译器是如何处理这个问题的？
浏览 0提问于2018-05-14得票数 5
回答已采纳
在需要指针的函数的参数解析过程中，为什么选择的是引用到指针的转换，而不是指针转换？
template<typename T>
class resource_ptr
{
public:
operator T*()const {...} // <- C1: Convert to raw pointer for observation.
operator T*&() {...} // <- C2: Convert to reference to pointer, for assignment.
...
};
浏览 1提问于2012-07-13得票数 3
我正在试验scala的隐式转换特性。
我尝试编写一种方法，将Int隐式转换为三个相同整数的列表。
虽然list方法是适用的，但是当我们打印值时，它仍然显示为Integer
scala> implicit def conversion(x:Int) = List(x,x,x)
conversion: (x: Int)List[Int]
scala> 1
res31: Int = 1
scala> res31.length
res32: Int = 3
scala> res31.tail
res33: List[Int] = List(1, 1)
scala>
浏览 3提问于2017-07-12得票数 0
回答已采纳
2回答
我对Scala非常陌生(如果这是特定于火花的话)，所以请原谅这个超级简单的问题。
在我看来，这段代码应该编译得很好：
sqlContext.udf.register("json_extract_string", (rawJson: String, keyPath: String*) => {
[String]UDFs.jsonExtract(rawJson, keyPath:_*)
})
然而，编译却产生了错误：
Error:(31, 89) ')' expected but identifier found.
sqlContext
浏览 3提问于2016-01-11得票数 0
回答已采纳
3回答
import scala.concurrent.duration._
import scala.language.implicitConversions
import scala.concurrent.{Future, Await}
import scala.concurrent.ExecutionContext.Implicits.global
object test extends App {
case class Person(name: String, age: Int)
implicit def t2p(t: (String, Int)) : Person = Per
浏览 7提问于2015-06-24得票数 3
回答已采纳
1回答
有人能解释一下为什么会这样吗？
scala> def as[T](v: Any) = Try(v.asInstanceOf[T])
as: [T](v: Any)scala.util.Try[T]
scala> as[Int]("Hello")
res0: scala.util.Try[Int] = Success(Hello)
scala> res0.map(_ + 1)
res1: scala.util.Try[Int] = Failure(java.lang.ClassCastException: java.lang.String cannot be
浏览 1提问于2015-09-26得票数 1
回答已采纳
2回答
我想把拼花文件写到PostgreSQL。我正在使用Spark并编写文件，我使用的是Spark的write.jdbc函数。对于长、十进制或文本这样的拼花列类型，一切都可以正常工作。问题在于像Map这样的复杂类型。我想将Map作为json存储在我的PostgreSQL中。因为我知道PostgreSQL可以自动将文本数据类型转换为json (使用强制转换操作)，所以我将映射转储到json字符串。
但是星火程序抱怨说，我们试图将“字符变化”数据类型插入到"json“类型的列中。这表明PostgreSQL不会自动将“字符变化”转换为JSON。
我继续登录到我的数据库，手动尝试将一个JSON字符串
浏览 1提问于2018-04-20得票数 2
回答已采纳
我是Scala编程的新手。我提出了一个问题，为什么每个辅助构造函数都应该调用Scala中先前定义的构造函数之一？
浏览 21提问于2017-08-03得票数 1
4回答
我不明白为什么这个程序不能同时使用g++ 7.3或clang++ 5.0使用-std=c++14编译。
A可以从const int初始化，如下图所示。对A的const引用也可以从const int创建，但是使用const int调用f(const A &)失败。为什么？
#include <iostream>
struct V {
int i;
template <class T>
V(const T &t) : i{t} {}
};
struct A {
int i;
A(V v) : i{v.i} {}
};
void f(
浏览 1提问于2018-06-27得票数 3
回答已采纳
我正在play_2.9.1-2.0.3上构建一个应用程序，并使用specs2_2.9.1-1.7.1进行测试(它与play捆绑在一起)。我有一个动作是这样的：
def createPoll() = Action { request =>
request.body.asJson.map {jsonBod =>
Poll.fromJsonValue(jsonBod).fold(
thrown => CommonResponses.invalidCreatePollRequest(this),
poll =&g
浏览 2提问于2012-10-29得票数 1
回答已采纳
我一直在讨论这个问题，这是很烦人的(Scala2.13.4)。
case class Coord(x: Int, y: Int)
val data: List[(Int, Int)] = List( (1,2), (3,4) )
data.map{ (x,y) =>
Coord(x,y)
}
给我这个错误：
found : (Int, Int) => Coord
required: ((Int, Int)) => Coord
可以通过添加"case“关键字来解决这个问题。
data.map{ case (
浏览 11提问于2021-12-05得票数 0
回答已采纳
2回答
在Scala中定义方法时，我发现
def method1: Int => Int = (j: Int) => j // works
def method2: Int => Int = j => j // works
def method3: Int => Int = j: Int => j // error
def method4: Int => Int = {j: Int => j} // works
有人能解释为什么method3不能工作吗？里面有什么含糊不清的地方吗？
浏览 3提问于2017-07-25得票数 3
回答已采纳
1回答
我已经浏览了很多与转换相关的问题，但似乎没有一个问题是以这种方式讨论显式关键字的。下面是代码：
struct B;
struct A{
/*explicit*/ A(const B&){ cout << 1; } // *1
};
struct B{
/*explicit*/ operator A()const{ cout << 2; } // *2
};
void foo(const A &){}
int main(void){
B b;
foo( /*static_cast<A>*/ (b) ); /
浏览 0提问于2015-12-31得票数 7
回答已采纳
@uncheckedVariance可以用来弥合Scala的声明、站点差异、注解和Java的不变泛型之间的差距。
scala> import java.util.Comparator
import java.util.Comparator
scala> trait Foo[T] extends Comparator[T]
defined trait Foo
scala> trait Foo[-T] extends Comparator[T]
<console>:5: error: contravariant type T occurs in
浏览 2提问于2010-03-16得票数 40
回答已采纳
我有以下数据(只是显示了一个代码片段)
DEST_COUNTRY_NAME ORIGIN_COUNTRY_NAME count
United States Romania 15
United States Croatia 1
United States Ireland 344
Egypt United States 15
我在inferSchema选项设置为true的情况下读取它，然后对列执行describe操作。它似乎工作得很好。
scala> val data = spark.read.option("header", "true
浏览 0提问于2019-02-03得票数 1
为什么asInstanceOf不抛出一个ClassCastException？
scala> List("a").asInstanceOf[List[Int]]
res34: List[Int] = List(a)
浏览 1提问于2014-09-28得票数 16
回答已采纳
1回答
在Scala (v2.8.0，在SimplyScala.com上)中，如果我定义了一个带有默认参数的2进制函数，为什么不能将它作为一个1进制函数传递呢？
这
def bah(c:Char, i:Int = 0) = i
List('a','b','c').map(bah)
给出这个
error: type mismatch;
found : (Char, Int) => Int
required: (Char) => ?
List('a','b','c').map(
浏览 0提问于2014-07-02得票数 0
回答已采纳
我有一段代码，它试图将一个函数包装在另一个函数中，进行动态类型检查：
class Base
class Foo extends Base
class Bar extends Base
object Main{
def checker[A <: Base]( func : A => String) : Base => String =
(b : Base) => b match {
case a : A => func(a)
case _ => "error"
}
def fooFunc(
浏览 0提问于2012-03-10得票数 4
回答已采纳
为什么调用所有参数都有默认值的方法与调用scala中没有参数的方法不同？
示例：
scala> def a(a:Int=1)=print(a)
a: (a: Int)Unit
scala> def b=print(1)
b: Unit
scala> a
<console>:13: error: missing argument list for method a
Unapplied methods are only converted to functions when a function type
is expected.
You can make th
浏览 0提问于2017-10-18得票数 2
为什么这段代码不进行类型检查？
def foo: Either[String, List[Int]] = {
val x = null: Either[String, String]
x match {
case l @ Left(_) => l
case Right(_) => Right(List(3))
}
}
具体地说，为什么编译器不能/不能具体化LeftA，X和EitherA，B的类型
这发生在scala 2.8.2和scala 2.9.2中
浏览 0提问于2012-08-07得票数 4
回答已采纳
我试图从scala返回继承的java类型，并且我正在.Java定义的特征列表在E类型中是不变的
Java代码:
public interface Foo {
....
}
public class Bar implements Foo {
....
}
public interface FooReader {
List<Foo> getFoos() throws Exception;
}
Scala代码：
import scala.collection.JavaConverters._
class Buz extends FooReader {
def getFoos: uti
浏览 2提问于2015-11-08得票数 2
回答已采纳
4回答
我最近一直在读泛型，我偶然发现了这个方法：
protected <V> RunnableScheduledFuture<V> decorateTask(Callable<V> callable, RunnableScheduledFuture<V> task) {
return new ExceptionHandlingFutureTask<V>(callable, task);
}
你看，我理解为什么在protected之后有一个<V>。我不明白的是，为什么在RunnableScheduledFu
浏览 1提问于2012-03-29得票数 0
回答已采纳
我是C语言的初学者，在JavaScript之后就开始了，不能适应这些类型。
好的，math.h的sqrt函数应该可以使用doubles函数，据我所知，在C中，您不能将错误的类型作为参数传递。
但当我走的时候
int b = sqrt(1234); //it works
也是如此。
float b = sqrt(1234); // it works
int b = sqrt(1234.22) // it works
为什么这些都起作用了？这里的过程是什么样子的？
我的猜测是:无论传递什么，sqrt的参数都会自动转换为double，如果我要分配给的变量是int类型，结果double将转换为int。
浏览 3提问于2014-11-24得票数 0
回答已采纳
我一直在使用基本Scala数据类型。我注意到scala.Any类定义了来自的方法asInstanceOf[T0]: T0，API有它可以“将接收对象强制转换为T0类型”。使用此方法作为起点，我想研究Scala中的转换。另外，我还查找了关于这个主题的其他问题，我想出了一个，手里拿着这些信息，我编写了一个愚蠢的程序。
package com.att.scala
import com.att.scala.Sheltie
object Casting {
//def foo(x: String){
浏览 11提问于2012-09-10得票数 15
我需要绑定这个特征的实现： trait ClientRepository[F[_]] {
def list(): F[Iterable[ClientDTO]]
} 对于此实现： import cats.effect.IO
@Singleton
class ClientRepositoryImpl @Inject()(db: OldDataBase, c: IOContextShift)
extends ClientRepository[IO] {
override def list(): IO[Iterable[ClientDTO]] = ???
} 我正在使用Scala
浏览 3提问于2019-06-19得票数 2
回答已采纳
在Scala中，许多类型都扩展了Any。Scala类层次结构图的。
例如，Double和Tuple都扩展了Any，并且下面的代码按预期工作：
def foo(x: Any) { println(x.toString) }
foo(3.0) // prints: 3.0
foo((2,3)) //prints: (2,3)
然而，我不明白为什么下面的方法不起作用，因为它遵循上面所有的逻辑：
def bar(fn: Any => String) { println(fn.toString) }
def dub(d: Double): String = "dub"
def t
浏览 1提问于2014-07-20得票数 0
我正在用Scala尝试一些来自Python的东西。由于Scala在保持类型一致性方面要严格得多，所以我惊讶地发现，我可以进行以下连接，这将在Python中崩溃：
def adder(one:Any, two:String) = {one+two}
adder("word", "suffix")
res13: String =String后缀
但也包括：
val x:Int = 1
adder(x, "suffix")
res12: String =1后缀
所以它只是将一个Int转换成一个String w/out告诉我。这叫
浏览 11提问于2017-05-24得票数 3
回答已采纳
2回答
我有一个类，它的隐式参数定义为：
class Test(implicit one: String)
我想实例化这个对象如下：
val grr = new Test("aha")
我得到了以下例外。
error: too many arguments for constructor Test: ()(implicit one: String)Test
val grr = new Test("aha")
但如果我这么说的话
val grr = new Test()("haha")
grr: Test = Test@3bd40a57
我
浏览 1提问于2017-03-07得票数 2
回答已采纳
2回答
我正在尝试将Scala引入到我的Android项目中，该项目使用Guice进行DI。对于工作指南，我需要将@Inject注释添加到我希望Guice使用的构造函数中。在我的例子中，我创建了一个Scala类，我需要在我的Java代码中使用它。
scala:
class scalaClass1(a: String) {
var myA = a
@Inject
def this() = { this("test") }
}
这看起来没问题，对吧？但是在另一种情况下，构造函数没有任何参数，所以我尝试了
scala:
class scalaClass2() {
v
浏览 0提问于2014-05-23得票数 1
回答已采纳
我有这个代码。在main中，我希望使用类型转换，但在使用debug时，我在这一行中理解为ob2=(Point2D<double>)ob1;
构造函数template <class T1> Point2D(Point2D<T1>& ob)被调用，而不考虑之前的explicit，即template <class T1> explicit Point2D(Point2D<T1>& ob)。为什么会发生这种情况？我希望调用operator Point2D<T1>()。
template <class T>
浏览 2提问于2011-12-11得票数 5
回答已采纳
这个问题与Java和Scala之间的集成有关。为了让事情更清晰，我对它做了一些简化。
我有两个用Java编写的类：
class A<T>{}
class AT extends A<Boolean> {}
在Java中，我有一个方法，它以以下方式使用类：
public A<Boolean> a(){
return new AT();
}
我想在scala中做同样的事情。但是下面的代码不能编译。
def a(): A[Boolean] = {
return new AT();
}
消息显示：“类型不匹配；找到:需要org.rarry.samp
浏览 1提问于2013-04-08得票数 6
回答已采纳
在scala中，def用于定义方法，val，var用于定义变量。
考虑以下代码：
scala> def i = 3
i: Int
scala> i.getClass()
res0: Class[Int] = int
scala> val v = 2
v: Int = 2
scala> v.getClass()
res1: Class[Int] = int
scala> println(v)
2
scala> println(i)
3
scala> i+v
res4: Int = 5
scala> def o = () => 2
浏览 2提问于2016-11-28得票数 3
回答已采纳
我想这已经被讨论过很多次了，但这是我不明白的：
class A(val name: String) {
println("A ("+ name +")")
}
class B(override val name: String) extends A(name = name + "1") {
println("B ("+ name +")")
}
val b = new B("Olle")
println(b.name)
这将给出输出：
A (Olle1)
B (Olle
浏览 1提问于2011-04-08得票数 1
回答已采纳
如何在Scala中定义函数myEval(f, args)，该函数以另一个函数f和参数args作为输入，其输出为f(args)
我不希望myEval对f的重要性或参数类型有任何事先的了解。
为什么这个有用？它是解决通用timeMyFunction(f, args)方法实现问题的一种方法。如果有一种方法可以通过某种懒惰的val结构来实现，那也会很有趣。
编辑：在中解释了实现定时方法的更好方法。通过调用timeMyFunction( { f(args) } )，函数调用被包装在一个匿名函数Unit => Unit中。因此，timeMyFunction只需要接受0-的函数。
编辑2：参见Dirk
浏览 4提问于2014-04-15得票数 8
回答已采纳
3回答
字符串级联运算符+歧义
、、、、
我目前正在开发一种基于JVM的编程语言，它支持操作符重载和自定义操作符。我想坚持使用Java，并使用+操作符进行字符串连接，这是在我的语言中实现的，工作非常完美。但是，运算符也用于其他各种地方，例如，将元素添加到集合中：
public interface Collection[E]
{
// ...
public Collection[E] +(E element)
// ...
}
List[String] strings = List()
List[String] strings2 = strings + "a"
正如您可以看到的，这里有一个歧义：
浏览 5提问于2015-06-12得票数 2
回答已采纳
我正在考虑在clojure和scala之间进行一些互操作。由于java本身现在有lambdas，我在考虑数据之间的泛化以及如何将函数应用于集合。
构造函数扩展了clojure.lang.IFn和generalises在clojure.lang.ISeq上的集合操作
scala函数扩展了scala.Function和scala.collection.Traversable上的集合操作。
java扩展了java.util.function.Function，并在java.util.stream.Stream上扩展了集合操作。
问题：
在这种情况下，monads会有用吗？
浏览 0提问于2018-09-16得票数 7
回答已采纳
3回答
我们都很熟悉通过引用方式返回：
//global
int x;
int& getElX()
{
return x;
}
因为函数是返回类型的int &，为什么不用说return (int&)X呢？
再一次，我明白回溯是如何运作的。这是一个主要关于语法的问题。
此外，如果您执行return (int&)x，其含义是否会发生变化？
浏览 3提问于2016-04-29得票数 3
回答已采纳
尝试将String转换为Double显然应该失败：
scala> Try("abc".asInstanceOf[Double])
res11: scala.util.Try[Double] = Failure(java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Double)
但是，如果我将上述内容定义为一个函数：
scala> def convertAsTypeOf[T](anyValue: Any): Try[T] = Try(anyValue.asInstance
浏览 1提问于2014-08-10得票数 1
在Scala中，匹配匿名函数的模式一直令我吃惊。我刚刚发现了以下的行为，我想知道如何理解它。
看来，匿名函数{ case (a, b) => (b, a) }的参数签名可以注释为单个元组参数和参数元组：
scala> ({ case (a, b) => (b, a) }: ((Int, Int)) => (Int, Int))
val res1: ((Int, Int)) => (Int, Int) = $Lambda$1160/0x0000000801127040@689fe2a3
scala> ({ case (a, b) => (b, a) }
浏览 6提问于2020-09-12得票数 2
回答已采纳
最近，在使用linq的方法时，我遇到了使用它的问题--用户定义的强制转换(强制转换操作重载)。
我在这里找到了一个关于我的问题的，我还找到了一个，它很好地解释了这个问题。我的问题解决了。
但有件事让我很好奇：
为什么这不管用：
foolist.Cast<bar>(); // throws InvalidCastException
虽然这样做是可行的：
foolist.Select(f => (bar)f).ToList(); // works fine
我相信这与每个方法的实现有关。如果是这样的话，Cast方法不能有一个与类似的实现，允许将它用于用户定义的强制转换(因为这在某
浏览 4提问于2013-03-04得票数 2
在下面的代码中，我创建了一个Java集合。稍后，当我将其转换为Scala时，我可以在Int中存储null。但是如果我直接创建一个scala map，我就不能存储null。为什么？
scala> import collection.JavaConverters._
import collection.JavaConverters._
scala> val mapJava:java.util.HashMap[String,java.lang.Integer] = new java.util.HashMap[String,java.lang.Integer]
mapJava: jav
浏览 0提问于2017-11-14得票数 1
Haskell的懒惰评估比急切的评估采取更多的评估步骤。
另一方面，Scala的逐名评估比按值调用更多的评估步骤(如果短路的好处被重复计算的成本所抵消)。
我以为按名字叫大致相当于懒散的评估。那为什么时间保证会有这样的差别呢？
我猜想Haskell语言可能指定在评估过程中必须使用回忆录；但是在这种情况下，Scala为什么不这样做呢？
浏览 2提问于2017-01-22得票数 11
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频活动推荐
腾讯云开发者
