The FRQ

  1. A high school club maintains information about its members in a MemberInfo object. A MemberInfo object stores a club member’s name, year of graduation, and whether or not the club member is in good standing. A member who is in good standing has fulfilled all the responsibilities of club membership.

A partial declaration of the MemberInfo class is shown below.

public class MemberInfo
{
/** Constructs a MemberInfo object for the club member with name name,
* graduation year gradYear, and standing hasGoodStanding.
*/
public MemberInfo (String name, int gradYear, boolean hasGoodStanding)
{ /* implementation not shown */ }

/ ** Returns the graduation year of the club member. */
public int getGradYear ()
{ /* implementation not shown */ }

/ ** Returns true if the member is in good standing and false otherwise. */
public boolean inGoodStanding()
{ /* implementation not shown */ }

// There may be instance variables, constructors, and methods that are not shown.

}

The ClubMembers class maintains a list of current club members. The declaration of the
ClubMembers class is shown below.

public class ClubMembers
{

*

private ArrayList<MemberInfo> memberList;

/** Adds new club members to memberList, as described in part (a).
Precondition: names is a non-empty array. **/
}

public void addMembers (String[] names, int gradYear)
{ /* to be implemented in part (a) */ }

/** Removes members who have graduated and returns a list of members who have graduated
* and are in good standing, as described in part (b).
*/
public ArrayList<MemberInfo> removeMembers (int year)
{ /* to be implemented in part (b) */ }

// There may be instance variables, constructors, and methods that are not shown.

Penalties:

1. Array/Collection Access Confusion

Make sure is use [] for arrays and .get(index) for ArrayList.

int[] arr = {1, 2, 3};
System.out.println(arr[0]); // Correct for arrays

ArrayList<Integer> list = new ArrayList<>();
list.add(10);
System.out.println(list.get(0)); // Correct for ArrayLists

2. Extraneous Code:

  • Avoid unnecessary code that doesn’t align with the problem’s requirements
  • This would include unnecessary pringting or extra logic

3. Local variables used but not declared

  • always declare local variables before using them
int total = 0; // Declare the variable first
total += 5;    // Use it after declaration

4. Destruction of Persistent data

  • Don’t unintentionally modify objects passed as parameters unless explicitly asked.

5. Void method returning

  • Methods declared void cannot return a value. return type specified in the method signature

Free Points

1. Declare class header

  • always begin with a correct class declaration:
public class ClubMembers {
    // Class content here
}

2. Declare variables

  • Ensure to identitfy and declare the necessary instance variables
  • The problem above specifies that the memberList as an ArrayList of MemberInfo objects:
private ArrayList<MemberInfo> memberList;

3. Constructor

  • Ensure that ClubMembers constructor initializes memberList:
public ClubMembers() {
    memberList = new ArrayList<>();
}

4. length/size confusion for array

  • length/size confusion for array, String, List, or ArrayList with or without () Extraneous [] when referencing entire array

Part A

Write the ClubMembers method addMembers, which takes two parameters. The first parameter is a String array containing the names of new club members to be added. The second parameter is the graduation year of all the new club members. The method adds the new members to the memberList instance variable. The names can be added in any order. All members added are initially in good standing and share the same graduation year, gradYear.

Complete the addMembers method.

  • Adds new club members to memberList, as described in part (a).
  • Precondition: names is a non-empty array.
  • public void addMembers (String[] names, int gradYear)

Helpful Acronym

P.L.A.N

  1. P: Parameter and Return Type
  2. L: Loop Through Data
  3. A: Apply Logic
  4. N: New/Updated Array/ArrayList

Step 1: Declare Method Header:

  • The question specifies the method name, parameter types, and return type
public void addMembers(String[] names, int gradYear) {
    // Method implementation
}

Step 2: Iterate Through the Array:

  • Must iterate through the array
for (String name : names) {
    // Process each name
}

Losing points:

  • Points will be lost of they fail to access elements of the array even if the loop bounds are correct.

3. Create and add objects:

  • For each name a new MemberInfo object should be created
  • It should then be added to memberList. The MemberInfo constructor takes three arguements:
  • Name(String)
  • Graduation year(int)
  • Good standing(boolean, should default to true)
MemberInfo newMember = new MemberInfo(name, gradYear, true);

4. Complete the Method

  • MemberInfo objects adds to memberList
  • You can still earn points even if instantiate MemberInfo objects incorrectly
memberList.add(newMember);

CollegeBoard Solution

public void addMembers(String[] names, int gradYear)
{
    for (String n : names)
    {
        MemberInfo newMember = new MemberInfo(n, gradYear, true);
        memberList.add(newMember);
    }
}

FRQ Part B - Key Points

1. Reverse Iteration

The loop iterates backward (i = memberList.size() - 1; i >= 0; i--) because removing elements from a list while iterating forward can cause index shifting issues, leading to skipped elements or runtime errors.

2. Conditional Check

Two conditions are checked:

  • Graduation Year (getGradYear()): Ensures members meet the graduation year cutoff.
  • Good Standing (inGoodStanding()): Adds members to the removed list only if they’re in good standing.

3. Removal from memberList

Members are removed regardless of whether they’re in good standing, provided they meet the graduation year condition.

Part B

Write the ClubMembers method removeMembers, which takes the following actions.

  • Returns a list of all students who have graduated and are in good standing. A member has graduated if the member’s graduation year is less than or equal to the method’s year parameter. If no members meet these criteria, an empty list is returned.

  • Removes from memberList all members who have graduated, regardless of whether or not they are in good standing.

Step 1: Parameter and Return Type

The identified return type is an ArrayList, which is given to us in the start of the method.

public ArrayList<MemberInfo> removeMembers(int year) {
    
}

Step 2: Loop Through Data

The problem tell us to both return a list of graduated students with a good standing, and remove all graduated students from the list. We will need to loop through the memberList provided to us to accomplish this using reverse iteration.

public ArrayList<MemberInfo> removeMembers(int year) {
    for(int i = memberList.size() - 1; i >= 0; i++) {

    }
}

Step 3: Apply Logic

Now, how can we determine whether the members have graduated or are in good standing? This is where logic comes in.

We check the member’s graduation year, and check if it is less than or equal to the current year to see if they have graduated or not. Then, we check if they are in good standing. Then, regardless of whether they are in good standing or not, we remove them from the memberList.

public ArrayList<MemberInfo> removeMembers(int year) {
    for(int i = memberList.size() - 1; i >= 0; i++) {
        if (memberList.get(i).getGradYear() <= year) {
            if (memberList.get(i).inGoodStanding) {
            }
            memberList.remove(i);
        }
    }
}

Step 4: New/Updated Array/ArrayList

Now, we need to find a way to return all of the graduated students with a good standing in a new ArrayList. We can define a new ArrayList “graduated”, and use .add to add the members that pass both of our previous if statements to add them to the ArrayList, and return the final ArrayList after exiting the loop, matching our defined return type.

public ArrayList<MemberInfo> removeMembers(int year) {
    ArrayList<MemberInfo> graduated = new ArrayList<MemberInfo>();
    for(int i = memberList.size() - 1; i >= 0; i++) {
        if (memberList.get(i).getGradYear() <= year) {
            if (memberList.get(i).inGoodStanding) {
                graduated.add(memberList.get(i));
            }
            memberList.remove(i);
        }
    return graduated;
    }
}