Question

我写了一个做不同事情的课程。我试图用一个循环来计算数组列表中的用户数。基本上，班级正在获取信息并添加有关学生的信息。输入的其中一项是学生参加的学分数量。假设我在我的阵列列表中输入了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;

Answer 1

你正在遍历数组，但你没有做任何事情。您应该从列表中取出每个学生并检查建议的条件。我没有把代码放在一边，因为我认为这是你的功课部分。

Answer 2

你需要这样的东西：

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++;
   }
}

Answer 3

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

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

中

 int count =0;
    for (int i = 0; i < studentList.size(); i++)
        count = (creditList.get(i)== credits)?count+1:count;

Answer 4

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

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

上面的示例假设您有某种Student课程，并使用getNumberOfCredits()方法返回学生正在学习的学分数。没有看到你的代码，这是我最好的猜测。

另请注意，由于列表中每个学生的位置并不重要，您可以使用enhanced for-loop使代码更清晰：

for (Student student : studentList) {
    if (student.getNumberOfCredits() == credits) {
        count++;
    }
}

Answer 5

这是一个更具功能性的谓词和过滤器方法。

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);
    }
}

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

数组列表和计数循环

5 个答案: