Mo_mo???
Mo_mo???

Flutter Dart：泛型的协变与逆变

Flutter Dart：泛型的协变与逆变_第1张图片

本文字数：16281 字

预计阅读时间 41 分钟

Flutter Dart也支持泛型和泛型的协变与逆变，并且用起来比Java，Kotlin更方便。那么Dart中的泛型协变和逆变，应该如何理解和使用呢？它与Java，Kotlin中的逆变和协变又有什么区别呢？文章将从浅到深跟大家一起来探讨学习。

一、Dart泛型

Dart中的泛型和其他语言的泛型一样，都是为了减少大量的模板代码，举例说明：

// Dart

//这是一个打印int类型msg的PrintMsg

class PrintMsg {

  int _msg;

  set msg(int msg) { this._msg = msg;}

  void printMsg() { print(_msg);}

}

当打印需求发生变化，需要支持打印更多种类的数据类型，不支持范型的话，代码会大量增加，如下面这样：

// Dart

//非范型写法，现在需要新增支持String，double和自定义类的Msg，

class Msg {

  @override

  String toString() { return "This is Msg";}

}

class PrintMsg {

  int _intMsg;

  String _stringMsg;

  double _doubleMsg;

  Msg _msg;

  set intMsg(int msg) { this._intMsg = msg;}

  set stringMsg(String msg) { this._stringMsg = msg;}

  set doubleMsg(double msg) { this._doubleMsg = msg;}

  set msg(Msg msg) {this._msg = msg;}

  void printIntMsg() { print(_intMsg);}

  void printStringMsg() { print(_stringMsg);}

  void printDoubleMsg() { print(_doubleMsg);}

  void printMsg() { print(_msg);}

}

而有范型的支持后，不管增加多少种数据类型，打印类都可以简化成如下几行：

// Dart

//泛型写法，简化成几行代码，且支持无数种数据类型:

class PrintMsg {

    T _msg;

    set msg(T msg) { this._msg = msg; }

    void printMsg() { print(_msg); }

}

1、泛型类型省略

Dart中可以指定实际的泛型参数类型，也可以省略。实际上，编译器会自动进行类型推断，把泛型参数类型转为dynamic类型。举例说明：

// Dart

List<int> numTest = [1, 2, 3];   //注意int在Dart中是个类，继承自num类。和Java中的基础类型int不一样，java中的int是不能作为泛型的实参的，因为int不是Object的子类。

Mapint> mapTest = {'a': 1, 'b': 2, 'c': 3};

//Dart可简写成如下形式, 但非常不推荐，因为泛型简写会被自动类型推断为dynamic（非泛型简写的类型推断不会变成dynamic）。

List numTest = [1, 2, 3];

Map mapTest = {'a': 1, 'b': 2, 'c': 3}

print(numTest.runtimeType.toString());   // output“List”

print(mapTest.runtimeType.toString());   // output“_InternalLinkedHashMap”

//所以Dart的简写方式，相当于如下形式

List numTest = [1, 2, 3];

Map mapTest = {'a': 1, 'b': 2, 'c': 3};

2、真伪泛型

在Java中，ArrayList是支持泛型的，但是它的数据存储用的却是Object[]，这是因为Java在编译的时候会进行类型擦除，也可以说Java中的泛型是种伪泛型，泛型只存在编译时期，运行时泛型就会被擦除（所以运行时无法获取泛型T的真实类型信息）。

Kotlin最终也会编译生成和Java相同规格的class文件，所以Kotlin中的泛型也会被擦除，也无法使用{a is T;}进行类型判断。

不过Kotlin为泛型的类型判断做了一点改进，支持在inline函数里判断reified修饰的泛型类型。它的原理是，在编译过程中，编译器会将inline内联函数的代码替换到实际调用的地方，并且对reified定义的泛型参数，不进行泛型擦除，而把调用方的形参直接替换成具体的实参类型，这样编译的结果，就支持inline内联函数内部对reified泛型进行类型判断，举例说明:

// Kotlin

inline fun PrintMsg(value:T) {

    LogUtil.d("test", T::class.toString())  // 非inline函数的reified泛型，不能调用T::class

    LogUtil.d("test", value!!::class.toString())  //不管是否inline函数，都会打印参数的真实类型信息

    var b = value is List<*>  // * 不能换成任何具体类型，编译器会报错。注意，PrintMsg方法里的泛型T,不是List中的泛型E, E在Kotlin中运行时都会被擦除成为Object了。

    LogUtil.d("test", b.toString())

    b = "abc" is T  // 非inline函数的reified泛型，则不能调用 is T

    LogUtil.d("test", b.toString())

}

fun main() {

    PrintMsg("test")

    PrintMsg(arrayListOf(1, 2, 3))

    PrintMsg(arrayListOf("a", "b", "c"))

}

// output

//D/test: class java.lang.String   // 在inline函数里，泛型T直接换成了实参类型String

//D/test: class java.lang.String   // 读取的是实参的真实类型信息。

//D/test: false

//D/test: true

//D/test: class java.util.ArrayList   //泛型T换成了实参ArrayList，ArrayList中的元素E已经都换成了Object

//D/test: class java.util.ArrayList   //此处ArrayList中的元素E已经都换成了Object

//D/test: true

//D/test: false

//D/test: class java.util.ArrayList    //泛型T换成了实参ArrayList，此处ArrayList中的元素E已经都换成了Object

//D/test: class java.util.ArrayList   //此处ArrayList中的元素E已经都换成了Object

//D/test: true

//D/test: false

而Dart的泛型是真泛型，在编译期和运行期都可以通过泛型拿到其真实类型，所以Dart中可以直接用泛型进行类型判断，用代码举例说明 ：

// Dart

void PrintMsg(T value) {

  print("test---"+ T.toString());   //使用没有限制，可以获取List中的泛型E的具体类型

  print("test---"+ value.runtimeType.toString());

  var b = value is List;   // 可以直接判断范型结合体的具体类型

  print("test---2 "+ b.toString());

  b = "abc" is T;   //使用没有限制，T就是一种类型

  print("test---3 "+ b.toString());

}

void main() {

  PrintMsg("abc");

  PrintMsg(List<int>.from({1,2,3}));

 PrintMsg(List.from({"a","b","c"}));

}

// output

//I/flutter (21231): test---String

//I/flutter (21231): test---String

//I/flutter (21231): test--- false

//I/flutter (21231): test--- true

//I/flutter (21231): test---List   //此处List中的E元素仍然是int对象

//I/flutter (21231): test---List   //此处List中的E元素仍然是int对象

//I/flutter (21231): test--- false

//I/flutter (21231): test--- false

//I/flutter (21231): test---List  //此处List中的E元素仍然是String对象

//I/flutter (21231): test---List  //此处List中的E元素仍然是String对象

//I/flutter (21231): test--- true

//I/flutter (21231): test--- false

通过示例代码和output log，我们可以看出，泛型是编译期的一个概念，在运行期，Java/Kotlin 把泛型都转换成了Object，而Dart保留了具体的实参类型，都不再是一个不确定的形参类型。

二、泛型关系：协变，逆变和不变

协变，逆变和不变是一种描述泛型类型关系变化的概念。在了解Dart中的协变，逆变和不变之前，我们先来搞清楚什么是类型关系。

1、类和类型，子类和子类型

类和类型的关系容易混淆。Dart中的类可分为两大类: 泛型类和非泛型类。

非泛型类是开发中接触最多的类。非泛型类去定义一个变量时，这个非泛型类就是这个变量的类型。例如:

  •  定义一个非泛型类 Class Person，那么就会有个Person类型。

  •  定义一个非泛型类 Class Boy extend Person类，会有个Boy类型

泛型类比非泛型类复杂，一个泛型类可以对应无限种类型。在定义泛型类的时候会定义泛型形参，要拿到一个真实的泛型类型，就需要在使用泛型类的地方，给泛型类传入具体的类型实参替换定义中的类型形参。

我们经常使用的集合基本都会使用泛型，所以以集合举例说明，List是一个类，它不是一个类型，它可以衍生成无限种类型。例如，List， List，List>都是不同的类型。

所以，每个非泛型类会对应一个类型。而每个泛型类，会对应无限种类型。

知道了类和类型的关系，我们再来看子类和子类型的关系。

子类就是派生类，它继承父类。例如: class Boy extends Person，则Boy就是Person的子类，Person 是 Boy类的父类。

子类型没有继承关系，它的定义是: 需要A类型值的任何地方，都可以使用B类型的值来替换，则B类型就是A类型的子类型，或A类型是B类型的超类型。‍

举例说明：

  • Boy是Person的子类和子类型。

  • List类可以衍生出很多类型，这些类型之间都不是子类关系，但可能是子类型关系。如 List不是List的子类，但是List是List的子类型(Dart默认支持协变，后面会讲)。

  • List是Iterable的子类，但因为List不是一种类型，所以List和Iterable不是子类型关系。

所以属于子类关系的类型，也会成为子类型关系。例如：Boy是Person的子类，它能代替Person出现的任何地方，所以它们之间存在子类型关系。而double不能替代int出现的地方，所以它们不存在子类型关系。但子类型关系，不一定是子类关系。

介绍完泛型和子类型关系概念，下面开始具体介绍类型关系变换：协变，逆变和不变。我们下面以Java为示例进行概念说明，在Java代码中使用 和 来表达协变与逆变（在Kotlin中用 和 表示 ）。

2、类型关系的定义与意义

协变，逆变和不变是用来描述类型转换后的类型关系，其定义如下:

如果A，B表示类型，f(*)表示类型转换，< 表示子类型关系(比如，A

  • f(*)是

    协变

    （covariant）的，当A

  • f(*)是

    逆变

    （contravariant）的，当A

  • f(*)是

    不变

    （invariant）的，当A

上面的定义看起来比较抽象，下面以Java中的ArrayList集合举例说明：

  • ArrayList这种形式的泛型是

    支持协变的

    ，它可以被赋值为ArrayList、ArrayList，但是不能被赋值为ArrayList

    • ArrayList这种形式的泛型是

      支持逆变的

      ，它可以被赋值为ArrayList、ArrayList，但是不能被赋值为ArrayList

      • ArrayList这种形式的泛型是

        不变的

        ，就是说ArrayList list，不能被赋值为ArrayList，也不能被赋值为ArrayList，只能被赋值为ArrayList

        为什么要提出上面的协变与逆变概念呢？其意义就是为了让泛型实现多态。

        我们知道，多态能将子类/实现类的对象赋值给父类/父接口，从而实现相同引用类可以指向不同实现体。比如PrintMsg(num i)，参数可以传入int，double，num，这样就能用一个方法实现不同数据类型的相似功能。

        那么泛型不能实现多态吗？因为泛型使用场景会牵扯到两种类型Class1，所有要分情况来说：

        • 对于Class1来说，是支持多态的，比如

          Collection

          collect = new

           ArrayList

          ()；

        • 对于Class2来说，有两个维度去理解：

        （1）Class2本身是支持多态的，比如ArrayList

        Number> list, 这个list可以add任何Number子类的对象，如 list.add(

        （2）Class1结合体是不支持多态的，比如ArrayList list = new ArrayList()，这个是不对的（注意，Java泛型结合体是不变的，默认是不支持协变的）。

        因此，范型结合体不支持多态，而逆变和协变为这种场景提供了支持多态的解决方案。

        3、多态的实现和限制

        首先，在Java中，普通泛型是“不变”的，即不支持多态，以ArrayList举例说明：

        ArrayList list1 = new ArrayList();

        ArrayList list2 = new ArrayList();

        list1 = list2；// 编译错误！

        Integer是Number的子类，如果可以把list2赋值给list1，则二者都指向了new ArrayList()。这时，list1.get取数据没问题，因为里边都是Integer的对象。但是如果list1.add(Double)，从list1的角度来说是正确的，因为Double也是Number类型。但是从list2的角度来说就是错误的，因为Double肯定不是Integer类型，list2取出一个Double类型的数据，这是破坏语言基本规则的，肯定不能通过编译。

        所以普通泛型只能是不变的，即其普通泛型结合体不支持多态。

        那如何解决普通泛型不支持多态的问题呢？

        上面举例中，如果普通泛型支持多态，写入会导致问题。那通过限制不允许写入，就可以解决这个问题，如下：

        ArrayList list1 = new ArrayList();

        ArrayList list2 = new ArrayList();

        list1 = list2；

        Number a = list1.get(0)；

        list1.add(1) // 编译错误！

        上面extends Number>其实就是实现了泛型协变，即：

        Integer  <  Number

        ArrayList  < ArrayList

        因为list1 只能读不能写，所以能保证上面的泛型协变，实现了范型结合体的多态。

        上面的范型协变，是写限制的范型，那可不可以即支持多态还不限制写呢？

        通过限制范型不允许读，就可以解决这个问题，如下：

        ArrayList list1 = = new ArrayList();

        ArrayListlist2=new ArrayList();

        list1 = list2；

        Number a = list1.get(0)；// 编译错误！

        list1.add(1)；

        首先，任何范型只能写入声明的类及其子类的对象才不会出错。上面list1 = list2，list1和list2相当于都指向了ArrayList，list1.add的都是Number及其子类的对象，也肯定是Number父类的子类，所以list.add不会出错。

        但是如果list2.add过Object的对象，list1.get读出来的就不是Number的对象了，这肯定是破坏语言基本规则的，所以此时的多态，就通过限制范型不允许读来避免问题。

        上面super Number>其实就是实现了泛型逆变，即：

        Number <  Object

        ArrayList  >  ArrayList

        因为list1 只能写不能读，所以能保证上面的泛型逆变，也实现了范型结合体的多态。

        4、协变和逆变的应用和实践

        上面了解完泛型结合体的多态实现，接下来我们就要正确运用协变和逆变，这需要对其使用的场景有充分的理解。

        协变很好理解，和我们常用的多态场景是类似的。协变只能读取数据，不能添加数据，所以只能作为生产者，向外提供数据，不能向它写入数据。

        逆变就不太好理解，其难以理解的点就在于，一个超类型，数据更泛化（可能泛化到Object），那不是做不了什么吗？如果把逆变的场景换到参数的函数功能复用，而非参数的数据使用，就能更好理解了。

        协变和逆变在集合中都有广泛的运用，所有我们继续以Java的ArrayList为例，举例说明：

        // Java

        public class ArrayList extends AbstractList

                implements List, RandomAccess, Cloneable, java.io.Serializable {

            transient Object[] elementData;

            private int size;

            // 省略代码......

            public boolean addAll(Collectionextends E> c) { // c参数支持协变

                Object[] a = c.toArray();  // 对c进行读操作

                int numNew = a.length;

                ensureCapacityInternal(size + numNew); 

                System.arraycopy(a, 0, elementData, size, numNew); // 写入到elementData数组中

                size += numNew;

                return numNew != 0;

            }

            public void forEach(Consumersuper E> action) {// action参数支持逆变

                Objects.requireNonNull(action);

                final int expectedModCount = modCount;

                @SuppressWarnings("unchecked")

                final E[] elementData = (E[]) this.elementData;

                final int size = this.size;

                for (int i=0; modCount == expectedModCount && i < size; i++) {

                    action.accept(elementData[i]);  // 对action写操作

                }

                if (modCount != expectedModCount) {

                    throw new ConcurrentModificationException();

                }

            }

        }

        class Person {

            String name;

            char sex;

            Person(String n, char s) {

                name = n;

                sex = s;

            }

        }

        class Boy extends Person {

            Boy(String n) {

                super(n, "male");

            }

        }

        class Girl extends Person {

            Girl(String n) {

                super(n, "female");

            }

        }

        public void main() {

            ArrayList array1 = new ArrayList();

            array1.add(new Person("p1b", "male"));

          array1.add(new Person("p1g", "female"));

            ArrayList array2 = new ArrayList();

            array2.add(new Boy("b1"));

            array2add(new Boy("b2"));

          // Boy是Person的子类型，所以Collection也是Collection<？extends Person>的子类型,

           // 而ArrayList继承自Collection，所以ArrayList是Collection的子类型，也同样是Collection<？extends Person>的子类型，

           // 然后，array1的addAll参数支持Collection<？extends Person>泛型协变，

           // 所以，array1的addAll参数可以传入array2.

            array1.addAll(array2);  

            int count = 0;

         Consumer comsumerPerson = new Consumer(){

                  @Override

                  public void accept(Person person) {

                       if(person.name.contain("g")) {

                             // do some action

                             count++;

                       }

                  }

             };

            // array1的forEach支持Consumer泛型逆变，

           //  Consumer参数属于本来类型，默认支持。

            array1.forEach(comsumerPerson)

            ArrayList array3 = new ArrayList();

            array3.add(new Girl("g1"));

            array3.add(new Girl("g2"));

          //  array3的forEach参数支持Consumer泛型逆变，

          // Person是Girl的超类型，所以Consumer是Consumer的子类型，

          // 所以，comsumerPerson可以作为forEach的参数。

            array3.forEach(comsumerPerson) 

        }

        通过上面的例子，我们可以看出来：

        • addAll函数中的参数c是作为生产者，从自身读取元素提供给ArrayList。通过协变参数Collection 中读取的元素肯定是ArrayList中元素E的子类型，子类型放进数组中肯定是支持的。

        • forEach函数中的参数action则是作为消费者，从ArrayList拿取元素提供给给自己使用。在array3.forEach(comsumerPerson) 中，Consumer是Consumer的子类型，可以作为参数传入，comsumerPerson拿到array3的Girl元素，在accept函数中统计Person名字含“g”的人员数。这样comsumerPerson的函数功能就得到了很好的复用。

        把只能从中读取的对象称为生产者（Producer），只能写入的对象称为消费者（Consumer），即只能从Producer中get对象，只能put对象给Consumer，这就是著名的PECS原则（Producer-Extends, Consumer-Super），也是协变和逆变的最佳实践原则。

        在狐友的代码中也通过使用协变和逆变，使得通用类可以适配大量的数据类型。以单例的事件总线LivedataBus为例说明：

        Flutter Dart：泛型的协变与逆变_第2张图片

        事件总线bus通过BusMutableLiveData声明支持协变，这样就可以在总线bus中添加所有BusEvent子类型事件。比如BusMutableLiveData （TeamUpPublishEvent 继承BusEvent），BusMutableLiveData。

        事件总线bus通过Event的类型名称作为key进行事件发布和订阅的匹配桥梁，让发布的事件可以通知到所有订阅者。

        Flutter Dart：泛型的协变与逆变_第3张图片

        Flutter Dart：泛型的协变与逆变_第4张图片

        BusMutableLiveData的observe方法，通过Observer声明参数支持逆变，让在onChange处理相似数据类型的Observer，可以有机会被多次复用。

        而BusMutableLiveData作为可感知生命周期，可观察数据变化的类型，用它来包装总线事件BusEvent，可以方便业务订阅各种事件通知， 如订阅组局发布事件 TeamUpPublishEvent，组局搜索事TeamUpSearchResultEvent ：

        Flutter Dart：泛型的协变与逆变_第5张图片

        a2a831043d6b371648c78c75d75e120e.jpeg

        这里，TeamUpPublishEvent的事件订阅者，会在onChanged收到事件时，先判断发布成功才会刷新UI。TeamUpSearchResultEvent的事件订阅者，则会在onChanged收到事件时上报搜索的结果。

        所以，通过运用协变和逆变，事件总线LivedataBus只用了简单少量的代码，就支持了无数种事件类型的发布和订阅处理。

        三、Dart协变

        实际上在Dart1.x的版本种是既支持协变又支持逆变，但是在Dart2.x版本开始仅支持协变。所以后面我们就不再讨论Dart的逆变。

        在Dart中所有泛型类都默认支持协变（类似Java的<？extend T>，Kotlin的），不需要像Java或Kotlin一样，需要用额外的关键字声明。

        从上一节的分析可知，协变实际上就是泛型结合体保留了泛型参数的子类型化关系。比如说int是num的子类型，所以List就是List的子类型，这就是结合体的子类型关系保留了泛型参数的子类型关系，用例子说明：

        // Dart

        class Person {

          final String name;

          final String sex;

          Person(this.name, this.sex);

        }

        class Boy extends Person {

          Boy(this.name) : super(this.name, "male");

        }

        class Girl extends Person {

          Girl(this.name) : super(this.name, "female");

        }

        void PrintMsg(List persons) { //根据多态的概念，persons可以传入List or 其子类型的对象。

          for (var person in persons) {

             print('${persons.name}---${persons.sex}');

          }

        }

        void main() {

        List girls = [];

        girls.add(Girl("g1"));

          // Girl是Person的子类型，List支持协变，则List是List子类型。

          // 而PrintMsg函数接收一个List类型，根据协变的原则，可以使用子类型代替超类型，可以使用List类型替代。

          PrintMsg(girls);

          List boys = [];

          boys.add(Boy("b1"));

          PrintMsg(boys);// 同上，List也是List的子类型

          List persons = [];

          persons.add(Person("p1","female"));

          persons.add(Person("p2","male"));

          PrintMsg(persons);// List自身，也是可以的。

        }

        从上面例子可以看出，在Dart中泛型声明默认是支持协变的，不需要像Java那样在代码中额外声明。

        我们在Flutter项目中，也有大量的泛型协变的应用，以实际代码举例：

        Flutter Dart：泛型的协变与逆变_第6张图片

        在buildBody方法中，接受一个List参数进行Page构建。

        再看调用的位置，实际上传参是一个通过buildButton返回的ElevatedButton(继承自Widget)构建出来的一个List，如下所示：

        Flutter Dart：泛型的协变与逆变_第7张图片

        因为List默认支持协变，所以buildBody方法可以接受一个List类型的实参。buildBody方法正是通过协变，支持了更多种类的页面数据，从而构建起item不同，布局类似的page页面。

        四、Dart协变安全

        Java，Kotlin中协变和逆变都是安全的，但是Dart的泛型型变是存在安全问题的，因为Dart中的协变是支持读写的，而Java，Kotlin中协变是不支持写的。

        以List集合为例，它在Java和Kotlin中都是不变的。

        Java通过声明List变量支持协变，并限制其数据T只能读不能写，从而保证了泛型协变安全。

        Kotlin和Java一样，也通过声明List来支持协变并限制其数据只读。但Kotlin对集合做了进一步优化，通过把集合分为可读写集合MutableList和只读集合List来保证安全问题。其中MutableList是可读可写，但不支持协变和逆变，而List只读，且支持协变。

        Dart中，List默认支持协变，又是可读可写的，这样就会存在安全问题，我们举例说明:

        // Dart

        class Person {

          final String name;

          final String sex;

          Person(this.name, this.sex);

        }

        class Boy extends Person {

          Boy(this.name) : super(this.name, "male");

        }

        class Girl extends Person {

          Girl(this.name) : super(this.name, "female");

        }

        void PrintMsg(List persons) { //根据多态的概念，persons可以传入List or 其子类型的对象。但是，这里的List实际是不安全的！！！

          for (var person in persons) {

            print('${persons.name}---${persons.sex}');

          }

        }

        void main() {

        List girls = [];

        girls.add(Girl("g1"));

        PrintMsg(girls);  // Girl是Person的子类型，List支持协变，则List是List子类型。

        }

        上面代码编译和运行都没有问题，但是PrintMsg中的List参数实际是不安全的！！！我们在上面的PrintMsg中对参数进行写操作，如下：

        // Dart

        void PrintMsg(List persons) { 

           //根据多态的概念，persons可以传入List or 其子类型的对象。但是，这里的List类型，因为可写，实际上是不安全的！！！

          // 在Dart1.x版本中运行也是可以通过的，原因不做探究。但是后续main通过girls读出一个Boy来也会出错！

          // 在Dart2.x版本中运行是会报错的:type 'Boy' is not a subtype of type 'Girl'

          // 在Dart中，List都是可读写的，协变的。看似在List中添加Boy，实际上是在List中添加Boy。如果后续从List中读出一个Boy来，这是不允许的。

          persons.add(Boy("b999")); // 编译通过，但运行报错！！！

          for (var person in persons) {

            print('${persons.name}---${persons.sex}');

          }

        }

        main() {

        List girls = [];

        girls.add(Girl("g1"));

        PrintMsg(girls);  // Girl是Person的子类型，List支持协变，则List是List子类型。

        }

        而在Kotlin中的不会存在上面那种问题。Kotlin中集合分为可读写集合MutableList和只读集合List， 举例说明：

        // Kotlin

        fun PrintMsg(persons: List) { 

            // Kotlin中List支持协变，且只读。这样的泛型类型是具有安全性的。

            //因为在Kotlin中List被定义为只读集合List，

            //没有add, remove等写操作方法，

            //所以List中是无法添加一个Boy的。

            persons.add(Boy("b1")) // 此处编译不通过。

            for (person in persons) {

                println(person.name + "---" + person.sex)

            }

        }

        fun main() {

            val girls = listOf(Girl("g1"))

           // Girl是Person的子类型，List支持协变，则List是List子类型，

           // 可以作为PrintMsg的参数。

            PrintMsg(girls)

        }

        在Dart中使用协变List很方便，但是发生协变的情况下，需要注意写操作的控制。

        五、Dart协变关键字convariant

        上面说到，在Dart中泛型声明默认是支持协变的，不需要额外声明。但是，在Dart中有个协变关键字convariant，它又有什么作用呢？举例说明 :

        // Dart

        class Person {

          final String name;

          final String sex;

          Person(this.name, this.sex);

        }

        class Boy extends Person {

          Boy(this.name) : super(this.name, "male");

        }

        class Girl extends Person {

          Girl(this.name) : super(this.name, "female");

        }

        class House { //宿舍

          void checkin(Person person) {

            print('checkin ${persons.name}---${persons.sex}');

          }

        }

        class BoyHouse extends House { //男宿舍

          @override

          void checkin(Person person) { // 因为是重写的checkin方法，参数需要和父类保持一致

            super.checkin(person);

          }

        }

        class GirlHouse extends House { //女宿舍

           @override

           void checkin(Person person) { // 因为是重写的checkin方法，参数需要和父类保持一致

             super.checkin(person);

           }

        }

        void main() {

          var bh = BoyHouse();

          bh.checkin(Boy("b1"));

          bh.checkin(Girl("g1")); //把女孩安排到男宿舍！！！编译运行都不会有问题！

          var gh = GirlHouse();

          gh.checkin(Girl("g2"));

          gh.checkin(Boy("b2"));//把男孩安排到女宿舍！！！编译运行都不会有问题！

        }

        上面的例子中，我们发现可以把女孩安排到男宿舍住，男孩安排到女宿舍住。男女宿舍的划分相当于形同虚设。

        为了解决这个问题，Dart可以通过 covariant 协变关键字，让重写方法中的参数更具体，举例说明：

        // Dart

        class BoyHouse extends House { //男宿舍

          @override

          void checkin(covariant Boy person) { // 重写的checkin方法，但通过covariant协变关键字，限制参数为更具体的Person的子类Boy

             super.checkin(person);

          }

        }

        class GirlHouse extends House { //女宿舍

           @override

           void checkin(covariant Girl person) { // 重写的checkin方法，但通过covariant协变关键字，限制参数为更具体的Person的子类Girl

              super.checkin(person);

           }

        }

        void main() {

          var bh = BoyHouse();

          bh.checkin(Boy("b1"));

          bh.checkin(Girl("g1")); //编译不通过！BoyHouse的checkin限制了参数只能是Boy类型

          var gh = GirlHouse();

          gh.checkin(Girl("g2"));

          gh.checkin(Boy("b2"));//编译不通过！GirlHouse的checkin限制了参数只能是Girl类型

        }

        在我们的摸鱼项目中，也有大量的convariant运用场景，以_KKPageViewState子类代码为例说明：

        Flutter Dart：泛型的协变与逆变_第8张图片

        Flutter Dart：泛型的协变与逆变_第9张图片

        父类State中didUpdateWidget方法只能知道要通知StatefullWidget的更新，通过convariant关键字，可以在子类_KKPageViewState的didUpdateWidget方法中，限制其参数必须是KKPageView (KKPageView 是 StatefullWidget的子类，支持参数协变)。

        六、总结

        通过上面的学习，我们对Dart中的协变有了更深入的理解，开发过程中也能更好更安全地运用Dart中的协变。我们最后总结下文章的核心内容：

        1. 泛型是为了功能复用，减少模板代码而提出来的一种设计思想。

        2.子类关系是一种继承关系，子类型关系则是一种多态关系。子类关系一般是子类型关系，但子类型关系不一定是子类关系。

        3.泛型的逆变，协变和不变，描述的是类型转换关系，是为了泛型结合体支持多态而提出来的。PECS是其最佳的实践原则。

        4.Dart的新版本不支持逆变，支持协变，且默认支持协变。但是Dart的协变支持写操作，有安全隐患，使用时需要额外注意。

        你可能感兴趣的:(flutter,android,kotlin,开发语言,java)

        • 【八股学习】面试问到JMM如何优雅回答？ illus10n_CHOU 八股学习面试java开发语言
          我将用尽可能短的时间挑重点来讲清楚这个问题：什么是JMMJMM是Java定义的并发编程相关的一组规范。1、Java是跨平台语言，需要自己提供内存模型来屏蔽硬件和系统的差异。2、JMM简化多线程编程（屏蔽底层设计可能导致的多线程问题）3、JMM抽象了线程和主内存之间的关系。（线程本地内存和主内存类比CPU三级缓存和内存）4、JMM规定了Java源代码到CPU可执行指令转化要遵守的并发原则和规范（针对
        • Java操作Neo4J实例：简单易学的后端数据库 OyLinux 数据库javaneo4j后端
          Neo4J是一种图形数据库，广泛应用于存储和处理大规模的图形数据。它提供了一种高效的方式来表示和查询复杂的关系网络。在本文中，我们将学习如何使用Java来操作Neo4J数据库。我们将介绍如何建立连接、创建节点、创建关系以及执行查询操作。引入Neo4J驱动程序首先，我们需要引入Neo4J的Java驱动程序。你可以从Neo4J的官方网站上下载并导入相关的jar包。确保你的Java开发环境已经配置好。i
        • apk反编译有哪些重要作用 ios
          哈喽呀，大家好呀，淼淼又来和大家见面啦，这一期淼淼要讲一讲apk反编译的一些相关内容，APK反编译在Android开发、安全分析、软件调试、个人学习及软件定制等领域扮演着重要角色，其重要作用主要包括但不限于以下几点：1.学习与研究：对于开发者而言，反编译他人应用是一种快速学习软件架构、设计模式和实现技巧的方式。通过查看高质量的应用代码，开发者能够提升自己的编程技能，了解行业最佳实践。2.软件本地化
        • 【华为OD机考真题】- 星际篮球争霸赛（Java） 敲击Time 华为odjava
          1.题目描述具体题目描述如下：在星球争霸篮球赛对抗赛中，最大的宇宙战队希望每个人都能拿到MVP，MVP的条件是单场最高分得分获得者。可以并列，所以宇宙战队决定在比赛中，尽可能让更多队员上场,并且让所有得分的选手得分都相同，然而比赛过程中的每1分钟的得分都只能由某一个人包揽。2.输入描述输入第一行为一个数字t，表示为有得分的分钟数10;i--){intremain=sum%i;if(remain!=
        • 2024华为OD机试真题-日志排序(C++)-E卷-100分 2024剑指offer 华为OD机试(C++)2025华为odc++
          2024华为OD机试最新E卷题库-(C卷+D卷+E卷)-(JAVA、Python、C++)目录题目描述输入描述输出描述示例1示例2示例3解题思路代码c++题目描述运维工程师采集到某产品现网运行一天产生的日志N条，现需根据日志时间按时间先后顺序对日志进行排序。日志时间格式为H:M:S.N，其中：H表示小时（0-23）。M表示分钟（0-59）。S表示秒（0-59）。N表示毫秒（0-999）。时间可能没
        • 2024华为OD机试真题-分班(C++/Java/Python)-E卷B卷-100分 2024剑指offer 华为OD机试(C++)2025华为odc++
          2024华为OD机试题库-(E卷+D卷)-(JAVA、Python、C++)目录题目描述输入描述:输出描述:示例1：解题思路考点代码c++题目描述幼儿园两个班的小朋友在排队时混在了一起，每位小朋友都知道自己是否与前面一位小朋友是否同班，请你帮忙把同班的小朋友找出来。小朋友的编号为整数，与前一位小朋友同班用Y表示，不同班用N表示。输入描述:输入为空格分开的小朋友编号和是否同班标志。比如：6/N2/Y
        • 基于WinSW的创建服务的脚本攻击 zhaoyong631 安全威胁分析
          WinSW（WindowsServiceWrapper）是一个开源的实用工具，用于将任何可执行程序（如脚本、Java应用等）包装成Windows服务。以下是其核心解析：WinSW的核心功能#典型使用示例（将Python脚本包装为服务）WinSW.exeinstall→创建服务WinSW.exestart→启动服务功能描述服务化封装将非服务程序（如.bat/.py）转换为Windows服务自动重启支
        • Java多线程与并行计算：深入剖析Java线程，线程池，以及利用Java进行并行计算的策略 哎 你看 Javajava开发语言线程并行并发
          一、Java线程概述线程基础概念：线程是操作系统调度的最小单元，它是进程的一部分，每个线程都有自己的程序计数器、栈和局部变量。线程之间共享进程的堆和方法区。Java线程创建和启动：在Java中主要有两种方式创建线程：继承Thread类：创建一个新class，继承自Thread类，然后重写run()方法，并在该方法中执行需要在该线程中运行的代码。最后创建该class的实例，并调用其start()方法
        • java线程池最大线程数_Java项目中，线程池中线程数量太大会有什么影响？ 徐佳昇 java线程池最大线程数
          1.线程栈是需要分配内存空间的，所以有数量上限2.cpu切换线程涉及到上下文恢复，这个是需要耗费时间的，如果线程非常多而且切换频繁(处理IO密集任务)，这个时间损耗是非常可观的。线程池应该设置多大，取决于你处理的任务类型。对于CPU密集型的任务，因为线程中基本不会有阻塞导致让出CPU，只有在时间片用完以后，才可能让出CPU，这种情况发生线程切换的次数要少很多，因此不建议设置太大，netty的建议是
        • Java线程池如何合理设置核心线程数 寻烟的衣袖 多线程linuxjava服务器
          问题：线程池数量设置为多少比较合理呢？线程数的设置的最主要的目的是为了充分并合理地使用CPU和内存等资源，从而最大限度地提高程序的性能，先判断是CPU密集型任务还是IO密集型任务：CPU密集型任务和IO密集型任务：比如像加解密，压缩、计算等一系列需要大量耗费CPU资源的任务，大部分场景下都是纯CPU计算。IO密集型任务：比如像MySQL数据库、文件的读写、网络通信等任务，这类任务不会特别消耗CPU
        • 利用微软的 HTML 应用程序宿主程序的攻击 zhaoyong631 microsofthtml前端
          mshta.exe是微软的HTML应用程序宿主程序（MicrosoftHTMLApplicationHost），属于Windows系统组件。它的核心功能是运行.hta（HTMLApplication）文件，允许通过HTML、JavaScript、VBScript等技术创建交互式图形界面应用。何时会调用mshta.exe？1.合法用途运行本地/企业级HTA应用：企业可能用.hta开发内部工具（如配置
        • Java线程池怎么调整线程大小最合适 兮动人 #JUCjava开发语言怎么调整线程大小最合适
          文章目录怎么调整线程大小最合适？案例1：CPU密集型任务（计算素数）案例2：IO密集型任务（模拟网络请求）怎么调整线程大小最合适？核心线程数、最大线程数是不是越大越好？线程池的核心线程数（corePoolSize）和最大线程数（maximumPoolSize）的设定需根据任务类型和系统资源动态调整，盲目调大可能引发性能问题甚至系统崩溃。1.CPU密集型任务：线程数过多会引发频繁的上下文切换，消耗C
        • 解决 java.lang.RuntimeException: org.codehaus.plexus.component.repository 错误的全面指南 梦幻南瓜 javajava开发语言
          java.lang.RuntimeException:java.lang.RuntimeException:org.codehaus.plexus.component.repository是一个常见的错误，通常与Maven构建工具相关。这个错误可能由多种原因引起，例如依赖冲突、插件配置错误或POM文件中的问题。以下是一些可能的原因和解决方法：1.依赖冲突Maven项目中的依赖冲突是导致此错误的常见
        • JVM 详解：Java 虚拟机的核心机制 一点多余. jvm
          目录引言：为什么JVM是Java生态的基石？一、什么是JVM？1.1JVM的核心作用二、JVM的架构2.1类加载器（ClassLoader）2.2运行时数据区（RuntimeDataAreas）2.3执行引擎（ExecutionEngine）2.4本地方法接口（JNI）三、JVM的工作原理3.1类加载过程3.2字节码执行3.3垃圾回收四、JVM的垃圾回收机制4.1垃圾回收算法4.2垃圾回收器五、J
        • 设计模式之工厂模式 周努力. 设计模式设计模式
          工厂模式属于创建型设计模式的一种，其实在我看来它更是在面向对象编程语言的抽象层的更加灵活的应用。工厂模式其实在创建型模式中难度较高，整体的理解上需要一定时间进行消化，在一些Java常见框架中，这种模式也是频繁出现的设计，如果我们可以在自己的项目中灵活使用这个模式那将会让我们的代码更加灵活、耦合度会更低。此篇文章我们将工厂模式拆成三个不同的工厂形式来循序渐进地讲解，以便开发者能够深刻理解工厂设计模式
        • java Long[] ids转为List＜Long＞ ids Java开发追求者 javalist开发语言
          方法1：使用Arrays.asListimportjava.util.Arrays;importjava.util.List;publicclassMain{publicstaticvoidmain(String[]args){Long[]ids={1L,2L,3L,4L};Listlist=Arrays.asList(ids);System.out.println(list);//输出:}}注意
        • react 组件封装原则_如何基于antd封装自己的react组件并发布到npm 楚云卿 react组件封装原则
          引言在前端项目开发过程中，有大量重复的内容，比如布局相似的模块，较多的功能表单等，我们可以提炼成组件来提升效率，减少重复建设。文章以实际工作中的项目为例，介绍如何将项目中常用的组件进行封装并发布到npm中。1前提要求在开始前你需要具备以下条件：安装了Node&npm安装了Git基本掌握npm，git使用方法熟练使用JavaScript&ES6&CSS基本掌握React熟悉React,antd2开始
        • Java基础入门流程控制全解析：分支、循环与随机数实战 shy2005_5_31 Java全栈开发学习javapython开发语言intellij-ideajava-eejvm
          引言流程控制是编程语言的核心逻辑结构，决定了程序的执行顺序与逻辑判断能力。本文以分支结构、循环结构和随机数生成为核心，结合代码示例与底层原理，全面解析Java中流程控制的应用场景与实战技巧。一、分支结构1.if分支作用：根据条件表达式的结果（true/false）决定代码执行路径。三种形式单分支if(条件){//条件为true时执行}双分支if(条件){//条件为true时执行}else{//条件
        • 如何部署Java应用到服务器 DKPT #软件开发服务器环境搭建服务器服务器
          准备工作：确保服务器上安装了Java运行环境（JRE或JDK）。安装Web服务器，如ApacheTomcat、Jetty或WildFly。配置服务器网络，确保可以远程访问。打包Java应用：使用IDE（如IntelliJIDEA或Eclipse）或构建工具（如Maven或Gradle）将Java项目打包成WAR或JAR文件。上传应用到服务器：使用FTP、SCP或其他文件传输工具将打包好的文件上传到
        • Node_文件上传&令牌 katsukichan Node
          信息获取来源EnoYao创建脚手架expresskatsuki-project（express名称）在katsuki-project目录下安装依赖包npminstall上传单文件项目在katsuki-project安装multer模块npminstallmulter--save目录中创建一个uploads文件夹，不创建运行也会自动创建项目结构publicjavascriptsjquery.jsup
        • 替换word模板内容 Java实现 一头酸奶牛_ 工具类java
          文章目录第一步：准备文件第二步：将word文件另存为.xml格式第三步：放到idea中的一个目录下第四步：修改占位符第五步：代码示例第六步：效果图1第六步：效果图2第一步：准备文件这里以这个文件为例，在要替换的地方用占位符$replaceXX@替换。第二步：将word文件另存为.xml格式第三步：放到idea中的一个目录下这里已src目录为例第四步：修改占位符第五步：代码示例packagecom.
        • 【经典游戏】Java实现俄罗斯方块小游戏（附源码） 枫蜜柚子茶 小游戏java开发语言游戏
          一、需求分析俄罗斯方块（Tetris）是一款经典的益智类电子游戏，最初由俄罗斯设计师AlexeyPajitnov于1984年创建。该游戏的目标是通过移动、旋转和适当摆放下落的不同形状的方块，使它们在底部组成完整的水平线，一旦一条水平线被填满，该线将消失并为新的方块腾出空间。游戏的难度会随着时间的推移而加大，方块下落的速度也会逐渐增加。CSDN资源-经典游戏java实现俄罗斯方块游戏【预期实现效果】
        • 谈谈List,Set,Map的区别 蓝莓浆糊饼干 面试：java部分java
          List、Set和Map是Java集合框架（JavaCollectionsFramework）中的三种主要接口，它们各自有不同的特点和用途。以下是它们的区别和使用场景的详细解释：1.List（列表）1.1特点有序集合：List是一个有序集合，元素的插入顺序和访问顺序一致。允许重复：List允许存储重复的元素。索引访问：可以通过索引（index）快速访问元素。典型实现：ArrayList：基于动态数
        • java基础之选择结构（if）、循环结构（for、while）篇 Rookie_lyj java基础java开发语言后端
          前言本章主要是对选择结构（if-else）、循环结构（for、while）的练习一、选择结构判断瑞年题目要求：闰年的条件是能被4整除，但不能被100整除；或能被400整除。思路：输入要判断的年份添加条件（条件1：能被4整除，但不能被100整除，条件2：能被400整除）数据结果publicclasstest{publicstaticvoidmain(Stringargs[]){Scannerscan
        • Java实现的简易俄罗斯方块游戏 2301_79595709 java
          前言欢迎阅读本文，本文将介绍如何使用Java语言实现一个简易的俄罗斯方块游戏。俄罗斯方块，作为一种经典的益智游戏，不仅操作简单，而且富有娱乐性，深受很多玩家喜欢。通过本文，读者将了解到如何利用Java编程语言，结合GUI技术，实现一个基本的俄罗斯方块游戏。本文参考b站尚学堂博主代码，在此基础上有些改动。代码解释初始化游戏窗口生成一个宽650，高850的窗口。publicvoidinitWindow
        • 深入解析Java虚拟机（JVM）：架构、内存管理与性能优化 EvLast jvmjava职场和发展性能优化
          ##引言Java虚拟机（JavaVirtualMachine,JVM）是Java生态系统的核心引擎，它不仅实现了"一次编写，到处运行"的跨平台承诺，更通过自动内存管理、即时编译等机制深刻影响着现代软件开发。截至2023年，全球超过90%的《财富》500强企业使用基于JVM的技术栈，其重要性可见一斑。##一、JVM核心架构解析###1.1类加载子系统-**双亲委派模型**：采用层级式加载机制，防止核
        • 融云 IM 干货丨如何确保私有云IMKit的跨平台兼容性？ 融云im即时通讯
          确保私有云IMKit的跨平台兼容性，可以参考以下方法和建议：1.适配不同操作系统和硬件平台统一接口封装：通过抽象出公共的功能模块，使得SDK能在多个平台无缝工作。例如，融云的IMKit通过适配不同操作系统和硬件平台，确保在Android、iOS、Web等多个平台上集成使用。适配层技术：采用适配层技术，为不同平台提供对应的实现。例如，Android与iOS的UI渲染机制与线程管理存在明显区别，通过适
        • 【leetcode】113. 路径总和 II(Java) 待别三日 Leetcodeleetcodejava算法
          题目描述题目链接113.路径总和II题解经典回溯。终止条件：当遍历到叶子节点，并且此时路径的值==targerSum，此时收集当前的path。处理逻辑：我们遍历到一个节点时，可以把targetSum-root.val作为下一层的targetSum，所以当我们找到叶子节点的时候，并且root.val==targetSum，就可以收集了。完整代码classSolution{List>res=newAr
        • LeetCode 376. 摆动序列 java题解 奔跑的废柴 LeetCodeleetcodejava算法贪心贪心算法
          https://leetcode.cn/problems/wiggle-subsequence/description/只要不满足摆动条件，就不更新count和prediff当prevDiff取等号时，比如prevDiff==0，在这种情况下，如果currDiff>0，说明从持平状态转变为上升状态，这是一种有效的摆动起始情况；同理，如果currDiff0，这种从持平到上升的情况应该被视为摆动的开始
        • c#读取json某一节点数据_C#获取Json字符串中的某个值 鹿哥说 c#读取json某一节点数据
          问题描述：json数据格式{"resCode":0,"resMag":"aaa","data":[{"parkName":"B1停车场"，"freeSpaceNum":100}]}。第一方法：使用JavaScriptSerializerJavaScriptSerializerJss=newJavaScriptSerializer();DictionaryDicText=(Dictionary)Js
        • 插入表主键冲突做更新 a-john
          有以下场景： 用户下了一个订单，订单内的内容较多，且来自多表，首次下单的时候，内容可能会不全（部分内容不是必须，出现有些表根本就没有没有该订单的值）。在以后更改订单时，有些内容会更改，有些内容会新增。 问题： 如果在sql语句中执行update操作，在没有数据的表中会出错。如果在逻辑代码中先做查询，查询结果有做更新，没有做插入，这样会将代码复杂化。 解决： mysql中提供了一个sql语
        • Android xml资源文件中@、@android:type、@*、？、@+含义和区别 Cb123456 @+@?@*
          一.@代表引用资源 1.引用自定义资源。格式：@[package:]type/name android：text="@string/hello"   2.引用系统资源。格式：@android:type/name     android:textColor="@android:color/opaque_red"
        • 数据结构的基本介绍 天子之骄 数据结构散列表树、图线性结构价格标签
          数据结构的基本介绍 数据结构就是数据的组织形式，用一种提前设计好的框架去存取数据，以便更方便，高效的对数据进行增删查改。正确选择合适的数据结构，对软件程序的高效执行的影响作用不亚于算法的设计。此外，在计算机系统中数据结构的作用也是非同小可。例如常常在编程语言中听到的栈，堆等，就是经典的数据结构。   经典的数据结构大致如下：   一：线性数据结构 (1)：列表 a
        • 通过二维码开放平台的API快速生成二维码 一炮送你回车库 api
           现在很多网站都有通过扫二维码用手机连接的功能，联图网(http://www.liantu.com/pingtai/)的二维码开放平台开放了一个生成二维码图片的Api,挺方便使用的。闲着无聊，写了个前台快速生成二维码的方法。        html代码如下:(二维码将生成在这div下) ? 1  &nbs
        • ImageIO读取一张图片改变大小 3213213333332132 javaIOimageBufferedImage
          package com.demo; import java.awt.image.BufferedImage; import java.io.File; import java.io.IOException; import javax.imageio.ImageIO; /** * @Description 读取一张图片改变大小 * @author FuJianyon
        • myeclipse集成svn（一针见血） 7454103 eclipseSVNMyEclipse
                                           &n
        • 装箱与拆箱----autoboxing和unboxing darkranger J2SE
          4.2　自动装箱和拆箱 基本数据(Primitive)类型的自动装箱(autoboxing)、拆箱(unboxing)是自J2SE 5.0开始提供的功能。虽然为您打包基本数据类型提供了方便，但提供方便的同时表示隐藏了细节，建议在能够区分基本数据类型与对象的差别时再使用。 4.2.1　autoboxing和unboxing 在Java中，所有要处理的东西几乎都是对象(Object)
        • ajax传统的方式制作ajax aijuans Ajax
          //这是前台的代码 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%> <% String path = request.getContextPath(); String basePath = request.getScheme()+
        • 只用jre的eclipse是怎么编译java源文件的？ avords javaeclipsejdktomcat
          eclipse只需要jre就可以运行开发java程序了，也能自动 编译java源代码，但是jre不是java的运行环境么，难道jre中也带有编译工具？ 还是eclipse自己实现的？谁能给解释一下呢问题补充：假设系统中没有安装jdk or jre，只在eclipse的目录中有一个jre，那么eclipse会采用该jre，问题是eclipse照样可以编译java源文件，为什么呢？ &nb
        • 前端模块化 bee1314 模块化
          背景： 前端JavaScript模块化，其实已经不是什么新鲜事了。但是很多的项目还没有真正的使用起来，还处于刀耕火种的野蛮生长阶段。   JavaScript一直缺乏有效的包管理机制，造成了大量的全局变量，大量的方法冲突。我们多么渴望有天能像Java（import），Python (import)，Ruby(require)那样写代码。在没有包管理机制的年代，我们是怎么避免所
        • 处理百万级以上的数据处理 bijian1013 oraclesql数据库大数据查询
          一.处理百万级以上的数据提高查询速度的方法：        1.应尽量避免在 where 子句中使用!=或<>操作符，否则将引擎放弃使用索引而进行全表扫描。         2.对查询进行优化，应尽量避免全表扫描，首先应考虑在 where 及 o
        • mac 卸载 java 1.7 或更高版本 征客丶 javaOS
          卸载 java 1.7 或更高 sudo rm -rf /Library/Internet\ Plug-Ins/JavaAppletPlugin.plugin 成功执行此命令后，还可以执行 java 与 javac 命令 sudo rm -rf /Library/PreferencePanes/JavaControlPanel.prefPane 成功执行此命令后，还可以执行 java
        • 【Spark六十一】Spark Streaming结合Flume、Kafka进行日志分析 bit1129 Stream
          第一步，Flume和Kakfa对接，Flume抓取日志，写到Kafka中 第二部，Spark Streaming读取Kafka中的数据，进行实时分析   本文首先使用Kakfa自带的消息处理（脚本）来获取消息，走通Flume和Kafka的对接 1. Flume配置 1. 下载Flume和Kafka集成的插件，下载地址：https://github.com/beyondj2ee/f
        • Erlang vs TNSDL bookjovi erlang
                TNSDL是Nokia内部用于开发电信交换软件的私有语言，是在SDL语言的基础上加以修改而成，TNSDL需翻译成C语言得以编译执行，TNSDL语言中实现了异步并行的特点，当然要完整实现异步并行还需要运行时动态库的支持，异步并行类似于Erlang的process（轻量级进程），TNSDL中则称之为hand，Erlang是基于vm(beam)开发，
        • 非常希望有一个预防疲劳的java软件, 预防过劳死和眼睛疲劳,大家一起努力搞一个 ljy325 企业应用
          　非常希望有一个预防疲劳的java软件，我看新闻和网站，国防科技大学的科学家累死了，太疲劳，老是加班，不休息，经常吃药，吃药根本就没用，根本原因是疲劳过度。我以前做java,那会公司垃圾，老想赶快学习到东西跳槽离开，搞得超负荷，不明理。深圳做软件开发经常累死人，总有不明理的人，有个软件提醒限制很好，可以挽救很多人的生命。 相关新闻： （1）IT行业成五大疾病重灾区：过劳死平均37.9岁
        • 读《研磨设计模式》-代码笔记-原型模式 bylijinnan java设计模式
          声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ /** * Effective Java 建议使用copy constructor or copy factory来代替clone()方法： * 1.public Product copy(Product p){} * 2.publi
        • 配置管理---svn工具之权限配置 chenyu19891124 SVN
          今天花了大半天的功夫，终于弄懂svn权限配置。下面是今天收获的战绩。 安装完svn后就是在svn中建立版本库，比如我本地的是版本库路径是C:\Repositories\pepos。pepos是我的版本库。在pepos的目录结构 pepos    component    webapps 在conf里面的auth里赋予的权限配置为 [groups]
        • 浅谈程序员的数学修养 comsci 设计模式编程算法面试招聘
                                           浅谈程序员的数学修养
        • 批量执行 bulk collect与forall用法 daizj oraclesqlbulk collectforall
          BULK COLLECT 子句会批量检索结果，即一次性将结果集绑定到一个集合变量中，并从SQL引擎发送到PL/SQL引擎。通常可以在SELECT INTO、 FETCH INTO以及RETURNING INTO子句中使用BULK COLLECT。本文将逐一描述BULK COLLECT在这几种情形下的用法。     有关FORALL语句的用法请参考：批量SQL之 F
        • Linux下使用rsync最快速删除海量文件的方法 dongwei_6688 OS
          1、先安装rsync：yum install rsync 2、建立一个空的文件夹：mkdir /tmp/test 3、用rsync删除目标目录：rsync --delete-before -a -H -v --progress --stats /tmp/test/ log/这样我们要删除的log目录就会被清空了，删除的速度会非常快。rsync实际上用的是替换原理，处理数十万个文件也是秒删。
        • Yii CModel中rules验证规格 dcj3sjt126com rulesyiivalidate
          Yii cValidator主要用法分析：  yii验证rulesit 分类： Yii yii的rules验证 cValidator主要属性 attributes ,builtInValidators,enableClientValidation,message,on,safe,skipOnError  
        • 基于vagrant的redis主从实验 dcj3sjt126com vagrant
          平台: Mac 工具: Vagrant 系统: Centos6.5 实验目的: Redis主从   实现思路 制作一个基于sentos6.5, 已经安装好reids的box, 添加一个脚本配置从机, 然后作为后面主机从机的基础box   制作sentos6.5+redis的box   mkdir vagrant_redis cd vagrant_
        • Memcached(二)、Centos安装Memcached服务器 frank1234 centosmemcached
          一、安装gcc rpm和yum安装memcached服务器连接没有找到，所以我使用的是make的方式安装，由于make依赖于gcc，所以要先安装gcc 开始安装，命令如下，[color=red][b]顺序一定不能出错[/b][/color]： 建议可以先切换到root用户，不然可能会遇到权限问题：su root 输入密码...... rpm -ivh kernel-head
        • Remove Duplicates from Sorted List hcx2013 remove
          Given a sorted linked list, delete all duplicates such that each element appear only once. For example,Given 1->1->2, return 1->2.Given 1->1->2->3->3, return&
        • Spring4新特性——JSR310日期时间API的支持 jinnianshilongnian spring4
          Spring4新特性——泛型限定式依赖注入 Spring4新特性——核心容器的其他改进 Spring4新特性——Web开发的增强 Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC  Spring4新特性——Groovy Bean定义DSL Spring4新特性——更好的Java泛型操作API  Spring4新
        • 浅谈enum与单例设计模式 247687009 java单例
          在JDK1.5之前的单例实现方式有两种(懒汉式和饿汉式并无设计上的区别故看做一种)，两者同是私有构 造器，导出静态成员变量，以便调用者访问。 第一种 package singleton; public class Singleton { //导出全局成员 public final static Singleton INSTANCE = new S
        • 使用switch条件语句需要注意的几点 openwrt cbreakswitch
          1. 当满足条件的case中没有break，程序将依次执行其后的每种条件（包括default）直到遇到break跳出 int main() { int n = 1; switch(n) { case 1: printf("--1--\n"); default: printf("defa
        • 配置Spring Mybatis JUnit测试环境的应用上下文 schnell18 springmybatisJUnit
          Spring-test模块中的应用上下文和web及spring boot的有很大差异。主要试下来差异有： 单元测试的app context不支持从外部properties文件注入属性 @Value注解不能解析带通配符的路径字符串 解决第一个问题可以配置一个PropertyPlaceholderConfigurer的bean。 第二个问题的具体实例是：    
        • Java 定时任务总结一 tuoni javaspringtimerquartztimertask
           Java定时任务总结  一.从技术上分类大概分为以下三种方式：  1.Java自带的java.util.Timer类，这个类允许你调度一个java.util.TimerTask任务;   说明：    java.util.Timer定时器，实际上是个线程，定时执行TimerTask类 &
        • 一种防止用户生成内容站点出现商业广告以及非法有害等垃圾信息的方法 yangshangchuan rank相似度计算文本相似度词袋模型余弦相似度
          本文描述了一种在ITEYE博客频道上面出现的新型的商业广告形式及其应对方法，对于其他的用户生成内容站点类型也具有同样的适用性。   最近在ITEYE博客频道上面出现了一种新型的商业广告形式，方法如下：     1、注册多个账号（一般10个以上）。     2、从多个账号中选择一个账号，发表1-2篇博文