更改存储在ArrayList或HashMap中的对象的属性的最佳方法是什么？

Question

I have to do a little exercise (homework, like a friendlist) in Java, and i'm a little stuck on one of the tasks that i have to implement in my program. The exercise is about storing some friend-objects with a variety of attributes in a container-class and implementing some methods in the container-class for various tasks on the friend-objects.

The overall exercise is not a problem at all, but i'm quite unconvinced that my solution is the way to go. I hope you can give me some tips here.

The method that is left over, should be something like a "updateFriend" method, with which you can set the value of a given attribute to a new value, straight from the container-class.

I've already set up my friend-class with a handfull of attributes (eg prename, lastname, date of birth, adress, and so on) an getters/setters for all of them. I've also implemented the container-class (as an ArrayList), but i can't seem to find an elegant way to implement this specific method. My updateFriend()-method right now takes three parameters.

1.The specific id of the friend-object

2.The name of the attribute that i want to change

3.The new value of the attribute

It uses an enum to check if the entered attribute is an existing attribute and if yes, the method searches the ArrayList for the object that contains that attribute and should overwrite the existing value. It gets a little bulky, as i have implemented a switch on the enum, that calls the fitting setter-method for each attribute of the friend, if the type in attribute exists at all.

So basically the friend-class looks like this:

public class Friend {

    private static int friendCount = 1;

    private String firstname;
    private String lastname;
    private LocalDate dateOfBirth;
    private String phonenumber;
    private String mobilenumber;
    private String eMail;
    private Adress home;
    private int friendID;

//Getters & Setters
...
}

The method that gives me problems in the container-class looks something like this at the moment:

public void updateFriend(int id, String toChange, String newValue)
{
    for(Attribute a : attribute.values())
      {
          if(String.valueOf(a).equalsIgnoreCase(toChange))
          {
              for(Friend f : friends)
              { 
                  int counter = 1;
                  if(f.getID() == id)
              {
                     switch(a)
                     {
                          case FIRSTNAME:
                         {
                         f.setPreName(neuerWert);
                           break;   
                        }
                   //a case for each attribute
               }

I'm quite certain that my take on the given method is messy, slow, and cumbersome. What would be an elegant way of solving this? Excuse my wording and thanks in advance, greets.

Answer 1

I would suggest 3 performance improvements.

1. Use HashMap instead of List with key as id . Since, id will be unique, it will take O(1) time to get the relevant object for modification instead of spending O(n) time on List iteration.

2. You can change the type of toChange parameter from String to enum . This will avoid enum to String conversion and then comparing it.

3. Since, you are already doing validation of the attribute to be modified and you must be following standard java convention while naming your getters and setters, you can use reflection to call the method on the Friend object by creating the method name from attribute name like set{Attributename} .

Answer 2

Okay, lets start using the enum Attribute to handle all the changes (Since you already holding the attribute values)

Attribute Enum

public enum Attribute {

    FIRSTNAME("fname", (friend, name) -> friend.setFirstname(String.valueOf(name))),
    LASTNAME("lname", (friend, lname) -> friend.setLastname(String.valueOf(lname))),
    DATEOFBIRTH("dob", (friend, dob) -> friend.setDateOfBirth((LocalDate) dob)),
    PHONENUMBER("pno", (friend, pno) -> friend.setFirstname(String.valueOf(pno))),
    MOBILENUMBER("mno", (friend, mno) -> friend.setFirstname(String.valueOf(mno)));

    private String attributeName;

    private BiConsumer<Friend, Object> attributeSetter;

    public static Attribute getAttributeSetterByName(String attributeName) {
        return Arrays.stream(Attribute.values())
                .filter(attribute -> attribute.getAttributeName().equalsIgnoreCase(attributeName))
                .findFirst()
                .orElseThrow(() -> new RuntimeException(String.format("Invalid Attribute name - %s", attributeName)));
                //.orElse(null);
    }

    //Getter, Setter & Args Constructor (Use Lombok to reduce Boiler Plate code)
}

Update Logic

    public void updateFriend(int id, String toChange, String newValue) {
        Attribute attribute = Attribute.getAttributeSetterByName(toChange);
        for (Friend friend : friends) {
            if (friend.getId() == id) {
                attribute.getAttributeSetter().accept(friend, newValue);
                break;
            }
        }
    }

Answer 3

You can use a java.util.function.Consumer<T> object to change an object inside your container where you have all the type safety you get. Instead of having magic strings and string arguments for values, which might not be even for string fields, you can work directly on the objects type:

public void updateFriend(int id, Consumer<Friend> c) {
    // find the friend object
    Friend found = null;
    for (Friend f: this.friends) {
        if (f.getId() == id) {
            found = f;
            break;
        }
    }
    if (found == null) {
        throw new IllegalArgumentException("There is no friend object with the given id");
    }

    // use the friend object.
    c.accept(found);
}

You can use this method like this:

container.updateFriend(42, f -> f.setVorName("abc"));
container.updateFriend(9, f -> f.setAddress(some_address_object));