¿Qué significa “un objeto arbitrario de un tipo particular” en Java 8?

Nuestro team redactor ha estado horas investigando respuestas a tus preguntas, te ofrecemos la respuesta de modo que nuestro objetivo es servirte de gran apoyo.

Solución:

El ejemplo dado del Oracle Doc vinculado es:

String[] stringArray =  "Barbara", "James", "Mary", "John", "Patricia", "Robert", "Michael", "Linda" ;
Arrays.sort(stringArray, String::compareToIgnoreCase);

El equivalente lambda de

 String::compareToIgnoreCase

sería

(String a, String b) -> a.compareToIgnoreCase(b)

Él Arrays.sort() El método está buscando un comparador como su segundo argumento (en este ejemplo). Paso String::compareToIgnoreCase crea un comparador con a.compareToIgnoreCase(b) como el cuerpo del método de comparación. Entonces preguntas bien qué es a y b. El primer argumento para el método de comparación se convierte en a y el segundo b. Esos son los objetos arbitrarios, del tipo String (el tipo particular).

¿No entiendes?

• Asegúrate de saber Qué es un comparador y cómo implementarlo.
• saber lo que un interfaz funcional es y cómo afecta a las lambdas en Java.
• UN comparador es una interfaz funcional es por eso que la referencia del método se convierte en el cuerpo del método de comparación dentro del objeto comparador.
• Leer el fuente a continuación para otro ejemplo al final de la página.

Lea más en la fuente: http://moandjiezana.com/blog/2014/understanding-method-references/

Es una referencia a un método de instancia de algún tipo. En el caso del ejemplo, compareToIgnoreCase es un método de String. El programa sabe que puede invocar este método en una instancia de Stringpor lo que puede tomar la referencia y cualquier objeto de ese tipo y garantizar que el método existe.

Yo compararía esto con el Method class en el sentido de que se refieren a un método y se pueden invocar en una instancia arbitraria de algún tipo.

Para el ejemplo, puede usar dos String objetos y llamada compareToIgnoreCase en uno y use el otro como argumento para hacer coincidir la firma del método. Esto le permite tomar la array y ordenarlo en función de cualquier método de la array escriba en lugar de requerir una instancia de comparación para hacer esto en su lugar.

Y aquí está el ejemplo para cualquiera que no haya hecho clic en el enlace de la pregunta:

String[] stringArray =  "Barbara", "James", "Mary", "John",
"Patricia", "Robert", "Michael", "Linda", "George" ;
Arrays.sort(stringArray, String::compareToIgnoreCase);

Consulte el ejemplo de código a continuación que explica la categoría “Referencia a un método de instancia de un objeto arbitrario de un tipo particular” descrita en https://docs.oracle.com/javase/tutorial/java/javaOO/methodreferences.html

import java.util.Arrays;

class Person
String name;

//constructor
public Person(String name)
    this.name = name;


//instance method 1
public int personInstanceMethod1(Person person)
    return this.name.compareTo(person.name);


//instance method 2
public int personInstanceMethod2(Person person1, Person person2)
    return person1.name.compareTo(person2.name);



class Test 
public static void main (String[] args) throws Exception
    Person[] personArray = new Person("A"), new Person("B");

    // Scenario 1 : Getting compiled successfully
    Arrays.sort(personArray, Person::personInstanceMethod1);

    // Scenario 2 : Compile failure
    Arrays.sort(personArray, Person::personInstanceMethod2);

    // Scenario 3 : Getting compiled successfully. 
    Person personInstance = new Person("C");
    Arrays.sort(personArray, personInstance::personInstanceMethod2);

    // Scenario 4 : Getting compiled successfully. As the same way as "Scenario 1"
    String[] stringArray =  "Barbara", "James", "Mary", "John",
            "Patricia", "Robert", "Michael", "Linda" ;
    Arrays.sort(stringArray, String::compareToIgnoreCase);

El escenario 1 y el escenario 4 describen la categoría “Referencia a un método de instancia de un objeto arbitrario de un tipo particular” descrita en https://docs.oracle.com/javase/tutorial/java/javaOO/methodreferences.html

Si el parámetro del método toma una variable en el mismo tipo de instancia que el tipo de instancia del elemento, puede llamar a ese método de instancia usando Type.(Person::personInstanceMethod1)

Compare el método de instancia “personInstanceMethod1” en la clase “Persona” con el método de instancia “compareToIgnoreCase” en la clase “String” (https://docs.oracle.com/javase/8/docs/api/java/lang/String.html#compareToIgnoreCase -java.lang.String-) para ver la similitud. Ambos están tomando un solo parámetro con el mismo Tipo.

Compare el Escenario 1 y el Escenario 2 para ver la diferencia.

Si para ti ha resultado de provecho nuestro artículo, agradeceríamos que lo compartas con el resto entusiastas de la programación de este modo nos ayudas a extender nuestra información.

---

---

Utiliza Nuestro Buscador