Java基础-day08-再谈泛型

已于 2022-08-14 21:38:59 修改
阅读量220 收藏
点赞数
分类专栏： Java基础精讲 文章标签： java jvm 开发语言
于 2022-08-10 22:14:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39276337/article/details/126275089
版权

泛型通配符

泛型的通配符:不知道使用什么类型来接收的时候,此时可以使用?,?表示未知通配符。此时只能接受数据,不能往该集合中存储数据。


package com.huyuhang.day08;

import java.util.ArrayList;

public class Test5 {
    public static void main(String[] args) {
        // 关系 String继承Object, Integer继承Number, Number继承Object
        ArrayList<Object> list1 = new ArrayList<>();
        ArrayList<String> list2 = new ArrayList<>();
        ArrayList<Integer> list3 = new ArrayList<>();
        ArrayList<Number> list4 = new ArrayList<>();
        list2.add("哈哈");
        list1.add(11);
        method1(list2);
        method1(list3);
        method1(list4);
        method2(list2);
        method2(list3);
    }
    // 定义一个方法, 可以接受以上4个集合
    public static void method1(ArrayList list){

        list.add("haha");
        Object obj = list.get(0);
        System.out.println("obj" + obj);
        System.out.println("list" + list);
    }

    public static void method2(ArrayList<?> list){
        // ?表示未知通配符。此时只能接受数据,不能往该集合中存储数据。
        list.add("haha"); 编译报错
        list.add(111); 编译报错
        Object obj = list.get(0);
        System.out.println("obj" + obj);
        System.out.println("list" + list);
    }
}

通配符高级使用----受限泛型
之前设置泛型的时候，实际上是可以任意设置的，只要是类就可以设置。但是在JAVA的泛型中可以指定一个泛型的上限和下限。

泛型的上限：

  • 格式： 类型名称 <? extends 类 > 对象名称
  • 意义： 只能接收该类型及其子类

泛型的下限：

  • 格式： 类型名称 <? super 类 > 对象名称
  • 意义： 只能接收该类型及其父类型
package com.huyuhang.day08;

import java.util.ArrayList;

public class Test6 {

    public static void main(String[] args) {
        // 关系 String继承Object, Integer继承Number, Number继承Object
        ArrayList<Object> list1 = new ArrayList<>();
        ArrayList<String> list2 = new ArrayList<>();
        ArrayList<Integer> list3 = new ArrayList<>();
        ArrayList<Number> list4 = new ArrayList<>();
        list2.add("哈哈");
        list1.add(11);
        method1(list1);  // Object是Number父类 不行
        method1(list2);  // String是Number无关类 不行
        method1(list3);  // 行  子类
        method1(list4); // 行 自己
        method2(list1); // 行  fu类
        method2(list2); // String是Integer无关类 不行
        method2(list3);  // 行 自己
        method2(list4);  // 行 fu类
    }
    // 上限 只能是Number或者Number的子类
    public static void method1(ArrayList<? extends  Number> list){
    }
    // 下限 只能是Integer或者Number父类

    public static void method2(ArrayList<? super Integer> list){

    }
}

例子:

package com.huyuhang.day08;

public class MySort {
    public <E extends Comparable<E>> void selectSort(E[] arr){
        for (int i = 0; i < arr.length; i++) {
            int minIndex = i;
            for (int j = i; j < arr.length; j++) {
                // j 比 minIndex 位置的值小
                if (arr[j].compareTo(arr[minIndex]) < 0)
                    minIndex = j;
            }
            swap(arr, i, minIndex);
        }
    }
    public static <E> void swap(E[] arr, int i, int j){
        E t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }
}

student类

package com.huyuhang.day08;

public class Student implements Comparable<Student>{
    private String name;
    private Integer age;
    private Double score;

    public Student() {
    }

