1.方法引用簡述

方法引用是用來直接訪問類或者實例的已經(jīng)存在的方法或者構(gòu)造方法。方法引用提供了一種引用而不執(zhí)行方法的方式，它需要由兼容的函數(shù)式接口構(gòu)成的目標(biāo)類型上下文。計算時，方法引用會創(chuàng)建函數(shù)式接口的一個實例。

當(dāng)Lambda表達(dá)式中只是執(zhí)行一個方法調(diào)用時，不用Lambda表達(dá)式，直接通過方法引用的形式可讀性更高一些。方法引用是一種更簡潔易懂的Lambda表達(dá)式。

Lambda表達(dá)式全文詳情地址：http://blog.csdn.net/sun_promise/article/details/51121205

2.作用

方法引用的唯一用途是支持Lambda的簡寫。

方法引用提高了代碼的可讀性，也使邏輯更加清晰。（優(yōu)點）

3.組成

使用::操作符將方法名和對象或類的名字分隔開。

“::” 是域操作符（也可以稱作定界符、分隔符）。

eg：

4.分類

1）靜態(tài)方法引用

組成語法格式：ClassName::staticMethodName

Note：

• 靜態(tài)方法引用比較容易理解，和靜態(tài)方法調(diào)用相比，只是把 . 換為 ::
• 在目標(biāo)類型兼容的任何地方，都可以使用靜態(tài)方法引用。
  

eg：

-- String::valueOf   等價于lambda表達(dá)式 (s) -> String.valueOf(s)

-- Math::pow       等價于lambda表達(dá)式  (x, y) -> Math.pow(x, y);

-- 假設(shè)需要從一個數(shù)字列表中找出最大的一個數(shù)字。

方法引用方式：

(max是一Collections里的一個靜態(tài)方法，它需要傳入一個List類型的參數(shù)。)

Function<List<Integer>, Integer> maxFn =Collections::max;

maxFn.apply(Arrays.asList(1, 10, 3, 5))。

上面 等價于Lambda表達(dá)式 Function<List<Integer>, Integer> maxFn = (numbers) -> Collections.max(numbers);。

--  以字符串反轉(zhuǎn)為例：

/*
* 函數(shù)式接口
* */
interface StringFunc {
 String func(String n);
}
class MyStringOps {
 //靜態(tài)方法： 反轉(zhuǎn)字符串
 public static String strReverse(String str) {
 String result = "";
 for (int i = str.length() - 1; i >= 0; i--) {
  result += str.charAt(i);
 }
 return result;
 }
}
class MethodRefDemo {
 public static String stringOp(StringFunc sf, String s) {
 return sf.func(s);
 }
 public static void main(String[] args) {
 String inStr = "lambda add power to Java";
 //MyStringOps::strReverse 相當(dāng)于實現(xiàn)了接口方法func() ，并在接口方法func()中作了MyStringOps.strReverse()操作
 String outStr = stringOp(MyStringOps::strReverse, inStr);
 System.out.println("Original string: " + inStr);
 System.out.println("String reserved: " + outStr);
 }
}

輸出結(jié)果：

Original string: lambda add power to Java
String reserved: avaJ ot rewop dda adbmal

分析：

在程序中，特別注意下面這行代碼：String outStr = stringOp(MyStringOps::strReverse, inStr);

其中將對MyStringOps內(nèi)聲明的靜態(tài)方法strReverse()的引用傳遞給stringOp()方法的第一個參數(shù)?？梢赃@么做，因為
strReverse與StringFunc函數(shù)式接口兼容。因此，表達(dá)式MyStringOps::strReverse的計算結(jié)果為對象引用，其中，
strReverse提供了StringFunc的func()方法的實現(xiàn)。

--  找到列表中具有最大值的對象

（找到集合中最大元素的一種方法是使用Collections類定義的max()方法。對于這里使用的max()版本，必須傳遞一個集合引用，以及一個實現(xiàn)了Comparator<T>接口的對象的實例。Comparator<T>接口指定如何比較兩個對象，它只定義了抽象方法compare()，該方法接受兩個參數(shù)，其類型均為要比較的對象的類型。如果第一個參數(shù)大于第二個參數(shù)，該方法返回一個正數(shù)；如果兩個參數(shù)相等，返回0；如果第一個參數(shù)小于第二個參數(shù)，返回一個負(fù)數(shù)。

