-2

さまざまなことを行うクラスを作成しました。配列リスト内のユーザー数をカウントするためにループを使用しようとしています。基本的に、クラスは生徒に関する情報を取得し、その情報を追加します。入力されているものの 1 つは、学生が取得している単位数です。配列リストに 5 人の生徒を入力したとします。2 人の学生が 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

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 に答える