Java连载93-泛型实现Comparable、自定义泛型

Java连载93-泛型实现Comparable、自定义泛型

一、泛型初步

1.泛型是编译阶段的语法，在编译阶段统一集合中的类型。

 

package com.bjpowernode.java_learning;

import java.util.*;

public class D93_1_GenercityInitial {

  public static void main(String[] args) {

    //创建一个List集合，只能存储字符串类型

    List<String> strs = new ArrayList<String>();

    //添加元素

    strs.add("jodsf");

    strs.add("jodsffds");

    strs.add("jodsfsdf");

    strs.add("jodsfjhgfh");

    //遍历

    Iterator<String> it = strs.iterator();

    while(it.hasNext()) {

      String s = it.next();

      System.out.println(s);

    }

   

    Map<String,Integer> maps = new HashMap<String,Integer>();

    //存储

    maps.put("西瓜",10);

    maps.put("苹果",10);

    maps.put("香蕉",20);

    //遍历

    Set<String> keys = maps.keySet();

    Iterator<String> it2 = keys.iterator();

    while(it2.hasNext()) {

      String k = it2.next();

      Integer v =  maps.get(k);

      System.out.println(k+"----->"+v);

    }

  }

}

二、Comparable\定义泛型

1.可以使用泛型是实现Comparable比较类，可以省去了强制转换类型的麻烦

2.自定义泛型?

 

package com.bjpowernode.java_learning;

import java.util.*;

?

public class D93_2_GenericityInitial {

  public static void main(String[] args) {

    SortedSet<Manager93> ss = new TreeSet<Manager93>();

    //添加

    Manager93 m1 = new Manager93(1000.0);

    Manager93 m2 = new Manager93(1500.0);

    Manager93 m3 = new Manager93(1300.0);

   

    ss.add(m1);

    ss.add(m2);

    ss.add(m3);

    //遍历

    Iterator<Manager93> it = ss.iterator();//迭代器也要使用泛型，写的时候忘了

    while(it.hasNext()) {

      Manager93 m = it.next();

      System.out.println(m);

    }

    System.out.println("=============");

    MyClass93<String> mc = new MyClass93<String>();

    //mc.m1(100);这个语句就报错了，因为我们上面指定了MyClass93类中存储String类型；

    mc.m1("100");

  }

}

class Manager93 implements Comparable<Manager93>{//实现的Comparable也要使用泛型，用的时候也忘了

  double sal;

  Manager93(double sal){

    this.sal = sal;

  }

  public String toString() {

    return sal+"";

  }

  public int compareTo(Manager93 m) {

    double sal1 = this.sal;

    double sal2 = m.sal;//这里使用了泛型不需要强制类型转换了

    if(sal1>sal2) {

      return 1;

    }else if (sal1==sal2){

      return 0;

    }else {

      return -1;

    }

  }

}

//自定义泛型，这里的T代表可以指定任意类型

class MyClass93<T>{

  public void m1(T t) {

    System.out.println(t);

  }

}

三、源码：

D93_1_GenercityInitial.java

D93_2_GenericityInitial.java

https://github.com/ruigege66/Java/blob/master/D93_1_GenercityInitial.java

https://github.com/ruigege66/Java/blob/master/D93_2_GenericityInitial.java

2.CSDN：https://blog.csdn.net/weixin_44630050

3.博客园：https://www.cnblogs.com/ruigege0000/

4.欢迎关注微信公众号：傅里叶变换，个人公众号，仅用于学习交流，后台回复”礼包“，获取大数据学习资料

 

 

原文链接:https://www.cnblogs.com/ruigege0000/p/12431857.html
如有疑问请与原作者联系

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有