Maps of sObjects

List<Account> accounts = [SELECT Id, Name, Industry FROM Account];
Map<Id, Account> accountsById = new Map<Id, Account>(accounts);

Id someAccountId = accounts[0].Id;
System.debug(accountsById.get(someAccountId).Name);

1. List<Account> accounts = [SELECT Id, Name, Industry FROM Account]; — a SOQL query returning a List<Account>.
2. Map<Id, Account> accountsById = new Map<Id, Account>(accounts); — passing a List<Account> directly into new Map<Id, Account>(...) automatically builds a map keyed by each record's Id — no manual loop needed.
3. (blank line)
4. Id someAccountId = accounts[0].Id; — grabs one real Id from the query results.
5. System.debug(accountsById.get(someAccountId).Name); — looks it up instantly through the map. This is such a common pattern that Apex has built-in support for it.

// DON'T DO THIS — a query inside a loop
for (Opportunity opp : opportunities) {
    Account acc = [SELECT Name FROM Account WHERE Id = :opp.AccountId]; // a query per iteration!
    System.debug(acc.Name);
}

1. // DON'T DO THIS — a query inside a loop — the label says it all.
2. for (Opportunity opp : opportunities) { — loops over every opportunity.
3. Account acc = [SELECT Name FROM Account WHERE Id = :opp.AccountId]; — a separate query runs for every single opportunity.
4. System.debug(acc.Name); — uses the result.
5. } — closes the loop.

List<Opportunity> opportunities = [SELECT Id, AccountId FROM Opportunity];

Set<Id> accountIds = new Set<Id>();
for (Opportunity opp : opportunities) {
    accountIds.add(opp.AccountId);
}

Map<Id, Account> accountsById = new Map<Id, Account>(
    [SELECT Id, Name FROM Account WHERE Id IN :accountIds]
);

for (Opportunity opp : opportunities) {
    Account relatedAccount = accountsById.get(opp.AccountId);
    System.debug(relatedAccount.Name);
}

1. List<Opportunity> opportunities = [SELECT Id, AccountId FROM Opportunity]; — one query, run once.
2. (blank line)
3. Set<Id> accountIds = new Set<Id>(); — a Set to collect unique Account Ids, deduplicating automatically (this module's first lesson).
4. for (Opportunity opp : opportunities) { — loops over the opportunities already in memory — no querying here.
5. accountIds.add(opp.AccountId); — collects the id, duplicates silently ignored.
6. } — closes the loop.
7. (blank line)
8. Map<Id, Account> accountsById = new Map<Id, Account>( — builds a lookup map...
9. [SELECT Id, Name FROM Account WHERE Id IN :accountIds] — ...from a second query, but only ever one, fetching exactly the needed Accounts.
10. ); — closes the constructor call.
11. (blank line)
12. for (Opportunity opp : opportunities) { — loops again over the same in-memory list.
13. Account relatedAccount = accountsById.get(opp.AccountId); — an instant map lookup, no query.
14. System.debug(relatedAccount.Name); — uses the result.
15. } — closes the loop.

One query collects the needed Account Ids, one query fetches those Accounts, and the Map makes every subsequent lookup instant — regardless of how many opportunities there are. This exact pattern reappears constantly in later modules on triggers and bulkification.