scala基础之泛型详解

最新推荐文章于 2023-07-01 18:36:38 发布
最新推荐文章于 2023-07-01 18:36:38 发布
阅读量9.8k 收藏 14
点赞数 1
分类专栏： 大数据/Scala 基础 文章标签： scala 泛型
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhanglh046/article/details/72845897
版权

在Scala中你可以使用类型参数来实现类和函数，这样的类和函数可以用于多种类型。比如Array[T] 你可以存放任意指定类型T的数据.

类、特质、函数都可以有类型参数；将类型参数放在名字后面用方括号括起来

 

一 泛型类

1.1Java 实现

public class Animals<A,B> {
    private A name;
    private B age;

    public Animals() {
    }
    public Animals(A name, B age) {
        this.name = name;
        this.age = age;
    }

    public A getName() {
        return name;
    }

    public void setName(A name) {
        this.name = name;
    }

    public B getAge() {
        return age;
    }

    public void setAge(B age) {
        this.age = age;
    }
}

public class MainClient {
    public static void main(String[] args) {
        Animals<String,Integer> animals = new Animals<String,Integer>();
        animals.setName("小花");
        animals.setAge(2);
    }
}

 

1.2Scala实现

class Animals[A,B](var name:A, var age:B) {
    println(s"Name is $name, Age is $age")
}
 
object GenericClient extends App {
    val cat = new Animals[String,Int]("小花",2)
    val dog = new Animals[String,String]("阿黄","5")
}

 

二 泛型函数

2.1Java 实现

public <T> T convertJsonToObject(String jsonData, Class<T> clazz) {
    Gson gson = new Gson();
    T object =  gson.fromJson(jsonData, clazz);
    return object;
}

protected static <T> List<T> asList(T[] pSrc) {
    if (pSrc == null || pSrc.length == 0) {
        return new ArrayList<T>();
    } else {
        return Arrays.asList(pSrc);
    }
}

 

2.2Scala实现

def asList[T](pSrc:Array[T]): List[T] = {
    if (pSrc == null || pSrc.isEmpty) {
        List[T]()
    } else {
        pSrc.toList
    }
}
val friends = Array("小白","琪琪","乐乐")
val friendList = cat.asList(friends)
println(friendList.isInstanceOf[List[String]])

 

三 类型变量界定

3.1 上边界

有时候我们需要对变量类型进行限制，比如：

class Pair[T](val first:T, val second:T) {
    def smaller = if (first.compareTo(second))
}

我们并不知道类型T到底有没有compareTo方法，所以编译报错。

我们可以添加一个上边界

Java版上边界实现：

public class Pair<T extends Comparable<T>> {
    private T first;
    private T second;
    public void smaller(){
        if (getFirst().compareTo(getSecond()) < 1) {
            System.out.println("first < second");
        } else if (getFirst().compareTo(getSecond()) > 1) {
            System.out.println("first > second");
        } else {
            System.out.println("first = second");
        }
    }

    public T getSecond() {
        return second;
    }

    public void setSecond(T second) {
        this.second = second;
    }

    public T getFirst() {
        return first;
    }

    public void setFirst(T first) {
        this.first = first;
    }
}
Pair<String> p = new Pair<String>();
p.setFirst("10");
p.setSecond("20");
p.smaller();

 

 

Scala版上边界实现：

class Pair[T <: Comparable[T]](val first:T, val second:T) {
    def smaller = {
        if (first.compareTo(second) < 0) {
            println("first < second")
        } else if (first.compareTo(second) > 0) {
            println("first > second")
        } else {
            println("first = second")
        }
    }
}
val p = new Pair[String]("10","20")
p.smaller

 

3.2 下边界

Java实现：