過去，要在max()方法中使用用戶定義的對象，必須首先通過一個類顯式實現(xiàn)Comparator<T>接口，然后創(chuàng)建該類的一個實例，通過這種方法獲得Comparator<T>接口的一個實例，然后，把這個實例作為比較器傳遞給max()方法。在JDK 8中，現(xiàn)在可以簡單地將比較方法的引用傳遞給max()方法，因為這將自動實現(xiàn)比較器。）

class MyClass {
 private int val;
 MyClass(int v) {
 val = v;
 }
 public int getValue() {
 return val;
 }
}
class UseMethodRef {
 public static int compareMC(MyClass a, MyClass b) {
 return a.getValue() - b.getValue();
 }
 public static void main(String[] args) {
 ArrayList<MyClass> a1 = new ArrayList<MyClass>();
 a1.add(new MyClass(1));
 a1.add(new MyClass(4));
 a1.add(new MyClass(2));
 a1.add(new MyClass(9));
 a1.add(new MyClass(3));
 a1.add(new MyClass(7));
 //UseMethodRef::compareMC生成了抽象接口Comparator定義的compare()方法的實例。
 MyClass maxValObj = Collections.max(a1, UseMethodRef::compareMC);
 System.out.println("Maximum value is: " + maxValObj.getValue());
 }
}

輸出結(jié)果：

Maximum value is: 9

分析：

在程序中，注意MyClass即沒有定義自己的比較方法，也沒有實現(xiàn)Comparator接口。但是，通過調(diào)用max()方法，仍然可以獲得MyClass對象列表中的最大值，這是因為UseMethodRef定義了靜態(tài)方法compareMC()，它與Comparator定義的compare()方法兼容。因此，沒喲必要顯式的實現(xiàn)Comparator接口并創(chuàng)建其實例。

2）實例方法引用

這種語法與用于靜態(tài)方法的語法類似，只不過這里使用對象引用而不是類名。

實例方法引用又分以下三種類型

a.實例上的實例方法引用

組成語法格式：instanceReference::methodName

Note：

對于具體（或者任意）對象的實例方法引用，在實例方法名稱和其所屬類型名稱間加上分隔符 ：

與引用靜態(tài)方法引用相比，都換為實例對象的而已。

eg：

-- Function<String, String> upper = String::toUpperCase;

--

/*
* 函數(shù)式接口
* */
interface StringFunc {
 String func(String n);
}
class MyStringOps {
 //普通方法： 反轉(zhuǎn)字符串
 public String strReverse(String str) {
 String result = "";
 for (int i = str.length() - 1; i >= 0; i--) {
  result += str.charAt(i);
 }
 return result;
 }
}
class MethodRefDemo2 {
 public static String stringOp(StringFunc sf, String s) {
 return sf.func(s);
 }
 public static void main(String[] args) {
 String inStr = "lambda add power to Java";
 MyStringOps strOps = new MyStringOps();//實例對象
 //MyStringOps::strReverse 相當(dāng)于實現(xiàn)了接口方法func() ，并在接口方法func()中作了MyStringOps.strReverse()操作
 String outStr = stringOp(strOps::strReverse, inStr);
 
 System.out.println("Original string: " + inStr);
 System.out.println("String reserved: " + outStr);
 }
}

輸出結(jié)果：

Original string: lambda add power to Java
String reserved: avaJ ot rewop dda adbmal

分析：

這里使用了類的名稱，而不是具體的對象，盡管指定的是實例方法。使用這種形式時，函數(shù)式接口的第一個參數(shù)匹配調(diào)用對象，第二個參數(shù)匹配方法指定的參數(shù)。

-- 定義了一個方法counter()，用于統(tǒng)計某個數(shù)組中，滿足函數(shù)式接口MyFunc的fun()方法定義的條件的對象個數(shù)。本例中，統(tǒng)計HighTemp類的實例個數(shù)。

