第十六章 泛型和比较器

最新推荐文章于 2022-01-05 19:09:16 发布
最新推荐文章于 2022-01-05 19:09:16 发布
阅读量301 收藏 1
点赞数
分类专栏： JavaSE
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Burn_/article/details/95622156
版权

javase笔记


程序调试：

一、泛型

1.泛型类

泛型：就是参数化类型

//定义
class 类<泛型类型标识>{
}
//应用
类名<具体类> 对象名 = new 类名 <具体类> （）;

类型擦除
1.参数化类型–>原生类型

//类型擦除（父类的擦除后和子类的一样）
class Base{
	public void f(Point<String>point) throws Exception{}
}
class Sub extends Base{
	@Override
	public void f(Point point)throws InputMismatchException{}//子类的异常处理不能比父类的范围更大
}

2.类型参数：无界类型参数–>Object类型

class Point<T>{
	private T x; //T-->Object
	private T y;
}

泛型类

/**  泛型类：T表示一种不确定的引用类型（可以定义多个类型）
 *   <T>:表示类型参数
 */
class Point<T>{
	private T x; //Integer-> x
	private T y;
	public T getX() {
		return x;
	}
	public void setX(T x) {
		this.x = x;
	}
	public T getY() {
		return y;
	}
	public void setY(T y) {
		this.y = y;
	}
}
public class TestPoint1 {

	public static void main(String[] args) {
		Point<Integer> point = new Point<>();
		point.setX(11);//int->Integer(自动装箱)->Object(向上类型转换)
		point.setY(22);
		System.out.println(point.getX()+","+point.getY());//11,22
		Point<Double> point1 = new Point<>();
		point1.setX(11.1);//double->Double(自动装箱)->Object(向上类型转换)
		point1.setY(22.2);
		System.out.println(point1.getX()+","+point1.getY());//11.1,22.2
		Point<String> point2 = new Point<>();
		point2.setX("11");//String->Object(向上类型转换)
		point2.setY("22");
		System.out.println(point2.getX()+","+point2.getY());//11,22
		/**  引用   
		 *   参数化类型：一个类型后边定义一个具体的类型参数（Point<Integer>）
		 *   		  <具体参数必须是引用数据类型>
		 *   		     编译期间会用于类型检查
		 *   原生类型：一个类型后边没有指定具体的类型参数（Point point3 = new Point();）
		 *   		     编译期间不会类型检查
		 *   定义了原生类型，泛型类没有任何意义
		 */
		                 //<>:7.0之后支持自动类型推断（ 菱形语法、钻石操作符）
		Point<Object> point3 = new Point<>();
		point3.setX(11);//int->Integer(自动装箱)->Object(向上类型转换)
		point3.setY(22);
		Integer x = (Integer) point3.getX();//强制转换
		Integer y = (Integer) point3.getY();
		System.out.println(x+","+y);
		/**  只生成了一个类
		 *   因为泛型只提供了编译期的类型检查
		 *   在生成字节码的文件中所有的泛型信息会被擦除掉
		 */
		System.out.println(point.getClass(+));//class cn.day0712.Point
		System.out.println(point1.getClass());//class cn.day0712.Point
		System.out.println(point2.getClass());//class cn.day0712.Point
		//2.应用(创建对象调用方法)
		new TestPoint1().showPoint(point1);
	}
	//需要指定具体的类型参数(Point<Double> p)
	public void showPoint(Point<Double> p) {
		System.out.println(p.getX()+":"+p.getY());
	}
}

泛型接口

//泛型接口
interface Info<T>{//Type Element
	T af(T t);//T表示不确定
}
//实现方式一(实现接口的时候能确定T的类型)
class InfoImpl1 implements Info<String>{
	@Override
	public String af(String t) {
		// TODO Auto-generated method stub
		return t;
	}
}
//实现方式二(实现接口的时候还是不能确定T的类型)
class InfoImpl2<T> implements Info<T>{
	@Override
	public 	T af(T t) {
		// TODO Auto-generated method stub
		return t;
	}
}
public class Demo2 {
	public static void main(String[] args) {
		InfoImpl1 in1 = new InfoImpl1();
		String s1 = in1.af("hello");
		System.out.println(s1);//hello
		InfoImpl2<Double> in2 = new InfoImpl2<>();
		double s2 = in2.af(22.2);
		System.out.println(s2);//22.2
	}
}

