【2.1.4 通用函数接口java.util.function.*   返回目录】

 

为了配合λ表达式的使用，定义了一些作为形参的函数接口。java.util.function包基本覆盖了程序员对函数接口的各种需求。

1.方法的类型签名

函数的类型签名，描述方法的形参列表类型通过本方法处理后，形成返回值类型。以如下格式描述：(形参列表类型) ->返回值类型

从方法的类型签名分析，java.util.function包的核心函数接口有4个。

Ø        函数型T ->R，完成参数类型T向结果类型R的转换。核心函数接口Function

Ø        判断型T ->boolean，核心函数接口Predicate/谓词

Ø        消费型T ->void，核心函数接口Consumer 

Ø        供给型void->T，核心函数接口Supplier

其他函数接口与它们类似。各种类型签名可以拓展到二元如(T, U) -> R，三元及更多元的类型签名，难以支持。

由于Java泛型采用擦除技术，Java中不可以用同一个名字定义不同类型或不同数量的参数的泛型类，即无法定义Function<T, R>、Function<T,U, R>、Function<Integer, Integer >等，而必须取不同的类型名字。

 

2.避免装箱和拆箱

 

Java泛型仅针对引用类型，如果使用Function<Integer, Integer>，会将代码中的int进行装箱，从而在性能上付出代价。java.util.function包针对基本类型的int、double和long提供支持，当输入或/和输出为基本类型时，可以避免自动装箱的操作。


			
核心函数接口
			
			

			
简化或二元拓展
			
			

			
基本类型
			
		

			
Function<T, R> ,T ->R

			
共25个接口
			
			

			
 
			
			

			
IntFunction<R>,int->R

			
LongFunction<R>

			
DoubleFunction<R>

			
IntToDoubleFunction, int->double

			
IntToLongFunction

			
LongToDoubleFunction,

			
LongToIntFunction,

			
DoubleToIntFunction

			
DoubleToLongFunction

			
ToIntFunction<T>, T->int

			
ToDoubleFunction<T>,

			
ToLongFunction<T>
			
		

			
BiFunction<T,U,R> ,(T,U) ->R
			
			

			
ToIntBiFunction<T,U>,

			
ToLongBiFunction<T,U>,

			
ToDoubleBiFunction<T,U>
			
		

			
UnaryOperator<T>, T->T
			
			

			
IntUnaryOperator,

			
LongUnaryOperator,

			
DoubleUnaryOperator
			
		

			
BinaryOperator<T> (T,T) ->T 
			
			

			
IntBinaryOperator,

			
LongBinaryOperator,

			
DoubleBinaryOperator
			
		

			
Predicate<T>  T->boolean 

			
共5个接口
			
			

			
 
			
			

			
IntPredicate,

			
LongPredicate,

			
DoublePredicate
			
		

			
BiPredicate<L,R>  (L,R)->boolean
			
			

			
 
			
		

			
Consumer<T>, T->void

			
共8个接口
			
			

			
 
			
			

			
IntConsumer,

			
LongConsumer,

			
DoubleConsumer
			
		

			
BiConsumer<T,U>  (T,U)->void
			
			

			
ObjIntConsumer<T>,

			
ObjLongConsumer<T>,

			
ObjDoubleConsumer<T>
			
		

			
Supplier<T> ()->T

			
共5个接口
			
			

			
 
			
			

			
BooleanSupplier,

			
IntSupplier,

			
LongSupplier,

			
DoubleSupplier
			
		
 

3.自定义函数接口

 

虽然java.util.function包提供了通用函数接口，在后面的例子中仍然使用了自定义函数接口，主要考虑在演示代码中自定义函数接口比通用函数接口更容易理解。某种程度上，使用通用函数接口，如同定义各种类时，将各种类的方法全部命名为doSth()一样，会降低代码的可读性。

另一方面，通过自定义函数接口，可以掌握通用函数接口的使用，这里就不举例说明通用函数接口的用法了。

