double colon operator in Java 8

Question

I was exploring the Java 8 source and found this particular part of code very surprising     defined in IntPipeline java  Override public final OptionalInt reduce IntBinaryOperator op        return evaluate ReduceOps makeInt op        Override public final OptionalInt max         return reduce Math  max     this is the gotcha line      defined in Math java public static int max int a  int b        return  a  gt   b    a   b      Is Math  max something like a method pointer   How does a normal static method gets converted to IntBinaryOperator

User · Answer

is a new operator included in Java 8 that is used to refer a method of an existing class  You can refer static methods and non-static methods of a class   For referring static methods  the syntax is   ClassName    methodName    For referring non-static methods  the syntax is  objRef    methodName   And  ClassName    methodName   The only prerequisite for referring a method is that method exists in a functional interface  which must be compatible with the method reference    Method references  when evaluated  create an instance of the functional interface    Found on  http   www speakingcs com 2014 08 method-references-in-java-8 html

User · Answer

The previous answers are quite complete regarding what    method reference does  To sum up  it provides a way to refer to a method or constructor  without executing it  and when evaluated  it creates an instance of the functional interface that provides the target type context   Below are two examples to find an object with the max value in an ArrayList WITH and WITHOUT the use of    method reference  Explanations are in the comments below     WITHOUT the use of     import java util     class MyClass       private int val      MyClass  int v    val   v        int getVal     return val       class ByVal implements Comparator lt MyClass gt           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 lt MyClass gt  myClassList   new ArrayList lt MyClass gt             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                 WITH the use of     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 lt MyClass gt  myClassList   new ArrayList lt MyClass gt             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

User · Answer

This is a method reference in Java 8   The oracle documentation is here   As stated in the documentation        The method reference Person  compareByAge is a reference to a static   method       The following is an example of a reference to an instance method of a   particular object    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         The method reference myComparisonProvider  compareByName invokes the method compareByName   that is part of the object myComparisonProvider  The JRE infers the   method type arguments  which in this case are  Person  Person

User · Answer

In older Java versions  instead of      or lambd  you can use   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        Or passing to the method   public static void doSomething Action action        action execute

User · Answer

is called Method Reference  It is basically a reference to a single method  I e  it refers to an existing method by name   Short Explanation  Below is an example of a reference to a static method   class Hey        public static double square double num           return Math pow num  2            Function lt Double  Double gt  square   Hey  square  double ans   square apply 23d     square can be passed around just like object references and triggered when needed  In fact  it can be just as easily used as a reference to  normal  methods of objects as static ones  For example   class Hey       public double square double num            return Math pow num  2            Hey hey   new Hey    Function lt Double  Double gt  square   hey  square  double ans   square apply 23d     Function above is a functional interface  To fully understand     it is important to understand functional interfaces as well  Plainly  a functional interface is an interface with just one abstract method   Examples of functional interfaces include Runnable  Callable  and ActionListener   Function above is a functional interface with just one method  apply  It takes one argument and produces a result     The reason why   s are awesome is that      Method references are expressions which have the same treatment as lambda expressions        but instead of providing a method body  they refer an existing method by name    E g  instead of writing the lambda body  Function lt Double  Double gt  square    Double x  - gt  x   x    You can simply do  Function lt Double  Double gt  square   Hey  square    At runtime  these two square methods behave exactly the same as each other  The bytecode may or may not be the same  though  for the above case  the same bytecode is generated  compile the above and check with javap -c    The only major criterion to satisfy is  the method you provide should have a similar signature to the method of the functional interface you use as object reference   The below is illegal   Supplier lt Boolean gt  p   Hey  square     illegal   square expects an argument and returns a double  The get method in Supplier returns a value but does not take an argument  Thus  this results in an error    A method reference refers to the method of a functional interface   As mentioned  functional interfaces can have only one method each     Some more examples  the accept method in Consumer takes an input but doesn t return anything   Consumer lt Integer gt  b1   System  exit       void exit int status  Consumer lt String   gt  b2   Arrays  sort      void sort Object   a  Consumer lt String gt  b3   MyProgram  main     void main String    args   class Hey       public double getRandom             return Math random             Callable lt Double gt  call   hey  getRandom  Supplier lt Double gt  call2   hey  getRandom  DoubleSupplier sup   hey  getRandom     Supplier is functional interface that takes no argument and gives a result   Above  getRandom takes no argument and returns a double  So any functional interface that satisfies the criteria of  take no argument and return double can be used    Another example   Set lt String gt  set   new HashSet lt  gt     set addAll Arrays asList  leo   bale   hanks     Predicate lt String gt  pred   set  contains  boolean exists   pred test  leo      In case of parameterized types   class Param lt T gt        T elem      public T get             return elem             public void set T elem            this elem   elem             public static  lt E gt  E returnSame E elem            return elem           Supplier lt Param lt Integer gt  gt  obj   Param lt Integer gt   new  Param lt Integer gt  param   obj get    Consumer lt Integer gt  c   param  set  Supplier lt Integer gt  s   param  get   Function lt String  String gt  func   Param   lt String gt returnSame    Method references can have different styles  but fundamentally they all mean the same thing and can simply be visualized as lambdas    A static method  ClassName  methName  An instance method of a particular object  instanceRef  methName  A super method of a particular object  super  methName  An instance method of an arbitrary object of a particular type  ClassName  methName  A class constructor reference  ClassName  new  An array constructor reference  TypeName    new    For further reference  see http   cr openjdk java net  briangoetz lambda lambda-state-final html

