:: (doppelter Doppelpunkt) operator in Java 8

:: heißt Methode Referenz. Es ist im Grunde ein Verweis auf eine einzelne Methode. I. e. es bezieht sich auf eine bestehende Methode durch name.

Kurze Erklärung:

Unten ist ein Beispiel für einen Verweis auf eine statische Methode:

class Hey {
     public static double square(double num){
        return Math.pow(num, 2);
    }
}

Function<Double, Double> square = Hey::square;
double ans = square.apply(23d);

square übergeben werden können, wie Objekt-Referenzen und ausgelöst, wenn benötigt. In der Tat, es kann genauso gut als ein Verweis auf die "normalen" Methoden von Objekten als static lieben. Zum Beispiel:

class Hey {
    public double square(double num) {
        return Math.pow(num, 2);
    }
}

Hey hey = new Hey();
Function<Double, Double> square = hey::square;
double ans = square.apply(23d);

Function oben ist ein funktionale Schnittstelle. Um vollständig zu verstehen :: ist es wichtig zu verstehen, funktionale Schnittstellen als gut. Klar, ein funktionale Schnittstelle ist ein interface mit nur einer abstrakten Methode.

Beispiele von funktionalen Schnittstellen sind Runnable, Callable, und ActionListener.

Function oben ist ein funktionales interface mit nur einer Methode: apply. Es dauert ein argument und ein Ergebnis erzeugt.

Der Grund, warum ::s sind genial ist dass:

Methode Verweise sind Ausdrücke, die die gleiche Behandlung wie lambda-Ausdrücke (...), sondern um die Bereitstellung einer Methode, die Körper, die Sie beziehen eine bestehende Methode durch name.

E. g. statt zu schreiben die lambda-Körper

Function<Double, Double> square = (Double x) -> x * x;

Können Sie einfach tun

Function<Double, Double> square = Hey::square;

Zur Laufzeit werden diese zwei square Methoden verhält sich genauso wie jeder andere. Der bytecode kann oder kann nicht das gleiche (obwohl, für den oben genannten Fall, für den gleichen bytecode erzeugt wird; kompilieren Sie die oben und prüfen Sie mit javap -c).

Die einzige wichtige Kriterium zu erfüllen ist: die Methode, die Sie liefern sollten, haben eine ähnliche Signatur der Methode der funktionalen Schnittstelle, die Sie verwenden, die als Objekt-Referenz.

Die unten ist illegal:

Supplier<Boolean> p = Hey::square; //illegal

square erwartet ein argument und gibt eine double. Die get Methode in Lieferant gibt einen Wert zurück, nimmt aber nicht ein argument. So, dies führt zu einem Fehler.

Eine Methode, die Referenz bezieht sich auf die Methode der funktionalen Schnittstelle. (Wie erwähnt, funktionale Schnittstellen kann jeweils nur eine Methode).

Einige weitere Beispiele: die accept Methode in Verbraucher nimmt eine Eingabe, aber nichts zurückgibt.

Consumer<Integer> b1 = System::exit;   //void exit(int status)
Consumer<String[]> b2 = Arrays::sort;  //void sort(Object[] a)
Consumer<String> b3 = MyProgram::main; //void main(String... args)

class Hey {
    public double getRandom() {
        return Math.random();
    }
}

Callable<Double> call = hey::getRandom;
Supplier<Double> call2 = hey::getRandom;
DoubleSupplier sup = hey::getRandom;
//Supplier is functional interface that takes no argument and gives a result

Oben getRandom übernimmt keine Argumente und gibt eine double. So eine funktionale Schnittstelle, die erfüllt die Kriterien von: nehmen kein argument und zurück double verwendet werden kann.

Anderes Beispiel:

Set<String> set = new HashSet<>();
set.addAll(Arrays.asList("leo","bale","hanks"));
Predicate<String> pred = set::contains;
boolean exists = pred.test("leo");

Bei parametrisierten Typen:

class Param<T> {
    T elem;
    public T get() {
        return elem;
    }

    public void set(T elem) {
        this.elem = elem;
    }

    public static <E> E returnSame(E elem) {
        return elem;
    }
}

Supplier<Param<Integer>> obj = Param<Integer>::new;
Param<Integer> param = obj.get();
Consumer<Integer> c = param::set;
Supplier<Integer> s = param::get;

Function<String, String> func = Param::<String>returnSame;

Methode Referenzen können verschiedene Stile haben, aber im Grunde sind Sie alle das gleiche bedeuten und kann einfach visualisiert werden, wie Lambda-Ausdrücke:

1. Eine statische Methode (ClassName::methName)
2. Eine Instanz-Methode von einem bestimmten Objekt (instanceRef::methName)
3. Eine super Methode eines bestimmten Objekts (super::methName)
4. Eine Instanz-Methode eines beliebigen Objekts von einem bestimmten Typ (ClassName::methName)
5. Eine Klasse Konstruktor-Referenz (ClassName::new)
6. Ein array-Konstruktor-Referenz (TypeName[]::new)

Weitere Referenz, siehe http://cr.openjdk.java.net/~briangoetz/lambda/lambda-state-final.html.

InformationsquelleAutor Jatin

:: ist ein new-operator enthalten, die in Java 8, die verwendet wird, zu finden eine Methode einer bestehenden Klasse. Sie können sich statische Methoden nicht-statische Methoden einer Klasse.

Für die Vermittlung von statischen Methoden, die syntax ist:

ClassName :: methodName 

Für die Vermittlung nicht-statischen Methoden, die syntax ist

objRef :: methodName

Und

ClassName :: methodName

Die einzige Voraussetzung für die Vermittlung ist eine Methode, die Methode besteht in einer funktionalen Schnittstelle, die kompatibel sein muss mit der Methode verweisen.

Methode verweist, die bei der Auswertung, erstellen Sie eine Instanz der funktionalen Schnittstelle.

Gefunden auf: http://www.speakingcs.com/2014/08/method-references-in-java-8.html

InformationsquelleAutor sreenath

Scheint es seine etwas spät aber hier sind meine zwei Cent. Ein lambda-Ausdruck dient zum erstellen von anonymen Methoden. Es tut nichts, sondern rufen Sie eine vorhandene Methode, aber es ist klarer zu beziehen, um die Methode direkt durch seinen Namen. Und Methode Referenz ermöglicht uns zu tun, dass mit der Methode-Referenz-operator :: .

Betrachten Sie die folgende einfache Klasse, bei dem jeder Mitarbeiter hat einen Namen und eine Klasse.

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;
    }
}

Nehmen wir an, wir haben eine Liste von Mitarbeitern zurückgegeben, die von einer bestimmten Methode, und wir möchten, Sortieren Sie die Mitarbeiter von Ihre grade. Wir wissen, wir können machen Verwendung von anonyme Klasse:

    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());
           }
    });

wo getDummyEmployee() ist eine Methode, wie:

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

Nun wissen wir, dass Komparator ist eine Funktionale Schnittstelle. Ein Funktionale Schnittstelle ist die, die genau eine abstrakte Methode (auch wenn es vielleicht enthalten ein oder mehrere standardmäßige oder statische Methoden). Lambda-Ausdruck liefert die Umsetzung von @FunctionalInterface so eine funktionale Schnittstelle kann nur über eine abstrakte Methode. Wir können lambda-Ausdruck als:

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

Es scheint alles gut, aber was ist, wenn die Klasse Employee auch eine ähnliche Methode:

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);
    }
}

In diesem Fall der name der Methode selbst wird mehr klar. Daher können wir direkt beziehen-Methode mithilfe der Methode als Referenz:

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

Als pro docs es gibt vier Arten von Methode Referenzen:

+----+-------------------------------------------------------+--------------------------------------+
|    | 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                       |
+------------------------------------------------------------+--------------------------------------+

