Java8使用lambda表达式写的一个List,Set,Map遍历工具类

@FunctionalInterface
public interface BeanOperator<T> {
/**
* 适用于普通对象
* @param t
*/
public boolean operator(T t);
}

@FunctionalInterface
public interface ListOperator<T> {
/**
* 适用于集合等有下标的操作
* @param t
* @param index
*/
public boolean operator(T t,int index);
}

@FunctionalInterface
public interface MapOperator<K,V> {
/**
* 适用于Map等键值对的操作
* @param t
* @param key
*/
public boolean operator(K key,V value);
}

package com.cykj.base.common.util;

import java.lang.reflect.Field;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.Predicate;

import org.springframework.util.ConcurrentReferenceHashMap;

import com.cykj.base.common.model.lambda.BeanOperator;
import com.cykj.base.common.model.lambda.FieldOperator;
import com.cykj.base.common.model.lambda.ListOperator;
import com.cykj.base.common.model.lambda.MapOperator;

/**
* 数组工具类
*
* @author LeiYong
*/
public class ArrayUtil {
private static final Map<Class<?>, Field[]> declaredFieldsCache = new ConcurrentReferenceHashMap<Class<?>, Field[]>(
256);
private static final Field[] NO_FIELDS = {};

/**
* 对list执行排序
*
* @param list
* @param asc
*            是否正序排序
* @return
*/
public static <T extends Comparable<T>> List<T> sortList(List<T> list, boolean asc) {
if (list == null) {
return list;
}
list.sort((T a, T b) -> {
if (asc) {
return a.compareTo(b);
} else {
return b.compareTo(a);
}
});
return list;
}

/**
* 对list中数据执行过滤
*
* @param list
* @param predicate
*            过滤接口
* @return
*/
@SuppressWarnings("unchecked")
public static <T> List<T> filter(List<T> list, Predicate<T> predicate) {
return (List<T>) Arrays.asList(list.stream().filter(predicate).toArray());
}

/**
* 遍历List 请勿做删除操作,需执行删除请调用list原生foreach((T t)->{list.remove(t);})
*
* @param list
* @param operator
* @return 仅当operate返回false时,停止遍历并返回false
*/
public static <T> boolean foreach(List<T> list, ListOperator<T> operator) {
if (list == null) {
return true;
}
for (int i = 0; i < list.size(); i++) {
boolean res = operator.operator(list.get(i), i);
if (!res) {
return res;
}
}
return true;
}

/**
* 遍历Array 请勿做删除操作,需执行删除请调用list原生foreach((T t)->{list.remove(t);})
*
* @param array
* @param operator
* @return 仅当operate返回false时,停止遍历并返回false
*/
public static <T> boolean foreach(T[] array, ListOperator<T> operator) {
if (array == null) {
return true;
}
for (int i = 0; i < array.length; i++) {
boolean res = operator.operator(array[i], i);
if (!res) {
return res;
}

}
return true;
}

/**
* 遍历Set
*
* @param list
* @param operator
* @return 仅当operate返回false时,停止遍历并返回false
*/
public static <T> boolean foreach(Set<T> set, BeanOperator<T> operator) {
if (set == null) {
return true;
}
for (T k : set) {
boolean res = operator.operator(k);
if (!res) {
return res;
}
}
return true;
}

/**
* 遍历Map
*
* @param list
* @param operator
* @return 仅当operate返回false时,停止遍历并返回false
*/
public static <K, V> boolean foreach(Map<K, V> map, MapOperator<K, V> operator) {
if (map == null) {
return false;
}
return foreach(map.keySet(), (k) -> {
return operator.operator(k, map.get(k));
});
}

/**
* 遍历Bean
* 此处参考spring遍历bean方法,采用jdk1.8特性重写
* @param obj
* @param operator
* @param fieldFilter 属性过滤器,不过滤为null
* @return 仅当operate返回false时,停止遍历并返回false
*/
public static<K,V> boolean foreach(Object obj,boolean inSuper,FieldOperator operator){
if (obj==null) {
return true;
}

Class<?> targetClass = obj.getClass();
do {
Field[] fields = getDeclaredFields(targetClass);
for (Field field : fields) {
boolean res = operator.operator(field, ReflectionUtil.getFieldAndSetAccessible(field, obj));
if (!res) {
return res;
}
}
}
while (inSuper&&(targetClass = targetClass.getSuperclass()) != null && targetClass != Object.class);
return true;
}
/**
* 获取Bean属性,并缓存
* @param clazz
* @return
*/
private static Field[] getDeclaredFields(Class<?> clazz) {
Field[] result = declaredFieldsCache.get(clazz);
if (result == null) {
result = clazz.getDeclaredFields();
declaredFieldsCache.put(clazz, (result.length == 0 ? NO_FIELDS : result));
}
return result;
}
}

