搜索特定元素是否已存在于ArrayList中

时间：2015-01-07 10:05:20

标签： java

我有一个成绩，科目和年份的列表，但是我想这样做，以便检查某个科目和年份是否已经有成绩，我无法弄清楚如何在名单。 

public List<Nota> notas;
public Double notaMedia;

//Constructor
public ExpedienteImpl() {
    this.notas = new ArrayList<Nota>();
    this.notaMedia = getNotaMedia();
}

private void checkNota(Integer cursoAcademico, TipoConvocatoria tipoConvocatoria, Asignatura asignatura){
    if (this.notas.contains()){

    }
}

这样的事情就是我所做的，但是包含只适用于一个对象（？），我想搜索Nota字段中是否存在给定cursoAcademico，tipoConvocatoria和asignatura（course，subject）的任何内容。

Nota的代码：

public interface Nota {

Asignatura getAsignatura();

Integer getCursoAcademico(); //Dado por el primer año del curso, eg: 2014/15 -> 2014

TipoConvocatoria getTipoConvocatoria(); //Primero, segundo o tercero

Double getValorNota();
TipoNota getTipoNota(); //0-5 Supenso, 5-7 Aprobado, 7-9 Notable, 9-10 Sobresaliente, 9-10 + mención = Matrícula de Honor,  
Boolean getMencionHonor();


}

public class NotaImpl implements Nota {

//Atributos
private Integer cursoAcademico;
private TipoConvocatoria tipoConvocatoria;
private Double valorNota;
private TipoNota tipoNota;
private Boolean mencionHonor;
private Asignatura asignatura;

//Constructores
public NotaImpl(Asignatura asignatura, Integer cursoAcademico, TipoConvocatoria tipoConvocatoria, Double valorNota, TipoNota tipoNota, Boolean mencionHonor) {
    checkerNumero(valorNota);
    checkerMencion(mencionHonor, valorNota);
    this.cursoAcademico = cursoAcademico;
    this.tipoConvocatoria = tipoConvocatoria;
    this.tipoNota = tipoNota;
    this.valorNota = valorNota;
    this.mencionHonor = mencionHonor;
}

不确定是否需要更多。

4 个答案:

答案 0 :(得分：0)

您可以遍历整个列表，然后将每个对象的字段与参数进行比较。

答案 1 :(得分：0)

你必须遍历列表，获取对象并进行比较。 最简单的方法是用标记等创建一个nota对象。 覆盖Nota的equals方法。

现在， 使用contais检查它是否存在。

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

public class ExpedienteImpl {

    public List<Nota> notas;
    public Double notaMedia;

    //Constructor
    public ExpedienteImpl() {
        this.notas = new ArrayList<Nota>();
        this.notaMedia = getNotaMedia();
    }

    private Double getNotaMedia() {
        // TODO Auto-generated method stub
        return null;
    }

