Java初识泛型 | 如何通过泛型类/泛型方法实现求数组元素最大值?

简介: 这是一个关于如何使用泛型在Java中找到数组中最大值的问题。

一、引言


给定一个整型数组,求数组中所有元素的最大值


该题同样是编程入门的基础题。关键在于拓展:能不能通过程序,实现给定的任意类型的数组,都能求出数组中所有元素的最大值?

这里我们先给出整型数组求最大值的代码,作为基础:


public class Util {
    public int findMaxInt(int[] array) {
        int max = array[0];
        for (int i = 0; i < array.length; i++) {
            if(max < array[i]) {
                max = array[i];
            }
        }
        return max;
    }
}


调用并运行:

public class Test {
    public static void main(String[] args) {
        int[] array = {1,0,9,4,5};
        System.out.println("max is " + util.findMaxInt(array));
    }
}



接下来我们来分析,如果通过泛型类或泛型方法使程序能够适用于任意一个数据类型。


二、编程分析

1、泛型类实现


解题之前,我们首先要了解泛型、泛型上界、泛型方法的概念。对于这些概念有所遗忘的同学,可以阅读文章:🔗Java初识泛型 | 如何通过泛型类/泛型方法获取任意类型的三个数的最大值?的知识解析部分熟悉一下。


这里,我们直接讲解思路,不再进行基础知识的铺垫。


思路


按照泛型的思路,我们试着将原来的类改成泛型类。用占位符E代替原代码中所有的int。但仅仅更改这些,最后会发现编译器在比较的位置报错了:



是什么原因导致编译失败呢?



原因:max和array[i]都是E类型也就是引用类型的变量,两个引用变量之间不能用大于小于号进行大小比较。可行的方法应当是调用比较对象的compareTo()方法。但是,compareTo()方法是不能直接调用的,它要求调用的对象的类型必须实现过Comparable接口。



如图 尝试直接调用compareTo()方法失败


换句话说,它对类型E有约束,这个约束就是: 必须实现过Comparable接口。因此,这里要用到类型的上界的知识,来进行约束。


public class Util<E extends Comparable<E>> {
    ...
}


<E extends Comparable<E>> 的含义为:传入的E类型必须是实现了Comparable接口的。如果传入的类型没有实现过Comparable接口,那么编译会报错。

此时,我们可以成功地调用compareTo()方法了:



此时调用成功


整合后,便能得出完整的代码了。


代码


泛型类:


public class Util<E extends Comparable<E>> {
    public E findMax(E[] array) {
        E max = array[0];
        for (int i = 0; i < array.length; i++) {
            if(max.compareTo(array[i]) < 0) {
                max = array[i];
            }
        }
        return max;
    }
}
 


调用:


Integer


1.public class Test {
    public static void main(String[] args) {
        Util<Integer> util = new Util<>();
        Integer[] array = {1,0,9,4,5};
        System.out.println("max is " + util.findMax(array));
    }
}



Double(只需更改main中的数据类型即可,Util类不用变动)


public class Test {
    public static void main(String[] args) {
        Util<Double> util = new Util<>();
        Double[] array = {13.6,100.5,0.0,-3.1,5.8};
        System.out.println("max is " + util.findMax(array));
    }
}



String 


public class Test {
    public static void main(String[] args) {
        Util<String> util = new Util<>();
        String[] array = {"China","America","Australia","Ireland"};
        System.out.println("max is " + util.findMax(array));
    }
}



自定义的类型Tmp,已手动实现了Comparable<Tmp>接口


//Tmp.java
 
public class Tmp implements Comparable<Tmp>{
    public int parameter1;
    public String parameter2;
 
    public Tmp(int parameter1, String parameter2) {
        this.parameter1 = parameter1;
        this.parameter2 = parameter2;
    }
 
    @Override
    public int compareTo(Tmp o) {
        //以parameter2为标准来比较Tmp
        //parameter2是String类,比较可以直接调用String类的compareTo方法
        return this.parameter2.compareTo(o.parameter2);
    }
 
    @Override
    public String toString() {
        return "Tmp{" +
                "parameter1=" + parameter1 +
                ", parameter2='" + parameter2 + '\'' +
                '}';
    }
}



//Test.java
 
public class Test {
    public static void main(String[] args) {
        Util<Tmp> util = new Util<>();
        Tmp tmp1 = new Tmp(10,"substantial");
        Tmp tmp2 = new Tmp(20,"circumspect");
        Tmp tmp3 = new Tmp(5,"coby");
        Tmp[] array = {tmp1,tmp2,tmp3};
        System.out.println("max is " + util.findMax(array));
    }
}



2、泛型方法实现


思路


