Una referencia al tipo primitivo en Java (Cómo forzar un conjunto de datos primitivos de permanecer en caja)

uri:

Me gustaría pasar una referencia a un tipo primitivo a un método, que puede cambiarlo.

Considere el siguiente ejemplo:

public class Main {

    Integer x = new Integer(42);
    Integer y = new Integer(42);

    public static void main(String[] args) {
        Main main = new Main();
        System.out.println("x Before increment: " + main.x);

        // based on some logic, call increment either on x or y
        increment(main.x);

        System.out.println("x after increment: " + main.x);
    }

    private static void increment(Integer int_ref) {
        ++int_ref;
    }
}

La salida de la ejecución del ejemplo es:

x Before increment: 42
x after increment: 42

Lo que significa int_ref había pasado a la función por valor, y no por referencia, a pesar de mi nombre optimista.

Es obvio que hay maneras de evitar este ejemplo particular, pero mi verdadera aplicación es mucho más compleja, y en general se podría imaginar que un "puntero" o referencia a número entero serían útiles en muchos escenarios.

He tratado de pasar a la función del objeto (entonces Conversión a int), y varios otros métodos, sin suerte. Una solución que parece estar funcionando sería definir mi propia versión de la clase Entero:

private static class IntegerWrapper {
    private int value;

    IntegerWrapper(int value) { this.value = value; }
    void plusplus() { ++value; }
    int getValue() { return value; }
}

Al hacer esto, y pasando una referencia a IntegerWrapper funciona como se esperaba, pero a mi gusto me parece muy poco convincente. Viniendo de C #, donde la variable en caja solo permanecerá en caja, espero que algo se pierda.

EDITAR:

Yo diría que mi pregunta no es un duplicado de es Java "el paso por referencia" o "pass-by-value"? , Ya que mi pregunta no es teórico, ya que simplemente buscar una solución. Filosóficamente, todas las llamadas a métodos en todos los idiomas están pasan por valor: O bien se pasan el valor real, o una referencia al valor - por valor.

Por lo tanto, me gustaría reformular mi pregunta: ¿Cuál es el paradigma común para solucionar el problema de que en java que soy incapaz de pasar una referencia a un entero. Se sugirió la IntegerWrapper por encima de un paradigma conocida? ¿Tiene una clase similar (tal vez MutableInt) ya existe en la biblioteca? Tal vez una matriz de longitud 1 una práctica común y tiene cierta ventaja en el rendimiento? ¿Soy la única persona molesta por el hecho de que puede almacenar una referencia a cualquier tipo de objeto, pero los tipos básicos?

oleg.cherednik:

Integer es inmutable, como se puede observar.

Su enfoque con private static class IntegerWrapperes correcta. Uso de matriz con tamaño 1 también es correcto, pero en la práctica nunca he visto usando array para este caso. Lo mismo ocurre con el usoIntegerWrapper.

Exactamente la misma aplicación se puede encontrar en Apache org.apache.commons.lang3.mutable.MutableInt.

En el ejemplo también se puede proporcionar Maininstancia al método estático:

public class Main {

    private int x = 42;

    public static void main(String[] args) {
        Main main = new Main();
        incrementX(main);
    }

    private static void incrementX(Main main) {
        main.x++;
    }
}

Y, por último, a partir Java8 se podría definir una incfunción y utilizarlo para el valor mínimo de la subasta:

public class Main {

    private static final IntFunction<Integer> INC = val -> val + 1;

    private int x = 42;

    public static void main(String[] args) {
        Main main = new Main();
        main.x = INC.apply(main.x);
    }

}