    private void checkNota(Integer cursoAcademico, TipoConvocatoria tipoConvocatoria, Asignatura asignatura){
        Nota objNota = new NotaImpl(asignatura, cursoAcademico, tipoConvocatoria, 0.0, null, null);
        if(notas.contains(objNota)){
                System.out.println("Nota matched");
        }
    }

}

interface Nota {

Asignatura getAsignatura();

Integer getCursoAcademico(); //Dado por el primer año del curso, eg: 2014/15 -> 2014

TipoConvocatoria getTipoConvocatoria(); //Primero, segundo o tercero

Double getValorNota();
TipoNota getTipoNota(); //0-5 Supenso, 5-7 Aprobado, 7-9 Notable, 9-10 Sobresaliente, 9-10 + mención = Matrícula de Honor,  
Boolean getMencionHonor();


}

class NotaImpl implements Nota {

//Atributos
private Integer cursoAcademico;
private TipoConvocatoria tipoConvocatoria;
private Double valorNota;
private TipoNota tipoNota;
private Boolean mencionHonor;
private Asignatura asignatura;

//Constructores
public NotaImpl(Asignatura asignatura, Integer cursoAcademico, TipoConvocatoria tipoConvocatoria, Double valorNota, TipoNota tipoNota, Boolean mencionHonor) {
    checkerNumero(valorNota);
    checkerMencion(mencionHonor, valorNota);
    this.cursoAcademico = cursoAcademico;
    this.tipoConvocatoria = tipoConvocatoria;
    this.tipoNota = tipoNota;
    this.valorNota = valorNota;
    this.mencionHonor = mencionHonor;
}

private void checkerMencion(Boolean mencionHonor2, Double valorNota2) {
    // TODO Auto-generated method stub

}

private void checkerNumero(Double valorNota2) {
    // TODO Auto-generated method stub

}

@Override
public Asignatura getAsignatura() {
    return null;
}

@Override
public Integer getCursoAcademico() {
    // TODO Auto-generated method stub
    return null;
}

@Override
public TipoConvocatoria getTipoConvocatoria() {
    // TODO Auto-generated method stub
    return null;
}

@Override
public Double getValorNota() {
    // TODO Auto-generated method stub
    return null;
}

@Override
public TipoNota getTipoNota() {
    // TODO Auto-generated method stub
    return null;
}

@Override
public Boolean getMencionHonor() {
    // TODO Auto-generated method stub
    return null;
}

public boolean equals(Nota nota){
    if(this.getCursoAcademico().equals(nota.getCursoAcademico()))
        return true;
    return false;
}
}


class Asignatura{
}

class TipoConvocatoria{

}

class TipoNota{

}

以满足您的平等标准的方式更新equals方法。

答案 2 :(得分：0)

如果您使用Java 8，则可以使用Stream API：s。

// Filter out all Nota-objects that match the provided input
// and store them in a list
final List<Nota> filtered = this.notas.stream()
    .filter(nota -> {
        return nota.getCursoAcademico().equals(cursoAcademico) &&
                nota.getTipoConvocatoria().equals(tipoConvocatoria) &&
                nota.getAsignatura().equals(asignatura);
    })
    .collect(Collectors.toList());

// Or, count the number of matching objects
final long count = this.notas.stream()
    .filter(nota -> {
        return nota.getCursoAcademico().equals(cursoAcademico) &&
               nota.getTipoConvocatoria().equals(tipoConvocatoria) &&
               nota.getAsignatura().equals(asignatura);
    })
    .count();

这样，只要TipoConvocatoria和Asignatura等于方法，您就可以过滤掉匹配项。

您可以阅读有关溪流here的更多信息，您可以特别查看filter - 方法。

答案 3 :(得分：0)

在C＃中，这将是：

public class Grade{
    public int Mark { get; set; }
    public string Subject { get; set; }
    public int Year { get; set; }
}

现在假设您有一些数据

var grades = new List<Grade>()
{
    new Grade() {Mark = 3, Subject = "Calculus II", Year = 2015},
    new Grade() {Mark = 2, Subject = "Calculus II", Year = 2014}
};
var grade = new Grade() {Mark = 10, Subject = "Calculus II", Year = 2015};

如果您想检查是否存在具有相同主题和年份的成绩，您可以写下：

if (!grades.Any(o => o.Subject == grade.Subject && o.Year == grade.Year))
{//does not exists - add
    grades.Add(grade);
}
else
{//exists

}

在Java 1.4,1.5,6,7中你没有lambda＆s;写这个有点麻烦，因为它需要相当多的样板代码。然而，有Google Guava正式称为Google Collections，它增加了对java 6的支持（它曾经是java 1.5，但不确定atm。）。还有一个名为Appache Collections的替代方案，在很大程度上做同样的事情有点不同。

无论如何你写

Predicate<Integer> isEven = new Predicate<Grade>() {
    @Override public boolean apply(Grade item) {
        return item.Subject == grade.Subject && item.Year == grade.Year;
    }               
};
if (Iterables.filter(grades, isEven).isEmpty())
{//does not exists - add
    grades.Add(grade);
}
else
{//exists

}

这会滥用Java中匿名函数的变量范围可见性，但它非常干净且易于阅读，性能卓越，应该可以使用Java 1.5。如果iterables没有 .isEmpty（），则它与 .size（）＆lt; = 0 大致相同。 （遗憾的是，我没有因为编写Java而获得报酬，所以不要让dev环境准备好检查，这只是从内存中写的。）

相关问题
最新问题