如果用泛型类实现,则每次使用前还需要创建类对象。能不能把这一个步骤省去呢?答案是可以的,我们可以通过静态泛型方法来完成。


按照泛型方法的语法,我们对原代码稍作修改:


public class Util {
    public static  <E>  E findMax(E[] array) {
        ...
    }
}


此时的Util类已经不再是泛型类了,而是一个普通类。通过在修饰符后添加 static <E> 将普通方法改为了静态泛型方法。但此时还不够完善,同样的,我们需要把类型参数E实现了Comparable接口这一约束体现出来。只需要把<E>改为 <E extends Comparable<E>> 即可。


代码

public class Util {
    public static  <E extends Comparable<E>>  E findMax(E[] array) {
        E max = array[0];
        for (int i = 0; i < array.length; i++) {
            if(max.compareTo(array[i]) < 0) {
                max = array[i];
            }
        }
        return max;
    }
}


此时,测试时的代码也更加简略了:


public class Test {
    public static void main(String[] args) {
        Tmp tmp1 = new Tmp(10,"substantial");
        Tmp tmp2 = new Tmp(20,"circumspect");
        Tmp tmp3 = new Tmp(5,"coby");
        Tmp[] array = {tmp1,tmp2,tmp3};
        System.out.println("max is " + Util.findMax(array));
    }
}


依旧能够正确运行


三、拓展:数组排序(以冒泡排序为例)


1、int类型 原代码


//Tmp.java
 
public class Tmp{
    public static void bubbleSort(int[] array){
        for (int i = 0; i < array.length-1; i++) {
            boolean flag = false;
            for (int j = 0; j < array.length-1-i; j++) {
                if(array[j] > array[j+1]) {
                    int tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                    flag = true;
                }
            }
            if(!flag) {
                break;
            }
        }
    }
}


//Test.java
 
import java.util.Arrays;
 
public class Test {
    public static void main(String[] args) {
        int[] array = {0,3,1,8,9,6,4,5,2};
        Tmp.bubbleSort(array);
        System.out.println(Arrays.toString(array));
    }
}



2、泛型类


//Util.java
 
public class Util<E extends Comparable<E>> {
    public void bubbleSort(E[] array){
        for (int i = 0; i < array.length-1; i++) {
            boolean flag = false;
            for (int j = 0; j < array.length-1-i; j++) {
                if(array[j].compareTo(array[j+1]) > 0) {
                    E tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                    flag = true;
                }
            }
            if(!flag) {
                break;
            }
        }
    }
}


//Test.java
 
import java.util.Arrays;
 
public class Test {
    public static void main(String[] args) {
        Util<Integer> util = new Util<>();
        Integer[] array = {10,8,-33,7,21,78};
        util.bubbleSort(array);
        System.out.println(Arrays.toString(array));
    }
}



3、泛型方法


//Util.java
 
public class Util {
    public static <E extends Comparable<E>> void bubbleSort(E[] array){
        for (int i = 0; i < array.length-1; i++) {
            boolean flag = false;
            for (int j = 0; j < array.length-1-i; j++) {
                if(array[j].compareTo(array[j+1]) > 0) {
                    E tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                    flag = true;
                }
            }
            if(!flag) {
                break;
            }
        }
    }
}
 


//Test.java
 
import java.util.Arrays;
 
public class Test {
    public static void main(String[] args) {
        Integer[] array = {10,8,-33,7,21,78};
        Util.bubbleSort(array);
        System.out.println(Arrays.toString(array));
    }
}



拓展阅读: 🔗Java初识泛型 | 如何通过泛型类/泛型方法获取任意类型的三个数的最大值?

相关文章
|
1天前
|
Java
java泛型
java泛型
6 0
|
1天前
|
机器学习/深度学习 算法 搜索推荐
Java数组(3)
Java数组(3)
12 0
|
1天前
|
存储 Java
Java数组(2)
Java数组(2)
3 0
|
1天前
|
存储 Java 编译器
Java数组(1)
Java数组(1)
5 0
|
1天前
|
算法 安全 Java
Java中的泛型详解:边界、类型擦除与实际应用
Java中的泛型详解:边界、类型擦除与实际应用
|
1天前
|
Java 机器人 程序员
深入理解Java中的类与对象:封装、继承与多态
深入理解Java中的类与对象:封装、继承与多态
|
1天前
|
Java
数组栈(java)
数组栈(java)
4 0
|
1天前
|
Java
环形数组链表(java)
环形数组链表(java)
5 0
|
1天前
|
Java
数组链表(java)
数组链表(java)
4 0
|
9月前
|
Java
JAVA方法的定义
JAVA方法的定义
46 0