:: (двойное двоеточие) оператор в Java 8

:: называется методом ссылки. Это в основном ссылка на один метод. Т.е. это относится к существующему методу по имени.

Краткое объяснение:
Ниже приведен пример ссылки на статический метод:

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 может быть передан так же, как ссылки на объекты, и сработать при необходимости. Фактически, его можно использовать так же легко, как ссылку на "нормальные" методы объектов, как static. Например:

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 выше - это функциональный интерфейс. Для полного понимания :: важно также понимать функциональные интерфейсы. Проще говоря, функциональный интерфейс - это интерфейс только с одним абстрактным методом.

Примеры функциональных интерфейсов включают Runnable, Callable и ActionListener.

Вышеуказанная Function - это функциональный интерфейс с одним методом: apply. Он принимает один аргумент и дает результат.

---

Причина, по которой :: удивительны, заключается в том, что:

Ссылки на методы - это выражения, которые обрабатываются так же, как лямбда-выражения (...), но вместо предоставления тела метода они ссылаются на существующий метод по имени.

Например, вместо написания лямбда-тела

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

Вы можете просто сделать

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

Во время выполнения эти два square метода ведут себя точно так же, как и другие. Байт-код может совпадать или не совпадать (хотя для вышеупомянутого случая генерируется один и тот же байт-код; скомпилируйте вышеприведенное и проверьте с помощью javap -c).

Единственный основной критерий, который нужно выполнить: метод, который вы предоставляете, должен иметь аналогичную сигнатуру с методом функционального интерфейса, который вы используете в качестве ссылки на объект.

Нижеследующее является незаконным:

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

square ожидает аргумент и возвращает double. Метод get в Supplier возвращает значение, но не принимает аргумент. Таким образом, это приводит к ошибке.

Ссылка на метод относится к методу функционального интерфейса. (Как уже упоминалось, функциональные интерфейсы могут иметь только один метод).

Еще несколько примеров: метод accept в Consumer принимает входные данные, но ничего не возвращает.

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

Выше, getRandom принимает аргументов и возвращает double. Таким образом, может использоваться любой функциональный интерфейс, который удовлетворяет критериям: не принимать аргументов и возвращать double.

Другой пример:

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

В случае параметризованных типов:

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;

Ссылки на методы могут иметь разные стили, но по сути все они означают одно и то же и могут просто отображаться как лямбды:

1. Статический метод (ClassName::methName)
2. Метод экземпляра определенного объекта (instanceRef::methName)
3. Супер метод конкретного объекта (super::methName)
4. Метод экземпляра произвольного объекта определенного типа (ClassName::methName)
5. Ссылка на конструктор класса (ClassName::new)
6. Ссылка на конструктор массива (TypeName[]::new)

Для получения дополнительной информации см. Http://cr.openjdk.java.net/~briangoetz/lambda/lambda-state-final.html.

Да это правда. Оператор :: используется для ссылки на метод. Таким образом, можно извлечь статические методы из классов, используя его или методы из объектов. Один и тот же оператор может использоваться даже для конструкторов. Все случаи, упомянутые здесь, приведены в примере кода ниже.

Официальную документацию от Oracle можно найти здесь.

Вы можете получить лучший обзор изменений JDK 8 в этой статье. В разделе ссылок на метод/конструктор также приведен пример кода:

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

:: - это новый оператор, включенный в Java 8, который используется для ссылки на метод существующего класса. Вы можете ссылаться на статические методы и нестатические методы класса.

Для обращения к статическим методам синтаксис:

ClassName :: methodName 

Для ссылки на нестатические методы синтаксис

objRef :: methodName

и

ClassName :: methodName

Единственным предварительным условием для обращения к методу является тот метод, который существует в функциональном интерфейсе, который должен быть совместим с ссылкой на метод.

Ссылки на методы, при оценке, создают экземпляр функционального интерфейса.

Найдено по: http://www.speakingcs.com/2014/08/method-references-in-java-8.html

Это ссылка на метод в Java 8. Документация оракула здесь.

Как указано в документации...

Ссылка метода Person:: compareByAge - это ссылка на статическую Метод.

Ниже приведен пример ссылки на метод экземпляра конкретный объект:

class ComparisonProvider {
    public int compareByName(Person a, Person b) {
        return a.getName().compareTo(b.getName());
    }

    public int compareByAge(Person a, Person b) {
        return a.getBirthday().compareTo(b.getBirthday());
    }
}

ComparisonProvider myComparisonProvider = new ComparisonProvider();
Arrays.sort(rosterAsArray, myComparisonProvider::compareByName); 

