spark自定义函数

背景

在日常使用spark的过程中，我们经常会使用到各种自定义的函数，目的是为了更好的对数据进行各种处理，本文就简答的记录一些spark中的自定义函数

spark 自定义函数

首先hive的数据类型binary字节数组对应使用java写用户自定义函数udf时的数据类型是BytesWritable,下面我们写几个自定义的函数，作为练习用
// 1.Array数组包含函数

        /**
         * 判断source数组是否包含全部的目标dest数组的元素
         * */
        public class ArrayContainsUDF extends UDF {

            public boolean evaluate(ArrayList<String> sourceArray, ArrayList<String> destArray) {
                if (null == destArray || destArray.size() == 0) {
                    return false;
                }
                if (null == sourceArray || sourceArray.size() == 0) {
                    return false;
                }
                return sourceArray.containsAll(destArray);
            }
        }

// 2.binary数组相与并返回结果的binary

        /**
         * 获取两个字节数组的每个字节相与的结果数组
         * */
        public class BinaryAndUDF extends UDF {

            public BytesWritable evaluate(BytesWritable sourceBytes, BytesWritable destBytes) {
                if (null == sourceBytes || sourceBytes.getLength() == 0) {
                    return null;
                }
                if (null == destBytes || destBytes.getLength() == 0) {
                    return null;
                }
                if(sourceBytes.getLength() != destBytes.getLength()){
                    return null;
                }
                byte[] sourceArr = sourceBytes.getBytes();
                byte[] destArr = destBytes.getBytes();
                byte[] result = new byte[sourceBytes.getLength()];
                for (int i = 0; i < sourceArr.getLength(); i++) {
                    result[i] = sourceArr[i] & destArr[i];
                }
                return new BytesWritable(result);
            }
        }

// 3.binary数组相或并返回结果的binary

        /**
         * 获取两个字节数组的每个字节相或的结果数组
         * */
        public class BinaryOrUDF extends UDF {

            public BytesWritable evaluate(BytesWritable sourceBytes, BytesWritable destBytes) {
                if (null == sourceBytes || sourceBytes.getLength() == 0) {
                    return null;
                }
                if (null == destBytes || destBytes.getLength() == 0) {
                    return null;
                }
                if(sourceBytes.getLength() != destBytes.getLength()){
                    return null;
                }
                byte[] sourceArr = sourceBytes.getBytes();
                byte[] destArr = destBytes.getBytes();
                byte[] result = new byte[sourceBytes.getLength()];
                for (int i = 0; i < sourceArr.getLength(); i++) {
                    result[i] = sourceArr[i] | destArr[i];
                }
                return new BytesWritable(result);
            }
        }

// 4.Array数组转换成Bitmap结构的binary

        /**
         * Bitmap的字节数组转成对应的Array[INT]
         * */
        public class BitmapBinaryToArrayUDF extends UDF {

            public ArrayList<Integer> evaluate(BytesWritable bitmapBinary) {
                if(null == bitmapBinary || bitmapBinary.getLength() == 0) {
                    return null;
                }
                RoaringBitmap roaringBitmap = bytesArrToRoaringbitmap(bitmap.getBytes());
                ArrayList<Integer> list = Lists.newArrayList(roaringBitmap.iterator());
                return list;
            }

        }

// 5.Bitmap结构的binary类型转换成对应的Array

    /**
     * Array【INT】数组转成bitmap的binary字节数组
     * */
    public class ArrayToBitmapUDF extends UDF {

        public BytesWritable evaluate(ArrayList<Integer> array) {
            if (null == array || array.size() == 0) {
                return null;
            }
            RoaringBitmap roaringBitmap = new RoaringBitmap();
            for (Integer val : array) {
                roaringBitmap.add(val.intValue());
            }
            return new BytesWritable(roaringBitmap2Bytes(roaringBitmap));
        }
    }