泛型和实现IC Comparable
泛型是一种编程语言特性，它允许在定义类、接口或方法时使用类型参数，以便在使用时可以指定具体的类型。泛型的主要目的是增加代码的重用性和类型安全性。
IC Comparable是一个接口，用于实现对象之间的比较。它定义了一个compareTo()方法，用于比较两个对象的大小关系。实现IC Comparable接口的类可以通过重写compareTo()方法来定义自己的比较规则。
泛型和IC Comparable在实际开发中经常一起使用。通过使用泛型，我们可以在定义类或方法时指定IC Comparable接口的实现类作为类型参数，从而实现对不同类型对象的比较操作。
泛型和IC Comparable的优势在于：
- 代码重用性：通过使用泛型和IC Comparable，我们可以编写通用的比较逻辑，而不需要为每种类型都编写一套比较代码。
- 类型安全性：泛型可以在编译时进行类型检查，避免在运行时出现类型错误。
- 灵活性：通过实现IC Comparable接口，我们可以根据具体需求定义不同的比较规则，使得比较操作更加灵活。
泛型和IC Comparable的应用场景包括但不限于：
- 数据结构：在实现各种数据结构（如链表、树、堆等）时，可以使用泛型和IC Comparable来实现元素的比较和排序。
- 排序算法：在实现各种排序算法（如冒泡排序、快速排序等）时，可以使用泛型和IC Comparable来比较和交换元素。
- 容器类：在实现各种容器类（如集合、队列、栈等）时，可以使用泛型和IC Comparable来实现元素的比较和存储。
腾讯云提供了一系列与泛型和IC Comparable相关的产品和服务，例如：
- 腾讯云数据库（https://cloud.tencent.com/product/cdb）：提供了多种数据库产品，支持存储和查询泛型和IC Comparable相关的数据。
- 腾讯云函数计算（https://cloud.tencent.com/product/scf）：提供了无服务器计算服务，可以使用泛型和IC Comparable来实现函数的比较和排序逻辑。
- 腾讯云对象存储（https://cloud.tencent.com/product/cos）：提供了可扩展的对象存储服务，可以存储和检索泛型和IC Comparable相关的数据。
总之，泛型和IC Comparable是云计算领域中重要的编程概念，通过它们可以实现对不同类型对象的比较操作，提高代码的重用性和类型安全性。腾讯云提供了多种相关产品和服务，可以满足开发者在泛型和IC Comparable方面的需求。
相关·内容
2回答
请解释这两种定义之间的区别：
public class Box<T implements Comparable<T>>
和
public class Box<T> implements Comparable<T>
浏览 0提问于2014-11-20得票数 1
回答已采纳
1回答
对通用数据结构数组进行排序
、、、、
我有一个包含数组的泛型类。该数组可以是任何数据类型(Double、Integer、String.)我正在努力学习如何在构建之后对这个数组进行排序。我已经编写了一种排序方法，用于在构造后对数组进行排序。但是，由于不匹配，java禁止使用mysort方法对泛型数组进行排序。
public class SortingTest<E> {
private E[] array;
//constructor which creates an object and sorts its array via mysort method.
public SortingTest(
浏览 2提问于2014-06-05得票数 0
回答已采纳
1回答
可比较通用的如何使用ist
、、、、
我在Java方面很新。我不知道这个<T extends Comparable<T>>。我的意思是，为什么T在扩展之前就扩展了？这不足以写extends Comparable<T>吗？为什么javadoc中的extends而不是implements是一个接口，对吗？据我所知，Comparable比较了两个对象吗？
public class TopNPrinter<T extends Comparable<T>> {
private int N;
private String header;
public Top
浏览 1提问于2019-12-10得票数 3
回答已采纳
2回答
我一直在读Herbert的"Java，一个初学者指南“。在一页的通用接口一节中，作者写道(重点是我的)：
实现泛型接口的任何类本身都必须是泛型。
在下一页(强调我的)：
在一般中，如果一个类实现了泛型接口，那么该类也必须是泛型，至少在一定程度上它接受传递给接口的类型参数。
那么，是否存在非泛型类可以在Java中实现泛型接口的特定情况？或者所有这些类都是泛型的，因为它们从泛型接口中“继承”了这种通用性？
UPD:，我应该进一步阅读这一节。提交人接着说：
当然，如果另一个高级类实现了特定类型的泛型接口，如这里所示：class MyClass implements Cont
浏览 0提问于2019-01-22得票数 2
回答已采纳
2回答
我想为一个泛型类创建一个迭代器，它工作得很好。我以为迭代器会尝试使用泛型类的TypeParameter进行迭代，但显然并非如此，因为Eclipse告诉我需要一个对象。
如果有人知道我做错了什么，我会很高兴的。
public class GenericClass<T extends OtherClass> implements Comparable, Iterable
{
private ArrayList<T> list = new ArrayList<T>();
[...]
@Override
public Iterator
浏览 5提问于2013-06-08得票数 0
2回答
似乎您通常没有指定类型参数就实现了java.lang.Comparable接口。
public abstract class Area implements Comparable {
@Override
public int compareTo(Object other) {
if (other instanceof Area)
return new Double(getArea()).compareTo(other.getArea());
return -1; // or something else
}
浏览 4提问于2014-11-20得票数 2
回答已采纳
当我试图完成一项任务时，有一种情况需要处理:抛出类的泛型类型的异常是不可比较的。有关详细信息，请参阅以下代码。
public class C <T>
{
public C()
{
// throw exception if T is not comparable
}
}
浏览 0提问于2015-05-02得票数 3
3回答
有人能帮我理解一下Java的泛型是如何工作的吗？我理解它的概念。但是对于这个具体的代码示例，我不清楚编译器的错误消息。
示例代码:测试类
// Test code
public class A < ListType extends Comparable < ListType >> {
// To make the instance variable y
public int y;
// To make the instance variable s
public String s;
//Constructor Method
public A(int required
浏览 1提问于2016-04-20得票数 0
回答已采纳
我正在使用java中的优先级队列实现Dijkstra算法。我正在为队列使用类“Node”的对象。为了实现这一点，我覆盖了Node类中的compareTo()方法。如果我使用"Object obj“作为compareTo()的参数，它工作得很好。但是，当我将"Node obj“作为参数提供给compareTo()时，会显示一个错误，说"Node不是抽象的，并且没有覆盖可比较的抽象方法compareTo(Object)”。根据我所读到的，这应该是可能的。怎么啦？
public class Node implements Comparable
{ in
浏览 0提问于2017-05-25得票数 1
在下面的代码片段中，keys = (Key[]) new Comparable[initCapacity];是做什么的？
public class BinarySearchST<Key extends Comparable<Key>, Value> {
private static final int INIT_SIZE = 8;
private Value[] vals; // symbol table values
private Key[] keys; // symbol table keys
private in
浏览 1提问于2017-12-05得票数 1
回答已采纳
我试图在我的E[]上实现我的排序方法，该方法以一个通用的int[]作为参数。我收到错误：
类型E[]中的方法排序( HeapSort )不适用于参数(int[])。
我的代码如下：
public <E extends Comparable<E>> void sort(E[] array){
//my code
}
public static void main(String[] args){
int[] arr = new int[30];
for(int rep = 0; rep < arr.length; rep++){
浏览 3提问于2016-02-29得票数 2
回答已采纳
3回答
在集合中，经常使用强制转换为Comparable接口，例如。在PriorityQueue中
private static <T> void siftUpComparable(int k, T x, Object[] es) {
Comparable<? super T> key = (Comparable<? super T>) x;
...
if (key.compareTo((T) e) >= 0)
break;
...
}
比方说，我们创建了整数队列并添加了一些东西：
Priorit
浏览 1提问于2019-02-14得票数 3
2回答
我以前使用过类似的接口，但是将它与泛型对象一起使用，第二个对象给我带来了一些困难。
这是我的司机程序
import java.io.*;
import java.util.*;
public class Prog2 {
public static void main (String[]args){
//Declare Variables
Scanner inFile = null;
ListArray<Part> partArray = new ListArray<Part>(13);
//Open the fil
浏览 0提问于2018-09-16得票数 0
回答已采纳
我正在创建一个使用二进制搜索树实现泛型集的类。我在我的一些方法中使用了"compareTo“方法，无论我做什么，我都会得到声明的警告。任何帮助都是非常感谢的！
// Allow short name access to following classes
import csc143.data_structures.*;
public class MySet<E> implements SimpleSet<E> {
// the root of the "tree" that structures the set
private BTN
浏览 0提问于2013-08-09得票数 3
1回答
我试图在java中实现二进制搜索树。只要该对象实现可比较的接口，它就可以将任何对象作为树中节点的数据。这是必要的，因为在树中放置一个新节点时，我们需要决定新节点的价值是否比它的父节点更小或更大。我的Node课程如下所示。
package com.java.ds.bst;
public class Node<T extends Comparable<T>> implements Comparable<T> {
private T data;
private Node<T> left = null;
private Node<T&
浏览 1提问于2019-01-09得票数 0
回答已采纳
1回答
Comparable是一个包含compareTo()方法的接口。
在使用泛型方法返回三个可比较对象中最大的对象的代码中，直接使用compareTo()方法而不实现。那件事怎么可能？是因为我们在类中“扩展”该接口而不是“实现”它吗？
public class Max {
public static <T extends Comparable <T>> T maximum(T x, T y, T z) {
T max=x;
if (y.compareTo(max) > 0)
max=y;
浏览 0提问于2019-10-31得票数 0
public class MergeSort
{
/**
* @param a Array to be sorted.
* @param n Last element to be sorted.
* @return void.
*/
public static <T extends Comparable<T>> void sort(T[] a, int n)
{
}
/**
* @param inp Input Array.
* @param out Output Ar
浏览 2提问于2011-04-07得票数 1
回答已采纳
1回答
如何实现通用BST？
、、、、
我想创建一个通用的bst，每个节点都有键和值，方法将按键工作。我是否必须在Tree类中扩展可比较的？或者仅在节点类中？
我试图弄清楚是否必须按节点进行扩展比较，或者仅按键就足够了。
public class ThreadedGenericNode<K,V> implements Comparable<ThreadedGenericNode<K,V>>
{
K _key;
V _value;
private ThreadedGenericNode _right;
private ThreadedGenericNode _left
浏览 4提问于2019-07-07得票数 1
回答已采纳
1回答
我的链表使用了未预定义的变量，但我今天才学会使用这些变量。我已经设置了使用简单整数的列表，但是我意识到我不能以同样的方式比较我的变量，因为它们没有定义为整数，因此我在if语句上收到一个语法错误，该语句试图比较来自链接列表节点的整数值，以找到列表中的最大和最小值。
我已经将if语句标记为错误。如果需要更多代码或信息，请告诉我。
package lab01Pkg;
public class LinkedList <T> //<T> is defining the type of node we are creating
{
private int size;
浏览 0提问于2018-09-14得票数 0
我正在上一门数据结构课程，我们正在使用Mark Weiss的Java第二版中的数据结构和算法分析。在他的BinaryHeap实现中，他的构造函数创建了一个转换为AnyType[]的Comparable[]数组。你知道他为什么要这么做而不是创建一个新的AnyType[]吗？
我理解BinaryHeap的结构，但我想跟上泛型的速度。类声明足够简单，请确保AnyType扩展的类型可与AnyType或任何继承层次结构上的任何超类相媲美(如果AnyType是类型的子类，并且不需要更改其compareTo方法即可运行)。
然而，array = (AnyType[]) new Comparable[ cap
浏览 1提问于2010-11-23得票数 4
回答已采纳
我在做在线算法课的家庭作业时遇到了一个问题。将Object[]转换为T[]，其中T是可比较的，会引发运行时异常
public static <T extends Comparable<? super T>> void mergeSort(T[] xs) {
T[] aux = (T[]) new Object[xs.length];
mergeSort(xs, aux, 0, xs.length);
}
我可以用C#重写它，它在创建泛型数组方面没有任何问题，但我更愿意学习如何在Java语言中处理这个问题。
浏览 1提问于2013-04-13得票数 7
回答已采纳
2回答
我有一个这样的类：
class BSTNode<K extends Comparable, V> {
K key;
BSTNode(K key, V value) { ... }
}
然后我使用
node.key.compareTo(root.key) >= 0
其中node和root是BSTNode。在这一行中，我得到了一个未经检查的错误。为什么？
warning: [unchecked] unchecked call to compareTo(T) as a member of the raw type Comparable
} els
浏览 6提问于2012-09-07得票数 0
回答已采纳
在中，类实现了接口Comparable、Serializable。
在中，类实现了接口Serializable、Comparable<BigInteger>。
这只是一个帮助我了解<和>的例子。我真正想知道的是<和>的东西。
我的问题有三个：
<BigInteger>部分的implements语句意味着什么？
那个语法叫什么？
那它是做什么的？
P.S.：谷歌在<和>上真的很难搜索，所以从一开始就不可能搜索<和>。
谢谢!
浏览 3提问于2009-01-16得票数 7
回答已采纳
2回答
泛型定义
、、
我无法理解整个泛型声明，即使在阅读了无数关于Java的文章和条目之后，他们似乎都没有用简单明了的方式来解释它。有人能解释一下吗？：
class Something<T> {...}
我知道T是什么，而且我知道，当我们想要为传入的任何类型的对象编写一个通用定义/方法时，我们使用泛型，而不是为一种类型的对象扩展编写不同类型的方法，我们编写一个泛型方法，它可以包含一个或多个类型(因此是大写T)。但我最喜欢的一件事是下一个声明例子：
public <T extends Comparable<T>> void Something{...}
首先，可比性是一个接口，而不
浏览 3提问于2013-11-07得票数 1
回答已采纳
如果我需要编写一个类来处理“可比较”类型的数据，我可以用两种方法来实现：
1)
public class MyClass<T extends Comparable>
{
private T value;
MyClass(T value)
{
this.value = value;
}
other code...
}
2)
public class MyClass
{
private Comparable value;
MyClass(Comparable value)
{
浏览 4提问于2011-05-30得票数 3
回答已采纳
我有一个方法：
public List<Stuff> sortStuff(List<Stuff> toSort) {
java.util.Collections.sort(toSort);
return toSort;
}
这会产生一个警告：
Type safety: Unchecked invocation sort(List<Stuff>) of the generic method sort(List<T>) of type Collections.
Eclipse说修复这个警告的唯一方法是在我的sortStuff方法中添
浏览 0提问于2013-03-19得票数 13
回答已采纳
这是课堂作业的一部分，我不知道这句话对挽救我自己的生命意味着什么。
public static <T extends Comparable<? super T>> void sort(Arraylist<T> list){}
该方法没有实现，因为我应该自己执行。要排序的列表将包含一个Integer类型、一个Double类型和一个String类型。
我应该如何使用Comparable对不同对象类型的列表进行排序，Comparable<? super T>到底是什么意思？
我的课堂教材是非常模糊和深奥的，这是如此具体，我不知道在网上找到它。
编辑：
浏览 0提问于2016-02-11得票数 2
回答已采纳
我正在实现一个通用的AVL树，但是我遇到了一些编译错误。
我的AVL必须处理T型Node<T>。
在这个例子中，类型是事件类，我想比较节点。
但每种类型的数据都必须进行不同的比较，为此，我要将比较传递给数据本身来进行比较。
我试图使Node实现可比较的接口和事件类的相同功能。
我的代码结构如下：
树的结构：
public class AvlTree<T extends Comparable<T>> {
private Node<T> root;
public AvlTree() {
root = null;
}
//other me
浏览 1提问于2015-04-17得票数 1
回答已采纳
3回答
我正在将一些代码升级到Java5，显然我不理解泛型的一些东西。我还有其他实现了一次可比较的类，我已经能够实现了。但现在我有了一个类，由于继承，它最终尝试实现2个类型的可比较。这是我的情况：
我有以下类/接口：
interface Foo extends Comparable<Foo>
interface Bar extends Comparable<Bar>
abstract class BarDescription implements Bar
class FooBar extends BarDescription implements Foo
这样一来，我就得
浏览 0提问于2010-04-22得票数 15
1回答
这是一个无效的结构。
class A <T extends String & Comparable<T>>{}
退出：
java: java.lang.Comparable cannot be inherited with different arguments: <T> and <java.lang.String>
但它是有效的
class A <T extends Number & Comparable<T>>{}
我不认为它与字符串相关是最终的，但数字-不是。
但我认为T字符串在一开始是有效的。为
浏览 2提问于2014-03-11得票数 0
回答已采纳
似乎奇怪的是，这没有如我所预期的那样起作用。我编写了一个简单的java类，它实现了类似的接口，并覆盖了compareTo()方法。但是，它不允许我传递对象以外的特定类型的参数。我在网上查看了其他人的代码，他们使用了其他类型的对象，我将他们的代码复制到eclipse中，但我还是得到了同样的错误。
我的问题是，我要做什么来比较这个对象和类型的对象，比如Person。比较器接口(比较法)也有同样的问题。
这段代码是我在网上找到的。
public class Person implements Comparable {
private String name;
private int age;
p
浏览 0提问于2015-10-08得票数 3
回答已采纳
我尝试创建实现另一个通用接口的接口：
public interface MinMax implements Comparable<T> {
}
但是在T上，我得到的错误不能解决符号T。
所以我尝试了这个语法：
public interface MinMax <T extends Comparable> {
}
这是有效的，我在上面的语法上没有任何错误。
我不明白为什么我应该使用扩展而不是实现，而可比较的是接口。
浏览 11提问于2017-07-12得票数 1
回答已采纳
2回答
我知道我可以像这样在java中创建一个类：
public class test {/*some code*/}
但现在我有了这个：
public class coada < T extends Number & Comparable < Number>> {
List <T> pq = new ArrayList <T>();
public void add(T e , List <T> c) {
c.add(e);
Collections.sort(c);
}
浏览 0提问于2015-04-04得票数 1
1回答
首先，我必须提到，在阅读了大量的问题和教程以及观看了一些视频之后，问题仍然没有得到解决。
我是一名Java的中级程序员，我写了一些代码来比较优先级队列中的元素，在优先级队列中，元素被保存为可比较的元素，int优先级。显然，较高的优先级将被弹出。
问题是:我将代码修改为具有最高优先级的第一个元素，但它不起作用！我已经缩小了范围，当比较前两个元素时，compareTo方法返回0，这是它不应该返回的，因此代码失败！
这是具有O(1)的push和O(N)的Pop的类：
public class PriorityQueueU<T>
{
public clas
浏览 1提问于2017-05-01得票数 0
2回答
带有泛型参数的泛型类参数
、、、
如何正确地用Java编写以下类声明？
public class BinarySearchTree<T extends BinarySearchNode<E implements Comparable<E>>> implements Iterable<E>
基本上，我试图创建一个T类的BinarySearchTree，它继承了类似数据类型E的BinarySearchNode (而且我的BinarySearchTree也应该是Iterable的)。
如何在Java中正确声明该类？谢谢!
浏览 1提问于2017-05-08得票数 2
回答已采纳
1回答
我迷上了泛型(Java)。真正的场景涉及JPA和CriteriaBuilder的。
<Y extends Comparable<? super Y>> Predicate greaterThan(Expression<? extends Y> x, Y y);
但是，我在下面的类中简化了相同的情况：
public class GenericsTest {
public class Bean<T> {
};
public <T extends Comparable<T>> T targetMet
浏览 3提问于2016-02-06得票数 1
3回答
这可能是一个新手的问题，但我正在学习java，我遇到了一个接口，它的定义如下：
public interface MyClass <T extends Comparable<T>>
有人能解释一下这是什么意思吗？我的意思是创建什么样的界面。
浏览 7提问于2012-08-21得票数 0
回答已采纳
2回答
实际上，我已经从这个例子中得到了这样的效果：
static <K,V extends Comparable<? super V>>
List<Entry<K, V>> entriesSortedByValues(Map<K,V> map) {
List<Entry<K,V>> sortedEntries = new ArrayList<Entry<K,V>>(map.entrySet());
Collections.sort(sortedEntries,
浏览 7提问于2014-11-17得票数 0
回答已采纳
我看了很多这方面的问题，却找不到具体解决我问题的问题。
基本上，这是一个家庭作业分配，其中我有一个带有节点的链接列表，其中包含一个元素。节点类(LinearNode)和元素类(Golfer)都实现了可比的，并覆盖了compareTo方法。但是，运行库试图向列表中添加一个新节点(第一个节点添加得很好)失败，但有类强制转换异常:不能将supersenior.LinearNode转换为supersenior.Golfer。我不知道为什么要将节点与要比较的节点的元素进行比较……我甚至尝试过显式转换。观察到以下错误：
Exception in thread "main" java.lan
浏览 0提问于2013-10-10得票数 1
回答已采纳
1回答
我最近在使用Spring Security进行开发时遇到了一个问题。它有一个带有以下签名的接口GrantedAuthority：
public interface GrantedAuthority extends Serializable, Comparable
对于Java1.5和更高版本，接口Comparable接受一个类型参数T，这在Spring Security库中被省略了(显然是为了与JVM1.4兼容)。
因此，我正在尝试在Scala中实现GrantedAuthority。
class Role extends GrantedAuthority {
. . .
def com
浏览 1提问于2010-02-14得票数 6
回答已采纳
3回答
简单地说，我有：
public interface Dictionary<E extends Comparable<E>> extends Iterable<E> {
和
public class TreeDictionary implements Dictionary<TreeDictionary> {
编译时，会导致错误。
TreeDictionary.java:4:类型参数TreeDictionary不在其绑定的公共类TreeDictionary实现字典内。
我想原因可能是因为我对字典界面的声明不太清楚。
如果有人能解释我这个问题，我会
浏览 4提问于2012-05-10得票数 1
回答已采纳
3回答
我正在尝试实现一个条目的通用DDLinkedList。我定义了以下类。
class DoublyLinkedList<T extends Comparable<T>>
class DLLNode<T extends Comparable<T>>
Entry<K extends Comparable<K>, V> implements Comparable<Entry<K, V>>
一旦我尝试创建一个Entry类型的DoublyLinkedlist数组，如下所示：
DoublyLinkedList
浏览 0提问于2015-04-16得票数 3
2回答
我正在创建一个泛型类，它有一个方法，用于对一个数组集合进行排序，该数组集合可以是Book，也可以是CD。我在两个类型类中实现了比较，并尝试在GenericCollection类中对数组进行排序。
我的方法现在看起来像这样：
public void sort(){
for (int i = 0; i < collection.length; i++) {
for (int j = 0; j < collection.length; j++) {
if (((T)collection[i]).compareTo((T)collection
浏览 0提问于2011-08-30得票数 2
回答已采纳
3回答
有人知道如何使用泛型和避免编译器警告来编写下面的代码段吗？(@SuppressWarning(“unchecked”)被认为是作弊)。
也许，通过泛型检查“左”的类型是否与“右”的类型相同？
public void assertLessOrEqual(Comparable left, Comparable right) {
if (left == null || right == null || (left.compareTo(right) > 0)) {
String msg = "["+left+"] is not less than
浏览 0提问于2009-09-17得票数 1
回答已采纳
我有一个MySpecialClass <T extends Comparable<T>>类
我正在尝试做以下几件事：
toItemList() ->应该获取List<Dog>并将其转换为List<T>，以便MySpecialClass可以对其进行操作。
fromItemList() ->应该接收内存List<T>并将其转换为对象列表。所以如果我有List，它应该将它转换成List<Dog>，这样我就可以在所有操作完成后得到一个反向转换。
我如何在Java中构造这样的东西？我的MySpecialClass可以与L
浏览 1提问于2011-03-23得票数 0
1回答
长话短说，玩弄泛型和可比性，直接打印值有困难。下面是一个简单的例子
class Ideone<Key extends Comparable<Key>>
{
private Key[] keys = (Key[]) new Comparable[10];
public static void main (String[] args) throws java.lang.Exception
{
Ideone<Integer> test = new Ideone();
test.keys[0] = 3;
浏览 1提问于2015-03-23得票数 0
在树形类中，我假设比较两个节点，因为你知道搜索和添加项目。我有一些关于如何让它具有可比性的问题。当一个人向树中添加数据(通用的，任何东西)时，会调用tree类，然后生成一个新的Node对象。如何在Node类中声明变量data/element，以便它是E类型(任何类型)并且仍然具有可比性？说真的，我试了又试，但没有得出任何结论。
浏览 1提问于2009-09-26得票数 1
回答已采纳
3回答
Java中的泛型和排序
、、、
假设您用Java语言编写了一个静态函数来对数组进行排序，就像Arrays.sort()一样。Arrays.sort()的问题是它接收一个对象数组，如果它的元素没有实现Comparable，就会抛出一个ClassCastException。
因此，您希望您的函数接收Comparable的子类型的数组作为参数。像这样的东西可能会起作用：
static <T extends Comparable> void sort(T[] array);
该签名的问题是，您仍然可以传递一个包含整数和字符串的可比较数组，这将导致RuntimeException。
那么，如何创建一个只接收一个数组的函数，
浏览 9提问于2010-01-15得票数 15
2回答
我从IDE中得到了一个奇怪的警告，但是代码仍然运行良好。
代码是
class TaskQueue<T extends Comparable> {
private final PriorityQueue<QueueItem<T>> queue =
new PriorityQueue<>(Comparator.comparing(QueueItem::getDeadline));
}
IDE给了我一个警告和一个错误：
警告
Unchecked call to 'PriorityQueue(Comparat
浏览 1提问于2017-03-22得票数 2
回答已采纳
2回答
我正在用Java构建一个通用的二叉树类。我以前没有过多地使用过泛型，所以我不知道我是否做得很好。下面是一些代码，后面跟着我的问题：
public class Node<T> {
T data;
Node<T> left, right;
//assume setters and getters
}
public class BinaryTree<T extends Comparable <T>> {
private Node<T> root;
//assume typi
浏览 3提问于2014-03-16得票数 0
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
云直播活动推荐
腾讯云开发者