2.通配符

1.(?): 无界通配符，匹配所有的类型
2.(？ extengs E):通配符上线，匹配E或者E的子类型
3.(？ super E): 通配符下线，匹配E或者E的父类型

/**  泛型类：T表示一种不确定的引用类型（可以定义多个类型）
 *   <T>:表示类型参数
 */
class Point<T>{
	private T x; //Integer-> x
	private T y;
	public T getX() {
		return x;
	}
	public void setX(T x) {
		this.x = x;
	}
	public T getY() {
		return y;
	}
	public void setY(T y) {
		this.y = y;
	}
}
public class TestPoint1 {

	public static void main(String[] args) {
		Point<Integer> point = new Point<>();
		point.setX(11);//int->Integer(自动装箱)->Object(向上类型转换)
		point.setY(22);
		System.out.println(point.getX()+","+point.getY());//11,22
		/**	1.(?):          无界通配符，匹配所有的类型
		 * 	2.(？ extengs E):通配符上线，匹配E或者E的子类型
		 * 	3.(？ super E):  通配符下线，匹配E或者E的父类型
		 */
		//通配符
		new TestPoint1().showPoint(point);
	}
	public void showPoint(Point<?> p) {//匹配所有的类型
		System.out.println(p.getX()+":"+p.getY());
	}
}

3.比较器

1.Comparable：是一个泛型接口：

作用： 使得一个类具备排序的能力。（只能进行升序排序）

import java.util.Arrays;
class Student implements Comparable<Student>{
	private int no;
	private String name;
	private int age;
	public Student(int no, String name, int age) {
		this.no = no;
		this.name = name;
		this.age = age;
	}
	public int getNo() {
		return no;
	}
	public void setNo(int no) {
		this.no = no;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "Student [no=" + no + ", name=" + name + ", age=" + age + "]";
	}
	@Override
	public int compareTo(Student o) {
		//this  o
		/**	  升序比较规则：
		 *       this.属性     >   o.属性      正数
		 *       this.属性     <   o.属性      负数
		 *       this.属性     ==  o.属性      0
		 */
		//年龄升序排序
		/*if (this.age>o.age) {
			return 1;
		} else if(this.age<o.age) {
			return -1;
		}else {
			return 0;
		}*/
		return this.age-o.age
	}
}
public class TestComparable {

	public static void main(String[] args) {
		//数组类型
		int [] arr = {11,54,28,36,69};
		Arrays.sort(arr);//升序排序
		System.out.println(Arrays.toString(arr));//[11, 28, 36, 54, 69]
		//引用类型
		String [] arrs = {"aa","bb","ee","cc","dd"};
		Arrays.sort(arrs);
		System.out.println(Arrays.toString(arrs));//[aa, bb, cc, dd, ee]
		//------------------------------------------
		Student guojing = new Student(1,"郭靖",22);
		Student yangkang = new Student(3,"杨康",26);
		Student huangrong = new Student(2,"黄蓉",20);
		Student [] s = {guojing,yangkang,huangrong};
		/**		引用类型都是自然排序
		 * 		都是按照Comparable接口提供的比较方式排序
		 */
		//自然排序（按Comparable接口的比较方式排序）
		Arrays.sort(s);
		Arrays.stream(s).forEach(System.out::println);
	}
}

2.Comparabtor：是一个函数式泛型接口：

作用： 是一个外部比较器，让用户定义排序顺序。（可以进行升序和降序排序）