InformationsquelleAutor i_am_zero

Dem :: ist bekannt als Methode Referenzen. Angenommen, wir bezeichnen will calculatePrice Methode der Klasse Kaufen. Dann können wir schreiben als:

Purchase::calculatePrice

Es kann auch gesehen werden als Kurzform des Schreibens der lambda-Ausdruck, Weil die Methode Referenzen umgewandelt werden lambda-Ausdrücke.

InformationsquelleAutor Sonu

return reduce(Math::max); ist NICHT GLEICH zu return reduce(max());

Aber es bedeutet, so etwas wie dieses:

IntBinaryOperator myLambda = (a, b)->{(a >= b) ? a : b};//56 keystrokes I had to type -_-
return reduce(myLambda);

Können Sie nur sparen 47 Tastenanschläge wenn Sie schreiben, wie diese

return reduce(Math::max);//Only 9 keystrokes ^_^

InformationsquelleAutor Jude Niroshan

Da viele der Antworten hier gut erklärt :: Verhalten, außerdem möchte ich klarstellen, dass :: Betreiber nicht brauchen zu haben, die genau dieselbe Signatur wie das vorlegende Funktionale Schnittstelle, wenn es verwendet wird, für Instanz-Variablen. Nehmen wir an, wir brauchen eine BinaryOperator die Art der TestObject. In der traditionellen Art und Weise umgesetzt sein, wie dies:

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

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

            return t;
        }
    };

Wie Sie sehen in anonymisierter Umsetzung erfordert zwei TestObject argument und gibt eine TestObject-Objekt als gut. Zur Erfüllung dieser Bedingung durch die Verwendung :: - operator wir beginnen mit einer statischen Methode:

public class TestObject {


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

und dann rufen:

BinaryOperator<TestObject> binary = TestObject::testStatic;

Ok, es kompiliert einwandfrei. Was ist, wenn wir brauchen eine Instanz-Methode? Lässt update-Testobjekt mit Instanz-Methode:

public class TestObject {

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

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

Nun können wir den Zugriff auf Instanz-wie folgt:

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

Dieser code kompiliert problemlos, aber unten nicht:

BinaryOperator<TestObject> binary = TestObject::testInstance;

Mein eclipse mir sagen, "Cannot make a static reference to the non-static Methode testInstance(TestObject, TestObject), von der Art Testobjekt ..."

Fair genug sein, eine Instanz-Methode, aber wenn wir die überlastung testInstance wie folgt:

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;
    }
}

Und rufen:

BinaryOperator<TestObject> binary = TestObject::testInstance;

Wird der code einfach kompilieren in Ordnung. Denn es wird call testInstance mit der einzelnen parameter statt Doppel. Ok, so was passiert unseren beiden parameter? Ermöglicht Ausdruck und siehe:

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;
    }
}

Die Ausgabe:

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

Ok, so JVM ist smart genug, um param1.testInstance(param2). Können wir testInstance aus der anderen Quelle aber nicht TestObject, d.h.:

public class TestUtil {

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

Und rufen:

BinaryOperator<TestObject> binary = TestUtil::testInstance;

Es wird einfach nicht kompiliert werden und der compiler wird sagen: "Der Typ TestUtil nicht definieren testInstance(TestObject, TestObject)". Also compiler suchen für einen statischen Verweis, wenn es nicht vom gleichen Typ sind. Ok was ist Polymorphismus? Wenn wir entfernen die letzten Modifikatoren und fügen Sie unsere SubTestObject Klasse:

public class SubTestObject extends TestObject {

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

}

Und rufen:

BinaryOperator<TestObject> binary = SubTestObject::testInstance;

Wird es nicht kompilieren als gut, der compiler wird immer noch so Aussehen, für statische Referenz. Aber unten code kompilieren in Ordnung, da es vorbei ist-ein-test:

public class TestObject {

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

}

BinaryOperator<TestObject> binary = TestObject::testInstance;

*Ich bin nur zu studieren, so habe ich herausgefunden durch ausprobieren und sehen, fühlen Sie sich frei, mich zu korrigieren, wenn ich falsch bin

InformationsquelleAutor HRgiger

So sehe ich hier Tonnen von Antworten, die sind ehrlich gesagt zu kompliziert, und das ist eine Untertreibung.

Ist die Antwort ziemlich einfach: : es ist als eine Methode bezeichnet, Verweise https://docs.oracle.com/javase/tutorial/java/javaOO/methodreferences.html

Damit ich nicht copy-paste, auf den link, finden Sie alle Informationen, wenn Sie nach unten scrollen, um den Tisch.

Nun, werfen wir einen kurzen Blick auf das, was ist eine Methode Referenzen:

A::B etwas ersetzt folgende inline-lambda-Ausdruck: (params ...) -> A. B(params ...)

Korrelieren diese mit Ihren Fragen, es ist notwendig zu verstehen, ein java-lambda-Ausdruck. Das ist nicht schwer.

Inline-lambda-Ausdruck ist ähnlich wie ein definiert funktionale Schnittstelle (eine Schnittstelle, die hat keine mehr und keine weniger als 1-Methode).
Werfen wir einen kurzen Blick, was ich meine:

InterfaceX f = (x) -> x*x; 

Interfacex gehe muss eine funktionale Schnittstelle. Eine funktionale Schnittstelle, die einzige Sache, was ist wichtig-interfacex gehe für diesen compiler ist, dass Sie das format definieren:

Interfacex gehe können sein:

interface InterfaceX
{
    public Integer callMe(Integer x);
}

oder diese

interface InterfaceX
{
    public Double callMe(Integer x);
}

oder allgemeineren:

interface InterfaceX<T,U>
{
    public T callMe(U x);
}

Nehmen wir den ersten Fall vorgestellt und die inline-lambda-Ausdruck definiert, dass wir früher.

Vor Java 8 war es definiert habe es ähnlich so:

 InterfaceX o = new InterfaceX(){
                     public int callMe (int x, int y) 
                       {
                        return x*x;
                       } };

Funktional, es ist die gleiche Sache. Der Unterschied liegt mehr darin, wie der compiler wahrnimmt.

Nun, haben wir einen Blick auf inline-lambda-Ausdruck, kehren wir zurück zur Methode Verweise (::). Lassen Sie uns sagen, Sie haben eine Klasse wie folgt aus:

class Q {
        public static int anyFunction(int x)
             {
                 return x+5;
             } 
        }

Da Methode anyFunctions hat die gleichen Typen wie interfacex gehe callMe, können wir equivalate denen zwei mit einer Methode Referenz.

Können wir schreiben es so:

InterfaceX o =  Q::anyFunction; 

und das ist äquivalent zu :

InterfaceX o = (x) -> Q.anyFunction(x);

Eine Coole Sache, und der Vorteil der Methode, die Referenzen sind, die auf den ersten, bis Sie ordnen Sie Variablen, Sie sind typeless. So können Sie diese als Parameter übergeben, um eine entsprechende Suche (hat die gleiche benutzerdefinierte Typen) funktionale Schnittstelle. Das ist genau das, was in Ihrem Fall

InformationsquelleAutor Nertan Lucian

Fand ich diese Quelle sehr interessant.

In der Tat, es ist die Lambda , verwandelt sich in einen Doppelten Doppelpunkt.
Der Doppel-Doppelpunkt ist mehr lesbar.
Wir Folgen diesen Schritten:

SCHRITT1:

//We create a comparator of two persons
Comparator c = (Person p1, Person p2) -> p1.getAge().compareTo(p2.getAge());

SCHRITT 2:

//We use the interference
Comparator c = (p1, p2) -> p1.getAge().compareTo(p2.getAge());

SCHRITT 3:

//The magic using method reference
Comparator c = Comparator.comparing(Person::getAge);

InformationsquelleAutor Husam Bdr