【java】使用 java.util.function中的方法实现代码 比正常使用java代码慢了十倍?

问题描述

今天学习了一下java.util.function中的几个方法,觉得很帅很优雅,于是学的过程中照搬着把我以前的

一个判断字段是否为空的代码重写了一遍(有些业务定义如果某个字段等于-1也默认认为它为空).

实现之后对照着跑了一遍,发现性能居然比原来的代码慢了十倍,所以有些疑惑,先看看代码吧:

相关代码

// 旧代码

public static <T> boolean isBlank(T t) {
if (t == null) {
return true;
}
if (t instanceof List) {
if (((List) t).size() == 0) {
return true;
}
} else if (t instanceof Map) {
if (((Map) t).size() == 0) {
return true;
}
if (((Map) t).get("-1") != null && ((Map) t).get("-1").equals("-1")) {
return true;
}
} else if (t instanceof Set) {
if (((Set) t).size() == 0) {
return true;
}
} else if (t instanceof Object[]) {
if (((Object[]) t).length == 0) {
return true;
}
} else if (t instanceof String) {
String str = (String) t;
if (str.length() == 0)
return true;
str = str.trim();
if (str.length() == 0)
return true;
}
return false;
}
public static <T> boolean isinFallback(T t) {
Class<?> c = t.getClass();
Method[] methods = c.getMethods();
try {
for (Method method : methods) {
if (method.getName().equals("getId")) {
Object o = method.invoke(t);
if (o == null) {
return true;
}
if (o.equals(-1L)) {
return true;
}
}
}
} catch (Exception e) {
e.printStackTrace();
return true;
}
return false;
}

//新代码

private static final Function<Method[], Method> filter = (s) -> {
for (Method m : s) {
if (m.getName().equals("getId")) {
return m;
} else if (m.getName().equals("getUid")) {
return m;
}
}
return null;
};
private static final Predicate<Object> object = (s) -> s.equals("-1");
private static final Function<Object, Predicate> getPre = (s) -> {
if (s instanceof List) {
return (Predicate<List>) l -> l.size() == 0;
} else if (s instanceof Map) {
return (Predicate<Map>) l -> l.size() == 0 || l.get("-1") != null;
} else if (s instanceof Set) {
return (Predicate<Set>) l -> l.size() == 0;
} else if (s instanceof Object[]) {
return (Predicate<Object[]>) l -> Objects.nonNull(l) && l.length == 0;
} else if (s instanceof String) {
return (Predicate<String>) String::isEmpty;
}
return null;
};
public static <T> boolean isBlank(T t) {
if (t == null) {
return true;
}
if (t instanceof String) {
String str = (String) t;
str = str.trim();
return getPre.apply(str).test(str);
}
Predicate apply = getPre.apply(t);
return apply != null && apply.test(t);
}
public static <T> boolean isinFallback(T t) {
Class<?> c = t.getClass();
Method[] method = c.getMethods();
try {
Method apply = filter.apply(method);
return apply != null && object.or(oj -> oj.equals(-1L)).test(apply.invoke(t));
} catch (IllegalAccessException | InvocationTargetException e) {
e.printStackTrace();
}
return false;
}

测试代码:

【java】使用 java.util.function中的方法实现代码 比正常使用java代码慢了十倍?

测试结果:

【java】使用 java.util.function中的方法实现代码 比正常使用java代码慢了十倍?

问题:

有三个方法结果不一致是因为我加了一些新的判断,所以不用在意,疑惑的地方是代码逻辑完全没有变,仅仅是把实现方法换成了java8的新实现方式,结果性能居然差了这么多.所以问题是:

1.如果是我代码写的逻辑不对导致的这个问题,那我是错在那些地方呢?

2.看方法介绍,Predicate这个类之所以存在似乎就是因为它能做一些判断性的动作,可是性能这么慢又有什么用它的必要呢?

3.如果是我杀鸡用牛刀了那么java.util.function包下的几个工具类的正确使用场景是在什么地方呢(Predicate, Consumer, Function, Supplier, UnaryOperator, BinaryOperator)?

回答

这个问题我也注意到了，但不是楼主说的那样使用 java.util.function中的方法实现代码 比正常使用java代码慢了十倍?。他是在初始化的时候慢。楼主用的测试用例，我稍微修改了一下就能看出。（这里的LegalPredicate.isBlank()方法都是用的Function实现的）

public static void main(String[] args) {
    long startTime = System.currentTimeMillis();
    Object o1 = null;
    System.out.println("o1====>" + LegalPredicate.isBlank(o1));
    Object o2 = "";
    System.out.println("o2====>" + LegalPredicate.isBlank(o2));
    long endTime = System.currentTimeMillis();
    System.out.println("程序运行时间： " + (endTime - startTime) + "ms");
    startTime = System.currentTimeMillis();
    Object o3 = null;
    System.out.println("o3====>" + LegalPredicate.isBlank(o3));
    Object o4 = "";
    System.out.println("o4====>" + LegalPredicate.isBlank(o4));
    endTime = System.currentTimeMillis();
    System.out.println("程序运行时间： " + (endTime - startTime) + "ms");
}

【java】使用 java.util.function中的方法实现代码 比正常使用java代码慢了十倍?
看到没，第一个程序运行时间远超第二个(第二个由于太快了，运行时间显示为0)。
或许有的人会说，说不定程序缓存了第一次的结果，所以第二次没有判断直接用的缓存结果所以快了。那么再把测试用例改一下：

public static void main(String[] args) {
    long startTime = System.currentTimeMillis();
    Object o1 = null;
    System.out.println("o1====>" + LegalPredicate.isBlank(o1));
    long endTime = System.currentTimeMillis();
    System.out.println("程序运行时间： " + (endTime - startTime) + "ms");
    startTime = System.currentTimeMillis();
    Object o3 = null;
    System.out.println("o3====>" + LegalPredicate.isBlank(o3));
    endTime = System.currentTimeMillis();
    System.out.println("程序运行时间： " + (endTime - startTime) + "ms");
}

【java】使用 java.util.function中的方法实现代码 比正常使用java代码慢了十倍?
这时在同一台电脑上（性能一样），减少了一个运算对象，程序时间和刚才差不多，如果是运算慢，那这时候运算时间应该是刚才的一半左右。

所以不是使用java.util.function中的方法实现代码 比正常使用java代码慢了十倍?，只是加载function方法时间慢。同样的我发现加载lambda表达式的也会慢

不过具体原因我也不知道，这应该是JVM的一些问题吧，对一块研究的还不深，网上也没找到资料，希望如果有人知道可以给出答案，或者探讨一下。

代码貌似没贴全，不知道是不是这样的问题：

  1. 直接判断 vs 包了一层的判断，后者肯定是慢的

  2. 但是如果有jit，把后者内联掉了，性能差距应该就不大了

  3. java8的函数接口更多是为了写lambda用的，不是直接拿出来用的

我不知道你知不知道这个属于Java反射的内容？
反射因为是涉及到动态类型解析的，所以他用不上虚拟机的优化，反射操作的性能是低于非反射操作的

以上是 【java】使用 java.util.function中的方法实现代码 比正常使用java代码慢了十倍? 的全部内容， 来源链接： utcz.com/a/73310.html

回到顶部