public class Father {
    protected String name;
    public Father(String name) {
        this.name = name;
    }
    public Father() {
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String message() {
        return "<Father> name is "+name;
    }
}

 

public class Child extends Father{
    public String message() {
        return "<Child> name is "+name;
    }
}
public class Children extends Child {
    public String message() {
        return "<Children> name is "+name;
    }
}
public class MethodClient {
    public String getMessage(Class<? super Child> clazz) {
        if (clazz == Child.class) {
            return new Child().message();
        }
        if (clazz == Father.class) {
            return new Father().message();
        }
        //这里编译通不过，因为Children是Child的子类，而我们所接受的参数是Child以及他的父类才可以
        if (clazz == Children.class) {
            return new Children().message();
        }
        return null;
    }
}

 

Scala实现：

class Father(val name: String)
class Child(name: String) extends Father(name)
def getIDCard[R >: Child](person:R) {
    if (person.getClass == classOf[Child]) {
        println("please tell us your parents' names.")
    } else if (person.getClass == classOf[Father]) {
        println("sign your name for your child's id card.")
    } else {
        println("sorry, you are not allowed to get id card.")
    }
}

val c = new Child("ALice")
getIDCard(c)

 

四 边界之视图边界（View Bounds）

刚才我们看过上边界一个例子，class Pair[T<: Comprable[T]]

如果你尝试new Pair[2,3],肯定会报错，提示Int不是Comparable[Int]的子类，Scala Int类型没有实现Comparable接口，(注意Java的包装类型是可以的)，但是RichInt实现了Comparable[Int]，同时还有一个Int到RichInt的隐式转换，这里就可以使用视图界定。

注意：视图边界用来要求一个可用的隐式转换函数（隐式视图）来将一种类型自动转换为另外一种类型，定义如下：

def func[A <% B](p:A) = 函数体

 

它其实等价于以下函数定义方式

def func[A](p:A) (implicit m:A=>B) = 函数体

 

 

class Person(val name: String) {
    def sayHello = println("Hello, I'm " + name)
    def makeFriends(p: Person) {
        sayHello
        p.sayHello
    }
}

class Student(name: String) extends Person(name)
class Dog(val name: String) {
    def sayHello = println("汪汪, I'm " + name)
    implicit def dog2person(dog: Object): Person = {
        if(dog.isInstanceOf[Dog]) {
            val _dog = dog.asInstanceOf[Dog];
            new Person(_dog.name);
        } else {
            null
        }
    }
}

class Party[T <% Person](p1:T,p2:T)

另外一个例子：

class Pairs[T <% Ordered[T]] (val first:T, val second:T) {
    def smaller = if (first < second) first else second
}

 

五 边界之上下文界定

我们知道View  Bounds: T <% V必须要求存在一个T 到V的隐式转换。而上下文界定的形式就是[T:M]，其中M是另一个泛型类，他要求必须存在一个类型为M[T]的隐式值

def func[T:S](p:T) = 函数体

表示这个函数参数p的类型是T，但是在调用函数func的时候，必须有一个隐式值S[T]存在，也可以这样写：

def func[T](p:T)(implicit arg:S[T]) = 函数体

 

类型参数可以有一个形式为T:M的上下文界定，其中M是另外一个泛型类型。它要求作用域存在一个M[T]的隐式值

举个例子：

class Fraction[T:Ordering] {}

他要求存在一个类型为Ordering[T]的隐式值，该隐式值可以用于该类的方法中，考虑如下例子：

class Fraction[T:Ordering](val a:T, val b:T) {
    def small(implicit order:Ordering[T]) = {
        if (order.compare(a,b) < 0) println(a.toString) else println(b.toString)
    }
}

 

假设现在有一对象Model，需要传入Fraction中，那么：

class Model(val name:String, val age:Int) {
    println(s"构造对象 {$name,$age}")
}

 

val f = new Fraction(new Model("Shelly",28),new Model("Alice",35))
f.small

由于需要一个Ordering[Model]的隐式值，但是我们又没有提供，所以上面编译是有问题的

 

怎么办呢？既然需要Ordering[Model]的隐式值，那么我们就先创建一个Ordering[Model]的类

class ModelOrdering extends Ordering[Model]{
    override def compare(x: Model, y: Model): Int = {
        if (x.name == y.name) {
            x.age - y.age
        } else if (x.name > y.name) {
            1
        } else {
            -1
        }
    }
}

这个类重写compare方法

然后，编译器需要能够找到这个隐式值这个隐式值 可以是变量也可以是函数。

object ImplicitClient extends App {
    //implicit valmo = new ModelOrdering
    implicit def mo = new ModelOrdering
    /*由于需要一个Ordering[Model]的隐式值，所以一下编译是有问题的*/
    val f = new Fraction(new Model("Shelly",28),new Model("Alice",35))
    f.small
}

 

六Manifest上下文界定

在Scala中，如果要实例化一个泛型数组，需要使用[T:Manifest]

泛型类型，这样才能实例化泛型数组

也就是说:

def func[T: Manifest](参数列表){}

等价于

def func[T](参数列表)(implicit evidence:Manifest[T]) {}

class Manifests {
    def convert[T:Manifest](array:T*): Unit ={
        val arr = new Array[T](array.length)
        for (i <- 0 until array.length){
            arr(i) = array(i)
        }
        arr
    }
}

 

七 多重界定

一个类型参数有多个类型约束,比如：

T>: A <: B

表示T所允许的范围是A的父类 或者是B的子类

T:A:B

表示作用域必须存在A[T]和B[T]隐式值

 

T <%A <% B

表示作用域必须有T到A 和 T到B 的隐式转换

class Person(val name:String, val age:Int) {
    def desc(color:String,weight:Int) = println(s"我的颜色：$color, 我的重量：$weight")
    def shopping(p:Person) = println("我正在和 "+p.name+"在万达广场购物")
}

class Dog(val name: String,val age:Int) {
    def sayHello = println("汪汪, 我是" + name)
    def actMute(): Unit = {
        println(s"$name 正在卖萌")
    }
}

class Cat(val name: String,val age:Int) {
    def sayHello = println("喵喵, 我是" + name)
}

class Converter{
    def act[T <% Person <% Dog](o:T,p:Person,d:Dog): Unit ={
        if (p != null) {
            println(o.shopping(p))
        }

        if (d != null) {
            println(o.actMute())
        }
    }
}

object GenericClient extends App {
    implicit def cat2person(cat: Object): Person = {
        if(cat.isInstanceOf[Cat]) {
            val _cat = cat.asInstanceOf[Cat];
            new Person(_cat.name,_cat.age);
        } else {
            null
        }
    }