Ссылка на метод myComparisonProvider:: compareByName вызывает метод compareByName это часть объекта myComparisonProvider. JRE представляет аргументы типа метода, которые в этом случае являются (Person, Person).

Кажется, уже немного поздно, но вот мои два цента. Лямбда-выражение используется для создания анонимных методов. Он ничего не делает, кроме как вызывает существующий метод, но яснее ссылаться на метод напрямую по его имени. И ссылка на метод позволяет нам сделать это с помощью метода-ссылки operator ::.

Рассмотрим следующий простой класс, где у каждого сотрудника есть имя и класс.

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

Предположим, у нас есть список сотрудников, возвращенных каким-либо методом, и мы хотим отсортировать сотрудников по их классам. Мы знаем, что можем использовать анонимный класс как:

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

где getDummyEmployee() - это некоторый метод как:

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

Теперь мы знаем, что Comparator - это функциональный интерфейс. Функциональный интерфейс - это интерфейс с ровно одним абстрактным методом (хотя он может содержать один или несколько стандартных или статических методов). Лямбда-выражение обеспечивает реализацию @FunctionalInterface поэтому функциональный интерфейс может иметь только один абстрактный метод. Мы можем использовать лямбда-выражение как:

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

Вроде бы все хорошо, но что, если класс Employee также предоставляет аналогичный метод:

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

В этом случае использование самого имени метода будет более понятным. Следовательно, мы можем напрямую ссылаться на метод, используя ссылку на метод как:

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

Согласно документации существует четыре вида ссылок на методы:

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

:: Оператор был введен в java 8 для ссылок на методы. Ссылка на метод - это сокращенный синтаксис выражения лямбда, который выполняет только один метод. Здесь общий синтаксис ссылки на метод:

Object :: methodName

Мы знаем, что вместо использования анонимного класса мы можем использовать лямбда-выражения. Но иногда выражение лямбда - это просто вызов некоторого метода, например:

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

Чтобы сделать код более понятным, вы можете превратить это лямбда-выражение в ссылку метода:

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

The:: известен как ссылки на методы. Допустим, мы хотим вызвать метод calculatePrice класса Purchase. Тогда мы можем записать его как:

Purchase::calculatePrice

Его также можно рассматривать как короткую форму записи выражения лямбда. Поскольку ссылки на методы преобразуются в лямбда-выражения.

В java-8 Streams Reducer в простых произведениях есть функция, которая принимает два значения в качестве входных данных и возвращает результат после некоторых вычислений. этот результат подается на следующей итерации.

в случае функции Math: max, метод возвращает максимальное значение двух пройденных значений и, в конце концов, у вас наибольшее количество в руке.

return reduce(Math::max); НЕ РАВНО до return reduce(max());

Но это означает, что-то вроде этого:

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

Вы можете просто сохранить 47 нажатий клавиш, если вы пишете вот так

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

Во время выполнения они ведут себя точно так же. Байт-код может/не быть одинаковым (для выше Incase он генерирует один и тот же байт-код (см. выше и проверьте javaap -c;))

Во время выполнения они ведут себя точно так же .method(math:: max);, он генерирует одну и ту же математику (см. выше и проверить javap -c;))

Предыдущие ответы вгляда относительно того, что :: эталонного метода делает. Подводя итог, он предоставляет способ ссылки на метод (или конструктор) без его выполнения, а при оценке он создает экземпляр функционального интерфейса, который предоставляет целевой контекст типа.

Ниже приведены два примера поиска объекта с максимальным значением в ArrayList WITH и БЕЗ использования ссылки на метод ::. Пояснения в комментариях ниже.

---

БЕЗ использования ::

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

---

С использованием ::

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

Так что я вижу здесь тонны ответов, которые, честно говоря, слишком сложны, и это занижение.

Ответ довольно прост: :: он называется "Метод ссылки" https://docs.oracle.com/javase/tutorial/java/javaOO/methodreferences.html

Так что я не буду копировать-вставлять, по ссылке, вы можете найти всю информацию, если прокрутите вниз до таблицы.

---

Теперь давайте кратко рассмотрим, что такое "Ссылки на метод":

A :: B несколько заменяет следующее встроенное лямбда-выражение: (params...) → AB (params...)

Чтобы соотнести это с вашими вопросами, необходимо понимать лямбда-выражение java. Что не сложно.

Встроенное лямбда-выражение аналогично определенному функциональному интерфейсу (который является интерфейсом, который имеет не более и не менее 1 метода). Давайте кратко рассмотрим, что я имею в виду:

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

