查看没有嵌套循环的类 Arraylist 对象

Question

上学期我有一个面向对象的编程项目，就是模拟一个简单的宿舍。

1. 应该有一个管理器类，其中主要方法和其他 80% 的方法必须存在。 2.一个宿舍类，包含一个数组列表。 3.包含房间数组列表的块类。 4.一个包含学生数组列表的房间类。 5.所有这些类都包含用于其私有变量的 getter 和 setter。

有一些我们应该添加到程序中的方法与我的问题无关，所以我不会在这里写它们，但问题是，其中一些方法需要查看这些arraylists 来查找特定对象。例如，具有特定学号的学生。我使用嵌套循环创建了这些方法。但我知道有一些方法可以避免大量嵌套。

这是我的简化代码。我将只让管理器类包含一个嵌套循环方法作为示例：

import java.util.Scanner;

public class Manager {

    private String name;
    private String familyName;
    private String userName;
    private String passWord;

    private static Scanner scan = new Scanner(System.in);
    private Dormitory dorm = new Dormitory();
    private static Menu menu = new Menu();
    private Student tempStudent;
    private Block tempBlock;
    private Room room;
    private boolean bool;

    {
        dorm.setDormManager(this);
    }

    public Manager(String managerName, String managerID) {
        name = managerName;
        userName = managerID;
    }

    //find student with its number
    public void findStudent() {
        //Taking the student number from the user.
        System.out.println("Please enter the student number:");
        String studentNum = scan.nextLine();
        for (int i = 0; i < dorm.getBlockList().size(); i++)
            for (int j = 0; j < dorm.getBlockList().get(i).getRooms().size(); j++)
                for (int k = 0; k < dorm.getBlockList().get(i).getRooms().get(j).getRoomStudents().size(); k++)
                    if (dorm.getBlockList().get(i).getRooms().get(j).getRoomStudents().get(k).getStudentNumber().equals(studentNum)) {
                        tempStudent = dorm.getBlockList().get(i).getRooms().get(j).getRoomStudents().get(k);
                        break;
                    }
    }

    public void create() {
        //Used loops for the original program.
        Block block1 = new Block("1");
        Block block2 = new Block("2");
        dorm.getBlockList().add(block1);
        dorm.getBlockList().add(block2);
        Room room1 = new Room("1");
        Room room2 = new Room("2");
        dorm.getBlockList().get(0).getRooms().add(room1);
        dorm.getBlockList().get(1).getRooms().add(room2);
        Student student1 = new Student("12345678");
        Student student2 = new Student("98765432");
        dorm.getBlockList().get(0).getRooms().get(0).getRoomStudents().add(student1);
        dorm.getBlockList().get(1).getRooms().get(0).getRoomStudents().add(student2);
    }

    public static void main(String[] args) {
        Manager manager = new Manager("Dumbledore", "@1112");
        manager.create();
    }
}

public class Dormitory {

    private int blocks;
    private Manager dormManager;
    private long allMembers;
    private ArrayList<Block> blockList = new ArrayList<Block>();
}

public class Block {

    private String blockNumber;
    private ArrayList<Room> rooms = new ArrayList<Room>();
    private Dormitory dorm = new Dormitory();

    public Block(String blockNum) {
        blockNumber = blockNum;
    }
}

public class Room {

    private String roomNumber;
    private ArrayList<Student> roomStudents = new ArrayList<Student>();
    private Block roomBlock;
    private Student roomManager;

    public Room(String roomNum) {
        roomNumber = roomNum;
    }
}

public class Student {

    private String studentName;
    private String studentFamilyName;
    private String studentNumber;
    private Room room;

    public Student(String studentNum) { //Creates a student object using the student number.
        studentNumber = studentNum;
    }
}

我尽力减少代码。 我搜索了很多，问了很多人，但我没有得到我想要的答案。我不知道为什么我找不到任何关于这个的东西，但如果你能借给我，我会非常感激帮忙或者给我相关文章的链接。

Answer 1

以下引用来自tutorialspoint。这是来自Stream 接口的forEach 方法的完美用例。我提供的链接和有关 Streams 的进一步阅读有助于避免重复代码。

使用 Java 中的集合框架，开发人员必须使用循环并进行重复检查。另一个问题是效率。由于多核处理器可以轻松使用，Java 开发人员必须编写可能非常容易出错的并行代码处理。

dorm.getBlockList().stream().forEach((b) -> {
    b.getRooms().stream().forEach((r) -> {
        ...
    })
});

您还可以从here 阅读有关parallelStreams 的信息。

Answer 2

简短回答：不，您永远不应该遍历所有检查 getStudentNumber().equals(studentNum) 的内容。这有linear time complexity O(N)

长答案：您应该根据您的查询索引您的数据

例如：使用具有constant time complexity O(1) 的 HashMap 进行索引。 （注意：这段代码不是线程安全的）

public class SchoolService {
    private Map<String, Student> studentsById = new HashMap<>();
    private Map<Long, Dorm> dormsById = new HashMap<>();

    /// dormsByAreaCode is showing an example of an index which groups objects into lists
    private Map<String, List<Dorm>> dormsByAreaCode = new HashMap<>();

    public void addStudent(Student student) {
       if (studentsById.containsKey(student.getName()) {
           throw new IllegalStateException("Duplicate student " + student.getName());
       }
       studentsById.put(student.getId(), student);
    }

    public Student getStudentById(String studentId) {
       Student student = studentsById.get(studentId);
       if (student == null) {
           throw new IllegalStateException("No such student " + studentId);
       }
       return student;
    }

    public void addDorm(Dorm dorm) {
        // TODO: validation
        dormsById.put(dorm.getId(), dorm);
        List<Dorm> areaDorms = dormsByAreaCode.get(dorm.getAreaCode());
        if (areaDorms == null) {
            areaDorms = new ArrayList<>();
            dormsByAreaCode.put(dorm.getAreaCode(), areaDorms);
        }
        areaDorms.add(dorm);
    }

    public Dorm getDormById(long dormId) {
        Dorm dorm = dormsById.get(id);
        // TODO: validation
        return dorm;
    }

    public List<Dorm> getDormsByAreaCode(String areaCode) {
        List<Dorm> areaDorms = dormsByAreaCode.get(areaCode);
        // TODO: validation
        return areaDorms;
    }

    // etc
}