interface MyFunc<T> {
 boolean func(T v1, T v2);
}
class HighTemp {
 private int hTemp;
 HighTemp(int ht) {
 hTemp = ht;
 }
 public boolean sameTemp(HighTemp ht2) {
 return hTemp == ht2.hTemp;
 }
 public boolean lessThanTemp(HighTemp ht2) {
 return hTemp < ht2.hTemp;
 }
}
class InstanceMethWithObjectRefDemo {
 public static <T> int counter(T[] vals, MyFunc<T> f, T v) {
 int count = 0;
 
 for (int i = 0; i < vals.length; i++) {
  if (f.func(vals[i], v)) count++;
 }
 return count;
 }
 public static void main(String[] args) {
 int count;
 HighTemp[] weekDayHighs = {
  new HighTemp(89), new HighTemp(82),
  new HighTemp(90), new HighTemp(89),
  new HighTemp(89), new HighTemp(91),
  new HighTemp(84), new HighTemp(83)};
 //HighTemp::sameTemp 為實例方法引用
 count = counter(weekDayHighs, HighTemp::sameTemp, new HighTemp(89));
 System.out.println(count + " days had a high of 89");
 HighTemp[] weekDayHighs2 = {
  new HighTemp(31), new HighTemp(12),
  new HighTemp(24), new HighTemp(19),
  new HighTemp(18), new HighTemp(12),
  new HighTemp(-1), new HighTemp(13)};
 
 count = counter(weekDayHighs2, HighTemp::sameTemp, new HighTemp(12));
 System.out.println(count + " days had a high of 12");
 
 count = counter(weekDayHighs, HighTemp::lessThanTemp, new HighTemp(89));
 System.out.println(count + " days had a high less than 89");
 
 count = counter(weekDayHighs2, HighTemp::lessThanTemp, new HighTemp(19));
 System.out.println(count + " days had a high of less than 19");
 }
}

輸出結(jié)果：

3 days had a high of 89
2 days had a high of 12
3 days had a high less than 89
5 days had a hign less than 19

分析：

注意HighTemp有兩個實例方法：someTemp()和lessThanTemp()。如果兩個HighTemp對象包含相同的溫度，

sameTemp()方法返回true。如果調(diào)用對象的溫度小于被傳遞的對象的溫度，lessThanTemp()方法返回true。這兩個方法都有一個HighTemp類型的參數(shù)，并且都返回布爾結(jié)果。因此，這兩個方法都與MyFunc函數(shù)式接口兼容，因為調(diào)用對象類型可以映射到func()的第一個參數(shù)，傳遞的實參可以映射到func()的第二個參數(shù)。因此，這個表達(dá)式：HighTemp::sameTemp

被傳遞給counter()方法時，會創(chuàng)建函數(shù)式接口的一個實例，其中第一個參數(shù)的參數(shù)類型就是實例方法的調(diào)用對象的類型，也就是HighTemp。第二個參數(shù)的類型也是HighTemp，因為這是sameTemp()方法的參數(shù)。對于lessThanTemp()，這也是成立的。

Note：

上面程序中函數(shù)式接口中的函數(shù)boolean func(T v1,T v2)中含有兩個參數(shù)，而HighTemp中函數(shù)sameTemp(HighTemp ht2)含有一個參數(shù)，但是能夠兼容的原因是：

其實HighTemp類中的sameTemp(HighTemp ht2)其實包含兩個參數(shù)，默認(rèn)隱藏調(diào)用這個函數(shù)的引用this。

故，當(dāng)使用類的實例方法作為方法引用時，函數(shù)式接口的第一個參數(shù)匹配類的實例方法的調(diào)用對象，第二個參數(shù)才匹配方法指定的參數(shù)。

b.超類上的實例方法引用

組成語法格式：super::methodName

方法的名稱由methodName指定

通過使用super，可以引用方法的超類版本。

eg： super::name

Note：還可以捕獲this 指針

this :: equals  等價于lambda表達(dá)式  x -> this.equals(x);

c.類型上的實例方法引用
組成語法格式：ClassName::methodName

Note：

若類型的實例方法是泛型的，就需要在::分隔符前提供類型參數(shù)，或者（多數(shù)情況下）利用目標(biāo)類型推導(dǎo)出其類型。

靜態(tài)方法引用和類型上的實例方法引用擁有一樣的語法。編譯器會根據(jù)實際情況做出決定。

一般我們不需要指定方法引用中的參數(shù)類型 ，因為編譯器往往可以推導(dǎo)出結(jié)果，但如果需要我們也可以顯式在::分隔符之前提供參數(shù)類型信息。

eg：

