import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.collections.MapUtils;
import org.apache.commons.lang.ArrayUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.*; public abstract class Utils { private static final Logger logger = LoggerFactory.getLogger(Utils.class); private Utils() {
} public static int[] share(int num, int parts) {
if (num <= || parts <= ) {
throw new IllegalArgumentException("Argument 'num' and 'parts' must be great than 0");
}
int[] ret = new int[parts];
int quotient = num / parts;
int remainder = num % parts;
for (int i = ; i < parts; i++) {
ret[i] = quotient;
}
for (int i = ; i < remainder; i++) {
ret[i] += ;
}
return ret;
} public static <T> List<List<T>> share(List<T> list, int parts) {
List<List<T>> ret = new ArrayList<List<T>>();
if (org.apache.commons.collections.CollectionUtils.isNotEmpty(list)) {
int[] divides = share(list.size(), parts);
int index = ;
for (int i = ; i < parts; i++) {
int divide = divides[i];
int from = index;
int to = from + divide;
index = to;
ret.add(list.subList(from, to));
}
}
return ret;
} public static <K, V> Map<K, V> asMap(K[] keys, V[] values) {
Map<K, V> map = new HashMap<K, V>();
if (ArrayUtils.isNotEmpty(keys)) {
for (int i = , len = keys.length; i < len; i++) {
if (null == values || i >= values.length) {
map.put(keys[i], null);
} else {
map.put(keys[i], values[i]);
}
}
}
return map;
} public static <E> List<E> asList(E... elems) {
List<E> list = new ArrayList<E>();
if (ArrayUtils.isNotEmpty(elems)) {
for (E e : elems) {
list.add(e);
}
}
return list;
} public static <E> Set<E> asSet(E... elems) {
Set<E> set = new HashSet<E>();
if (ArrayUtils.isNotEmpty(elems)) {
for (E e : elems) {
set.add(e);
}
}
return set;
} public static <K, V> Map<K, List<V>> list2MapList(List<V> list, KeyGenerator<V> keyGenerator) { if (CollectionUtils.isEmpty(list)) {
return new HashMap<K, List<V>>();
} else {
Map<K, List<V>> resultMap = new HashMap<K, List<V>>();
try {
for (V value : list) {
K key = keyGenerator.generate(value);
List<V> li = resultMap.get(key);
if (null == li) {
li = new ArrayList<V>();
}
li.add(value);
resultMap.put(key, li);
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
return resultMap;
}
} public static <V, K> List<K> list2List(List<V> list, FieldGenerator<V> generator) { if (CollectionUtils.isEmpty(list)) { return new ArrayList<K>();
} else { List<K> result = new ArrayList<K>(); try {
for (V value : list) { K k = generator.generate(value);
if (k != null) {
result.add(k);
}
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
} return result;
}
} public static <V, K> Set<K> list2Set(List<V> list, FieldGenerator<V> generator) { if (CollectionUtils.isEmpty(list)) { return new HashSet<K>();
} else { Set<K> result = new HashSet<K>(); try {
for (V value : list) { K k = generator.generate(value);
if (k != null) {
result.add(k);
}
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
} return result;
}
} public static <V, K> Set<V> list2Set(List<V> list, KeyGenerator<V> generator) { if (CollectionUtils.isEmpty(list)) { return new HashSet<V>();
} else { Map<K, V> map = new HashMap<K, V>(); try {
for (V value : list) { K k = generator.generate(value);
if (k != null) {
map.put(k, value);
}
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
} return new HashSet<V>(map.values());
}
} public static abstract class FieldGenerator<Object> {
public abstract <Field> Field generate(Object object);
} public static <K, V> Map<K, V> list2Map(List<V> list, KeyGenerator<V> keyGenerator) { if (CollectionUtils.isEmpty(list)) {
return new HashMap<K, V>();
} else { Map<K, V> resultMap = new HashMap<K, V>(); try { for (V value : list) { K key = keyGenerator.generate(value);
if (!resultMap.containsKey(key)) {
resultMap.put(key, value);
} else {
logger.error("key=[{}]的元素已经存在", key);
}
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
} return resultMap;
}
} public static <K, V> void put(Map<K, List<V>> map, K k, V v) { if (map == null) {
map = new HashMap<K, List<V>>();
} List<V> list = map.get(k);
if (null == list) {
list = new ArrayList<V>();
map.put(k, list);
}
list.add(v);
} public static <K1, V1, K2, V2> Map<K2, V2> map2Map(Map<K1, V1> originalMap, KeyTransformer<K1> keyTransformer, ValueTransformer valueTransformer) { Map<K2, V2> ret = new HashMap<K2, V2>();
if (MapUtils.isNotEmpty(originalMap)) { Iterator<K1> iterator = originalMap.keySet().iterator();
while (iterator.hasNext()) {
K1 k1 = iterator.next();
V1 v1 = originalMap.get(k1);
K2 k2 = keyTransformer.transform(k1);
V2 v2 = valueTransformer.transform(v1);
ret.put(k2, v2);
}
} return ret;
} public static <K1, V1, V2> Map<K1, V2> map2Map(Map<K1, V1> originalMap, ValueTransformer valueTransformer) { Map<K1, V2> ret = new HashMap<K1, V2>();
if (MapUtils.isNotEmpty(originalMap)) { Iterator<K1> iterator = originalMap.keySet().iterator();
while (iterator.hasNext()) {
K1 k1 = iterator.next();
Object v1 = originalMap.get(k1);
V2 v2 = valueTransformer.transform(v1);
ret.put(k1, v2);
}
} return ret;
} public static <T> T clone(T bean) {
T newBean = null;
if (null != bean) {
try {
newBean = (T) bean.getClass().newInstance();
BeanUtils.copyProperties(bean, newBean);
} catch (Exception e) {
logger.error(e.getMessage());
}
}
return newBean;
} public static byte[] md5Bytes(String text) {
MessageDigest msgDigest; try {
msgDigest = MessageDigest.getInstance("MD5");
} catch (NoSuchAlgorithmException e) {
throw new IllegalStateException("System doesn't support MD5 algorithm.");
} msgDigest.update(text.getBytes()); byte[] bytes = msgDigest.digest(); return bytes;
} /**
* @param min
* @param max
* @return [min, max)
*/
public static int randomInt(int min, int max) {
min = Math.min(min, max);
max = Math.max(min, max);
int temp = (int) (Math.random() * (max - min) + min);
return temp;
} public static <T> T randomElem(T[] array) {
if (ArrayUtils.isNotEmpty(array)) {
return array[randomInt(, array.length)];
}
return null;
} public static <T> T randomElem(List<T> list) {
if (CollectionUtils.isNotEmpty(list)) {
return list.get(randomInt(, list.size()));
}
return null;
} public static boolean randomBool() {
return randomElem(new Boolean[]{true, false});
} public static <X, T> Map<X, List<T>> group(List<T> list, Grouper<T> grouper) { Map<X, List<T>> ret = new HashMap<X, List<T>>(); if (CollectionUtils.isNotEmpty(list)) { for (int i = , len = list.size(); i < len; i++) { T elem = list.get(i);
X type = grouper.group(elem);
List<T> groups = ret.get(type);
if (null == groups) {
groups = new ArrayList<T>();
} groups.add(elem);
ret.put(type, groups);
}
} return ret;
} public static abstract class Grouper<T> {
public abstract <X> X group(T t);
} public static abstract class KeyGenerator<V> {
public abstract <X> X generate(V v);
} public static abstract class KeyTransformer<V> {
public abstract <X> X transform(V v);
} public static abstract class ValueTransformer {
public abstract <X> X transform(Object v);
} public static abstract class Filter<T> {
public abstract boolean filter(T t);
} public static int[] divide(int allocatedFrom, int allocateTo) {
if (allocatedFrom <= || allocateTo <= ) {
throw new IllegalArgumentException("argument 'allocatedFrom' and 'allocateTo' must be great than 0");
}
int[] ret = new int[allocateTo];
int quotient = allocatedFrom / allocateTo;
int remainder = allocatedFrom % allocateTo;
for (int i = ; i < allocateTo; i++) {
ret[i] = quotient;
}
for (int i = ; i < remainder; i++) {
ret[i] += ;
}
return ret;
} public static <T> List<List<T>> divide(List<T> allocatedFrom, int allocateTo) {
List<List<T>> ret = new ArrayList<List<T>>();
if (CollectionUtils.isNotEmpty(allocatedFrom)) {
int[] divides = divide(allocatedFrom.size(), allocateTo);
int index = ;
for (int i = ; i < allocateTo; i++) {
int divide = divides[i];
int from = index;
int to = from + divide;
index = to;
ret.add(allocatedFrom.subList(from, to));
}
}
return ret;
} public static List<Range<Date>> divide(Date fromDate, Date toDate, int allocateTo) {
List<Range<Date>> ret = new ArrayList<Range<Date>>();
int diff = DateUtils.getDiffDay(toDate, fromDate);
if (diff + >= allocateTo) {
int[] divides = divide(diff + , allocateTo);
int index = ;
for (int i = ; i < allocateTo; i++) {
int divide = divides[i];
Date from = DateUtils.getAddDate(fromDate, index);
Date to = DateUtils.getAddDate(from, divide - );
ret.add(new Range<Date>(from, to));
index += divide;
}
} else {
return divide(fromDate, toDate, diff + );
}
return ret;
} public static <T> void multiplySort(List<T> list, final List<? extends Comparator<T>> comparators) { if (CollectionUtils.isEmpty(list) || CollectionUtils.isEmpty(comparators)) {
return;
} Comparator<T> comparator = new Comparator<T>() {
@Override
public int compare(T o1, T o2) { for (Comparator _comparator : comparators) { if (_comparator.compare(o1, o2) > ) {
return ;
} else if (_comparator.compare(o1, o2) < ) {
return -;
}
} return ;
}
}; Collections.sort(list, comparator);
} public static <T extends Number> Double mean(Collection<T> numbers) {
Double ret = new Double(0D);
if (CollectionUtils.isNotEmpty(numbers)) { for (T number : numbers) {
ret += number.doubleValue();
}
ret = ret / numbers.size();
}
return ret;
} public static <T extends Number> Double sum(Collection<T> numbers) {
Double ret = new Double(0D);
if (CollectionUtils.isNotEmpty(numbers)) { for (T number : numbers) {
ret += number.doubleValue();
}
}
return ret;
} public static Object mapToObject(Map<String, Object> map, Class<?> beanClass) throws Exception {
if (map == null)
return null; Object obj = beanClass.newInstance(); Field[] fields = obj.getClass().getDeclaredFields();
for (Field field : fields) {
int mod = field.getModifiers();
if (Modifier.isStatic(mod) || Modifier.isFinal(mod)) {
continue;
} field.setAccessible(true);
field.set(obj, map.get(field.getName()));
} return obj;
} public static Map<String, Object> objectToMap(Object obj) throws Exception {
if (obj == null) {
return null;
} Map<String, Object> map = new HashMap<String, Object>(); Field[] declaredFields = obj.getClass().getDeclaredFields();
for (Field field : declaredFields) {
field.setAccessible(true);
map.put(field.getName(), field.get(obj));
} return map;
} /**
* 将String 类型转为 integer Long 等等类型 以 Object 类型的返回
*
* @param c
* @param value
* @return
*/
public static Object parseStringToMathType(Class c, String value) {
Object backValue = null;
String cName = c.getName();
if ("long".equals(cName)) {
backValue = Long.parseLong(value);
} else if ("java.lang.Long".equals(cName)) {
backValue = Long.parseLong(value);
} else if ("int".equals(cName)) {
backValue = Integer.parseInt(value);
} else if ("java.lang.Integer".equals(cName)) {
backValue = Integer.parseInt(value);
} else if ("float".equals(cName)) {
backValue = Float.parseFloat(value);
} else if ("java.lang.Float".equals(cName)) {
backValue = Float.parseFloat(value);
} else if ("double".equals(cName)) {
backValue = Double.parseDouble(value);
} else if ("java.lang.Double".equals(cName)) {
backValue = Double.parseDouble(value);
} else if ("java.lang.String".equals(cName)) {
backValue = value;
} return backValue;
} public static void main(String[] args) { List<Integer> numbers = new ArrayList<Integer>();
for (int i = ; i <= ; i++) { numbers.add(i);
} System.out.println(mean(numbers));
} }

Utils的更多相关文章

  1. 【C#公共帮助类】 Utils 10年代码,最全的系统帮助类

    为大家分享一下个人的一个Utils系统帮助类,可能有些现在有新的技术替代,自行修改哈~ 这个帮助类主要包含:对象转换处理 .分割字符串.截取字符串.删除最后结尾的一个逗号. 删除最后结尾的指定字符后的 ...

  2. python学习笔记-import utils报错

    今天遇到一个坑爹的问题,查找了半天原因,终于解决了,在此特地记录一下. 运行环境:Windows eclipse 我在eclipse中配置了python的运行环境,在eclipse中编写python代 ...

  3. Lind.DDD.Utils.HttpHelper里静态对象引出的Http超时问题

    回到目录 Lind.DDD.Utils.HttpHelper组件主要实现了对HTTP的各种操作,如Get,Post,Put和Delete,它属于最纯粹的操作,大叔把它封装的目的主要为了实现与API安全 ...

  4. Spring @Autowired注解在utils静态工具类

    [转] 使用场景:在一个静态方法中,如何使用以下注入: @Autowired private ItemMapper itemMapper; @Component public class TestUt ...

  5. utils.js

    /** * //2.0检测方式(目测,测量,专用仪器测试等) function GetCheckType() { $.ajax({ url: '@Url.Action("GetCheckTy ...

  6. Perl/Nagios – Can’t locate utils.pm in @INC

    While trying to use a Nagios plugin I got an error saying that “Can’t locate utils.pm in @INC”. Foll ...

  7. 读取 java.nio.ByteBuffer 中的字符串(String) 写入方式flash.utils.ByteArray.writeUTF

    通过研究ByteArray的写入格式以及方法说明,可以发现writeUTF是先使用2位写入字符串的长度,然后在其后写入字符串编码. flash.utils.ByteArray.writeUTF(val ...

  8. Spark中常用工具类Utils的简明介绍

    <深入理解Spark:核心思想与源码分析>一书前言的内容请看链接<深入理解SPARK:核心思想与源码分析>一书正式出版上市 <深入理解Spark:核心思想与源码分析> ...

  9. 【C#公共帮助类】 Utils最全的系统帮助类

    最近闲的没事做,自己想着做一些东西,不知不觉居然在博客园找到了这么多公共类,感觉还是挺有用的,平时自己还是用到了好多,就是缺少整理,现在为大家分享一下一个Utils系统帮助类,可能有些现在有新的技术替 ...

随机推荐

  1. html 空链接 href="#"与href="javascript:void(0)"的区别

    #包含了一个位置信息 默认的锚是#top 也就是网页的上端 而javascript:void(0) 仅仅表示一个死链接 这就是为什么有的时候页面很长浏览链接明明是#但跳动到了页首 而javascrip ...

  2. workman源代码阅读 - 使用信号处理器实现定时器

    <?php /** * SIGALRM信号处理器注册成功后,在什么情况下进程会收到该信号呢? * * 在Linux系统下,每个进程都有惟一的一个定时器,该定时器提供了以秒为单位的定时功能.在定时 ...

  3. 从零开始学Python07作业思路:模拟人生小游戏

    标签(空格分隔): 从零开始学Python 一,作业说明 模拟人生: 1 定义三个人物,屌丝John,美女Liz,高富帅Peter. John和Liz大学时是恋人,毕业工作后,Liz傍上了Peter, ...

  4. PHP工作笔记:数组转字符串与字符串转数组

    一个数组要入库,发现不可以,特定用函数转为字符串入库 $data = array( 'http://img4.bitautoimg.com/autoalbum/files/20110420/734/2 ...

  5. AdapterPattern(适配器模式)

    import org.omg.PortableServer.AdapterActivator; /** * 分两种情况: * 1.类适配器 * 2.对象适配器 * 作用:让原本接口不兼容的两个类可以在 ...

  6. 简析 .NET Core 构成体系

    简析 .NET Core 构成体系 Roslyn 编译器 RyuJIT 编译器 CoreCLR & CoreRT CoreFX(.NET Core Libraries) .NET Core 代 ...

  7. Javascript中数组方法和方法的扩展

    最近一直在努力的恶补javascript中的各种知识,比如说闭包,作用域,继承,构造函数,变量,内置对象等概念.同时,也在学习着ES6的新知识.最近想给大家分享的就是数组实例方法的练习以及如何去扩展一 ...

  8. wampserver安装配置

    按步骤安装--选择指定浏览器-安装成功后显示绿色图标: 打开浏览器:将文件夹移入wampserver安装路径的www文件夹中:找到电脑IP 在手机端访问 IP/文件夹/demo.html即可

  9. SAP Fiori和UI5的初学者导航

    你是UI5和Fiori的新手?来对地方了. 对我来说,今年是不得不“跟上时代”去提升自己ABAP世界以外的技术技能的困难的一年.幸运的是,有很多可免费获得的信息和课程可以帮你实现这个跳跃.不要等着别人 ...

  10. GitHub学习心得之 简单操作

    作者:枫雪庭 出处:http://www.cnblogs.com/FengXueTing-px/ 欢迎转载 前言 本文对Github的基本操作进行了总结, 主要基于以下文章: http://gitre ...