Java 作业顺序程序示例
我写的代码排序工作，根据减少利润秩序。编译器给出错误“int不能被延迟”。比较器代码有什么问题Java 作业顺序程序示例,java,collections,Java,Collections,我写的代码排序工作，根据减少利润秩序。编译器给出错误“int不能被延迟”。比较器代码有什么问题 import java.util.*; import java.util.Comparator; class Job { char jobId; int deadLine; int profit; public Job(char j, int d, int p) { jobId = j; deadLine = d;
import java.util.*;
import java.util.Comparator;
class Job {
char jobId;
int deadLine;
int profit;
public Job(char j, int d, int p) {
jobId = j;
deadLine = d;
profit = p;
}
public int getProfit() {
return profit;
}
}
public class JobSequencingProblem {
public void sequence(ArrayList<Job> list) {
Comparator<Job> cmp = new Comparator<Job>() {
@Override
public int compare(Job j1, Job j2) {
int p1 = j1.profit;
int p2 = j2.profit;
return (j1.getProfit()).compareTo(j2.getProfit());
}
};
}
public static void main(String args[]) {
JobSequencingProblem j = new JobSequencingProblem();
ArrayList<Job> list = new ArrayList<Job>();
list.add(new Job('a', 2, 100));
list.add(new Job('b', 1, 19));
list.add(new Job('c', 2, 27));
list.add(new Job('d', 1, 25));
list.add(new Job('e', 3, 15));
j.sequence(list);
}
}
import java.util.*；
导入java.util.Comparator；
班级作业{
char-jobId；
int截止日期；
国际利润；
公共作业（字符j、整数d、整数p）{
jobId=j；
截止日期=d；
利润=p；
}
公共int getProfit（）{
利润回报；
}
}
公共类职位分配问题{
公共无效序列（ArrayList列表）{
比较器cmp=新比较器（）{
@凌驾
公共整数比较（作业j1、作业j2）{
int p1=j1.1利润；
int p2=j2.1利润；
返回（j1.getProfit（））。与（j2.getProfit（））进行比较；
}
};
}
公共静态void main（字符串参数[]）{
JobSequencingProblem j=新的JobSequencingProblem（）；
ArrayList=新建ArrayList（）；
增加（新工作（'a'，2100））；
增加（新工作（'b'，1，19））；
增加（新工作（'c'，2，27））；
增加（新工作（'d'，1，25））；
增加（新工作（'e'，3，15））；
j、 顺序（列表）；
}
}
int.compareTo（int）整数对象的对象。但您可以使用：
进一步阅读：您不能将int.compareTo（int）
写入只适用于整数
对象的对象。但您可以使用：
进一步阅读：当您要对列表排序时，有两种解决方案：
要么您提供一个比较器（如您所提议的）
或者集合中的每个元素都实现了可比较的接口
比较器示例（在Java8中）
课堂作业{
char-jobId；
int截止日期；
国际利润；
公共作业（字符j、整数d、整数p）{
jobId=j；
截止日期=d；
利润=p；
}
公共int getProfit（）{
利润回报；
}
}
公共类职位分配问题{
公共静态void main（字符串参数[]）{
列表=新的ArrayList（）；
增加（新工作（'a'，2100））；
增加（新工作（'b'，1，19））；
增加（新工作（'c'，2，27））；
增加（新工作（'d'，1，25））；
增加（新工作（'e'，3，15））；
list.sort（Comparator.comparingit（Job:：getProfit））；
}
}
具有可比性的例子
class Job implements Comparable<Job> {
char jobId;
int deadLine;
int profit;
public Job(char j, int d, int p) {
jobId = j;
deadLine = d;
profit = p;
}
public int getProfit() {
return profit;
}
@Override
public int compareTo(Job o) {
return Comparator.comparingInt(Integer::intValue).
compare(this.getProfit(), o.getProfit());
}
}
public class JobSequencingProblem {
public static void main(String args[]) {
List<Job> list = new ArrayList<>();
list.add(new Job('a', 2, 100));
list.add(new Job('b', 1, 19));
list.add(new Job('c', 2, 27));
list.add(new Job('d', 1, 25));
list.add(new Job('e', 3, 15));
list.sort(Comparator.naturalOrder());
}
}
类作业实现了可比较的{
char-jobId；
int截止日期；
国际利润；
公共作业（字符j、整数d、整数p）{
jobId=j；
截止日期=d；
利润=p；
}
公共int getProfit（）{
利润回报；
}
@凌驾
公共内部比较（作业o）{
返回Comparator.comparingInt（整数：：intValue）。
比较（this.getProfit（），o.getProfit（））；
}
}
公共类职位分配问题{
公共静态void main（字符串参数[]）{
列表=新的ArrayList（）；
增加（新工作（'a'，2100））；
增加（新工作（'b'，1，19））；
增加（新工作（'c'，2，27））；
增加（新工作（'d'，1，25））；
增加（新工作（'e'，3，15））；
sort（Comparator.naturalOrder（））；
}
}
在这种情况下，“naturalOrder”将从可比较的实现中推导出来当您想要对列表进行排序时，有两种解决方案：
要么您提供一个比较器（如您所提议的）
或者集合中的每个元素都实现了可比较的接口
比较器示例（在Java8中）
课堂作业{
char-jobId；
int截止日期；
国际利润；
公共作业（字符j、整数d、整数p）{
jobId=j；
截止日期=d；
利润=p；
}
公共int getProfit（）{
利润回报；
}
}
公共类职位分配问题{
公共静态void main（字符串参数[]）{
列表=新的ArrayList（）；
增加（新工作（'a'，2100））；
增加（新工作（'b'，1，19））；
增加（新工作（'c'，2，27））；
增加（新工作（'d'，1，25））；
增加（新工作（'e'，3，15））；
list.sort（Comparator.comparingit（Job:：getProfit））；
}
}
具有可比性的例子
class Job implements Comparable<Job> {
char jobId;
int deadLine;
int profit;
public Job(char j, int d, int p) {
jobId = j;
deadLine = d;
profit = p;
}
public int getProfit() {
return profit;
}
@Override
public int compareTo(Job o) {
return Comparator.comparingInt(Integer::intValue).
compare(this.getProfit(), o.getProfit());
}
}
public class JobSequencingProblem {
public static void main(String args[]) {
List<Job> list = new ArrayList<>();
list.add(new Job('a', 2, 100));
list.add(new Job('b', 1, 19));
list.add(new Job('c', 2, 27));
list.add(new Job('d', 1, 25));
list.add(new Job('e', 3, 15));
list.sort(Comparator.naturalOrder());
}
}
类作业实现了可比较的{
char-jobId；
int截止日期；
国际利润；
公共作业（字符j、整数d、整数p）{
jobId=j；
截止日期=d；
利润=p；
}
公共int getProfit（）{
利润回报；
}
@凌驾
公共内部比较（作业o）{
返回Comparator.comparingInt（整数：：intValue）。
比较（this.getProfit（），o.getProfit（））；
}
}
公共类职位分配问题{
公共静态void main（字符串参数[]）{
列表=新的ArrayList（）；
增加（新工作（'a'，2100））；
增加（新工作（'b'，1，19））；
增加（新工作（'c'，2，27））；
增加（新工作（'d'，1，25））；
增加（新工作（'e'，3，15））；
sort（Comparator.naturalOrder（））；
}
}
在这种情况下，“naturalOrder”将从Java 8中的可比较实现中推导出来，您还可以执行Comparator cmp=Comparator.comparingit（job->job.profit.getProfit（））。请注意，sequence（）
方法在这两种方法中都没有任何作用。@shmosel您的评论中有太多的利润（双关语）。但它可以变得更简单；）你说得对。在Java8中，您还可以执行Comparator cmp=Comparator.comparingit（job->job.profit.getProfit（））。请注意，sequence（）
方法在这两种方法中都没有任何作用。@shmosel您的评论中有太多的利润（双关语）。但它可以变得更简单；）你说得对。我被原文中那些无用的变量弄糊涂了。
class Job {
char jobId;
int deadLine;
int profit;
public Job(char j, int d, int p) {
jobId = j;
deadLine = d;
profit = p;
}
public int getProfit() {
return profit;
}
}
public class JobSequencingProblem {
public static void main(String args[]) {
List<Job> list = new ArrayList<>();
list.add(new Job('a', 2, 100));
list.add(new Job('b', 1, 19));
list.add(new Job('c', 2, 27));
list.add(new Job('d', 1, 25));
list.add(new Job('e', 3, 15));
list.sort(Comparator.comparingInt(Job::getProfit));
}
}
class Job implements Comparable<Job> {
char jobId;
int deadLine;
int profit;
public Job(char j, int d, int p) {
jobId = j;
deadLine = d;
profit = p;
}
public int getProfit() {
return profit;
}
@Override
public int compareTo(Job o) {
return Comparator.comparingInt(Integer::intValue).
compare(this.getProfit(), o.getProfit());
}
}
public class JobSequencingProblem {
public static void main(String args[]) {
List<Job> list = new ArrayList<>();
list.add(new Job('a', 2, 100));
list.add(new Job('b', 1, 19));
list.add(new Job('c', 2, 27));
list.add(new Job('d', 1, 25));
list.add(new Job('e', 3, 15));
list.sort(Comparator.naturalOrder());
}
}