{"id":1349,"date":"2012-07-14T11:08:50","date_gmt":"2012-07-14T09:08:50","guid":{"rendered":"http:\/\/doanduyhai.wordpress.com\/?p=1349"},"modified":"2012-07-14T11:08:50","modified_gmt":"2012-07-14T09:08:50","slug":"java-8-lambda-in-details-part-iii-method-and-constructor-referencing","status":"publish","type":"post","link":"https:\/\/www.doanduyhai.com\/blog\/?p=1349","title":{"rendered":"Java 8 Lambda in details part III : Method and constructor referencing"},"content":{"rendered":"

In this third post dedicated to Java 8 Lambda expressions, we’ll look at the new ::<\/strong><\/font> operator introduced to allow method and constructor referencing.
\n<\/p>\n

DISCLAIMER: all the details exposed in this post were observed related to the JDK 8 demo version as of July 10th 2012<\/font>. Since the JDK is still in beta, some assertions may not hold in future<\/strong>\n<\/p><\/blockquote>\n

Please note that all the example code in this post can be found on my GitHub repository https:\/\/github.com\/doanduyhai\/Java8_Lambda_In_Details<\/a><\/p><\/blockquote>\n

 <\/p>\n

I Method referencing<\/h1>\n

With the JDK 8 it is possible to create a lambda expression by aliasing an existing method in a class. For this the new ::<\/strong><\/font> operator has been introduced. It is possible to reference a method:<\/p>\n

    \n
  1. from its class<\/strong> if it was declared static<\/li>\n
  2. from an instance variable<\/strong> of from the this<\/strong> keyword for non-static methods<\/li>\n<\/ol>\n
    \npublic interface MethodReferenceSAM\n{\n\tString process(String input);\n}\n\npublic class MethodReference\n{\n\tpublic static String toUpperStatic(String input)\n\t{\n\t\treturn input.toUpperCase();\n\t}\n\n\tpublic String toUpperInstance(String input)\n\t{\n\t\treturn input.toUpperCase();\n\t}\n\n\tpublic String toUpperFromThis(String input)\n\t{\n\t\tMethodReferenceSAM sam = this::toUpperInstance;\n\t\treturn sam.process(input);\n\t}\n\n\tpublic static void main(String... args)\n\t{\n\t\tMethodReferenceSAM sam = MethodReference::toUpperStatic;\n\t\tSystem.out.println(&quot;nntstatic method reference = &quot;+sam.process(&quot;static_input&quot;));\n\t\t\n\t\tMethodReference methodReference = new MethodReference();\n\t\tsam = methodReference::toUpperInstance;\n\t\tSystem.out.println(&quot;nntinstance method reference = &quot;+sam.process(&quot;instance_input&quot;));\n\t\t\n\t\tSystem.out.println(&quot;nnt&quot;this&quot; method reference = &quot;+methodReference.toUpperFromThis(&quot;this_input&quot;));\n\t\tSystem.out.println(&quot;&quot;);\n\t}\n}\n<\/pre>\n
    The output:<\/p>\n
    \nstatic method reference = STATIC_INPUT<\/p>\n
    instance method reference = INSTANCE_INPUT<\/p>\n
    “this” method reference = THIS_INPUT\n<\/p><\/blockquote>\n
    Pretty straightforward. With this feature, we can create a method (static or not) and possibly assigned it as lambda expression to two different SAM (S<\/strong>ingle A<\/strong>bstract M<\/strong>ethod) interface, as long as the method signatures match.<\/p>\n
    Example<\/p>\n
    \npublic interface SAM1\n{\n\tString process(String input);\n}\n\npublic interface SAM2\n{\n\tString differentName(String input);\n}\n\n...\nSAM1 sam1 = MethodReference::toUpperStatic;\n\nSAM1 sam2 = MethodReference::toUpperStatic;\n\n<\/pre>\n
    The above code example can be found on GitHub at https:\/\/github.com\/doanduyhai\/Java8_Lambda_In_Details<\/a>. Just execute the MethodReference.bat(MethodReference.sh)<\/strong> script<\/p><\/blockquote>\n
     <\/p>\n
    II Constructor referencing<\/h1>\n
    Constructor referencing is quite similar to method referencing. The SAM interface method should have the same signature as the constructor method being used.<\/p>\n
    \npublic interface ConstructorReferenceSAM&lt;T&gt;\n{\n\tT whatEverMethodName();\n}\n\npublic interface ConstructorReferenceSAMWithArgs&lt;T, U&gt;\n{\n\tT createMeANewObject(U arg);\n}\n\npublic interface ConstructorReferenceSAMWithParameterizedArg&lt;T, U&gt;\n{\n\tT magic(List&lt;U&gt; arg);\n}\n\npublic class ConstructorReference\n{\n\n\tprivate String content;\n\n\tprivate List&lt;String&gt; contents;\n\n\tpublic ConstructorReference() {\n\t\tthis.content = &quot;created by constructor reference&quot;;\n\t}\n\n\tpublic ConstructorReference(String content) {\n\t\tthis.content = content;\n\t}\n\n\tpublic ConstructorReference(List&lt;String&gt; contents) {\n\t\tthis.contents = contents;\n\t}\n\n\tpublic String getContent()\n\t{\n\t\treturn content;\n\t}\n\n\tpublic List&lt;String&gt; getContents()\n\t{\n\t\treturn contents;\n\t}\n\n\tpublic static void main(String... args)\n\t{\n\t\tConstructorReferenceSAM&lt;ConstructorReference&gt; constructorSam = ConstructorReference::new;\n\t\tSystem.out.println(&quot;nntcontent = &quot;+constructorSam.whatEverMethodName().getContent());\n\t\t\n\t\tConstructorReferenceSAMWithArgs&lt;ConstructorReference,String&gt; constructorSamWithArg = ConstructorReference::new;\t\t\n\t\tSystem.out.println(&quot;nntcontent by arg = &quot;+constructorSamWithArg.createMeANewObject(&quot;created by constructor reference with arg&quot;).getContent());\n\t\t\n\t\tConstructorReferenceSAMWithParameterizedArg&lt;ConstructorReference,String&gt; constructorSamWithParameterizedArg = ConstructorReference::&lt;String&gt;new;\n\t\tSystem.out.println(&quot;nntcontents size by parameterized arg = &quot;+constructorSamWithParameterizedArg.magic(new ArrayList&lt;String&gt;()).getContents().size());\n\t\tSystem.out.println(&quot;&quot;);\n\t\t\n\t}\n}\n<\/pre>\n
    The output:<\/p>\n
    \n
            content = created by constructor reference<\/p>\n
            content by arg = created by constructor reference with arg<\/p>\n
            contents size by parameterized arg = 0\n<\/p><\/blockquote>\n
    For constructor with parameterized arguments, please notice the special syntax for referencing (line 53<\/strong>) ConstructorReference::<String>new;<\/strong><\/p>\n
    The above code example can be found on GitHub at https:\/\/github.com\/doanduyhai\/Java8_Lambda_In_Details<\/a>. Just execute the ConstructorReference.bat(ConstructorReference.sh)<\/strong> script<\/p><\/blockquote>\n
     To be continued …
    \n 
    \n <\/p>\n","protected":false},"excerpt":{"rendered":"
    In this third post dedicated to Java 8 Lambda expressions, we’ll look at the new :: operator introduced to allow method and constructor referencing.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":[],"categories":[6,8],"tags":[],"_links":{"self":[{"href":"https:\/\/www.doanduyhai.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/1349"}],"collection":[{"href":"https:\/\/www.doanduyhai.com\/blog\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.doanduyhai.com\/blog\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.doanduyhai.com\/blog\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.doanduyhai.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=1349"}],"version-history":[{"count":0,"href":"https:\/\/www.doanduyhai.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/1349\/revisions"}],"wp:attachment":[{"href":"https:\/\/www.doanduyhai.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=1349"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.doanduyhai.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=1349"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.doanduyhai.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=1349"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}