包含Java对象的数组中的最大值

我有一个名为trick of type Card的数组，它存储西装和等级。 有没有办法使用Collections.max查找排名最高的卡？我在代码的其他方面使用了序数，但现在似乎无法使其正常工作

我已经试过了，（t是传递给方法的参数。技巧是包含卡片的数组）

Collections.max（t.trick.rank.ordinal（））

它是else-if语句的一部分，然后又转到另一个语句，所以我认为我不能用for循环开始它，作为继承类的一部分，我不能执行for-else循环，因为它抛出错误，因为它不是从另一个类继承的。

---

有没有一种简单的方法可以找到我排名最高的卡片

我建议您让您的Card类实现

Compariable

接口。 这要求您定义卡实例之间的比较函数

然后，您需要做的就是在卡上添加call

Collections.max

，以获得“最大”卡

完整但极简的解决方案如下所示：

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class TestingClass 
{

public static void main(String[] args) throws Exception 
{
    List <Card> a = new ArrayList<Card>();
    a.add(new Card(1));
    a.add(new Card(5));
    a.add(new Card(2));
    a.add(new Card(3));

    Card x= Collections.max(a);
    System.out.println(x.rank); //this will print 5
}

}

class Card implements Comparable<Card>
{
    public int rank;
    public Card(int rank)
    {
        this.rank=rank;
    }
     @Override
        public int compareTo(Card other) {
            if(this.rank<other.rank) return -1;
            else if(other.rank< this.rank) return 1;
            return 0;
        }

}

class ValueComparator implements Comparator<Card> {
    @Override
    public int compare(Card a, Card b)
    {
        return a.rank > b.rank ? 1 : a.rank == b.rank ? 0 : -1;
    }
}

import java.util.ArrayList；
导入java.util.Collections；
导入java.util.List；
公共类测试类
{
公共静态void main（字符串[]args）引发异常
{
列表a=新的ArrayList（）；
a、 增加（新卡（1））；
a、 增加（新卡（5））；
a、 增加（新卡（2））；
a、 增加（新卡（3））；
卡x=收款。最大值（a）；
System.out.println（x.rank）；//这将打印5
}
}
类卡实现可比性
{
公共int等级；
公共卡（国际等级）
{
这个.秩=秩；
}
@凌驾
公共int比较（卡其他）{
如果（this.rank，我建议您让您的Card类实现
Comparable
接口。
这要求您定义卡实例之间的比较函数

然后，您需要做的就是在卡上添加call
Collections.max
，以获得“最大”卡

完整但极简的解决方案如下所示：

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class TestingClass 
{

public static void main(String[] args) throws Exception 
{
    List <Card> a = new ArrayList<Card>();
    a.add(new Card(1));
    a.add(new Card(5));
    a.add(new Card(2));
    a.add(new Card(3));

    Card x= Collections.max(a);
    System.out.println(x.rank); //this will print 5
}

}

class Card implements Comparable<Card>
{
    public int rank;
    public Card(int rank)
    {
        this.rank=rank;
    }
     @Override
        public int compareTo(Card other) {
            if(this.rank<other.rank) return -1;
            else if(other.rank< this.rank) return 1;
            return 0;
        }

}

class ValueComparator implements Comparator<Card> {
    @Override
    public int compare(Card a, Card b)
    {
        return a.rank > b.rank ? 1 : a.rank == b.rank ? 0 : -1;
    }
}

import java.util.ArrayList；
导入java.util.Collections；
导入java.util.List；
公共类测试类
{
公共静态void main（字符串[]args）引发异常
{
列表a=新的ArrayList（）；
a、 增加（新卡（1））；
a、 增加（新卡（5））；
a、 增加（新卡（2））；
a、 增加（新卡（3））；
卡x=收款。最大值（a）；
System.out.println（x.rank）；//这将打印5
}
}
类卡实现可比性
{
公共int等级；
公共卡（国际等级）
{
这个.秩=秩；
}
@凌驾
公共int比较（卡其他）{
如果（这个.rank它取决于Java数组被
int
索引的数据类型。Java中的最大正
int
是
2^31–1=2147483647
。平台特定的限制可能非常接近这个数字——例如Java 1.7上的64位MB Pro，我可以很高兴地用
2147483645初始化数组或整数。
最大值-2
元素

我认为这不是一个好的做法。但这是一个好的信息！
这取决于Java数组被
int
索引的数据类型。Java中的最大正
int
是
2^31–1=2147483647
。平台特定的限制可能非常接近这个数字——例如Java 1.7i上的64位MB Pro可以使用最多2147483645
或整数初始化数组。
MAX_VALUE-2
元素

我认为这不是一个好的做法。但这是一个很好的信息！
集合的重载之一。max（）
将comparator作为第二个参数。使用它，您可以实现自己的comparator类，如下所示：

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class TestingClass 
{

public static void main(String[] args) throws Exception 
{
    List <Card> a = new ArrayList<Card>();
    a.add(new Card(1));
    a.add(new Card(5));
    a.add(new Card(2));
    a.add(new Card(3));

    Card x= Collections.max(a);
    System.out.println(x.rank); //this will print 5
}

}

class Card implements Comparable<Card>
{
    public int rank;
    public Card(int rank)
    {
        this.rank=rank;
    }
     @Override
        public int compareTo(Card other) {
            if(this.rank<other.rank) return -1;
            else if(other.rank< this.rank) return 1;
            return 0;
        }

}

class ValueComparator implements Comparator<Card> {
    @Override
    public int compare(Card a, Card b)
    {
        return a.rank > b.rank ? 1 : a.rank == b.rank ? 0 : -1;
    }
}

这样做的价值在于，您可以创建多个比较器，并使用它们执行基于比较的操作（max、sort等）用于各种比较类型。例如，如果您想在卡的套装上进行比较，可以实现套装比较器。其答案提供了一些非常有用的示例，说明如何使用比较器。
Collections.max（）的重载之一

将比较器作为第二个参数。使用它，您可以实现自己的比较器类，如下所示：

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class TestingClass 
{

public static void main(String[] args) throws Exception 
{
    List <Card> a = new ArrayList<Card>();
    a.add(new Card(1));
    a.add(new Card(5));
    a.add(new Card(2));
    a.add(new Card(3));

    Card x= Collections.max(a);
    System.out.println(x.rank); //this will print 5
}

}

class Card implements Comparable<Card>
{
    public int rank;
    public Card(int rank)
    {
        this.rank=rank;
    }
     @Override
        public int compareTo(Card other) {
            if(this.rank<other.rank) return -1;
            else if(other.rank< this.rank) return 1;
            return 0;
        }

}

class ValueComparator implements Comparator<Card> {
    @Override
    public int compare(Card a, Card b)
    {
        return a.rank > b.rank ? 1 : a.rank == b.rank ? 0 : -1;
    }
}

---

这样做的价值在于，您可以创建多个比较器，并使用它们执行基于比较的操作（max、sort等）用于各种比较类型。例如，如果您想在卡片的西服上进行比较，您可以实现西服比较器。它的答案提供了一些关于如何使用比较器的非常有用的示例。

就在此时，

t.trick.rank.ordinal（）

return？你能添加一个代码示例来说明你的数据结构吗？试图从你的文章中推断出这一点并不是我最喜欢的活动……我认为如果你真的需要任何帮助，你应该发布你的代码。

t.trick.rank.ordinal（）

return？你能添加一个代码示例来说明你的数据结构吗？试图从你的文章中推断出这一点并不是我最喜欢的活动……如果你真的需要帮助，我想你应该发布你的代码