import java.util.Arrays;
import java.util.Comparator;
class Student1 implements Comparable<Student1>{
	private int no;
	private String name;
	private int age;
	private int score;
	public Student1(int no, String name, int age,int score) {
		this.no = no;
		this.name = name;
		this.age = age;
		this.score = score;
	}
	public int getNo() {
		return no;
	}
	public void setNo(int no) {
		this.no = no;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public int getScore() {
		return score;
	}
	public void setScore(int score) {
		this.score = score;
	}
	@Override
	public String toString() {
		return "Student [no=" + no + ", name=" + name + ", age=" + age + ", score=" + score + "]";
	}
	@Override
	public int compareTo(Student1 o) {
		return this.score-o.score;
	}
}
//自定义的比较器(也是实现类)
class MyComparator implements Comparator<Student1>{
	@Override
	public int compare(Student1 o1, Student1 o2) {
		return o1.getAge()-o2.getAge();
	}
}
public class TestComparator {
	public static void main(String[] args) {
		Student1 guojing = new Student1(1,"郭靖",22,96);
		Student1 yangkang = new Student1(3,"杨康",26,88);
		Student1 huangrong = new Student1(2,"黄蓉",20,98);
		Student1 [] s = {guojing,yangkang,huangrong};
//自然排序（按Comparable接口的比较方式排序）
		Arrays.sort(s);
		Arrays.stream(s).forEach(System.out::println);
//自定义排序
	//1.方式一声明了一个类（只使用了一次）
		//MyComparator com = new MyComparator();
		//Arrays.sort(s, com);
		//Arrays.stream(s).forEach(System.out::println);//输出
	//2.方式二（匿名内部类）
		/*Arrays.sort(s, new Comparator<Student1>() {
			@Override
			public int compare(Student1 o1, Student1 o2) {
				return o2.getAge()-o1.getAge();
			}
		});
		Arrays.stream(s).forEach(System.out::println);//输出*/
	//3.方式三(Lambda表达式)
		Arrays.sort(s, (o1,o2)->{return o1.getAge()-o2.getAge();});
		Arrays.stream(s).forEach(System.out::println);//输出
	}
}

4.枚举类

枚举的底层

最后 班级 cn。HN。day0712。颜色 扩展了 java。郎。Enum < cn。HN。day0712。颜色> {
  public  static  final  cn。HN。day0712。颜色 红 ;
  public  static  final  cn。HN。day0712。颜色 绿色 ;
  public  static  final  cn。HN。day0712。颜色 蓝色 ;
  private  static  final  cn。HN。day0712。颜色 [] ENUM $ VALUES ;
  static {};
  私人 cn。HN。day0712。颜色（java的。郎。字符串，INT）;
  public  static  cn。HN。day0712。Color [] values（）;
  public  static  cn。HN。day0712。颜色 的valueOf（java的。郎。字符串）;
}

枚举的应用

import java.util.Scanner;
//枚举类：可以有访问修饰符,可以有抽象方法
enum Color{//三色光类（红绿蓝）
	RED(1,"红色") {
		@Override
		public void cxff() {
			System.out.println("red-cxff");
		}
	},GREEN(2,"绿色") {
		@Override
		public void cxff() {
			System.out.println("green-cxff");
		}
	},BLUE(3,"蓝色") {
		@Override
		public void cxff() {
			System.out.println("blue-cxff");
		}
	};//对象(已赋值)
	private int no;
	private String name;
	private Color(int no, String name) {
		this.no = no;
		this.name = name;
	}
	public int getNo() {
		return no;
	}
	public void setNo(int no) {
		this.no = no;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@Override
	public String toString() {
		return this.no+"\t"+this.name;
	}
	public void show () {
		System.out.println("show");
	}
	//抽象方法
	public abstract void cxff();
}
public class TestEnum {
	public static void main(String[] args) {
		/**		 注意：1.底层是一个类，隐式的继承了java.lang.Enum类；
		 * 			 2.构造都是 private（所以不能创建对象）
		 * 			 3.普通的枚举类都是final（不能扩展子类）
		 * 			 4.枚举类的所有对象 必须在枚举类的第一行代码处显示列举出来。而且都是public static final的
		 */
		System.out.println(Color.RED);//RED
		//遍历了所有的枚举对象-------------------
		for (Color cr:Color.values()) {
			System.out.print(cr.name());
			System.out.println("\t"+cr.ordinal());
		}
		//属性-------------------------------
		Color.RED.setNo(11);
		Color.RED.setName("红色");
		System.out.println(Color.RED.getNo()+"\t"+Color.RED.getName());//11	红色
		//switch-----------------------------
		Scanner sc = new Scanner(System.in);
		System.out.println("--请输入颜色：");
		String s = sc.next();
		Color color= Color.valueOf(s);
		switch (color) {
		case RED:
			System.out.println("红色的操作！");
			break;
		case GREEN:
			System.out.println("绿色的操作！");
			break;
		case BLUE:
			System.out.println("蓝色的操作！");
			break;
		}
		//构造已赋值-----------------------------
		System.out.println(Color.RED);//展示对象名称会调tostring方法
		System.out.println(Color.GREEN);
		System.out.println(Color.BLUE);
		//调用普通方法---------------------------
		Color.RED.show();
		//调用抽象方法---------------------------
		Color.RED.cxff();//red-cxff
		Color.GREEN.cxff();//green-cxff
		Color.BLUE.cxff();//blue-cxff
	}
}
Burn_
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java中的泛型&自定义比较器
diamond_0的博客
06-09 561
一、泛型 1、定义： 用来限制类型。 用在集合中，就会约束该集合中元素的数据类型。 以在集合中的使用为背景举例： List<String> list = new ArrayList<String>(); list.add("晴天"); //list.add(10); //发生编译错误 说明： <>中放"String"，则放入该集合中的元素必定为String类型 List list = new ArrayList(); list.add("晴天"); list.add(1
泛型限定二---用父类定义比较器，用于子类，减少代码，节约空间
YL的专栏
11-21 750
/* 定义比较器的时候可以定义父类的比较器，这样其子类对象都可以调用，避免了要根据不同的对象定义不同的比较器。 */ import java.util.Comparator; import java.util.Iterator; import java.util.TreeSet; class compare implements Comparator{ public int compare
什么是泛型？什么是比较器？
superliug的博客
08-12 147
标题泛型的定义和使用，还有比较器的使用 泛型 广泛的类型，在定义一个类的时候，类型中有些参数，返回值不确定，就使用一个符号，来表示哪些尚未确定的类型，这个符号就是泛型 泛型的使用 对于有泛型的类型，在这些类型后面加上尖括号，尖括号后面写上泛型的类型（在使用某个类创建对象的时候，已经确定这个具体的类型 了，那么就直接写出这个类型） 泛型的好处 提高了数据的安全性，将运行的问题，提前暴露在编译时期 ...
java 泛型比较器_java-基于泛型和反射机制的通用比较器实现
weixin_35679813的博客
02-23 238
一、前言Java的比较器是用来对List集合进行排序用的，分为内部比较器和外部比较器两类内部比较器：被排序的类要 implements Comparable 类，并实现compareTo方法。外部比较器：需要实现一个implements Comparator的比较器，实现compare方法，并在sort方法中将该比较器当参数传入。(具体实现，网络上有很多资料，此处不再赘述)二、发现问题外部比较器...
java 泛型比较器_带有泛型,比较器和排序错误的Java类层次结构
weixin_34885009的博客
02-23 112
我一直在环顾四周,看看是否能找到可以帮助我解决问题的方法,但是到目前为止没有运气.我有以下课程：public interface ISort {public List sort(List initialList);}public abstract class Sort implements ISort {private Comparator super T> comparator;publi...
C++ STL开发技术导引(第5章)
09-25
第16章　hash_map哈希映照容器　235 16.1　hash_map技术原理　235 16.2　hash_map应用基础　237 16.3　本章小结　242 第17章　string基本字符序列容器　243 17.1　string技术原理　243 17.2　string应用基础　258 ...
C++ STL 开发技术导引(第6章)
09-25
第16章　hash_map哈希映照容器　235 16.1　hash_map技术原理　235 16.2　hash_map应用基础　237 16.3　本章小结　242 第17章　string基本字符序列容器　243 17.1　string技术原理　243 17.2　string应用基础　258 ...
C++ STL开发技术导引(第3章)
09-25
第16章　hash_map哈希映照容器　235 16.1　hash_map技术原理　235 16.2　hash_map应用基础　237 16.3　本章小结　242 第17章　string基本字符序列容器　243 17.1　string技术原理　243 17.2　string应用基础　258 ...
Comparable与Comparator接口的区别
大白的成长之路
03-08 137
文章目录自定义类型实现comparable接口Comparable与Comparator的比较 自定义类型实现comparable接口 import java.util.TreeSet; public class TreeSetText { public static void main(String[] args) { Customer c1 = new Customer(32); Customer c2 = new Customer(20); C
里氏替换原则+排序_接口_泛型比较器+序列化+泛型集合.rar
09-18
简单介绍 里氏替换原则 简单工程模式 实现任意排序 使用了 is 和 as 方法 ArrayList数组 与 List<>泛型集合 Hashtable数组 与 Dictionary<k,v>泛型集合 的基本使用 序列化 将数据存储
java集合三种比较器（详解）
12-21
关于java集合比较器的创建和使用 概述： 在java集合中，TreeSet集合和TreeMap集合底层数据结构都是自平衡二叉树，所以在这两个集合中添加元素的时候会实现自动排序，排序方式为中序排序(即左根右的方式进行排序，详情请见二叉树数据结构，这里不做赘述)。 SUN公司编写源代码的时候已经为我们写好了排序代码，因此在我们输入数据元素后会实现自动排序(这里的数据都是对象，也就是引用类型，不能是基本数据类型)，源码中可见底层是调用了compareTo()方法进行了排序(详情请见TreeSet或者TreeMap源码) 如果我们要实现自定义的引用类型排序需要重写排序方法，就必须重写排序方法，有
Java自然排序Comparable使用方法解析
08-19
主要介绍了Java自然排序Comparable使用方法解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
[javase]自定义泛型比较器 排序
lemonlhy的博客
12-28 377
package day13; import java.util.Arrays; import java.util.Comparator; /** * 自定义外部排序 * * */ public class TestComparator { public static void main(String[] args) { Student1 student1=new Student1
Java Collection框架(五）集合与泛型 比较器 hashCode与equals
JavaBoy王皓
07-31 276
​集合与泛型，如何使用比较器，hashCode与equals的区别 2014我在郎木寺敖包下，友人所拍 微信公众号 本篇看一下关于集合的一些知识点。 集合与泛型 首先来看一下集合与泛型的结合使用，JDK1.5之后为了约束类型，更新了泛型技术。 ArrayList不加泛型 我们首先利用ArrayList来盛放元素，由于没有泛型限制，我...
实例解释接口、泛型、比较器使用
彻底拆分，一切可控！
12-10 728
提示：本例子目的是对参加短跑比赛的所有动物进行排名第一步：所有的动物都应该有一个提供速度的方法因此直接定义在接口Animal中定义，之后让每一个参加比赛的动物都实现这一接口即可Animal接口：public interface Animal {public int speed();}参加比赛的所有动物：猪：public class Pig implements Animal {@Overridep...
黑马程序员_日记54_TreeSet使用比较器和泛型的初级结合
itheima_1llt的专栏
04-16 311
——- android培训、java培训、期待与您交流！ ———-查阅API，得到： “TreeSet(Comparator六、比较器的泛型定义方式分析import java.util.*; class GenericDemo6 { public static void main(String[] args) { //方式二和方式一选其一，打开对于的代码块就可以了
JAVA泛型——自定义比较器的3种方式
小乖乖的臭坏坏
01-05 1010
方式一：通过实现Comparator接口对对象完成排序属性 例子：初始化一个TreeSet类型的集合，当集合中有元素时即对集合中元素以字符串长度为规则进行排序 import java.util.*; class GenericDemo2 { public static void main(String[] args) { TreeSet<String> ts = new TreeSet<String>(new LenComparator()); ts.add("ab
java泛型怎么比较大小
最新发布
04-14
首先，在进行泛型比较大小方面，需要实现Comparable接口或者使用Comparator进行比较，具体实现可以依据具体的需求进行设计。其次，在使用泛型进行比较大小时，需要注意一些类型转换问题，以保证比较的正确性。最后，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值