    implicit def cat2dog(cat: Object): Dog = {
        if(cat.isInstanceOf[Cat]) {
            val _cat = cat.asInstanceOf[Cat];
            new Dog(_cat.name,_cat.age);
        } else {
            null
        }
    }
    val converter= new Converter
    val p = new Person("王一彤",20)
    val d = new Dog("啸天",5)
    val c = new Cat("小白",2)
    converter.act(c,p,d)
}

 

八  类型约束

类型约束提供给你的是另外一个限定类型的方式，总共有三种关系可供使用

T =:= U 表示测试T 是否等于U类型

T <:< U 表示测试T 是否为U的子类型

T <%< U 表示是否存在T到U 的转换

 

十 协变和逆变

协变和逆变：用于父子类型的转换

Covariant: 协变表示子类转父类，比如子类型给以赋给父类型

Contravariant: 逆变表示父类转子类

简单举几个例子：

不可变：

public class Animal {
    private String name;
    private int age;

    public Animal(){

    }

    public Animal(String name,int age){
        super();
        this.name = name;
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

public class Mammal extends Animal {
    public Mammal(){

    }
    public Mammal(String name, int age){
        super(name,age);
    }

    public void suckle() {
        System.out.println("I'm suckling");
    }
}

 

/**
 * 不可变编译就会报错，类型不匹配
 * 因为ArrayList<Animal> 和 ArrayList<Mammal>是不相等
 */
ArrayList<Animal> animals1 = new ArrayList<Mammal>();

/*
 * 协变 <? extendsT>
 * 表示我可以接受T类型以及他的子类
 */
ArrayList<? extends Animal> animals2 = new ArrayList<Mammal>();

/*
 * 协变 <? superT>
 * 表示我可以接受T类型以及他的父类
 */
ArrayList<? super Mammal> animals3 = new ArrayList<Animal>();

 

 

协变与逆变的时机

一般而言：如果一个对象同时消费和产出某值，则类型保持不变；如果是消费某个对象的值，适合逆变，如果生产某个对象的值，则适合协变

public class Consumer<E> {
    public void consume(List<E> elements) {
        for (E e : elements) {
            System.out.print(e + " ");
        }
    }
}

public static void main(String[] args) {
    Consumer<Number> consumer = new Consumer<Number>();
    List<Integer> intList = new ArrayList<Integer>();
    intList.add(1);intList.add(2);intList.add(3);intList.add(6);intList.add(10);
    List<Float> floatList = new ArrayList<Float>();
    floatList.add(11.11f);floatList.add(2.2f);floatList.add(3.3f);floatList.add(6.6f);floatList.add(10.1f);
    consumer.consume(intList);
    consumer.consume(floatList);
}

 

假设我们初始化一个Comsumer<Number>,虽然Integer和Float都是Number子类，但是List<Integer> 和 List<Float> 都不是List<Number>子类，因为Java中泛型是不可变的。

所以我么应该改为：

public class Consumer<E> {
    public void consume(List<? extends E> elements) {
        for (E e : elements) {
            System.out.print(e + " ");
        }
    }
}

这样就可以了。

 

假设我们需要往一个集合添加数据：

public Collection<E> produce(Collection<E> c,List<? extends E> elementList) {
    for (E e : elementList) {
        c.add(e);
    }
    return c;
}

 

如果还是初始化一个Comsumer<Number>,那我们传递一个Collection<Object>，这时候类型不匹配，因为Collection<Number>并不是Collection<Object>的子类，

public Collection<? super E> produce(Collection<? super E> c,List<? extends E> elementList) {
    for (E e : elementList) {
        c.add(e);
    }
    return c;
}

这样的话，我就可以接收任何E类型父类型，然后把值添加进来

 

consumer.produce(new ArrayList<Object>(), intList);

 

Scala中的协变和逆变：

协变[+T]总结: 只有满足指定类型或者指定类型子类才可以被兼容,即使是指定类型的父类也不会被兼容,通俗地讲，只要是你或者你的子类我都可以编译通过

class Master(val name:String) {

}
class Professional(name:String) extends Master(name){

}
class Worker(val name:String){

}

class Card[+T](val name: String) {
    def enterMeet[T](card:Card[Master]){
        println("welcome you join the meeting!!");
    }
}

object Test extends App {
    val c1 = new Card[Master]("Master")
    c1.enterMeet(c1)
    val c2 = new Card[Professional]("Professional")
    c1.enterMeet(c2)
    val c3 = new Card[Worker]("Worker")
    /*由于Worker不是Master子类，所以不满足协变特性*/
    c3.enterMeet(c3)
}

 

逆变[-T]总结: 只有满足指定类型或者指定类型父类才可以被兼容,即使是指定类型的子类也不会被兼容通俗地讲，只要是你或者你的父类我都可以编译通过

class Master(val name:String) {

}
class Professional(name:String) extends Master(name){

}
class Worker(name:String) extends Professional(name) {

}

class Card[-T](val name: String) {
    def enterMeet(card:Card[Professional]){
        println("welcome you join the meeting!!");
    }
}

object Test extends App {
    val c1 = new Card[Master]("Master")
    c1.enterMeet(c1)
    val c2 = new Card[Professional]("Professional")
    c1.enterMeet(c2)
    val c3 = new Card[Worker]("Worker")
    /*由于Worker不是Professional的父类，所以不满足逆变特性*/
    c3.enterMeet(c3)
}

 

十一 object不能泛型

我们不能给object添加参数化类型

十二 类型通配符

莫言静好、
关注
  • 1
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
Scala 泛型
Smiling_lzy的博客
05-16 207
Scala 泛型1、泛型类和泛型函数2、泛型界定~泛型上限~泛型下限 1、泛型类和泛型函数 泛型类：定义类的时候，定义泛型，这个泛型就可以在类的任何地方使用 泛型函数：定义函数的时候定义泛型，这个泛型只能在函数的内部使用 object Generic1 { def main(args: Array[String]): Unit = { val p1 = new Point[Int](10,20) val x = p1.x val p2 = new Point[Double]
Scala入门之List使用详解
08-25
主要介绍了Scala入门之List使用详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Scala常用数据类型实战
cbb
10-13 79
1.数组 object ScalaDataType { def main(args: Array[String]): Unit = { // val 声明常量 val string = "scala"; // var 来声明变量 var str = "to"; str = " many"; val a = 20; if (a < 50) { println("number is " + a); } // p
scala初学_Scala初学者系列1基础
weixin_26705651的博客
08-21 112
scala初学This series is all about the taste of Scala. It is best suitable for all the newbies in Scala. So here we go… 这个系列是关于Scala的味道的。 它最适合Scala中的所有新手。 所以我们开始... This article will cover the fundamenta...
Scala 变量和数据类型
m0_72168501的博客
11-21 300
Scala 变量和数据类型
Scala泛型(泛型方法,泛型类,泛型特质,上下界,协变、逆变、非变)
Maverick_曲流觞的博客
04-03 426
Scala泛型,Scala泛型方法,Scala泛型类,Scala泛型特质,Scala上下界,Scala协变,Scala逆变,Scala非变
大数据---Scala基础入门(二)
qq_43785075的博客
09-28 80
基础的使用1、注释2、代码规范3、变量和常量4、标识符的命名规范5、字符串输出6、 键盘输入 1、注释 Scala 注释使用和 Java 完全一样。 1. 单行注释：// 2. 多行注释：/* */ 3. 文档注释：/** * * */ 2、代码规范 1. 使用一次 tab 操作，实现缩进，默认整体向右边移动，用 shift+tab 整体向左移 2. 或者使用 ctrl + alt + L 来进行格式化 3. 运算符两边习惯性各加一个空格 4. 一行最长不超过 80
Scala之泛型详解
最新发布
RainTicking的博客
07-01 817
泛型用于指定类或方法可以接受任意类型参数，参数在实际使用时才被确定，泛型可以有效地增强程序的适用性，使用泛型可以使得类或方法具有更强的通用性。
chisel线网（wire）和寄存器（reg）详解（更新）
耐心的小黑的博客
06-25 5291
主体内容摘自：https://blog.csdn.net/qq_34291505/article/details/87714172 在Verilog里，模块内部主要有“线网(wire)”和“四态变量(reg)”两种硬件类型，它们用于描述数字电路的组合逻辑和时序逻辑。在Chisel里，也按这个思路定义了一些硬件类型，包括基本的线网和寄存器。 在verilog中我们经常会对线网和寄存器赋值，以完成信号的传递或者电路的连接。在chisel中也是，线网和寄存器最常见的操作都是被赋值，因为只有这样我们才能实现各种我
Scala中的泛型详解
BlueLotuss的博客
08-24 1582
Scala中的泛型详解 类型参数可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法 类型参数 **调用时不指定[T]：可以通过给泛型声明的变量传递值来让scala自动推断泛型的实际类型；返回的是使表达式编译通过的合适的类型；在编译时不会检查类型是否满足 ** 调用时指定[T]：可以在函数的调用时候指定泛型的类型；则返回对就必须是T类型；会在编译时检查类型，不满足泛型规则编译不通过 泛型类 在类声明时，定义一些泛型类型，然后在类的内部，就可以使用这些泛型类型 在需要对类中的某些
快学scala习题及答案详解
05-22
快学scala习题、答案、详细解答 快学scala第一章习题答案.doc 快学scala第二章习题答案.doc 快学scala第三章习题答案.doc ......
Scala基础简介及代码示例
08-29
主要介绍了Scala基础简介及代码示例，小编觉得挺不错的，这里给大家分享下，供需要的朋友参考。
Scala编程基础.docx
04-05
Scala编程基础
Scala基础知识01
01-07
Option、 None、 Some 是 scala 中定义的类型，它们在 scala 语言中十分常用，因此这三个类型很重要。 None、 Some 是 Option 的子类，它主要解决值为 null 的问题，在 java 语言中，对于定义好的 HashMap，如果 get...
Scala 数组
happy19870612's blog
12-21 5476
一  Array 数组 在Scala中，Array代表的含义和Java中类似，也是长度不可变的数组 此外，由于Scala与Java都运行在JVM中，双方可以互相调用，因此 Scala数组的底层实际上是Java数组。例如字符串数组在底层就是 javaString[]，整数数组在底层就是Int[]   数组初始化四种方式：   >>val names = new Array[Strin
scala基础之特质trait
happy19870612's blog
06-02 1086
Scala中，trait相当于Java中的接口,遇到需要使用Java接口的场景时，你就在Scala中可以使用trait了。   我们知道Java中你可以实现多个接口，那么Scala中，你也可以继承多个trait   Java中接口不能有自己的实现方法，但是Scala中trait可以包含自己的实现方法   一 特质用作接口 接口的作用：对行为进行规范，具有解耦的作用，满足业务系统依赖倒
Scala 函数式编程
happy19870612's blog
12-21 1018
一 函数式编程 1.1将函数值赋给变量 >>Scala中函数可以独立存在，不必像Java一样，还需要依附于类。而且我们可以直接将函数作为值赋给变量 >>Scala语法规定，将函数赋值给变量时，相当于变量就是函数。必须在函数后面加上空格和下划线 scala>def sayHello(name:String) {println("welcome you," + name)} sayHello
Scala 面向对象编程
happy19870612's blog
12-21 1010
一 定义一个简单的类 1.1定义类，包含field以及方法 classHelloWorld {   private var name = "leo"   def sayHello() { print("Hello, " +name) }    def getName = name }                               1.2创建类的对象，并调用其方法
Scala编程之文件操作
05-22
Scala提供了丰富的文件操作API，可以方便地对文件进行读写、复制、删除等操作。 ## 读取文件内容 Scala中读取文件内容有多种方式，其中一种是使用Source对象。可以通过以下代码读取文件内容： ```scala import scala.io.Source val filename = "example.txt" val source = Source.fromFile(filename) val lines = source.getLines() for (line <- lines) { println(line) } source.close() ``` 以上代码使用`Source.fromFile`方法读取文件内容，并使用`getLines()`方法获取每一行的内容。最后需要调用`close()`方法关闭文件流。 ## 写入文件 写入文件同样可以使用`Source`对象，但需要使用`PrintWriter`作为输出流。下面是一个简单的例子： ```scala import java.io._ val filename = "example.txt" val writer = new PrintWriter(new File(filename)) writer.write("hello world") writer.close() ``` 以上代码通过`PrintWriter`将字符串写入文件，并调用`close()`方法关闭文件流。 ## 复制文件 Scala中复制文件可以使用Java中的`File`类和`Files`类。下面是一个使用`Files`类复制文件的例子： ```scala import java.io._ import java.nio.file.{Files, Paths} val sourceFile = "source.txt" val destinationFile = "destination.txt" Files.copy(Paths.get(sourceFile), Paths.get(destinationFile)) ``` 以上代码使用`Files.copy()`方法复制源文件到目标文件。 ## 删除文件 Scala中删除文件同样可以使用Java中的`File`类。下面是一个简单的例子： ```scala import java.io._ val filename = "example.txt" val file = new File(filename) if (file.exists()) { file.delete() } ``` 以上代码通过`File`类判断文件是否存在，并调用`delete()`方法删除文件。 以上就是Scala中文件操作的基本内容。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

莫言静好、

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值