4.方法引用

函数接口主要支持λ表达式的使用，例如

ToIntFunction<String>f = s->s.length();

值得注意的是，在λ表达式中调用某个类的方法或构造器的情形，Java 8提供了λ表达式的简化版本，方法引用。

ToIntFunction<String>f = String::length;

方法引用是否会降低代码的可读性，见仁见智。

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

IntConsumer   c2= System.out::println;

当调用accept()，要注意c需要的参数为泛型指出的String，而c2需要的参数为类名IntConsumer暗示的int。

c.accept("hello");

c2.accept(5);

另外，yqj2065觉得冒号冒号，很丑陋。

 

 

 

注：在我们讨论各种函数接口时，关心类型签名，而函数名applyAsDouble等等不需要知道，yqj2065说过：lambda表达式是省略了名字的函数。通常，通用函数接口中抽象方法的名字如applyAsDouble、apply、test，应用程序员甚至不需要知道，我们使用lambda表达式时就不需要写函数名。

 

int –> int封装为IntUnaryOperator。类似的，对于long–> long封装为LongUnaryOperator、double–> double封装为DoubleUnaryOperator。
	
对于参数和返回值为基本类型的一元函数，int –> long封装为IntToLongFunction、int –> double封装为IntToDoubleFunction、long–> int封装为LongToIntFunction、long–> double封装为LongToDoubleFunction、double–> int封装为DoubleToIntFunction、double–> long封装为DoubleToLongFunction。
	
参数为基本类型而返回值为R的一元函数，int –> R封装为IntFunction<R> 、long–> R封装为LongFunction<R>、double–> R封装为DoubleFunction<R>；
	
参数为T而返回值为int等情况，T–> int封装为ToIntFunction<T>、T–> long封装为ToLongFunction<T>、T–> double封装为ToDoubleFunction<T>。
	
更一般的一元函数，T–> R封装为Function<T,R>。如果是T–> T，则特化为UnaryOperator<T>。
一元函数就有了17个函数接口。下面是几个例子。


    public static void unaryFunction(){//一元函数
        F y = x-> x + 1; 
        pln(y.f(2));
        IntUnaryOperator y1 = x-> x + 1; //int –> int
        pln(y1.applyAsInt(2));
        IntToDoubleFunction y2 = x-> x + 1; //int –> double
        pln(y2.applyAsDouble(2));
        ToIntFunction<String> y3 = s->s.length();//T–> int
        pln(y3.applyAsInt("hello"));
        IntFunction<String> y4 = i->(i+"ok");//int–> R
        pln(y4.apply(5));
        Function<String,Integer>  y5 =  s->s.length();//String–> Integer
        pln(y5.apply("hello"));        
    }


 

从一元函数扩展到二元函数，Java中不能够定义不同个数参数的泛型类，如DoubleOP<T,U>、DoubleOP<T,U,V>、DoubleOP<T,U,V,W>，必须为它们取不同的名字，真是醉了。可以从自定义的double op(double m,double n)出发，也可以从一般到特殊：


一般的二元函数，(T, U) –> R封装为BiFunction<T,U,R>。如果是(T, T)–> T，则特化为BinaryOperator<T>。
	
(T, U) –> int封装为ToIntBiFunction<T,U>、(T, U) –> long封装为ToLongBiFunction<T,U>、(T, U) –> double封装为ToDoubleBiFunction<T,U>。
	
(int, int) –> int封装为IntBinaryOperator；类似的，(long, long) –> long封装为LongBinaryOperator、(double, double) –> double封装为DoubleBinaryOperator。
	
