scala类的序列化

A sequence comprehension statement consists of a generator part which generates a list of values from the specified range of inputs and a statement which operates on these generated elements which is then stored in the output list to be returned at the end of computation. For example;

序列理解语句由一个生成器部分和一个对这些生成的元素进行操作的语句组成，该生成器部分从指定的输入范围生成一个值列表，这些语句然后存储在输出列表中，以在计算结束时返回。 例如;

object Sequence {def main(args:Array[String]) {def increment(from: Int, to:Int):List[Int] =for(i <- List.range(from,to) if  i % 5 == 0) yield i
println(increment(1,30))
}
}

In this example we are creating a method that accepts two Integer parameters from and to that takes the range of the numbers. For every number starting from 1 we are checking whether the number is divisible by 5 as i%5 == 0 which prints only the numbers divisible by 5 in the range 1-30.

在此示例中，我们将创建一个方法，该方法从到接受两个Integer参数，并采用数字范围。 对于从1开始的每个数字，我们都在检查该数字是否可被5整除，因为i％5 == 0，它仅打印在1-30范围内被5整除的数字。

Below image shows the output produced and you can see that they all are divisible by 5.

下图显示了产生的输出，您可以看到它们都可以被5整除。

Consider an example which returns a pair of numbers when multiplied is equal to specified value y.

考虑一个示例，该示例在相乘等于指定值y时返回一对数字。

object Seq {def main(args:Array[String]){def multiples(x:Int, y:Int) =for(a <- 0 until x;b <- a until x if a * b == y) yieldTuple2(a,b);multiples(42,40) foreach {case(a,b) =>println("(" + a + " ," + b + ")")}}
}

In this example we are defining a method “multiples” that accepts two integer argument x and y . We are checking for the condition that variables a and b when multiplied gives the value equal to the value of y specified by the user. The result is a pair of numbers as shown in the below image.

在此示例中，我们定义了一个“ multiples”方法，该方法接受两个整数参数x和y。 我们正在检查变量a和b相乘时得出的值等于用户指定的y的条件。 结果是一对数字，如下图所示。

Consider an example of a comprehension which returns Unit.

考虑一个返回Unit的理解示例。

object Comprehension {def main(args:Array[String]){for (i <- Iterator.range(0, 15);j <- Iterator.range(i, 15) if i*j == 12)println("(" + i + ", " + j + ")")}
}

The yield keyword should not be used for such comprehensions. The range of numbers is specified using the Iterator.range. Above code produces following output.

yield关键字不应用于这种理解。 数字范围是使用Iterator.range指定的。 上面的代码产生以下输出。

Scala通用类 (Scala Generic Classes)

Scala supports generic classes which are useful for the development of collection classes. For example;

Scala支持泛型类，这对于开发集合类很有用。 例如;

object GenericClass {def main(args:Array[String]) {abstract class Multiply[x] {def multiply(a: x, b: x): x;}class intMultiply extends Multiply[Int] {def multiply(a: Int, b: Int): Int = a * b;}class DoubleMultiply extends Multiply[Double] {def multiply(a : Double, b : Double) : Double = a * b;}val m1 = new intMultiply().multiply(20,15);val m2 = new DoubleMultiply().multiply(20.34, 6.56);println(m1);println(m2);
}
}

In this example we declare an abstract class Multiply with x that can accept any data type and define multiply method with a and b variables of x data type. Now we define two classes intMultiply, DoubleMultiply that accepts Integer and Double types respectively. We create m1 and m2 and call the methods multiply by passing the arguments.

在此示例中，我们声明一个抽象类Multiply with x，它可以接受任何数据类型，并使用x数据类型的a和b变量定义乘法方法。 现在，我们定义两个类intMultiply和DoubleMultiply分别接受Integer和Double类型。 我们创建m1和m2并通过传递参数来调用方法相乘。

Scala内部类 (Scala Inner Classes)

A class can be defined inside another class in Scala which is termed as an inner class. The inner class is bound to the outer object. For example;

可以在Scala中的另一个类（称为内部类）中定义一个类。 内部类绑定到外部对象。 例如;

class Add {class Addtwonumbers {var a = 12;var b = 31;var c = a + b;}
}object Innerclass {def main(args:Array[String]) {val a1 = new Add
val a2 = new Add
val b1 = new a1.Addtwonumbers
val b2 = new a2.Addtwonumbersb1.a = 30;
b1.b = 45;
b2.a = 55;
b2.b = 24;
println(s"b1.a = ${b1.a}")
println(s"b1.b = ${b1.b}")
println(s"b2.a = ${b2.a}")
println(s"b2.b = ${b2.b}")
println(s"Result = ${b2.c}")}
}

In this example we define an Outer class Add and inside this class we define one more class Addtwonumbers which is the inner class. In the inner class Addtwonumbers, we are defining variables a, b, c and storing result of a+b in c.

在此示例中，我们定义了外部类Add，并且在该类内部定义了另一个类Addtwonumbers，它是内部类。 在内部类Twotwonumbers中，我们定义变量a，b，c，并将a + b的结果存储在c中。

We are assigning values for variables a and b and accessing it by creating instances of the outer class and then instance of inner class through this outer class instance. Below image shows the output produced when main method of Innerclass is invoked.

我们为变量a和b赋值，并通过创建外部类的实例，然后通过该外部类实例创建内部类的实例来访问它。 下图显示了调用Innerclass main方法时产生的输出。

That’s all for a brief introduction to sequence comprehensions, generics and inner classes in Scala programming language.

以上就是对Scala编程语言中的序列理解，泛型和内部类的简要介绍。

翻译自: https://www.journaldev.com/8483/scala-sequence-comprehensions-generic-classes-and-inner-class-example

scala类的序列化