    public Student(String name, Integer age, Double score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

    public Double getScore() {
        return score;
    }

    public void setScore(Double score) {
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }

    @Override
    public int compareTo(Student o) {
        // 倒序
//        return (int)(o.score - tohis.score);
        return (int)(this.score - o.score);
    }
}

测试

package com.huyuhang.day08;

import java.util.Arrays;

public class Test7 {
    public static void main(String[] args) {
        Integer[] arr = {1, 4, 2, 6, 5, 3};
        MySort mySort = new MySort();
        mySort.selectSort(arr);
        System.out.println(Arrays.toString(arr));
        //
        Student[] students = new  Student[5];
        students[0] = new Student("张三", 30, 100.0);
        students[1] = new Student("李四", 33, 32.4);
        students[2] = new Student("王五", 44, 44.9);
        students[3] = new Student("赵六", 55, 45.90);
        students[4] = new Student("田七", 12, 98.3);

        mySort.selectSort(students);
        for (int i = 0; i < 5; i++) {
            System.out.println(students[i]);
        }
    }
}
  • equals
package com.huyuhang.day09;

import java.util.Objects;

public class Student {
    private String name;
    private Integer age;
    private Double score;

    public Student() {
    }

    public Student(String name, Integer age, Double score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

    public Double getScore() {
        return score;
    }

    public void setScore(Double score) {
        this.score = score;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return Objects.equals(name, student.name );
    }

}
package com.huyuhang.day09;

public class Test1 {
    // equals 是 object 5大方法之一;
    public static void main(String[] args) {
        String str1 = new String("abcdefg");
        String str2 = new String("abcdefg");
        String str3 = "abcdefg";
        // == 如果说是基本类型比较的是字面量值, 引用类型(数组,类,接口) 比较的是地址值
        System.out.println(str1 == str2); //false
        System.out.println(str1.equals(str2)); // true
        System.out.println(str1==str3); // false
        System.out.println(str1.equals(str3)); // true

//        Student s1 = new Student("eric", 21, 222.9);
//        Student s2 = new Student("eric", 22, 90.1);
//        System.out.println(s1 == s2);
//        System.out.println(s1);
//        System.out.println(s2);
//        System.out.println(s1.equals(s2));

    }
}


public boolean addAll(Collection<? extends E> c) {
        Object[] a = c.toArray();
        int numNew = a.length;
        ensureCapacityInternal(size + numNew);  // Increments modCount
        System.arraycopy(a, 0, elementData, size, numNew);
        size += numNew;
        return numNew != 0;
    }

上面点addAll参数是一个Collection类型, 对于集合中元素限制不能大于E类型

综合案例

需求:

  • 按照斗地主的规则，完成造牌洗牌发牌的动作。
    具体规则：
    使用54张牌打乱顺序,三个玩家参与游戏，三人交替摸牌，每人17张牌，最后三张留作底牌。

分析:

  • 准备牌：
    牌可以设计为一个ArrayList,每个字符串为一张牌。
    每张牌由花色数字两部分组成，我们可以使用花色集合与数字集合嵌套迭代完成每张牌的组装。
    牌由Collections类的shuffle方法进行随机排序。
  • 发牌
    将每个人以及底牌设计为ArrayList,将最后3张牌直接存放于底牌，剩余牌通过对3取模依次发牌。
  • 看牌
    直接打印每个集合。

package com.claire.day12;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;

public class Test3 {
    public static void main(String[] args) {

//        - 准备牌
        ArrayList<String> pokerBox = new ArrayList<>();
        ArrayList<String> numbers = new ArrayList<>();
        ArrayList<String> colors = new ArrayList<>();

        numbers.add("J");
        numbers.add("Q");
        numbers.add("K");
        numbers.add("A");
        for (int i = 2; i <= 10 ; i++) {
//            numbers.add(String.valueOf(i));
            numbers.add("" + i);
        }
        colors.add("♣");
        colors.add("♠");
        colors.add("♦");
        colors.add("♥");
        pokerBox.add("大王");
        pokerBox.add("小王");
        for (String number: numbers){
            for (String color:colors){
               pokerBox.add( color + number);
            }
        }
//        System.out.println(pokerBox);
//        System.out.println(pokerBox.size());
    // 洗牌
//        Random random = new Random();
//        random.setSeed(555);
//        Collections.shuffle(pokerBox, random);
        Collections.shuffle(pokerBox);
        System.out.println(pokerBox);
        // 发牌
        ArrayList<String> player1 = new ArrayList<>();
        ArrayList<String> player2 = new ArrayList<>();
        ArrayList<String> player3 = new ArrayList<>();
        ArrayList<String> diPai = new ArrayList<>();
        for (int i = 0; i < pokerBox.size(); i++) {
            String pai = pokerBox.get(i);

            if (i >= 51){
                diPai.add(pai);
            }else if (i%3 ==0){
                player1.add(pai);
            }else if (i%3 ==1){
                player2.add(pai);
            }else if (i%3 ==2){
                player3.add(pai);
            }
        }

        // 显示
        System.out.println("玩家一" + player1);
        System.out.println("玩家二" + player2);
        System.out.println("玩家三" + player3);
        System.out.println("底牌" + diPai);

    }
}

Collections类

java.utils.Collections是集合工具类，用来对集合进行操作。
常用方法如下：