User · Answer

Usually  one would call the reduce method using Math max int  int  as follows   reduce new IntBinaryOperator         int applyAsInt int left  int right            return Math max left  right               That requires a lot of syntax for just calling Math max  That s where lambda expressions come into play  Since Java 8 it is allowed to do the same thing in a much shorter way   reduce  int left  int right  - gt  Math max left  right      How does this work  The java compiler  detects   that you want to implement a method that accepts two ints and returns one int  This is equivalent to the formal parameters of the one and only method of interface IntBinaryOperator  the parameter of method reduce you want to call   So the compiler does the rest for you - it just assumes you want to implement IntBinaryOperator   But as Math max int  int  itself fulfills the formal requirements of IntBinaryOperator  it can be used directly  Because Java 7 does not have any syntax that allows a method itself to be passed as an argument  you can only pass method results  but never method references   the    syntax was introduced in Java 8 to reference methods   reduce Math  max     Note that this will be interpreted by the compiler  not by the JVM at runtime  Although it produces different bytecodes for all three code snippets  they are semantically equal  so the last two can be considered to be short  and probably more efficient  versions of the IntBinaryOperator implementation above    See also Translation of Lambda Expressions

User · Answer

Since many answers here explained well    behaviour  additionally I would like to clarify that    operator doesnt need to have exactly same signature as the referring Functional Interface if it is used for instance variables  Lets assume we need a BinaryOperator which has type of TestObject  In traditional way its implemented like this   BinaryOperator lt TestObject gt  binary   new BinaryOperator lt TestObject gt                Override         public TestObject apply TestObject t  TestObject u                 return t                     As you see in anonymous implementation it requires two TestObject argument and returns a TestObject object as well  To satisfy this condition by using    operator we can start with a static method   public class TestObject         public static final TestObject testStatic TestObject t  TestObject t2           return t            and then call   BinaryOperator lt TestObject gt  binary   TestObject  testStatic    Ok it compiled fine  What about if we need an instance method  Lets update TestObject with instance method   public class TestObject        public final TestObject testInstance TestObject t  TestObject t2           return t             public static final TestObject testStatic TestObject t  TestObject t2           return t            Now we can access instance as below   TestObject testObject   new TestObject    BinaryOperator lt TestObject gt  binary   testObject  testInstance    This code compiles fine  but below one not   BinaryOperator lt TestObject gt  binary   TestObject  testInstance    My eclipse tell me  Cannot make a static reference to the non-static method testInstance TestObject  TestObject  from the type TestObject       Fair enough its an instance method  but if we overload testInstance as below   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            And call   BinaryOperator lt TestObject gt  binary   TestObject  testInstance    The code will just compile fine  Because it will call testInstance with single parameter instead of double one  Ok so what happened our two parameter  Lets printout and see   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            Which will output    1418481495    303563356    Test instance called  this hashCode 1418481495  Given parameter hashCode 303563356   Ok so JVM is smart enough to call param1 testInstance param2   Can we use testInstance from another resource but not TestObject  i e    public class TestUtil        public final TestObject testInstance TestObject t           return t            And call   BinaryOperator lt TestObject gt  binary   TestUtil  testInstance    It will just not compile and compiler will tell   The type TestUtil does not define testInstance TestObject  TestObject    So compiler will look for a static reference if it is not the same type  Ok what about polymorphism  If we remove final modifiers and add our SubTestObject class   public class SubTestObject extends TestObject        public final TestObject testInstance TestObject t           return t             And call   BinaryOperator lt TestObject gt  binary   SubTestObject  testInstance    It will not compile as well  compiler will still look for static reference  But below code will compile fine since it is passing is-a test   public class TestObject        public SubTestObject testInstance Object t           return  SubTestObject  t            BinaryOperator lt TestObject gt  binary   TestObject  testInstance        I am just studying so I have figured out by try and see  feel free to correct me if I am wrong

User · Answer

The    is known as method references  Lets say  we want to call a calculatePrice method of class Purchase  Then we can write it as   Purchase  calculatePrice   It can also be seen as short form of writing the lambda expression Because method references are converted into lambda expressions

User · Answer

Yes  that is true  The    operator is used for method referencing  So  one can extract static methods from classes by using it or methods from objects  The same operator can be used even for constructors  All cases mentioned here are exemplified in the code sample below   The official documentation from Oracle can be found here   You can have a better overview of the JDK 8 changes in this article  In the Method Constructor referencing section a code example is also provided   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

User · Answer

