Looking through class Arraylist objects without nested loops

I had this object oriented programming project last semester and it was all about simulating a simple dormitory.

1.There should have been a manager class in which the main method and like 80 percent of the other methods had to be there.
2.A dormitory class containing an arraylist of blocks.
3.A block class containing an arraylist of rooms.
4.A room class containing an arraylist of students.
5.All of these classes contained getters and setters for their private variables.

There were a few methods that we should've added to the program which has nothing to do with my question,so I will not write them in here,but the thing is,a few of theses methods needed to look through these arraylists to find a specific object.For example,a student with a specific student number.I created these methods with nested loops.But I know there is some way I could avoid heavy nesting.

Here is my reduced code.I will only let the manager class contain one nested loop method as an example:

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

I tried my best to reduce the code.
I searched a lot and asked a lot of people about this but I didn't get my desired answer.I'm not sure why I couldn't find anything about this,but I'd really appreciate it if you'd lend me a hand or give me the link of a related article.

Short answer: No, you should never loop through everything checking for getStudentNumber().equals(studentNum). This has linear time complexity O(N)

Long answer: You should index your data based on your queries

Eg: Indexing with HashMaps which have constant time complexity O(1). (Note: This code is not thread safe)

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
}

The following quote is from tutorialspoint. This is the perfect use case of the forEach method from the Stream interface. The link I provided and further reading on Streams can help avoid repetitive code.
> Using collections framework in Java, a developer has to use loops and make repeated checks. Another concern is efficiency; as multi-core processors are available at ease, a Java developer has to write parallel code processing that can be pretty error-prone.

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

You can also read about parallelStreams from here.