String::toString 等價于lambda表達(dá)式 (s) -> s.toString()

這里不太容易理解，實例方法要通過對象來調(diào)用，方法引用對應(yīng)Lambda，Lambda的第一個參數(shù)會成為調(diào)用實例方法的對象。

在泛型類或泛型方法中，也可以使用方法引用。

interface MyFunc<T> {
 int func(T[] als, T v);
}
class MyArrayOps {
 public static <T> int countMatching(T[] vals, T v) {
 int count = 0;
 for (int i = 0; i < vals.length; i++) {
  if (vals[i] == v) count++;
 }
 return count;
 }
}
class GenericMethodRefDemo {
 public static <T> int myOp(MyFunc<T> f, T[] vals, T v) {
 return f.func(vals, v);
 }
 public static void main(String[] args){
 Integer[] vals = {1, 2, 3, 4, 2, 3, 4, 4, 5};
 String[] strs = {"One", "Two", "Three", "Two"};
 int count;
 count=myOp(MyArrayOps::<Integer>countMatching, vals, 4);
 System.out.println("vals contains "+count+" 4s");
 count=myOp(MyArrayOps::<String>countMatching, strs, "Two");
 System.out.println("strs contains "+count+" Twos");
 }
}

輸出結(jié)果：

vals contains 3 4s
strs contains 2 Twos

分析：

在程序中，MyArrayOps是非泛型類，包含泛型方法countMatching()。該方法返回數(shù)組中與指定值匹配的元素的個數(shù)。注意這里如何指定泛型類型參數(shù)。例如，在main()方法中，對countMatching()方法的第一次調(diào)用如下所示：count = myOp(MyArrayOps::<Integer>countMatching,vals,4);
這里傳遞了類型參數(shù)Integer。

注意，參數(shù)傳遞發(fā)生在::的后面。這種語法可以推廣。當(dāng)把泛型方法指定為方法引用時，類型參數(shù)出現(xiàn)在::之后、方法名之前。但是，需要指出的是，在這種情況(和其它許多情況)下，并非必須顯示指定類型參數(shù)，因為類型參數(shù)會被自動推斷得出。對于指定泛型類的情況，類型參數(shù)位于類名的后面::的前面。

3）構(gòu)造方法引用

構(gòu)造方法引用又分構(gòu)造方法引用和數(shù)組構(gòu)造方法引用。

a.構(gòu)造方法引用 （也可以稱作構(gòu)造器引用）

組成語法格式：Class::new

構(gòu)造函數(shù)本質(zhì)上是靜態(tài)方法，只是方法名字比較特殊，使用的是new 關(guān)鍵字。

eg：

-- String::new， 等價于lambda表達(dá)式 () -> new String()

--

List<String> strings = new ArrayList<String>();
strings.add("a");
strings.add("b");
Stream<Button> stream = strings.stream().map(Button::new);
List<Button> buttons = stream.collect(Collectors.toList());

-- 可以把這個引用賦值給定義的方法與構(gòu)造函數(shù)兼容的任何函數(shù)式接口的引用

interface MyFunc {
 MyClass func(int n);
}
class MyClass {
 private int val;
 MyClass(int v) {
  val = v;
 }
 MyClass() {
  val = 0;
 }
 public int getValue() {
  return val;
 }
}
class ConstructorRefDemo {
 public static void main(String[] args) {
  MyFunc myClassCons = MyClass::new;
  MyClass mc = myClassCons.func(100);
  System.out.println("val in mc is: " + mc.getValue());
 }
}

輸出結(jié)果：

val in mc is: 100

b.數(shù)組構(gòu)造方法引用：

組成語法格式：TypeName[]::new

eg：

-- int[]::new 是一個含有一個參數(shù)的構(gòu)造器引用，這個參數(shù)就是數(shù)組的長度。

等價于lambda表達(dá)式  x -> new int[x]。

-- 假想存在一個接收int參數(shù)的數(shù)組構(gòu)造方法

IntFunction<int[]> arrayMaker = int[]::new;
int[] array = arrayMaker.apply(10) // 創(chuàng)建數(shù)組 int[10]

到此這篇關(guān)于Java8新特性：Lambda表達(dá)式之方法引用詳解的文章就介紹到這了,更多相關(guān)Java8 Lambda表達(dá)式之方法引用內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評論