-2

我写了一个做不同事情的类。我正在尝试使用循环来计算数组列表中的用户数。基本上，班级正在获取信息并添加有关学生的信息。输入的内容之一是学生所学的学分。假设我在我的数组列表中输入了 5 个学生。两个学生修了 5 个学分 2 个学生修了 6 个学分，最后一个学生修了 9 个学分。我在课堂上创建了一些代码，假设用户想知道数组中有多少学生正在学习 6 个学分。所以我创建了一个段，让用户输入该数字，班级将在数组中查找并返回有多少学生正在使用该数字，但它不起作用。我不知道这是否有意义

    System.out.print("Please enter a number of credits:\n");
      inputInfo = stdin.readLine().trim();
   int credits = Integer.parseInt(inputInfo);

     int count = 0;


    for (int i = 0; i < studentList.size(); ++i)
      {
        count++;
       }   


      System.out.println("The number of students who are taking " + credits
                           + " credits is: " + count);

       break;
4

5 回答 5

2

您正在遍历数组，但您并没有对它做任何事情。您应该从列表中选择每个学生并检查建议的条件。我没有放代码，因为我认为这是你的作业部分。

于 2013-09-19T16:21:44.000 回答
1

你将需要这样的东西：

for (int i = 0; i < studentList.size(); i++) {
   Student student = studentList.get(i);
   if (student.getCredits() == credits) {
      count++;
   }
}

更好地使用这种方式来迭代你的列表：

for (Student student : studentList) {
   if (student.getCredits() == credits) {
      count++;
   }
}
于 2013-09-19T16:21:43.500 回答
0

你有 ; ++i 在你的循环中，但你不想要 i++ 吗？

您还想检查特定学生的学分是否等于用户输入的学分值。假设个别学生的学分存储在 arrayList creditList 中：

 int count =0;
    for (int i = 0; i < studentList.size(); i++)
        count = (creditList.get(i)== credits)?count+1:count;
于 2013-09-19T16:22:15.897 回答
0

您需要credits与某些东西进行比较。现在，你只是在count每次循环中递增（这总是导致count == studentList.size()）。您想要的是检查每个学生是否正在学习该数量的学分：

for (int i = 0; i < studentList.size(); ++i) {
    if (studentLost.get(i).getNumberOfCredits() == credits) {
        count++;
    }
}

上面的示例假设您有某种类，Student该类具有getNumberOfCredits()返回学生所学学分的方法。没有看到你的代码，这是我最好的猜测。

另请注意，由于每个学生在列表中的位置并不重要，您可以使用增强的 for 循环来使您的代码更简洁：

for (Student student : studentList) {
    if (student.getNumberOfCredits() == credits) {
        count++;
    }
}
于 2013-09-19T16:22:46.150 回答
0

这里使用谓词和过滤器的更实用的方法。

public class StudentCredit {
    public static void main(String[] args) {
        List<Student> students = Arrays.asList(new Student(5), new Student(5),
                new Student(6), new Student(6), new Student(9));
        final int six = 6;
        Predicate<Student> hasSixCredits = new Predicate<Student>() {
            public boolean isTrue(Student object) {
                return object.getCredit() == six;
            }
        };
        List<Student> studentsWithSix = Filter.filter(students, hasSixCredits);
        System.out.println("Number of students with " + six + " credits is: "
                + studentsWithSix.size());

        Filter<Student> filter = new Filter<Student>();
        List<Student> result = filter.apply(students);
        System.out.println("Apply empty filter. #students: " + result.size());

        List<Student> otherResult = filter.setPredicate(hasSixCredits).apply(
                students);
        System.out.println("Apply 6-credits filter. #students: " + otherResult.size());
    }
}

class Student {
    private final int credit;

    public Student(int credit) {
        this.credit = credit;
    }

    public int getCredit() {
        return credit;
    }
}

interface Predicate<T> {
    /* tautology - always true */
    public static final Predicate<Object> ALWAYS_TRUE = new Predicate<Object>() {
        public boolean isTrue(Object object) {
            return true;
        }
    };

    /* contradiction - always false */
    public static final Predicate<Object> ALWAYS_FALSE = new Predicate<Object>() {
        public boolean isTrue(Object object) {
            return false;
        }
    };

    public boolean isTrue(T object);
}

final class Filter<T> {
    private Predicate<? super T> predicate = Predicate.ALWAYS_TRUE;

    public Filter() {
    }

    public Filter<T> setPredicate(Predicate<? super T> predicate) {
        this.predicate = predicate;
        return this;
    }

    public List<T> apply(List<T> list) {
        List<T> filtered = new ArrayList<T>();
        for (T element : list)
            if (predicate.isTrue(element))
                filtered.add(element);
        return filtered;
    }

    public static <T> List<T> filter(List<T> list, Predicate<? super T> predicate) {
        return new Filter<T>().setPredicate(predicate).apply(list);
    }
}

使用这种方法，您还可以创建其他谓词，而无需进行计数。您唯一关心的是谓词的逻辑。

于 2013-09-19T16:33:33.680 回答