Создать класс Группа, содержащая два массива - Имена и Оценки

public class Group implements Cloneable, Comparable<Group> {
    private static double passingScore;
 
    private List<String> studentNames;
 
    private List<Double> studentScores;
 
    public Group() {
        this.studentNames = new ArrayList<>();
        this.studentScores = new ArrayList<>();
    }
 
    public Group(Group other) {
        this.studentNames = other.getStudentNames();
        this.studentScores = other.getStudentScores();
    }
 
    public void addStudent(String name, double score) {
        studentNames.add(name);
        studentScores.add(score);
    }
 
    public List<String> getStudentNames() {
        return Collections.unmodifiableList(studentNames);
    }
 
    public List<Double> getStudentScores() {
        return Collections.unmodifiableList(studentScores);
    }
 
    public double getAverage() {
        return studentScores.stream()
                .mapToDouble(i -> i)
                .average()
                .getAsDouble();
    }
 
    @Override
    public String toString() {
        StringJoiner joiner = new StringJoiner("\n", "Students:\n", "\n");
 
        for (int i = 0; i < studentNames.size(); i++) {
            String studentName = studentNames.get(i);
            double studentScore = studentScores.get(i);
 
            joiner.add(studentName + " : " + studentScore);
        }
 
        return "Group:\n" +
                "  passing score: " + passingScore + '\n' +
                joiner;
    }
 
    @Override
    protected Object clone() throws CloneNotSupportedException {
        try {
            return super.clone();
        } catch (CloneNotSupportedException e) {
            return new Group(this);
        }
    }
 
    @Override
    public int compareTo(Group other) {
        return Double.compare(this.getAverage(), other.getAverage());
    }
 
    public static void setPassingScore(double passingScore) {
        Group.passingScore = passingScore;
    }
 
    public static double getPassingScore() {
        return passingScore;
    }
}

public class Main {
    public static void main(String[] args) throws CloneNotSupportedException {
        Group.setPassingScore(3.50);
 
        Group group = new Group();
        group.addStudent("Ivanov", 3.22);
        group.addStudent("Petrov", 4.91);
        group.addStudent("Kozlov", 3.79);
 
        Group clone = (Group) group.clone();
 
        System.out.println(group);
        System.out.println(clone);
 
        Group passingGroup = getPassingGroup(clone);
 
        System.out.println(passingGroup);
 
        System.out.println(group.compareTo(passingGroup));
    }
 
    private static Group getPassingGroup(Group source) throws CloneNotSupportedException {
        Map<String, Double> map = filterByPassingScore(createMap(source.getStudentNames(), source.getStudentScores()));
 
        Group result = new Group();
 
        map.forEach(result::addStudent);
 
        return result;
    }
 
    private static Map<String, Double> createMap(List<String> names, List<Double> scores) {
        return IntStream.range(0, names.size())
                .boxed()
                .collect(toMap(names::get, scores::get));
    }
 
    private static Map<String, Double> filterByPassingScore(Map<String, Double> map) {
        return map.entrySet().stream()
                .filter(entry -> entry.getValue() >= Group.getPassingScore())
                .collect(toMap(Map.Entry::getKey, Map.Entry::getValue));
    }
}

@Override
protected Object clone() throws CloneNotSupportedException {
        return new Group(this);
}

public Group(Group other) {
        studentNames = new ArrayList<>(other.getStudentNames());
        studentScores = new ArrayList<>(other.getStudentScores());
}

package com.example.studentgroup;
 
import androidx.annotation.NonNull;
 
import java.util.ArrayList;
 
public class Group implements Comparable, Cloneable {
    public Group() {
    }
 
    static private double prohodnoy_ball = 21.5; // статичная переменная проходного балла (базовая для всех)
 
 
    /*
    почему в задании написано 2 массива, если можно сделать одним Map<K, V> - непонятно.
    так и проще и лучше. ну ладно...
     */
    private ArrayList<String> names = new ArrayList<>(); // массив имен
    private ArrayList<Double> ball = new ArrayList<>(); // массив балов
 
 
    @Override
    public String toString() {
 
        /*
        красивый toString группы.
        т.к. в задании 2 массива, нам приходится всю дорогу сопостовлять ИМЯ и ОЦЕНКУ по ID в массивах
         */
        String ret = "Group { ";
        for (int i = 0; i < names.size(); i++) {
            ret += names.get(i) + " = " + ball.get(i) + "; ";
        }
        ret += "средний балл = " + this.sr_ball(); // заодно посчитаем средний балл
        ret += " }";
        return ret;
 
 
    }
 
