Projects >> nutz >>5829f229147071f7c8bddd11028bba0b6b8cc29f

Chunk
Conflicting content 
                lock.notifyAll();
            }
    }
<<<<<<< HEAD

    public static void runInAnThread(Runnable runnable) {
        new Thread(runnable).start();
=======
    
    /**
     * map对象浅过滤,返回值是一个新的map
     * @param source 原始的map对象
     * @param prefix 包含什么前缀,并移除前缀
     * @param include 正则表达式 仅包含哪些key(如果有前缀要求,则已经移除了前缀)
     * @param exclude 正则表达式 排除哪些key(如果有前缀要求,则已经移除了前缀)
     * @param map 映射map, 原始key--目标key (如果有前缀要求,则已经移除了前缀)
     * @return 经过过滤的map,与原始map不是同一个对象
     */
    public static Map filter(Map source, String prefix, String include, String exclude, Map keyMap) {
    	LinkedHashMap dst = new LinkedHashMap();
    	if (source == null || source.isEmpty())
    		return dst;
    	Pattern includePattern = include == null ? null : Pattern.compile(include);
    	Pattern excludePattern = exclude == null ? null : Pattern.compile(exclude);
    	
    	for (Entry en : source.entrySet()) {
    		String key = en.getKey();
    		if (prefix != null) {
    			if (key.startsWith(prefix))
    				key = key.substring(prefix.length());
    			else
    				continue;
    		}
    		if (includePattern != null && !includePattern.matcher(key).find())
    			continue;
    		if (excludePattern != null && excludePattern.matcher(key).find())
    			continue;
    		if (keyMap != null && keyMap.containsKey(key))
    			dst.put(keyMap.get(key), en.getValue());
    		else
    			dst.put(key, en.getValue());
		}
    	return dst;
>>>>>>> 899114230c9767d28853b44373c4cdecf88554d6
    }
}
Solution content 
                lock.notifyAll();
            }
    }

    public static void runInAnThread(Runnable runnable) {
        new Thread(runnable).start();
    }

    /**
     * map对象浅过滤,返回值是一个新的map
     * 
     * @param source
     *            原始的map对象
     * @param prefix
     *            包含什么前缀,并移除前缀
     * @param include
     *            正则表达式 仅包含哪些key(如果有前缀要求,则已经移除了前缀)
     * @param exclude
     *            正则表达式 排除哪些key(如果有前缀要求,则已经移除了前缀)
     * @param map
     *            映射map, 原始key--目标key (如果有前缀要求,则已经移除了前缀)
     * @return 经过过滤的map,与原始map不是同一个对象
     */
    public static Map filter(Map source,
                                             String prefix,
                                             String include,
                                             String exclude,
                                             Map keyMap) {
        LinkedHashMap dst = new LinkedHashMap();
        if (source == null || source.isEmpty())
            return dst;
        Pattern includePattern = include == null ? null : Pattern.compile(include);
        Pattern excludePattern = exclude == null ? null : Pattern.compile(exclude);

        for (Entry en : source.entrySet()) {
            String key = en.getKey();
            if (prefix != null) {
                if (key.startsWith(prefix))
                    key = key.substring(prefix.length());
                else
                    continue;
            }
            if (includePattern != null && !includePattern.matcher(key).find())
                continue;
            if (excludePattern != null && excludePattern.matcher(key).find())
                continue;
            if (keyMap != null && keyMap.containsKey(key))
                dst.put(keyMap.get(key), en.getValue());
            else
                dst.put(key, en.getValue());
        }
        return dst;
    }
}
File
Lang.java
Developer's decision
Manual
Kind of conflict
Comment
For statement
If statement
Method invocation
Method signature
Return statement
Variable
Chunk
Conflicting content 
    }

    /**
<<<<<<< HEAD
     * 使用给定的分隔符, 将一个数组拼接成字符串
     * 
     * @param sp
     *            分隔符
     * @param array
     *            要拼接的数组
     * @return 拼接好的字符串
     */
    public static  String join(String sp, T... array) {
        return Lang.concat(sp, array).toString();
=======
     * 将一个字节数变成人类容易识别的显示字符串，比如 1.5M 等
     * 
     * @param size
     *            字节数
     * @param SZU
     *            千的单位，可能为 1024 或者 1000
     * @return 人类容易阅读的字符串
     */
    private static String _formatSizeForRead(long size, double SZU) {
        if (size < SZU) {
            return String.format("%d bytes", size);
        }
        double n = (double) size / SZU;
        if (n < SZU) {
            return String.format("%5.2f KB", n);
        }
        n = n / SZU;
        if (n < SZU) {
            return String.format("%5.2f MB", n);
        }
        n = n / SZU;
        return String.format("%5.2f GB", n);
    }

    /**
     * @see #_formatSizeForRead(long, double)
     */
    public static String formatSizeForReadBy1024(long size) {
        return _formatSizeForRead(size, 1024);
    }

    /**
     * @see #_formatSizeForRead(long, double)
     */
    public static String formatSizeForReadBy1000(long size) {
        return _formatSizeForRead(size, 1000);
>>>>>>> 899114230c9767d28853b44373c4cdecf88554d6
    }

}
Solution content 
    }

    /**
     * 使用给定的分隔符, 将一个数组拼接成字符串
     * 
     * @param sp
     *            分隔符
     * @param array
     *            要拼接的数组
     * @return 拼接好的字符串
     */
    public static  String join(String sp, T... array) {
        return Lang.concat(sp, array).toString();
    }

    /**
     * 将一个字节数变成人类容易识别的显示字符串，比如 1.5M 等
     * 
     * @param size
     *            字节数
     * @param SZU
     *            千的单位，可能为 1024 或者 1000
     * @return 人类容易阅读的字符串
     */
    private static String _formatSizeForRead(long size, double SZU) {
        if (size < SZU) {
            return String.format("%d bytes", size);
        }
        double n = (double) size / SZU;
        if (n < SZU) {
            return String.format("%5.2f KB", n);
        }
        n = n / SZU;
        if (n < SZU) {
            return String.format("%5.2f MB", n);
        }
        n = n / SZU;
        return String.format("%5.2f GB", n);
    }

    /**
     * @see #_formatSizeForRead(long, double)
     */
    public static String formatSizeForReadBy1024(long size) {
        return _formatSizeForRead(size, 1024);
    }

    /**
     * @see #_formatSizeForRead(long, double)
     */
    public static String formatSizeForReadBy1000(long size) {
        return _formatSizeForRead(size, 1000);
    }
}
File
Strings.java
Developer's decision
Concatenation
Kind of conflict
Comment
Method declaration
Method invocation
Method signature
Return statement