:: (deux points) opérateur en Java 8

Généralement, qu'on pourrait appeler le reduce méthode à l'aide de Math.max(int, int) comme suit:

reduce(new IntBinaryOperator() {
    int applyAsInt(int left, int right) {
        return Math.max(left, right);
    }
});

Qui nécessite beaucoup de syntaxe pour appeler juste Math.max. C'est là que les expressions lambda entrent en jeu. Depuis Java 8, il est permis de faire la même chose en beaucoup plus court chemin:

reduce((int left, int right) -> Math.max(left, right));

Comment cela fonctionne? Le compilateur java "détecte", que vous souhaitez mettre en œuvre une méthode qui accepte deux ints et renvoie un int. C'est l'équivalent pour les paramètres formels d'une seule et unique méthode de l'interface IntBinaryOperator (le paramètre de la méthode reduce vous voulez l'appeler). Ainsi, le compilateur fait le reste pour vous, il a juste suppose que vous voulez mettre en œuvre IntBinaryOperator.

Mais comme Math.max(int, int) lui-même remplit les conditions de forme de IntBinaryOperator, il peut être utilisé directement. Parce que Java 7 n'a pas de syntaxe qui permet à une méthode même d'être passé comme argument (vous ne pouvez passer des résultats de la méthode, mais jamais de la méthode de référence, la :: syntaxe a été introduite dans Java 8 pour les méthodes de référence:

reduce(Math::max);

Noter que ce sera interprété par le compilateur, pas par la JVM au moment de l'exécution! Bien qu'elle produit différents bytecode pour tous les trois fragments de code, ils sont sémantiquement égaux, de sorte que les deux dernières peuvent être considérées comme des manches (et probablement plus efficace) des versions de la IntBinaryOperator de mise en œuvre ci-dessus!

(Voir aussi La traduction des Expressions Lambda)

OriginalL'auteur isnot2bad

Oui, c'est vrai. Le :: opérateur est utilisé pour la méthode de référencement. Ainsi, l'on peut extraire statique méthodes de classes en utilisant des méthodes ou des objets. Le même opérateur peut être utilisé même pour les constructeurs. Tous les cas mentionnés ici sont illustrées dans l'exemple de code ci-dessous.

La documentation officielle d'Oracle peut être trouvé ici.

Vous pouvez avoir une meilleure vue d'ensemble du JDK 8 changements dans cette article. Dans le Méthode ou le Constructeur de référencement section un exemple de code est également fournie:

interface ConstructorReference {
    T constructor();
}

interface  MethodReference {
   void anotherMethod(String input);
}

public class ConstructorClass {
    String value;

   public ConstructorClass() {
       value = "default";
   }

   public static void method(String input) {
      System.out.println(input);
   }

   public void nextMethod(String input) {
       //operations
   }

   public static void main(String... args) {
       //constructor reference
       ConstructorReference reference = ConstructorClass::new;
       ConstructorClass cc = reference.constructor();

       //static method reference
       MethodReference mr = cc::method;

       //object method reference
       MethodReference mr2 = cc::nextMethod;

       System.out.println(cc.value);
   }
}

OriginalL'auteur Olimpiu POP

Il semble que son peu en retard mais voici mes deux cents. Un expression lambda est utilisé pour créer des méthodes anonymes. Il ne fait rien, mais l'appel d'une méthode existante, mais il est plus clair de se référer à la méthode directement par son nom. Et méthode de référence nous permet de le faire à l'aide de la méthode de référence de l'opérateur :: .

Envisager les mesures suivantes simple de la classe où chaque employé a un nom et grade.

public class Employee {
    private String name;
    private String grade;

    public Employee(String name, String grade) {
        this.name = name;
        this.grade = grade;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getGrade() {
        return grade;
    }

    public void setGrade(String grade) {
        this.grade = grade;
    }
}

Supposons que nous avons une liste des employés renvoyés par un peu de méthode, et nous voulons trier les salariés par leur grade. Nous savons que nous pouvons faire usage de la classe anonyme comme:

    List<Employee> employeeList = getDummyEmployees();

    //Using anonymous class
    employeeList.sort(new Comparator<Employee>() {
           @Override
           public int compare(Employee e1, Employee e2) {
               return e1.getGrade().compareTo(e2.getGrade());
           }
    });

où getDummyEmployee() est une méthode comme:

private static List<Employee> getDummyEmployees() {
        return Arrays.asList(new Employee("Carrie", "C"),
                new Employee("Fanishwar", "F"),
                new Employee("Brian", "B"),
                new Employee("Donald", "D"),
                new Employee("Adam", "A"),
                new Employee("Evan", "E")
                );
    }

Maintenant, nous savons que Comparateur est une Interface Fonctionnelle. Un Interface Fonctionnelle est l'un avec exactement une méthode abstraite (même s'il peut contenir un ou plusieurs défaut ou méthodes statiques). Lambda expression permettant la mise en œuvre de @FunctionalInterface donc une interface fonctionnelle peut avoir qu'une seule méthode abstraite. Nous pouvons utiliser l'expression lambda comme:

employeeList.sort((e1,e2) -> e1.getGrade().compareTo(e2.getGrade())); //lambda exp

Il semble tout bon, mais ce que si la classe Employee fournit également une méthode similaire:

public class Employee {
    private String name;
    private String grade;
    //getter and setter
    public static int compareByGrade(Employee e1, Employee e2) {
        return e1.grade.compareTo(e2.grade);
    }
}

Dans ce cas, le nom de la méthode elle-même sera plus clair. Par conséquent, nous pouvons directement référence à la méthode par l'aide de la méthode de référence comme:

employeeList.sort(Employee::compareByGrade); //method reference

Comme par docs il y a quatre types de méthode références:

+----+-------------------------------------------------------+--------------------------------------+
|    | Kind                                                  | Example                              |
+----+-------------------------------------------------------+--------------------------------------+
| 1  | Reference to a static method                          | ContainingClass::staticMethodName    |
+----+-------------------------------------------------------+--------------------------------------+
| 2  |Reference to an instance method of a particular object | containingObject::instanceMethodName | 
+----+-------------------------------------------------------+--------------------------------------+
| 3  | Reference to an instance method of an arbitrary object| ContainingType::methodName           |
|    | of a particular type                                  |                                      |  
+----+-------------------------------------------------------+--------------------------------------+
| 4  |Reference to a constructor                             | ClassName::new                       |
+------------------------------------------------------------+--------------------------------------+

OriginalL'auteur i_am_zero

:: Operator a été introduit dans java 8 pour la méthode de référence. Une méthode de référence est l'abréviation syntaxe d'une expression lambda qui s'exécute UNE seule méthode. Voici la syntaxe générale d'une méthode de référence:

Object :: methodName

Nous savons que nous pouvons utiliser les expressions lambda au lieu d'utiliser une classe anonyme. Mais parfois, l'expression lambda est vraiment juste un appel à une méthode, par exemple:

Consumer<String> c = s -> System.out.println(s);

Pour rendre le code plus clair, vous pouvez transformer cette expression lambda dans une méthode de référence:

Consumer<String> c = System.out::println;

OriginalL'auteur Vaibhav9518

Au moment de l'exécution, ils se conduisent exactement la même.Le bytecode peut/ne pas être la même (ci-dessus au Cas où,il génère le même code binaire(complie ci-dessus et vérifier javaap -c;))

Au moment de l'exécution, ils se conduisent exactement la même.méthode(math::max);,il génère le même pour les mathématiques (complie ci-dessus et vérifier javap -c;))

OriginalL'auteur Alfa khatoon

Depuis de nombreuses réponses ici bien expliqué :: comportement, en outre, je tiens à préciser que :: opérateur n'a pas besoin d'avoir exactement la même signature que le renvoi Interface Fonctionnelle si elle est utilisée pour les variables d'instance. Supposons nous avons besoin d'un BinaryOperator qui a le type de TestObject. De façon traditionnelle son œuvre comme ceci:

BinaryOperator<TestObject> binary = new BinaryOperator<TestObject>() {

        @Override
        public TestObject apply(TestObject t, TestObject u) {

            return t;
        }
    };

Comme vous le voyez anonyme, mise en œuvre, il nécessite deux TestObject argument et renvoie un TestObject objet. Pour satisfaire à cette condition en utilisant :: opérateur, nous pouvons commencer avec une méthode statique:

public class TestObject {


    public static final TestObject testStatic(TestObject t, TestObject t2){
        return t;
    }
}

puis composez le:

BinaryOperator<TestObject> binary = TestObject::testStatic;

Ok il a compilé amende. Que dire si nous avons besoin d'une méthode d'instance? Permet de mettre à jour TestObject avec la méthode d'instance:

public class TestObject {

    public final TestObject testInstance(TestObject t, TestObject t2){
        return t;
    }

    public static final TestObject testStatic(TestObject t, TestObject t2){
        return t;
    }
}

Maintenant, nous pouvons accéder exemple comme ci-dessous:

TestObject testObject = new TestObject();
BinaryOperator<TestObject> binary = testObject::testInstance;

Ce code compile bien, mais en dessous d'un pas:

BinaryOperator<TestObject> binary = TestObject::testInstance;

Mon eclipse me dire "Ne peut pas faire une référence statique pour les non méthode statique testInstance(TestObject, TestObject) à partir du type TestObject ..."

Juste assez de son une méthode d'instance, mais si l'on surcharge testInstance comme ci-dessous:

public class TestObject {

    public final TestObject testInstance(TestObject t){
        return t;
    }

    public final TestObject testInstance(TestObject t, TestObject t2){
        return t;
    }

    public static final TestObject testStatic(TestObject t, TestObject t2){
        return t;
    }
}

Et appel:

BinaryOperator<TestObject> binary = TestObject::testInstance;

Le code juste compiler amende. Parce qu'il appellera testInstance avec un seul paramètre à la place de double. Ok, donc ce qui est arrivé à nos deux paramètre? Permet l'impression et à voir:

public class TestObject {

    public TestObject() {
        System.out.println(this.hashCode());
    }

    public final TestObject testInstance(TestObject t){
        System.out.println("Test instance called. this.hashCode:" 
    + this.hashCode());
        System.out.println("Given parameter hashCode:" + t.hashCode());
        return t;
    }

    public final TestObject testInstance(TestObject t, TestObject t2){
        return t;
    }

    public static final TestObject testStatic(TestObject t, TestObject t2){
        return t;
    }
}

Qui sera de sortie:

 1418481495  
 303563356  
 Test instance called. this.hashCode:1418481495
 Given parameter hashCode:303563356

Ok, donc JVM est assez intelligent pour appeler param1.testInstance(param2). Peut-on utiliser testInstance à partir d'une autre ressource, mais pas TestObject, c'est à dire:

public class TestUtil {

    public final TestObject testInstance(TestObject t){
        return t;
    }
}

Et appel:

BinaryOperator<TestObject> binary = TestUtil::testInstance;

Il sera tout simplement pas le compiler et de le compilateur va dire: "Le type TestUtil ne définit pas testInstance(TestObject, TestObject)". Donc le compilateur va chercher une référence statique si elle n'est pas du même type. Ok ce que sur le polymorphisme? Si on enlève la finale de modificateurs et d'ajouter notre SubTestObject classe:

public class SubTestObject extends TestObject {

    public final TestObject testInstance(TestObject t){
        return t;
    }

}

Et appel:

BinaryOperator<TestObject> binary = SubTestObject::testInstance;

Il ne compile pas ainsi, le compilateur va encore chercher statique de référence. Mais au-dessous de code compile très bien, puisque c'est en passant est-un test:

public class TestObject {

    public SubTestObject testInstance(Object t){
        return (SubTestObject) t;
    }

}

BinaryOperator<TestObject> binary = TestObject::testInstance;

*Je suis juste étudiant donc j'ai pu en essayer et voir, n'hésitez pas à me corriger si je me trompe

OriginalL'auteur HRgiger

Dans les anciennes versions de Java, au lieu de "::" ou lambd, vous pouvez utiliser:

public interface Action {
    void execute();
}

public class ActionImpl implements Action {

    @Override
    public void execute() {
        System.out.println("execute with ActionImpl");
    }

}

public static void main(String[] args) {
    Action action = new Action() {
        @Override
        public void execute() {
            System.out.println("execute with anonymous class");
        }
    };
    action.execute();

    //or

    Action actionImpl = new ActionImpl();
    actionImpl.execute();
}

Ou de passer à la méthode:

public static void doSomething(Action action) {
    action.execute();
}

OriginalL'auteur Kamil Tomasz Jarmusik

Les réponses précédentes sont tout à fait complet sur ce :: méthode de référence n'. Pour résumer, il offre un moyen de se référer à une méthode(ou le constructeur) sans l'exécuter, et au moment de l'évaluation, il crée une instance de l'interface fonctionnelle qui fournit le type de cible contexte.

Ci-dessous deux exemples de trouver un objet avec la valeur max dans un ArrayList AVEC et SANS l'utilisation de :: méthode de référence. Les explications sont dans les commentaires ci-dessous.

SANS l'utilisation de ::

import java.util.*;

class MyClass {
    private int val;
    MyClass (int v) { val = v; }
    int getVal() { return val; }
}

class ByVal implements Comparator<MyClass> {
    //no need to create this class when using method reference
    public int compare(MyClass source, MyClass ref) {
        return source.getVal() - ref.getVal();
    }
}

public class FindMaxInCol {
    public static void main(String args[]) {
        ArrayList<MyClass> myClassList = new ArrayList<MyClass>();
        myClassList.add(new MyClass(1));
        myClassList.add(new MyClass(0));
        myClassList.add(new MyClass(3));
        myClassList.add(new MyClass(6));

        MyClass maxValObj = Collections.max(myClassList, new ByVal());
    }
}

AVEC l'utilisation de ::

import java.util.*;

class MyClass {
    private int val;
    MyClass (int v) { val = v; }
    int getVal() { return val; }
}

public class FindMaxInCol {
    static int compareMyClass(MyClass source, MyClass ref) {
        //This static method is compatible with the compare() method defined by Comparator. 
        //So there's no need to explicitly implement and create an instance of Comparator like the first example.
        return source.getVal() - ref.getVal();
    }

    public static void main(String args[]) {
        ArrayList<MyClass> myClassList = new ArrayList<MyClass>();
        myClassList.add(new MyClass(1));
        myClassList.add(new MyClass(0));
        myClassList.add(new MyClass(3));
        myClassList.add(new MyClass(6));

        MyClass maxValObj = Collections.max(myClassList, FindMaxInCol::compareMyClass);
    }
}

OriginalL'auteur Liutong Chen

Deux points à savoir :: operator est introduire dans Java 8 en tant que méthode de référence. La méthode de référence est une forme d'expression lambda qui est utilisé pour désigner la méthode existante par son nom.

classname::methodName

ex:-

• flux.forEach(element -> Système.out.println(element))

En utilisant deux points ::

• flux.forEach(Système d'.out::println(element))

OriginalL'auteur ishant kulshreshtha