  • public static void shuffle(List<?> list):打乱集合顺序。
  • public static void sort(List list):将集合中元素按照默认规则排序。
  • public static void sort(List list，Comparator<? super T> ):将集合中元素按照指定规则排序。

public class Test4 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            list.add(i);
        }
        Collections.shuffle(list);
        System.out.println("打乱:" + list);
        Collections.sort(list);
        System.out.println("排序之后:" + list);

    }
}

自定义类型比较

实体类

package com.claire.day12;

//public class Student implements Comparable<Student>{
public class Student {
    private String name;
    private int age;
    private int score;
    // 比较规则
//    @Override
//    public int compareTo(Student o) {
//        // 前减后   升序排序
//        // 后减前  降序排序
//        return this.age - o.age;
//    }
    public Student() {
    }

    public Student(String name, int age, int score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }

    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{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }


}



package com.claire.day12;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class Test5 {
    public static void main(String[] args) {
        Student s1 = new Student("张三", 15, 90);
        Student s2 = new Student("李四", 12, 88);
        Student s3 = new Student("王五", 16, 70);
        Student s4 = new Student("赵六", 20, 60);

        ArrayList<Student> list = new ArrayList<>();
        list.add(s1);
        list.add(s2);
        list.add(s3);
        list.add(s4);
//        System.out.println(s1.compareTo(s2)); // 3
//        System.out.println(s1.compareTo(s3)); //-1

        for (Student s :list){
            System.out.println(s);
        }
//        Collections.sort(list);
        Collections.sort(list, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.getAge() - o2.getAge();
            }
        });
        System.out.println("排序后");
        for (Student s :list){
            System.out.println(s);
        }

    }
}
__Miracle__
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java 构建一个学生类_1实现添加功能 1.1定义一个学员类（Student），在Student类中定义姓名、性别和年龄属性，定义有参数的构造方法来初始化所以的成员属性 1.2创建学员类对象来存放学...
weixin_39997300的博客
02-26 4730
学生类package com.lanxi.demo1_3;public class Student {private String name;private String sex;private int age;@Override//重写toString方法public String toString() {return "Student [name=" + name + ", sex=" + s...
跟我学Java-day14-ArrayList集合.pdf
03-07
day14-ArrayList集合 1.ArrayList 1.1ArrayList类概述【理解】 什么是集合 提供一种存储空间可变的存储模型，存储的数据容量可以发生改变 ArrayList集合的特点 底层是数组实现的，长度可以变化 泛型的使用 ...
用java写Student类的功能
weixin_51248437的博客
04-04 6688
1）编写一个Java程序片断，以定义一个表示学生的类Student。这个类的属性有“学号”、“班号”、“姓名”、“性别”、“年龄”，方法有“获得学号”、“获得班号”、“获得性别”、“获得姓名”、“获得年龄”。 2）为类Student增加一个方法public String toString( )，该方法把Student类的对象的所有属性信息组合成一个字符串以便输出显示。编写一个Java Application程序，创建Student类的对象，并验证新增加的功能。 package xin; import ja
【PTA】lambda表达式1
qq_63806300的博客
11-18 258
Student类定义如下。利用Arrays工具类中的sort方法对Student数组进行排序。由于Student类没有实现Comparable接口，因此sort方法需要传入一个Comparator比较器作为排序时比较对象大小的依据。sort方法如下：Arrays.sort(T[] a,Comparator
Java学习记录｜toString方法
linanali0606的博客
03-01 247
getter和setter自动生成（IDEA） 步骤：右键-generate-setter getter 快捷键：command+N java.lang类 所有的类没有父类的话，默认继承java.lang类。 所有的类都是从Object类派生出来的，都是Object的子类。 Object类位于java.lang这个包里，java.lang包里的类都是可以直接使用的，不需要引入，所以Ob...
Student类
weixin_62443314的博客
05-19 311
public class Student { private String name; private int age; public Student(String name,int age) { this.age=age;this.name=name; } public void setName(String name) { this.name=name; } public String getName() { return name; } public ...
Java基础知识-day02【Collection、泛型】.pdf
最新发布
10-26
Java基础知识-day02【Collection、泛型】 本节课程主要讲解了 Java 中的 Collection 框架和泛型，涵盖了 Collection 的基本概念、Collection 框架的继承结构、Collection 的常用功能、迭代器的使用和泛型的定义等...
Day17 Java 集合和泛型.pdf
08-09
将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值
传智播客 刘意-2015年Java基础视频-深入浅出精华版 笔记day01-day27
11-02
在"传智播客 刘意-2015年Java基础视频-深入浅出精华版 笔记day01-day27"这套课程中，Java初学者将踏上一段全面而深入的Java编程之旅。刘意老师以其丰富的教学经验，将复杂的Java知识讲解得通俗易懂，旨在帮助学员...
LetsUpgrade-Day4-Java-Essential：letsUpgrade中对Java的第4天分配
02-13
在“LetsUpgrade-Day4-Java-Essential”这个学习计划中，我们专注于深入理解Java编程语言的核心概念。在第四天的学习中，我们将探讨以下几个关键知识点： 1. **类与对象**： Java是一种面向对象的编程语言，因此，...
对象流
weixin_45240352的博客
11-24 232
前面知识复习 需求 学生信息系统 (a) 假设有20个Student，每个学生有id(学号) name(姓名) age(年龄) className(班级名称) (b) 把20个学生的信息保存到文件中 © 从文件中把每个学生的信息都获取处理 student类 package com.paractice; public class Student { int id; String n...
【PTA】toString方法
qq_63806300的博客
10-19 724
给Student类添加toString方法，返回Student的信息，格式为学号,姓名,年龄。
关于重写 toString() 方法
Jerry的博客
05-29 362
关于重写 toString() 方法  学习方法一说。   首先，我们先来创建一个Persion类，它只简单的包含 firstname 和 lastname，当然，加上它的setter 和 getter 法。放在com.bean包下： package com.bean; public class Persion { private String fi
关于重写 toString() 方法
十字路口的转角~转角的十字路口
02-07 497
 学习Java的人都知道，Java所有类都是object的子类。所以，所有的Java对象都可以调用object类提供的方法。其中，toString()就是其中一个。下面讲解一下为什么会有重写toString()方法一说。   首先，我们先来创建一个Persion类，它只简单的包含 firstname 和 lastname，当然，加上它的setter 和 getter 法。放在com.bean包...
创建一个Student类，该有String类型的学号stuNo, String类型的姓名，要求将该类所有的成员变量进行封装， 并且提供公共的getter和setter方法，重写equals方法， 只要
我是“哈哈”
04-11 5808
创建一个Student类，该有String类型的学号stuNo, String类型的姓名，要求将该类所有的成员变量进行封装， 并且提供公共的getter和setter方法，重写equals方法， 只要学生的学号相同(说明两个对象相等)即返回true， 重写toString()方法，toString方法返回值类似”姓名:张三 学号:201301 public class Student { pr...
关于重写toString方法
小9的专栏
06-27 9603
关于重写toString
jackson简单用法
热门推荐
hi_kevin的专栏
07-03 2万+
jackson简单用法 Name类： Student类： import java.util.Date; public class Student { private int id; private Name name; private String className; private Date birthDay; public Student(){} public S
Java进阶（二十九）集合12：集合练习题
qq_33491651的博客
02-21 1057
1.从键盘随机输入10个整数保存到List中，并按照倒序、从大到小的顺序显示出来。 import java.util.ArrayList; import java.util.Collections; import java.util.Scanner; public class exer1 { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); Arr
Java基础-day09-set和hashmap
__Miracle__
08-14 2616
给HashSet中存放自定义类型元素时，需要重写对象中的hashCode和equals方法，建立自己的比较方式，才能保证HashSet集合中的对象唯一.Person p1 = new Person("张三" , 19);Person p2 = new Person("张三" , 20);Person p3 = new Person("张三" , 19);Person p4 = new Person("张三" , 19);} }...
JDK1.5-1.6-1.7新特性详解
"这篇博客文章总结了JDK1.5到1.7版本的主要新特性，包括自动装箱与拆箱、枚举类型、泛型、可变参数、增强的for循环、静态导入、注解等，对于了解这些Java版本更新的开发者来说是一份很好的参考资料。" 在Java的发展...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值