package com.cykj.common.util;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.junit.Before;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.cykj.base.common.util.ArrayUtil;

public class ArrayUtilTest {
/**
* Logger for this class
*/
private static final Logger logger = LoggerFactory.getLogger(ArrayUtilTest.class);

List<Integer> list;
@Before
public void testBefore(){
if (logger.isDebugEnabled()) {
logger.debug("testBefore() - start"); //$NON-NLS-1$
}

list = new ArrayList<>();
for (int i = 0; i < 20; i++) {
list.add((int)(Math.random()*100));
}

if (logger.isDebugEnabled()) {
logger.debug("testBefore() - end"); //$NON-NLS-1$
}
}
@Test
public void testSortList() {
if (logger.isDebugEnabled()) {
logger.debug("testSortList() - start"); //$NON-NLS-1$
}

System.out.println("this is sort method");
System.out.println(ArrayUtil.sortList(list, true));

if (logger.isDebugEnabled()) {
logger.debug("testSortList() - end"); //$NON-NLS-1$
}
}

@Test
public void testFileter() {
if (logger.isDebugEnabled()) {
logger.debug("testFileter() - start"); //$NON-NLS-1$
}

System.out.println("this is filter method");
System.out.println(ArrayUtil.filter(list,(t) -> {return t > 50;}));

if (logger.isDebugEnabled()) {
logger.debug("testFileter() - end"); //$NON-NLS-1$
}
}
@Test
public void testForeachList () {
if (logger.isDebugEnabled()) {
logger.debug("testFileter() - start"); //$NON-NLS-1$
}

System.out.println("this is foreach list method");
//一旦大于95停止遍历
boolean res = ArrayUtil.foreach(list,(t,i) -> {System.out.println(i+"--"+t);return t<95;});
System.out.println("是否有大于95的数字:"+!res);
if (logger.isDebugEnabled()) {
logger.debug("testFileter() - end"); //$NON-NLS-1$
}
}
@Test
public void testForeachMap () {
if (logger.isDebugEnabled()) {
logger.debug("testFileter() - start"); //$NON-NLS-1$
}
Map<String, Object> map = new HashMap<>();
map.put("ss", "tt");
map.put("ii", 193);
map.put("ll", list);
System.out.println("this is foreach list method");
ArrayUtil.foreach(map,(k,v) -> {System.out.println(k+"::"+v);return true;});

if (logger.isDebugEnabled()) {
logger.debug("testFileter() - end"); //$NON-NLS-1$
}
}
@Test
public void testForeachSet () {
if (logger.isDebugEnabled()) {
logger.debug("testFileter() - start"); //$NON-NLS-1$
}
Set<Object> ss = new HashSet<>();
ss.add("1");
ss.add("3");
ss.add(list);
System.out.println("this is foreach list method");
ArrayUtil.foreach(ss,(s) -> {System.out.println(s);return true;});

if (logger.isDebugEnabled()) {
logger.debug("testFileter() - end"); //$NON-NLS-1$
}
}

}