(int, long) –> int这样的组合太多，不提供封装类。


 

 本系列中25个接口。

 

    public static void testFunction(){

        principle.callback.lower.DoubleOP<Double,String> f = ( x, y)->{return x +y.length() ;};
        double d = f.applyAsDouble(1.0,"yqj2065");
        pln(d);
        
        ToDoubleBiFunction<Double,Double> f1 = ( m, n)->{return m +2*n ;};
        d = f1.applyAsDouble(1.0,3.0);        pln(d);
        
        Function<String,Double> f2 = x->(double)x.length();
        d = f2.apply("yqj2065"); pln(d);
        BiFunction<String,String,Double>  f3 = (x,y)->x.length()+y.length()*1.0;
        d = f3.apply("yqj","2065"); pln(d);
        BinaryOperator<Double> f4 = (x,y)->x+y;
        d = f4.apply(1.0,3.0); pln(d);
        DoubleBinaryOperator f5 = (x,y)->x+y;
        d = f5.applyAsDouble(1.0,3.0); pln(d);
        
    }

 

通用函数接口最大的用途，是框架或/和类库的设计。假设下面代码中m()是库函数，应用程序test2()可以视m()为一个高阶函数，它使用函数接口作为形参，而应用程序以lambda表达式作为实参。

 

 

    public static void m(Predicate<String> p, String t) {
        if (p.test(t)) {
            System.out.println("ok");
        }
    }
    public static void test2(){
        m(s->s.startsWith("a"),"aab");
    }

 

2.Predicate<T> 

谓词/Predicate，针对T数据进行测试，返回boolean。lambda表达式的类型签名T→boolean。

 

上面m()的形参为Predicate<String>，针对String数据进行测试；通常的形参为Predicate<T>或Predicate<? super T>——只读通配符（T 的某个父类型）

下面的例子，说明我们可以针对List<T>抽象出一般性的方法filter——换言之，过滤等函数不是什么了不起的想法，但在Stream中，它是延迟计算的，因而更给力。

 

    public static <T> List<T> filter(List<T> list, Predicate<T> p) {
        List<T> results = new ArrayList<>();
        /*list.stream().filter((s) -> (p.test(s))).//惰性
                forEach((s) -> {
                    results.add(s);
                });*/
        for (T s : list) {
            if (p.test(s)) {
                results.add(s);
            }
        }
        return results;
    }

Predicate提供了default方法与或非and、or、 negate()。

 

 

 

用到的命名空间  using System.Net;

 方法一:

        //url:POST请求地址
        //postData:json格式的请求报文,例如：{"key1":"value1","key2":"value2"}
        public static string PostUrl(string url, string postData)
        {
            string result = "";
            HttpWebRequest req = (HttpWebRequest)WebRequest.Create(url);
            req.Method = "POST";
            req.Timeout = 800000;//设置请求超时时间，单位为毫秒
            req.ContentType = "application/json";
            byte[] data = Encoding.UTF8.GetBytes(postData);
            req.ContentLength = data.Length;
            using (Stream reqStream = req.GetRequestStream())
            {
                reqStream.Write(data, 0, data.Length);
                reqStream.Close();
            }
            HttpWebResponse resp = (HttpWebResponse)req.GetResponse();
            Stream stream = resp.GetResponseStream();
            //获取响应内容
            using (StreamReader reader = new StreamReader(stream, Encoding.UTF8))
            {
                result = reader.ReadToEnd();
            }
            return result;
        }

方法二:

         /*  url:POST请求地址
          *  postData:json格式的请求报文,例如：{"key1":"value1","key2":"value2"} */       
         public static string PostJson(string url, string postData)
        {
            string result = "";            
            System.Net.Http.HttpContent httpContent = new System.Net.Http.StringContent(postData);
            httpContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json");
            httpContent.Headers.ContentType.CharSet = "utf-8";
            //string postUrl = "http://test.***.gov.cn:81/***/**/request";
            string postUrl = url;
             if (postUrl.StartsWith("https"))
             {
                 System.Net.ServicePointManager.SecurityProtocol = System.Net.SecurityProtocolType.Tls;
             }
            System.Net.Http.HttpClient httpClient = new System.Net.Http.HttpClient();
            try
            {
                System.Net.Http.HttpResponseMessage response = httpClient.PostAsync(postUrl, httpContent).Result;
                //result = response.IsSuccessStatusCode?string.Empty:response.StatusCode.ToString();
                result = response.Content.ReadAsStringAsync().Result; 
            }
            catch(Exception ex) 
            {
                result = ex.Message;
            }
            return result;
        }

 