    // добавление студента
    public void add_student(String s, Double d) {
        names.add(s);
        ball.add(d);
    }
 
    // удаление студента по имена без учета регистра
    public void del_student(String name) {
        int x = 0;
 
        for (String i : names) { // перебираем все имена в массиве
            if (i.equalsIgnoreCase(name)) { // и если есть воспадение без учета регистра
                x = names.indexOf(i); // узнаем его ID
                names.remove(x); // и удалим ИМЯ по ID
                ball.remove(x); // и ОЦЕНКУ по ID
                return; // дальше не ищем. выходим из перебора
            }
        }
    }
 
 
    public Group new_semestr() {
        Group new_gropup = new Group(); // создаем новую пустую группу
        for (int i = 0; i < ball.size(); i++) { // перебираем текущую по оценкам
            if (ball.get(i) >= prohodnoy_ball) { // если оценка больше проходного балла
                new_gropup.add_student(names.get(i), ball.get(i)); // в новую группу добавляем этого студента
            }
        }
        return new_gropup;
    }
 
 
    // новый проходной балл
    static public void new_prohodnou_ball(double a) {
        prohodnoy_ball = a;
    }
 
 
    // средний балл. используется только внутри класса для сортировка и метода toString()
    private double sr_ball() {
        double s = 0;
        for (double d : ball) {
            s += d;
        }
        s /= ball.size();
        return s;
    }
 
 
    // сортировка
    @Override
    public int compareTo(Object o) {
        Group g = (Group) o;
        if (this.sr_ball() > g.sr_ball()) return -1;
        else if (this.sr_ball() < g.sr_ball()) return 1;
        else return 0;
    }
 
 
    // клонирование
    @NonNull
    @Override
    protected Group clone() {
        Group g = new Group();
        g.names.addAll(this.names);
        g.ball.addAll(this.ball);
        return g;
    }
}

        // создание и вывод группы студентов и их оценок
        Group group = new Group();
        group.add_student("Wasya", 52.2);
        group.add_student("Misha", 14.7);
        group.add_student("Kostya", 9.0);
        group.add_student("Wlad", 30.7);
        group.add_student("Uber", 18.2);
        Log.e("!!!!", "Создание группы студентов");
        Log.e("!!!!", "" + group);
        Log.e("!!!!", "....................");
 
 
        // удаление студента по имени, без учета регистра
        group.del_student("uber");
        group.del_student("wLAd");
        Log.e("!!!!", "удаление студента по имени, без учета регистра");
        Log.e("!!!!", "" + group);
        Log.e("!!!!", "....................");
        // добавим удаленных назад
        group.add_student("Wlad", 30.7);
        group.add_student("Uber", 18.2);
 
 
        // создание новой группы, на основе проходного балла
        Group b = group.new_semestr();
        Log.e("!!!!", "создание новой группы, на основе проходного балла");
        Log.e("!!!!", "" + b.toString());
        Log.e("!!!!", "....................");
 
        // изменение проходного балла для всех
        Group.new_prohodnou_ball(10); // между этими двумя строчками разницы нет
        Group c = group.new_semestr();
        Log.e("!!!!", "изменение проходного балла для всех");
        Log.e("!!!!", "" + c.toString());
        Log.e("!!!!", "....................");
 
 
        // сортировка массива групп от лучшей к худшей (по оценкам)
        ArrayList<Group> arr = new ArrayList<>();
        arr.add(group);
        arr.add(b);
        arr.add(c);
        Log.e("!!!!", "сортировка массива групп от лучшей к худшей (по оценкам)");
        Log.e("!!!", "" + arr);
        Collections.sort(arr);
        Log.e("!!!", "" + arr);
        Log.e("!!!!", "....................");
 
 
        // клонирование объекта
        Group group1 = group.clone();
        group1.add_student("rrr", 88.4);
        Log.e("!!!!", "клонирование объекта ");
        Log.e("!!!!", "" + group);
        Log.e("!!!!", "" + group1);
        Log.e("!!!!", "....................");

@Override
public Group clone() {
    try {
        Group clone = (Group) super.clone();
            
        clone.studentNames = new ArrayList<>(this.studentNames);
        clone.studentScores = new ArrayList<>(this.studentScores);
 
        return clone;
    } catch (CloneNotSupportedException e) {
        throw new AssertionError();
    }
}