InterfaceX должен быть функциональным интерфейсом. Любой функциональный интерфейс, единственное, что важно для InterfaceX для этого компилятора, это то, что вы определяете формат:

InterfaceX может быть любым из этого:

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

или это

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

или более общий:

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

Давайте возьмем первый представленный случай и встроенное лямбда-выражение, которое мы определили ранее.

До Java 8 вы могли бы определить это так:

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

Функционально это одно и то же. Разница больше в том, как компилятор это воспринимает.

Теперь, когда мы взглянули на встроенное лямбда-выражение, вернемся к методам References (: :). Допустим, у вас есть такой класс:

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

Поскольку метод anyFunctions имеет те же типы, что и интерфейсный интерфейс callMe, мы можем сопоставить эти два с помощью метода Reference.

Мы можем написать это так:

InterfaceX o =  Q::anyFunction; 

и это эквивалентно этому:

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

Крутая вещь и преимущество ссылок на методы в том, что сначала, до тех пор, пока вы не назначите их переменным, они будут не иметь типов. Таким образом, вы можете передавать их в качестве параметров любому эквивалентному (имеющему одинаковые типы) функциональному интерфейсу. Что именно происходит в вашем случае

В более старых версиях Java вместо "::" или lambd вы можете использовать:

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

Или переходя к методу:

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

Я нашел этот источник очень интересным.

На самом деле это Lambda, который превращается в Double Colon. Двойной Колон более читабельен. Мы выполняем следующие шаги:

STEP1:

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

STEP2:

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

STEP3:

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

Поскольку многие ответы здесь объясняли хорошо поведение ::, дополнительно я хотел бы пояснить, что оператор :: не должен иметь точно такую ​​же подпись, что и ссылочный функциональный интерфейс, если он используется для переменных экземпляра. Предположим, нам нужен BinaryOperator, который имеет тип TestObject. Традиционно он реализован следующим образом:

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

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

            return t;
        }
    };

Как вы видите в анонимной реализации, он требует два аргумента TestObject и возвращает объект TestObject. Чтобы удовлетворить это условие, используя оператор ::, мы можем начать с статического метода:

public class TestObject {


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

а затем вызовите:

BinaryOperator<TestObject> binary = TestObject::testStatic;

Хорошо, он скомпилирован. А если нам нужен метод экземпляра? Позволяет обновить TestObject с помощью метода экземпляра:

public class TestObject {

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

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

Теперь мы можем получить доступ к экземпляру, как показано ниже:

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

Этот код компилируется отлично, но ниже одного нет:

BinaryOperator<TestObject> binary = TestObject::testInstance;

My eclipse сказать мне "Невозможно сделать статическую ссылку на нестатический метод testInstance (TestObject, TestObject) из типа TestObject..."

Достаточно справедливо его метод экземпляра, но если мы перегрузим testInstance, как показано ниже:

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

И вызов:

BinaryOperator<TestObject> binary = TestObject::testInstance;

Код будет просто компилироваться. Потому что он будет вызывать testInstance с единственным параметром вместо двойного. Хорошо, так что случилось с нашими двумя параметрами? Вывод распечатки и просмотр:

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

Будет выводиться:

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

Хорошо, поэтому JVM достаточно умен, чтобы вызвать param1.testInstance(param2). Можем ли мы использовать testInstance с другого ресурса, но не TestObject, то есть:

public class TestUtil {

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

И вызов:

BinaryOperator<TestObject> binary = TestUtil::testInstance;

Он просто не компилируется, и компилятор скажет: "Тип TestUtil не определяет testInstance (TestObject, TestObject)" . Поэтому компилятор будет искать статическую ссылку, если это не тот же тип. Хорошо, что о полиморфизме? Если мы удалим финальные модификаторы и добавим класс SubTestObject:

public class SubTestObject extends TestObject {

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

}

И вызов:

BinaryOperator<TestObject> binary = SubTestObject::testInstance;

Он не будет компилироваться, компилятор все равно будет искать статическую ссылку. Но ниже код будет компилироваться отлично, поскольку он проходит - это тест:

public class TestObject {

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

}

BinaryOperator<TestObject> binary = TestObject::testInstance;

* Я просто изучаю, поэтому я понял, что попробуй и посмотри, не стесняйся меня исправить, если я ошибаюсь

Оператор :: вводится в Java 8 как ссылка на метод. Ссылка на метод - это форма лямбда-выражения, которая используется для ссылки на существующий метод по его имени.

Синтаксис: - Имя класса :: methodName