我得到以下编译错误:
The method sort(List<T>, Comparator<? super T>) in the type Collections is not applicable for the arguments (T[], Comparator<capture#1-of ? extends T>) Main.java /Sorting/src/com/kash/test line 11
The method sort(List<T>, Comparator<? super T>) in the type
public void sortByLastName(){
Collections.sort(list, new Comparator<Person>() {
public int compare(Person p1, Person p2){
return p1.getLastName().compareTo(p2.getLastName());
}
} );
}
这里显示的代码是contactList数组的一部分,我在该数组中按姓氏对列表进行排序,似乎无法对其进行编译,也看不出有什么问题。
编辑:编译器上的错
Im应该创建一个返回任何列表的最大值的方法,我想这是一个通用的方法。但是我不明白参数,有人能解释一下吗?我还做了一个迭代器,我将在解决方案中使用这个迭代器来运行列表,但是当我创建迭代器的一个实例时,这个方法会给我以下错误:"#nameofclass不能从静态上下文中引用“,那么我如何在这里创建一个实例?(由于某种原因它应该是静态的)我会感激任何帮助!
public static <T> int maks(List<T> list, Comparator<? super T> c)
{
// return max in a list
}
我有一个名为Interval的泛型类
package com.test;
//import statements
public class Interval<T extends Comparable<? super T>> {
private boolean isStartInclusive;
private T start;
private T end;
private boolean isEndInclusive;
//Constructors
//Getter and Setters
//ToSt
我理解低界通配符存在的一个原因是,当添加新元素时,集合不是不可变的。
例如。
List<? extends Number> obj = new ArrayList<>();//Now this list is immutable
obj.add(new Integer(5));//Does not compile
List<? super Number> objTwo = new ArrayList<>();//This list is mutable
objTwo.add(new Integer(5));//Compiles
由于我试图获得数字
当通过数组类的JavaDocs时。我意识到有很多重载的方法。例如,
static int binarySearch(byte[] a, byte key)
static int binarySearch(char[] a, char key)
static <T> int binarySearch(T[] a, T key, Comparator<? super T> c)
我不能理解,为什么需要这么多重载方法,而最后一个泛型方法似乎已经足够了。
甚至在泛型出现之前,使用Object的方法就可以解决这个问题。
为什么Arrays类设计了这么多重载的方法?
我被要求创建一个toArray方法,该方法应该分别返回一个Iterator或数组,元素按其“add”计数(HashMap中的值)按升序排序。
但是,我收到以下错误消息,并且不知道如何修复它:
方法排序(列表,Comparator<?类型集合中的超级T>)不适用于参数(Set<Map.Entry<T、Integer>>、新Comparator<Map.Entry<T、Integer>>(){})。
因此,我似乎必须重写或创建排序方法。有人能帮我指出正确的方向吗?
public class OccurenceSet<T>
基本上,我创建了一个定制的链表类,它
public class LList<T> implements ListInterface<T>{
然而,当我尝试对自定义链表进行排序时,我得到了错误,找不到合适的构造函数。这就是错误
no suitable method found for sort(ListInterface<Patient>)
method Collections.<T#1>sort(List<T#1>) is not applicable
(cannot infer type-variable(s) T#1
我理解集合的:如果一个方法接受一个它将写入类型T的集合,则参数必须为Collection<? super T>,而如果它将从其中读取类型T,则参数必须为Collection<? extends T>。
但有没有人能解释一下签名:
public static <T> T max(Collection<? extends T> coll,
Comparator<? super T> comp)
特别是为什么是Comparator<? super T>而不是Comparator<?
约书亚·布洛赫提出了PECS,规定了何时使用? extends T和? super T的规则。如果你从Collections框架的角度来考虑PECS,那么它是非常简单的。如果向数据结构添加值,请使用? super T。如果从数据结构中读取,请使用? extends T。例如:
public class Collections {
public static <T> void copy(List<? super T> dest, List<? extends T> src) {
for (int i = 0; i < sr
我有很多这样的课程:
Class Person {
protected String name;
protected String surname;
...getters and setters...
}
我想按姓名或姓订购一批人。实际上,我只是在做这个:
Collections.sort(listofpersons, new Comparator<Person>(){
@Override
public int compare(Person p1, Person p2) { return p1.getName().compareTo(p2.getName())
众所周知,自动装箱可以是计算密集型的,但在我看来,允许将基元数组自动装箱为其Object等效的排序方法是一种合适的边缘情况,特别是在根据某些外部计算对值进行排序时。
我之前遇到了一个问题,在这个问题上,需要根据基于索引值的计算结果对给定的基本int数组进行排序。但是,java.util.Comparator不允许任何实现类和compare(T x, T y)方法的基元类型。
所以不要做这样的事
public void sortRow(int row){
Arrays.sort(this.buffer[row], new Comparator<Integer>(){
Intellij idea给了我一个错误:“比较器中的比较(T,T)不能应用于(T,T)”,用于下列代码:
public class LCCS<T extends Comparable<T>> {
private Comparator<T> comparator;
public LCCS(Comparator<T> comparator) {
this.comparator = comparator;
}
/**
* Loops the two given lists for fi
我的“人”class如下-
public class Person implements Comparable<Person> {
private int marks;
private String name;
Person(int marks, String name) {
this.marks = marks;
this.name = name;
}
public int getMarks() {
return marks;
}
public String getNam
我想了解比较器类的方法comparing的定义。我会留下一些代码,以防它有助于解释。我正在使用一个名为Person的类,它基本上存储了一个名字和一个姓氏。可以使用get方法检索此数据。
public class Person {
private final String name;
private final String lastname;
public Person(String name, String lastname) {
this.name = name;
this.lastname = lastname;
}
下面的代码运行良好。但我不明白它是怎么工作的?你能解释一下吗?特别是sortEmployeeByCriteria的方法签名(见下文)。
我知道它返回List<T>,但是<T, U extends Comparable<? super U>>是什么?
public static void sortIt() {
Employee[] employees = new Employee[] {
new Employee("John", 25, 3000.0, 9922001),
new Employee(
我有一种方法,它需要以许多可能的方式对集合进行排序。我不需要多次调用myCollection.sortedBy,而是希望在变量中传递给sortedBy的lambda,然后将该变量传递给对sortedBy的单个调用。但是,我不知道lambda变量应该具有什么样的类型。请记住,“按字段排序”可能有不同的类型(显然,它们都是Comparable )。
下面是我的问题的简化版本:
data class Person(val name: String, val age: Int)
enum class SortBy {
NAME, AGE
}
fun main(args: Array<
示例
private static final Comparator<A> PRODUCT_CODE_COMPARATOR = new Comparator<A>()
{
@Override
public int compare(final A o1, final A o2)
{
return o1.getCode().compareTo(o2.getCode());
}
};
public static <T extends A> List<T> sortProductsByCode(fi
我正在尝试根据类A的int r对B类中名为BinOrder的A类型的列表进行排序。
但是,我收到了行Collections.sort(BinOrder)的这个错误;
The method sort(List<T>) in the type Collections is not applicable for the arguments (ArrayList<A>)
A类:
public class A{
int s;
int r;
public A(int si, int ri) {
s=si;
r= ri;
}
}
B类:
import java.
在下面的代码中,我想了解Collections.sort函数在做什么。这意味着什么?
Collections.sort(list, new Comparator() { a complete java function });
我知道new Comparator()指的是一个类对象,但是这里的函数块的目的是什么,以及我们在java中对它的叫法。
谢谢。
/**
* Sorts/shuffles the given list according to the current sending queue
* mode. The list can contain either
在C#中,我想创建一套通用的卡片。使我能够创建一叠卡片,一排卡片或任何其他收集的卡片?假设此集合是从IEnumerable派生的。
public class Deck<T> where T : IEnumerable
{
private T<ICard> __Cards;
public Deck() : this(52){}
public Deck(int cards)
{
__Cards = new T<Card>(cards);
}
}
其他班级..。呼叫
Deck<List> _D
因此,我正在开发一个通用的Graph包,并尝试使用这种方法(我不允许更改)来根据它们的自然顺序对我的边集进行排序:
/** Returns the natural ordering on T, as a Comparator. For
* example, if stringComp = Graph.<Integer>naturalOrder(), then
* stringComp.compare(x1, y1) is <0 if x1<y1, ==0 if x1=y1, and >0
* otherwise. */
public static
这件事很简单,但我显然遗漏了一些东西.
我有一个2D数组,它包含从BufferedImage对象中计算出来的颜色值的整数表示。我也有一种基于整数值计算亮度值的方法。
我想根据亮度值对行进行排序。但是,我得到了
sort(java.lang.Integer[], Comparator<? super Integer>) in Arrays cannot be applied
to (int[], IntComparator)
我的比较方法:
private class IntComparator implements Comparator<Integer>{
@Ove
我得到一个我不理解的java泛型的编译时错误。
我有两种方法:
public static final <T> T doStuff(List<T> list, int k, Comparator<T> comparator) {
T element = null;
//some stuff done
return element;
}
public static final <T extends Comparable> T doStuff(List<T> list, int k) {
Comparator<T&
我在Java中有一个2D点数组,并希望对其进行排序。我使用过来自不同网站的比较器,例如来自的比较器,但它们都不适合我。
例如,如果我使用以下代码:
Point2D[] points = new Point2D[numPoints];
// add some points
Collections.sort(points, new Comparator<Point2D.Double>() {
public int compare(Point2D.Double p1, Point2D.Double p2) {
re
假设我们有
class A implements Comparable<A>
和
class B extends A
现在,我希望使用compareTo方法从集合中找到最大对象的泛型方法。
如果我这样声明这个方法:
public static <T extends Comparable<T>> T max(List<T> list)
它不适用于参数List<B> list,因为B不使用B类型来参数化Comparable。为了使这种方法起作用,我似乎很自然地要改变。
Comparable<T>
至
Comparable<
具有以下简单的类结构:
class A {
}
class B extends A {
}
class C extends B {
}
我正在创建一个ArrayList,以保留先前创建的类的对象:
List<? extends A> list1 = new ArrayList<A>();
List<? extends B> list2 = new ArrayList<B>();
List<? extends C> list3 = new ArrayList<C>();
List<? super A> li
我正在Java中实现快速排序(单枢轴)。
我读到有一个关于分区的术语,我认为我可以编写一个具有可扩展性的方法。
public static <E> void sort(
final List<? extends E> list,
final Comparator<? super E> comparator,
final BiFunction<List<? extends E>, Comparator<? super E>, Integer> p
我有一个比较器,它对给定的列反转后的数组进行排序。我希望,这个比较器不仅仅适用于int[],它也适用于其他类型的数字。我该怎么做呢?
比较器的代码如下:
public class ReverseComparator implements Comparator<int[]> {
int col;
public ReverseComparator(int col) {
this.col = col;
}
@Override
public int compare(int[] a, int[] b) {
if (a[col - 1] > b[col - 1