step1:选择本文所示例的接口"全国天气预报接口" url:https://www.juhe.cn/docs/api/id/39/aid/87

step2:每个接口都需要传入一个参数key,相当于用户的令牌,所以第一步你需要申请一个key

step3:看文档!!!学过java的同学们都知道,当我们对一个类或者方法不明白其意图和思想时,我们可以去查看文档,这里也不例外,而且对于英文不是特别好的同学来说很幸运的是,聚合网站上的文档都是中文版本的,比起阅读java源码里的英文文档应该轻松很多.

全国天气预报接口下面有六个子接口,打开第一个接口链接,看文档发现需要传入一个城市名或者城市ID参数,这个参数我们可以通过第六个子接口获取(接口之间参数的调用类似于java中方法之间的调用),即支持城市列表获取.所以示例中我们先调用这个接口.调用接口涉及到请求网络资源的问题,这里我封装了一个工具类,包含GET和POST两种方法

step4:上代码
Demo1:网络访问工具类(封装get和post方法)
package juheAPI;
  
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.Map;
/**
 * 网络访问工具类
 * @author silk
 *
 */
public class PureNetUtil {
    /**
     * get方法直接调用post方法
     * @param url 网络地址
     * @return 返回网络数据
     */
    public static String get(String url){
        return post(url,null);
    }
    /**
     * 设定post方法获取网络资源,如果参数为null,实际上设定为get方法
     * @param url 网络地址
     * @param param 请求参数键值对
     * @return 返回读取数据
     */
   public static  String post(String  url,Map   param){
        HttpURLConnection conn=null;
        try {
            URL u=new URL(url);
            conn=(HttpURLConnection) u.openConnection();
            StringBuffer sb=null;
            if(param!=null){//如果请求参数不为空
                sb=new StringBuffer();
                /*A URL connection can be used for input and/or output.  Set the DoOutput
                 * flag to true if you intend to use the URL connection for output,
                 * false if not.  The default is false.*/
                //默认为false,post方法需要写入参数,设定true
                conn.setDoOutput(true);
                //设定post方法,默认get
                conn.setRequestMethod("POST");
                //获得输出流
                OutputStream out=conn.getOutputStream();
                //对输出流封装成高级输出流
                BufferedWriter writer=new BufferedWriter(new OutputStreamWriter(out));
                //将参数封装成键值对的形式
                for(Map.Entry s:param.entrySet()){
                    sb.append(s.getKey()).append("=").append(s.getValue()).append("&");
                }
                //将参数通过输出流写入
                writer.write(sb.deleteCharAt(sb.toString().length()-1).toString());
                writer.close();//一定要关闭,不然可能出现参数不全的错误
                sb=null;
            }
            conn.connect();//建立连接
            sb=new StringBuffer();
            //获取连接状态码
            int recode=conn.getResponseCode();
            BufferedReader reader=null;
            if(recode==200){
                //Returns an input stream that reads from this open connection
                //从连接中获取输入流
                InputStream in=conn.getInputStream();
                //对输入流进行封装
                reader=new BufferedReader(new InputStreamReader(in));
                String str=null;
                sb=new StringBuffer();
                //从输入流中读取数据
                while((str=reader.readLine())!=null){
                    sb.append(str).append(System.getProperty("line.separator"));
                }
                //关闭输入流
                reader.close();
                if (sb.toString().length() == 0) {
                    return null;
                }
                return sb.toString().substring(0,
                        sb.toString().length() - System.getProperty("line.separator").length());
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }finally{
            if(conn!=null)//关闭连接
                conn.disconnect();
        }
        return null;
    }
  
}
Demo2:调用获取城市列表接口示例
package juheAPI;
 
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
 
 
/**
 * 获取城市列表
 * 全国天气预报接口调用JAVA示例
 *     dtype     string    N    返回数据格式：json或xml,默认json    
 *     key        string     Y    你申请的key    
 * @author silk
 *
 */
public class GetCityList {
    /**
     * 调用获取城市列表接口,返回所有数据
     * @return 返回接口数据
     */
    public static String excute(){
        String url="http://v.juhe.cn/weather/citys?key=***a7558b2e0bedaa19673f74a6809ce";//接口URL
        //PureNetUtil是一个封装了get和post方法获取网络请求数据的工具类
        return PureNetUtil.get(url);//使用get方法
    }
    /**
     * 调用接口返回数据后,解析数据,根据输入城市名得到对应ID
     * @param cityName 城市名称
     * @return 返回对应ID
     */
    public static String getIDBycityName(String cityName) {
        String result=excute();//返回接口结果,得到json格式数据
        if(result!=null){
            JSONObject obj=JSONObject.fromObject(result);
            result=obj.getString("resultcode");//得到返回状态码
            if(result!=null&&result.equals("200")){//200表示成功返回数据
                result=obj.getString("result");//得到城市列表的json格式字符串数组
                JSONArray arr=JSONArray.fromObject(result);
                for(Object o:arr){//对arr进行遍历
                    //将数组中的一个json个数字符串进行解析
                    obj=JSONObject.fromObject(o.toString());
                    /*此时obj如 {"id":"2","province":"北京","city":"北京","district":"海淀"}*/
                    //以city这个key为线索判断所需要寻找的这条记录
                    result=obj.getString("district");
                    //防止输入城市名不全,如苏州市输入为苏州,类似与模糊查询
                    if(result.equals(cityName)||result.contains(cityName)){
                        result=obj.getString("id");//得到ID
                        return result;
                    }
                }
            }
        }
        return result;
    }
    public static void main(String[] args) {
        System.out.println(getIDBycityName("香港"));
    }
}
Demo3:调用根据城市名/id查询天气
package juheAPI;
 
import net.sf.json.JSONObject;
 
 
/**
 * 根据城市名/id查询天气
 * @author silk
 *
 */
public class WeatherReportByCity {
    /**
     * 根据城市名获取
     * @param cityName
     * @return
     */
    public static String excute(String cityName){
        String url=//此处以返回json格式数据示例,所以format=2,以根据城市名称为例,cityName传入中文
                "http://v.juhe.cn/weather/index?cityname="+cityName+"&key=***a7558b2e0bedaa19673f74a6809ce";
        return PureNetUtil.get(url);//通过工具类获取返回数据
    }
    /**
     * 获取返回数据中的一个属性示例,此处以获取今日温度为例
     * "temperature": "8℃~20℃"     今日温度
     * @param args
     * @return 
     */
    public static String GetTodayTemperatureByCity(String city) {
        String result=excute(city);
        if(result!=null){
            JSONObject obj=JSONObject.fromObject(result);
            /*获取返回状态码*/
            result=obj.getString("resultcode");
            /*如果状态码是200说明返回数据成功*/
            if(result!=null&&result.equals("200")){
                result=obj.getString("result");
                //此时result中数据有多个key,可以对其key进行遍历,得到对个属性
                obj=JSONObject.fromObject(result);
                //今日温度对应的key是today
                result=obj.getString("today");
                obj=JSONObject.fromObject(result);
                //今日温度对应当key是temperature
                result=obj.getString("temperature");
                return result;
            }
        }
        return result;
    }
    public static void main(String[] args) {
        System.out.println(GetTodayTemperatureByCity("苏州"));
    }
}
Demo4:调用天气种类及表示列表接口示例
package juheAPI;
 
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
 
 
/**
 * 天气种类及标识列表接口调用JAVA示例
 * @author silk
 */
public class GetWeatherSignAndTypeList {
    //接口地址,因为只需要传入一个固定的key为参数,所以设为常量
    private static final String URL= "http://v.juhe.cn/weather/uni?key=***a7558b2e0bedaa19673f74a6809ce";
    /**
     * 通过工具类获取数据
     * @return
     */
    public static String excute(){
        return PureNetUtil.get(URL);//调用工具类获取接口数据
    }
    /**
     * 利用遍历数组的方式获取
     * @param wid天气对应id
     * @return 天气名称
     */
    public static String getWeatherByWid(String wid) {
        String result=excute();//获取接口数据
        if(result!=null){
            JSONObject obj=JSONObject.fromObject(result);
            result=obj.getString("resultcode");
            /*获取返回状态码*/
            if(result!=null&&result.equals("200")){
                /*获取数组数据*/
                result=obj.getString("result");
                JSONArray arr=JSONArray.fromObject(result);
                for(Object o:arr){//遍历数组
                    obj=JSONObject.fromObject(o.toString());
                    //如果遍历到需要的数据后直接返回结果,根据key(wid)得到value判断是否等于传入参数
                    if(obj.getString("wid").equals(wid)){
                        result=obj.getString("weather");
                        return result;
                    }
                }
            }
        }
        return result;
    }
    public static void main(String[] args) {
        System.out.println(getWeatherByWid("10"));
    }
}
step5:调用接口时候如果状态码不是200,仔细参考文档说明,也就是返回step3:看文档!

一、APP支付
支付宝更新了支付接口，同时也给出了服务端SDK供下载使用。该SDK提供了一系列的工具类和部分请求的实现。提供了一个AlipaySignature类来提供统一的签名工具类来帮助用户快速实现签名。在SDK下载的文档最后一个部分，提示用户在签名的时候使用
String AlipaySignature.rsaSign(Map<String, String> params, String privateKey, String charset)

这个方法来做签名。
使用该SDK，首先需要构建一个AlipayClient，如果单纯只是使用了签名的功能，对AlipayClient这个对象的实例化并不是很必要。


要注意的是，这边初始化的时候，要提供APP_PRIVATE_KEY和ALIPAY_PUBLIC_KEY，这两个需要明确一下。APP_PRIVATE_KEY是由使用支付宝支付的用户自己生成的RSA私钥，用户使用该私钥对串进行加密，支付宝使用用户提交给支付宝的对应公钥来校验是否合法的请求。而ALIPAY_PUBLIC_KEY是支付宝生成的RSA密钥中的公钥，支付宝保留自己私钥，在自己内部服务器中对请求加密，用户使用支付宝的公钥来校验请求是否合法，在支付宝支付的回调和请求的返回时都需要使用支付宝提供的公钥来校验。


这其中查看应用公钥就是用户自己生成的公钥，查看支付宝公钥就是支付宝提供的公钥。要记住，用户端加密过程中，使用的都是用户自己的私钥，而在接收到支付宝的返回请求时验签使用的都是支付宝提供的公钥。
加密的过程中，用户首先生成自己的请求Map数据，然后调用支付宝的rsaSign方法加密生成签名。之后需要按照申请支付请求参数说明中后部分所给出的方法对签名串和map中的数据组合成为一个字符串返回给客户端，客户端使用这个串来向支付宝发起支付。
需要注意的是，rsaSign签名使用的map数据，需要在map中加入sign_type=RSA这个key-value对。而在校验从支付宝回调回来的请求验签时又不需要sign_type这个键值对。
二、支付宝网页支付
支付宝提供的SDK中，网页支付是默认就有一套请求的实现的，对应的请求类是AlipayTradeWapPayRequest，在设置完成参数之后，调用alipayClient.executePage，就能够完成支付页面的生成，这个在支付宝的手机网站支付快速接入中已经有完整的调用流程，这种方法是通过将跳转页面输出到页面中来实现的。