return reduce Math  max   is NOT EQUAL to return reduce max      But it means  something like this   IntBinaryOperator myLambda    a  b - gt   a  gt   b    a   b    56 keystrokes I had to type - - return reduce myLambda     You can just save 47 keystrokes if you write like this  return reduce Math  max    Only 9 keystrokes

User · Answer

In java-8 Streams Reducer in simple works is a function which takes two values as input and returns result after some calculation  this result is fed in next iteration   in case of Math max function  method keeps returning max of two values passed and in the end you have largest number in hand

User · Answer

It seems its little late but here are my two cents  A lambda expression is used to create anonymous methods  It does nothing but call an existing method  but it is clearer to refer to the method directly by its name  And method reference enables us to do that using method-reference operator       Consider the following simple class where each employee has a name and 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            Suppose we have a list of employees returned by some method and we want to sort the employees by their grade  We know we can make use of anonymous class as       List lt Employee gt  employeeList   getDummyEmployees            Using anonymous class     employeeList sort new Comparator lt Employee gt                  Override            public int compare Employee e1  Employee e2                   return e1 getGrade   compareTo e2 getGrade                            where getDummyEmployee   is some method as     private static List lt Employee gt  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                              Now we know that Comparator is a Functional Interface  A Functional Interface is the one with exactly one abstract method  though it may contain one or more default or static methods   Lambda expression provides implementation of  FunctionalInterface so a functional interface can have only one abstract method  We can use lambda expression as   employeeList sort  e1 e2  - gt  e1 getGrade   compareTo e2 getGrade         lambda exp   It seems all good but what if the class Employee also provides similar method   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 this case using the method name itself will be more clear  Hence we can directly refer to method by using method reference as   employeeList sort Employee  compareByGrade      method reference   As per docs there are four kinds of method references    ---- ------------------------------------------------------- --------------------------------------         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                          ------------------------------------------------------------ --------------------------------------

User · Answer

I found this source very interesting   In fact  it is the Lambda that turns into a Double Colon  The Double Colon is more readable  We follow those steps   STEP1      We create a comparator of two persons Comparator c    Person p1  Person p2  - gt  p1 getAge   compareTo p2 getAge       STEP2      We use the interference Comparator c    p1  p2  - gt  p1 getAge   compareTo p2 getAge       STEP3      The magic using method reference Comparator c   Comparator comparing Person  getAge

User · Answer

Operator was introduced in java 8 for method references  A method reference is the shorthand syntax for a lambda expression that executes just ONE method  Here s the general syntax of a method reference   Object    methodName   We know that we can use lambda expressions instead of using an anonymous class  But sometimes  the lambda expression is really just a call to some method  for example   Consumer lt String gt  c   s - gt  System out println s     To make the code clearer  you can turn that lambda expression into a method reference   Consumer lt String gt  c   System out  println

User · Answer

At runtime they behave a exactly the same The bytecode may not be same  For above Incase it generates the same bytecode complie above and check javaap  -c     At runtime they behave a exactly the same method math  max   it generates the same math  complie above and check javap -c

User · Answer

Double colon i e     operator is introduced in Java 8 as a method reference  Method reference is a form of lambda expression which is used to refer the existing method by its name   classname  methodName  ex -   stream forEach element - gt  System out println element     By using Double Colon      stream forEach System out  println element

User · Answer

So I see here tons of answers that are frankly overcomplicated  and that s an understatement  The answer is pretty simple     it s called a Method References https   docs oracle com javase tutorial java javaOO methodreferences html So I won t copy-paste  on the link  you can find all the information if you scroll down to the table   Now  let s take a short look at what is a Method References  A  b somewhat substitutes the following inline lambda expression   params      - gt  A b params      To correlate this with your questions  it s necessary to understand a java lambda expression  Which is not hard  An inline lambda expression is similar to a defined functional interface  which is an interface that has no more and no less than 1 method   Let s take a short look what I mean  InterfaceX f    x  - gt  x x    InterfaceX must be a functional interface  Any functional interface  the only thing what s important about InterfaceX for that compiler is that you define the format  InterfaceX can be any of this  interface InterfaceX       public Integer callMe Integer x      or this interface InterfaceX       public Double callMe Integer x      or more generic  interface InterfaceX lt T U gt        public T callMe U x      Let s take the first presented case and the inline lambda expression that we defined earlier  Before Java 8  you could ve defined it similarly this way   InterfaceX o   new InterfaceX                         public int callMe  int x                                                    return x x                                                     Functionally  it s the same thing  The difference is more in how the compiler perceives this  Now that we took a look at inline lambda expression  let s return to Method References       Let s say you have a class like this  class Q           public static int anyFunction int x                                  return x 5                                  Since method anyFunctions has the same types as InterfaceX callMe  we can equivalate those two with a Method Reference  We can write it like this  InterfaceX o    Q  anyFunction    and that is equivalent to this   InterfaceX o    x  - gt  Q anyFunction x    A cool thing and advantage of Method References are that at first  until you assign them to variables  they are typeless  So you can pass them as parameters to any equivalent looking  has same defined types  functional interface  Which is exactly what happens in your case

[java] :: (double colon) operator in Java 8

Examples related to java

Examples related to java-8