Comment créer une version statique d'une carte contenant les getters/setters d'un objet ?

Contenu de la question

J'ai une carte qui est construite lorsqu'un objet est appelé, qui fournit à l'appelant des noms de variables comme clés et des paires getter/setter comme valeurs. Cela fonctionne comme prévu. Mon problème est que je le construis à chaque fois que je l'appelle, je me demande s'il existe un moyen de le déclarer comme statique et de simplement fournir l'objet sur lequel je veux l'appeler afin de ne pas avoir à construire la carte. à chaque fois car les getters et les setters ne changent pas au moment de l'exécution.

J'ai :

package main;
import org.javatuples.Pair;
import java.util.Map;
import java.util.function.Consumer;
import java.util.function.Supplier;

public interface MapPackHelperI 
{
     public Map<String, Pair<Supplier, Consumer>> getNameToGetterSetterMap();    
}

package main;

import java.util.List;
import java.util.Map;
import java.util.HashMap;
import org.javatuples.Pair;
import java.util.function.Consumer;
import java.util.function.Supplier;

public class SomeStruct implements MapPackHelperI
{
    private long somelong;
    private String somestring;
    private List<Float> somelistfloat;
    private SomeEnum someenum;

    public  Map<String, Pair<Supplier, Consumer>> getNameToGetterSetterMap()
    {
        Map<String, Pair<Supplier, Consumer>> nameToGetterSetterMap = new HashMap<>();        
        nameToGetterSetterMap.put("somelong", Pair.with( this::getSomelong, (Consumer<Long>)this::setSomelong));
        nameToGetterSetterMap.put("somestring", Pair.with( this::getSomestring, (Consumer<String>)this::setSomestring));
        nameToGetterSetterMap.put("somelistfloat", Pair.with( this::getSomelistfloat, (Consumer<List<Float>>)this::setSomelistfloat));
        nameToGetterSetterMap.put("someenum", Pair.with( this::getSomeenum, (Consumer<SomeEnum>)this::setSomeenum));
        return nameToGetterSetterMap;
    }

    public long getSomelong() {
        return this.somelong;
    }

    public void setSomelong(long somelong) {
        this.somelong = somelong;
    }

    public String getSomestring() {
        return this.somestring;
    }

    public void setSomestring(String somestring) {
        this.somestring = somestring;
    }

    public List<Float> getSomelistfloat() {
        return this.somelistfloat;
    }

    public void setSomelistfloat(List<Float> somelistfloat) {
        this.somelistfloat = somelistfloat;
    }

    public SomeEnum getSomeenum() {
        return this.someenum;
    }

    public void setSomeenum(SomeEnum someenum) {
        this.someenum = someenum;
    }

   // ... hashcode, toString, and equals, not relevant for the example
}

Cela me permet de faire depuis ailleurs :

public static String serialize(MapPackHelperI objectToSerialize) 
{
   Map<String, Pair<Supplier, Consumer>> nameToGetterSetterMap = objectToSerialize.getNameToGetterSetterMap();
   for(Entry<String, Pair<Supplier, Consumer>> current : nameToGetterSetterMap.entrySet())
   {
       String name = current.getKey();
       Supplier getter = current.getValue().getValue0();
       //code that serializes into string with name and getter regardless of the MapPackHelperI I pass in
   }

  // return the string representation of the object. I have another method that uses the same map to go the other way with the setter.
}

Comme je l'ai dit, cela fonctionne, mais chaque fois que je l'appelle, j'instancie et remplis la carte.

Existe-t-il un moyen d'obtenir SomeStruct 有一个 public static Map<String, Pair<Supplier, Consumer>> nameToGetterSetterMap = new HashMap<>(); （或一些等效的），这样 public Map<String, Pairphpcnltphp cnSupplier、Consumer>> getNameToGetterSetterMap() 将实例化的参数作为参数SomeStruct et d'appliquer l'appel uniquement à cet objet spécifique.

J'ai essayé de créer une carte statique et de la remplir avec SomeStruct::getSomelong etc. mais le compilateur a dit que je ne pouvais pas faire ça.

Bonne réponse

Champ membre

La réponse semble si évidente qu'il me manque quelque chose : mettre en cache la carte nouvellement construite en tant que champ membre privé.

public class SomeStruct implements MapPackHelperI
{
    private long somelong;
    private String somestring;
    private List<Float> somelistfloat;
    private SomeEnum someenum;
    private Map<String, Pair<Supplier, Consumer>> map = 
        Map.of( 
            "somelong", Pair.with( this::getSomelong, (Consumer<Long>)this::setSomelong) ,
            "somestring", Pair.with( this::getSomestring, (Consumer<String>)this::setSomestring) ,
            "somelistfloat", Pair.with( this::getSomelistfloat, (Consumer<List<Float>>)this::setSomelistfloat) ,
            "someenum", Pair.with( this::getSomeenum, (Consumer<SomeEnum>)this::setSomeenum)
        ) ;

    public  Map<String, Pair<Supplier, Consumer>> getNameToGetterSetterMap()
    {
        return this.map ;
    }

…

Veuillez noter que Map.of n'est pas modifiable.

Vous devriez pouvoir instancier map 成员变量设置为 static，但除非您确定自己正在对 SomeStruct un nombre infini de fois, sinon je ne pense pas que ce soit une micro-optimisation qui en vaille la peine.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!