Utilisation imbriquée des génériques de fonctions Java

Les génériques imbriqués permettent l'utilisation d'autres types génériques au sein de méthodes génériques, créant ainsi un code hautement réutilisable. En pratique, les génériques imbriqués peuvent être utilisés pour rechercher deux éléments de pic dans un tableau. L'exemple de code utilise la paire générique pour stocker les résultats et trouve la valeur de pic en vérifiant de manière itérative les éléments et en les comparant avec les éléments adjacents.

Utilisation imbriquée des génériques de fonctions Java

Les génériques sont une puissante fonctionnalité du langage Java qui nous permet de créer du code réutilisable pouvant fonctionner sur différents types de données. Les génériques de fonctions nous permettent d'utiliser des génériques dans les fonctions, augmentant ainsi la flexibilité.

Génériques imbriqués

Les génériques imbriqués font référence à l'utilisation d'autres types génériques dans des méthodes génériques. Cela nous permet de créer du code hautement réutilisable, en particulier lorsqu'il s'agit de structures de données complexes.

Ce qui suit est un exemple de générique imbriqué :

public class Pair<T, U> {
    private T first;
    private U second;

    public Pair(T first, U second) {
        this.first = first;
        this.second = second;
    }

    public T getFirst() {
        return first;
    }

    public U getSecond() {
        return second;
    }
}

La classe Pair est un générique imbriqué qui stocke deux éléments de types différents. Pair 类是一个嵌套泛型，它存储两个类型不同的元素。

实战案例

让我们考虑一个需要返回两个峰值元素的数组 nums 的场景。峰值元素是指比其相邻元素都大的元素。

以下是一个使用嵌套泛型的 Java 代码：

public class FindPeakElements {

    public static <T extends Comparable<T>> Pair<T, T> findPeakElements(T[] nums) {
        if (nums == null || nums.length < 3) {
            throw new IllegalArgumentException("Invalid array size");
        }

        T firstPeak = nums[0];
        T secondPeak = nums[nums.length - 1];

        for (int i = 1; i < nums.length - 1; i++) {
            T current = nums[i];
            T prev = nums[i - 1];
            T next = nums[i + 1];

            if (current > prev && current > next) {
                if (current > firstPeak) {
                    secondPeak = firstPeak;
                    firstPeak = current;
                } else if (current > secondPeak) {
                    secondPeak = current;
                }
            }
        }

        return new Pair<>(firstPeak, secondPeak);
    }

    public static void main(String[] args) {
        Integer[] nums = {1, 2, 3, 4, 5, 6, 7, 6, 5, 4, 3, 2, 1};
        Pair<Integer, Integer> peaks = findPeakElements(nums);
        System.out.println("First peak: " + peaks.getFirst());
        System.out.println("Second peak: " + peaks.getSecond());
    }
}

这个代码使用嵌套泛型 Pair

🎜Cas pratique🎜🎜🎜Considérons un scénario dans lequel nous devons renvoyer un tableau nums de deux éléments de pointe. Un élément de pointe est un élément plus grand que ses éléments voisins. 🎜🎜Ce qui suit est un code Java utilisant des génériques imbriqués : 🎜rrreee🎜Ce code utilise des génériques imbriqués Paire pour stocker deux éléments de pointe. Il trouve l'élément de pointe en parcourant le tableau et en vérifiant si l'élément est plus grand que ses voisins. 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!