精华内容
参与话题
问答
  • Util工具类

    万次阅读 2017-10-30 14:51:46
    Util工具类
    
    public class Util {
        /**
         * log4j
         */
        private final static Logger logger = LoggerFactory.getLogger(Util.class);
    
        /**
         * 随即获取32位ID
         * <p>
         * 2017年8月3日 13:26:45
         * xj
         *
         * @return String
         */
        public static String getUUID() {
            return UUID.randomUUID().toString().replaceAll("-", "");
        }
    
        /**
         * 将指定数据转换为int型
         *
         * 2017年8月3日 13:28:34
         * xj
         *
         * @param o 指定数据
         * @return int
         */
        public static int getInt(Object o) {
            if (o instanceof BigDecimal) {
                return ((BigDecimal) o).intValue();
            } else if (o instanceof Integer) {
                return ((Integer) o).intValue();
            } else if (o instanceof Float) {
                return ((Float) o).intValue();
            } else if (o instanceof Double) {
                return ((Double) o).intValue();
            }
    
            throw new RuntimeException("can't parse object to int");
        }
    
        /**
         * 获取股票得分表(SV_SCORE)当前月份表名
         *
         * @return
         */
        public static String getCurrentScoreTableName() {
            String name = null;
            Calendar calendar = Calendar.getInstance();
            int year = calendar.get(Calendar.YEAR);
    //        int month = calendar.get(Calendar.MONTH) + 1;
    //        if (month < 10) {
    //            name = "SV_SCORE_" + year + "0" + month;
    //        } else {
    //            name = "SV_SCORE_" + year + "" + month;
    //        }
            name = "SV_SCORE_" + year;
    
            return name;
        }
    
    
        /**
         * 获取股票得分表(SV_SCORE)指定格式的日期的月份表名
         * <p>
         * 2017年8月8日 16:25:18
         * xj
         *
         * @param date 指定日期
         * @return String
         */
        public static String getScoreTableNameByTime(String date) {
            String name = null;
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(Util.transformStringToDate(date, "yyyy-MM-dd"));
            int year = calendar.get(Calendar.YEAR);
    //        int month = calendar.get(Calendar.MONTH) + 1;
    //        if (month < 10) {
    //            name = "SV_SCORE_" + year + "0" + month;
    //        } else {
    //            name = "SV_SCORE_" + year + "" + month;
    //        }
            name = "SV_SCORE_" + year;
            return name;
        }
    
        /**
         * 获取指定时间的最近半年时间月份第一天
         * <p>
         * 2017年8月8日 17:19:10
         * xj
         *
         * @param date 指定日期
         * @return String[]
         */
        public static String[] getHalfYear(Date date) {
            String[] last6Months = new String[6];
            Calendar cal = Calendar.getInstance();
            cal.setTime(date);
            //要先+1,才能把本月的算进去
            cal.set(Calendar.MONTH, cal.get(Calendar.MONTH) + 1);
            for (int i = 0; i < 6; i++) {
                //逐次往前推1个月
                cal.set(Calendar.MONTH, cal.get(Calendar.MONTH) - 1);
                last6Months[5 - i] = cal.get(Calendar.YEAR) + "-" + (cal.get(Calendar.MONTH) + 1) + "-01";
            }
    
            return last6Months;
        }
    
        /**
         * 获取Date类型yyyy-MM-dd格式的当前时间
         *
         * 2017年8月3日 10:56:09
         * xj
         *
         * @return Date
         */
        public static Date getCurrentDate() {
            Date date = new Date();
            DateFormat format = new SimpleDateFormat("yyyy-MM-dd");
            String dateStr = format.format(date);
            Date curDay = null;
            try {
                curDay = format.parse(dateStr);
            } catch (ParseException e) {
                logger.error(e.getMessage(), e);
            }
    
            return curDay;
        }
    
        /**
         * 日期加减
         *
         * @param date       指定日期
         * @param dateFormat 指定日期格式
         * @param year       加减年数
         * @return -1 为日期格式错误
         */
        public static String minusYear(String date, String dateFormat, int year) {
            SimpleDateFormat format = new SimpleDateFormat(dateFormat);
            try {
                Calendar calendar = Calendar.getInstance();
                Date now = format.parse(date);
                calendar.setTime(now);
                calendar.add(Calendar.YEAR, year);
                return format.format(calendar.getTime());
            } catch (ParseException e) {
                logger.error(e.getMessage(), e);
                return "-1";
            }
        }
    
        /**
         * 日期加减
         *
         * @param date       指定日期
         * @param dateFormat 指定日期格式
         * @param day        加减天数
         * @return    -1 为日期格式错误
         */
        public static String minusDay(String date, String dateFormat, int day) {
            SimpleDateFormat format = new SimpleDateFormat(dateFormat);
            try {
                Calendar calendar = Calendar.getInstance();
                Date now = format.parse(date);
                calendar.setTime(now);
                calendar.add(Calendar.DAY_OF_MONTH, day);
                return format.format(calendar.getTime());
            } catch (ParseException e) {
                logger.error(e.getMessage(), e);
                return "-1";
            }
        }
    
        /**
         * 日期加减
         *
         * @param date       指定日期
         * @param dateFormat 指定日期格式
         * @param day        加减天数
         * @return null 为日期格式错误
         */
        public static Date minusDate(String date, String dateFormat, int day) {
            SimpleDateFormat format = new SimpleDateFormat(dateFormat);
            try {
                Calendar calendar = Calendar.getInstance();
                Date now = format.parse(date);
                calendar.setTime(now);
                calendar.add(Calendar.DAY_OF_MONTH, day);
                return calendar.getTime();
            } catch (ParseException e) {
                logger.error(e.getMessage(), e);
                return null;
            }
        }
    
        /**
         * 将日期字符串转换为Date类型
         * String类型的日期格式和要转化的format格式必须一样
         *
         * @param dateStr    日期字符串
         * @param dateFormat 日期格式  yyyy-MM-dd
         * @return date
         */
        public static Date transformStringToDate(String dateStr, String dateFormat) {
            Date date = null;
            DateFormat format = new SimpleDateFormat(dateFormat);
            try {
                date = format.parse(dateStr);
            } catch (ParseException e) {
                logger.error(e.getMessage(), e);
            }
    
            return date;
        }
    
        /**
         * 将Date类型转换为日期字符串
         *
         * @param date       日期字符串
         * @param dateFormat 日期格式
         * @return dateStr
         */
        public static String transformDateToString(Date date, String dateFormat) {
            if (date == null || StringUtils.isEmpty(dateFormat)) {
                return "";
            }
            DateFormat format = new SimpleDateFormat(dateFormat);
            return format.format(date);
        }
    
        /**
         * 获取某日期区间的所有日期  日期倒序
         *
         * @param startDate  开始日期
         * @param endDate    结束日期
         * @param dateFormat 日期格式
         * @return 区间内所有日期
         */
        public static List<String> getPerDaysByStartAndEndDate(String startDate, String endDate, String dateFormat) {
            DateFormat format = new SimpleDateFormat(dateFormat);
            try {
                Date sDate = format.parse(startDate);
                Date eDate = format.parse(endDate);
                long start = sDate.getTime();
                long end = eDate.getTime();
                if (start > end) {
                    return null;
                }
                Calendar calendar = Calendar.getInstance();
                calendar.setTime(eDate);
                List<String> res = new ArrayList<String>();
                while (end >= start) {
                    res.add(format.format(calendar.getTime()));
                    calendar.add(Calendar.DAY_OF_MONTH, -1);
                    end = calendar.getTimeInMillis();
                }
                return res;
            } catch (ParseException e) {
                logger.error(e.getMessage(), e);
            }
            return null;
        }
    
        /**
         * 获取某日期区间的所有12月31日的日期  日期倒序
         *
         * @param startDate 开始日期   yyyy-MM-dd
         * @param endDate   结束日期   yyyy-MM-dd
         * @return 区间内所有日期
         */
        public static List<String> getPerYearByStartAndEndDate(String startDate, String endDate) {
            String start = startDate.substring(0, startDate.indexOf("-"));
            String end = endDate.substring(0, endDate.indexOf("-"));
            int s = Integer.parseInt(start);
            int e = Integer.parseInt(end);
            if (!(end + "-12-31").equals(endDate)) {
                e--;
            }
            List<String> res = new ArrayList<String>();
            while (e >= s) {
                res.add(e + "-12-31");
                e--;
            }
            return res;
        }
    
        /**
         * 获取某日期区间的年份
         *
         * @param startDate 开始日期   yyyy
         * @param endDate   结束日期   yyyy
         * @return 区间内所有日期
         */
        public static List<String> getYearsByStartAndEndDate(String startDate, String endDate) {
            Integer s = Integer.parseInt(startDate);
            Integer e = Integer.parseInt(endDate);
            List<String> res = new ArrayList<String>();
            while (e >= s) {
                res.add(e.toString());
                e--;
            }
            return res;
        }
    
        /**
         * 对含有map的list排序
         *
         * @param areaList 原始值
         * @param isDesc   TRUE:从大到小  FALSE:从小到大
         */
        public static void sortListMap(List<Map.Entry<String, Double>> areaList, final boolean isDesc) {
            Collections.sort(areaList, new Comparator<Map.Entry<String, Double>>() {
                public int compare(Map.Entry<String, Double> o1,
                                   Map.Entry<String, Double> o2) {
                    int flag = 1;
                    if (isDesc) {
                        if (o2.getValue() - o1.getValue() < 0) {
                            flag = -1;
                        }
                    } else {
                        if (o2.getValue() - o1.getValue() > 0) {
                            flag = -1;
                        }
                    }
    
                    return flag;
                }
            });
        }
    
        /**
         * 对map中含有String类型的日期key值的list进行排序
         * <p>
         * 2017年9月29日 17:19:09
         * xj
         *
         * @param list   List<Map<String,Object>>,String为日期
         * @param format 日期格式
         * @param isDesc TRUE:从大到小  FALSE:从小到大
         */
        public static void sortListStringDateMap(List list, final String format, final boolean isDesc) {
            Collections.sort(list, new Comparator() {
                @Override
                public int compare(Object o1, Object o2) {
                    Map<String, Object> o1Map = (Map<String, Object>) o1;
                    Map<String, Object> o2Map = (Map<String, Object>) o2;
                    String o1Key = "";
                    for (String key : o1Map.keySet()) {
                        o1Key = key;
                    }
                    String o2Key = "";
                    for (String key : o2Map.keySet()) {
                        o2Key = key;
                    }
                    Integer o1K = Integer.valueOf(Util.transformDateToString(Util.transformStringToDate(o1Key, format), "yyyyMMdd"));
                    Integer o2K = Integer.valueOf(Util.transformDateToString(Util.transformStringToDate(o2Key, format), "yyyyMMdd"));
                    int flag = 1;
                    if (isDesc) {
                        if (o2K - o1K < 0) {
                            flag = -1;
                        }
                    } else {
                        if (o2K - o1K > 0) {
                            flag = -1;
                        }
                    }
    
                    return flag;
                }
            });
    
        }
    
        /**
         * null转为空字符串
         *
         * @param obj
         * @return
         */
        public static Object nvl(Object obj) {
            if (null == obj) {
                return "";
            }
            return obj;
        }
    
        /**
         * @methodName nullTrans
         * @describe 将空值转化成空字符串
         * @author xj
         * @date 2017/10/18 15:49
         * @param obj
         * @return java.lang.Object
         */
        public static String nullTrans(Object obj){
            String nullValue = "null";
            String nuValue = "nu";
            if (null == obj || nullValue.equals(obj) || nuValue.equals(obj)){
                return "";
            }
            return obj.toString();
        }
    
        /**
         * 数字类型数组转换为以逗号分隔的字符串
         *
         * @param arr
         * @return
         */
        public static String transformArrayToString(Object[] arr) {
            if (null == arr || arr.length == 0) {
                return null;
            }
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < arr.length; i++) {
                sb.append(arr[i]).append(",");
            }
            return sb.substring(0, sb.length() - 1);
        }
    
        /**
         * 字符串类型数组转换为以逗号分隔的字符串, 字符串加引号
         *
         * @param arr
         * @return
         */
        public static String transformArrayToStringQ(Object[] arr) {
            if (null == arr || arr.length == 0) {
                return null;
            }
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < arr.length; i++) {
                sb.append("'").append(arr[i]).append("'").append(",");
            }
            return sb.substring(0, sb.length() - 1);
        }
    
        /**
         * double类型加法,防止失去精度
         *
         * @param d1
         * @param d2
         * @return
         */
        public static double addDouble(Double d1, Double d2) {
            BigDecimal bd1 = new BigDecimal(d1.toString());
            BigDecimal bd2 = new BigDecimal(d2.toString());
            return bd1.add(bd2).doubleValue();
        }
    
        /**
         * 比较两个double是否相等
         *
         * @param d1
         * @param d2
         * @return  当此 BigDecimal 在数字上小于、等于或大于 val 时,返回 -1、0 或 1。
         */
        public static int compareToDouble(String d1, String d2) {
            BigDecimal bd1 = new BigDecimal(d1);
            BigDecimal bd2 = new BigDecimal(d2);
            return bd1.compareTo(bd2);
        }
    
        /**
         * double类型减法,防止失去精度
         *
         * @param d1
         * @param d2
         * @return
         */
        public static Double subtractDouble(Double d1, Double d2) {
            BigDecimal bd1 = new BigDecimal(d1.toString());
            BigDecimal bd2 = new BigDecimal(d2.toString());
            return bd1.subtract(bd2).doubleValue();
        }
    
        /**
         * double 乘法
         *
         * @param d1
         * @param d2
         * @return
         */
        public static Double multiplyDouble(Double d1, Double d2) {
            BigDecimal bd1 = new BigDecimal(d1.toString());
            BigDecimal bd2 = new BigDecimal(d2.toString());
            return bd1.multiply(bd2).doubleValue();
        }
    
        /**
         * double 除法
         *
         * @param d1
         * @param d2
         * @param scale 四舍五入 小数点位数
         * @return
         */
        public static Double divideDouble(Double d1, Double d2, int scale) {
            //  当然在此之前,你要判断分母是否为0,
            //  为0你可以根据实际需求做相应的处理
            BigDecimal bd1 = new BigDecimal(d1.toString());
            BigDecimal bd2 = new BigDecimal(d2.toString());
            return bd1.divide(bd2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
        }
    
        /**
         * 精度,四舍五入
         *
         * @param d1
         * @param scale
         * @return
         */
        public static Double round(Double d1, int scale) {
            if (d1 == null) {
                return null;
            }
            BigDecimal bd1 = new BigDecimal(d1.toString());
            return bd1.setScale(scale, RoundingMode.HALF_UP).doubleValue();
        }
    
        /**
         * 转码以提供中文名文件下载支持
         *
         * @param fileName
         * @return
         */
        public static String getAttachFileNameForCn(String fileName) {
            StringBuffer sb = new StringBuffer();
            try {
                sb.append("filename=").append(URLEncoder.encode(fileName, "UTF-8"))
                        .append(";filename*=UTF-8''").append(URLEncoder.encode(fileName, "UTF-8"));
            } catch (UnsupportedEncodingException e) {
                logger.error(e.getMessage(), e);
            }
    
            return sb.toString();
        }
    
        /**
         * 判断项目的架包目录中是否存在upload文件夹、svUpload文件夹
         * 如果存在直接返回svUpload文件夹完整url,如果不存在则创建upload文件夹、svUpload文件夹,
         * 在返回svUpload文件夹url
         * <p>
         * 2017年7月10日 15:16:19
         * xj
         *
         * @return String
         */
        public static String getUploadUrl() {
            String url = JarUrlUtil.getJarUrl();
            url += File.separator + "upload";
            File file2 = new File(url);
            if (!file2.isDirectory()) {
                file2.mkdir();
                url += File.separator + "svUpload";
                File file1 = new File(url);
                if (!file1.isDirectory()) {
                    file1.mkdir();
                }
            } else {
                url += File.separator + "svUpload";
                File file1 = new File(url);
                if (!file1.isDirectory()) {
                    file1.mkdir();
                }
            }
            return url;
        }
    
        /**
         * 判断项目的架包目录中是否存在download文件夹,
         * 如果存在则返回download文件夹完成路径,如果不存在,创建download文件夹,在返回其完整路径。
         * <p>
         * 2017年7月21日 10:32:54
         * xj
         *
         * @return String
         */
        public static String getDownloadUrl() {
            String url = JarUrlUtil.getJarUrl();
            url += File.separator + "download";
            File downloadFile = new File(url);
            if (!downloadFile.isDirectory()) {
                downloadFile.mkdir();
            }
            return url;
        }
    
        /**
         * 判断项目的架包目录中是否存在template文件夹,
         * 如果存在则返回template文件夹完成路径,如果不存在,创建template文件夹,在返回其完整路径。
         * <p>
         * 2017年7月27日 14:58:16
         * xj
         *
         * @return String
         */
        public static String getTemplateUrl() {
            String url = JarUrlUtil.getJarUrl();
            url += File.separator + "template";
            File templateFile = new File(url);
            if (!templateFile.isDirectory()) {
                templateFile.mkdir();
            }
            return url;
        }
    
        /**
         * 判断当前fileUrl是否存在fileName文件夹,
         * 如果存在则返回fileName文件夹完成路径,如果不存在,创建fileName文件夹,在返回其完整路径。
         * <p>
         * 2017年7月28日 14:59:48
         * xj
         *
         * @param fileUrl 文件所在路径
         * @return String
         */
        public static String getFileUrl(String fileUrl) {
            File file = new File(fileUrl);
            if (!file.isDirectory()) {
                file.mkdir();
            }
            return fileUrl;
        }
    
        /**
         * 格式化数字
         *
         * @param format
         * @param obj
         * @return
         */
        public static String formatByDecimalFormat(String format, Object obj) {
            if (null != obj && !"".equals(obj)) {
                DecimalFormat decimalFormat = new DecimalFormat(format);
                return decimalFormat.format(obj);
            }
            return "";
        }
    
        /**
         * 返回一个空表格格式Grid
         * <p>
         * 2017年7月12日 16:12:01
         * xj
         *
         * @param idsList
         * @param hdsList
         * @return
         */
        public static Grid getNullGrid(List<String> idsList, List<String> hdsList) {
            Grid grid = new Grid(null, 0);
            grid.setIds(idsList);
            grid.setHds(hdsList);
            grid.setRows(null);
            return grid;
        }
    
        /**
         * 将时间戳转换为时间
         * <p>
         * 2017年7月12日 17:40:43
         * xj
         *
         * @param s 时间戳
         * @return "yyyy-MM-dd HH:mm:ss"
         */
        public static String stampToDate(String s) {
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            long lt = new Long(s);
            Date date = new Date(lt);
            String res = simpleDateFormat.format(date);
            return res;
        }
    
        /**
         * 将字Clob转成String类型
         * <p>
         * 2017年8月31日 15:24:48
         * xj
         *
         * @param sc clob对象
         * @return String
         * @throws SQLException
         * @throws IOException
         */
        public static String ClobToString(Clob sc) throws SQLException, IOException {
            String reString = "";
            // 得到流
            Reader is = sc.getCharacterStream();
            BufferedReader br = new BufferedReader(is);
            String s = br.readLine();
            StringBuffer sb = new StringBuffer();
            // 执行循环将字符串全部取出付值给StringBuffer由StringBuffer转成STRING
            while (s != null) {
                sb.append(s);
                s = br.readLine();
            }
            reString = sb.toString();
            return reString;
        }
    
        /**
         * 获取传入时间某几年之前的日期
         * <p>
         * 2017年9月1日 10:12:40
         * xj
         *
         * @param date     指定日期
         * @param someYear 某几年
         * @return String
         */
        public static String getLastSomeYear(String date, Integer someYear) {
            Integer lastSomeYear = Integer.parseInt(date.substring(0, 4)) - someYear;
            date = lastSomeYear + date.substring(4);
            return date;
        }
    
        /**
         * 获取指定dateFormat格式的date,某几个月之前的日期
         * <p>
         * 2017年9月1日 11:15:31
         * xj
         *
         * @param date       传入日期
         * @param dateFormat 日期格式
         * @param someMonth  某几个月
         * @return Date
         */
        public static Date getLastSomeMonth(String date, String dateFormat, Integer someMonth) {
            SimpleDateFormat format = new SimpleDateFormat(dateFormat);
            Calendar c = Calendar.getInstance();
            c.setTime(Util.transformStringToDate(date, dateFormat));
            //得到前几个月
            c.add(Calendar.MONTH, -(someMonth));
            Date time = Util.transformStringToDate(format.format(c.getTime()), dateFormat);
            return time;
        }
    
        /**
         * 检查上传文件是否为空
         * <p>
         * 2017年9月4日 13:14:36
         * xj
         *
         * @param request 请求request对象
         * @return MultipartFile
         */
        public static MultipartFile checkFile(HttpServletRequest request) {
            if (!(request instanceof MultipartHttpServletRequest)) {
                throw new ServiceException(ResultEnum.NO_FILE);
            }
            MultipartFile file = ((MultipartHttpServletRequest) request).getFile("file");
            if (file.isEmpty()) {
                throw new ServiceException(ResultEnum.NO_FILE);
            }
            return file;
        }
    
        /**
         * <li>功能描述:时间相减得到天数
         * <p>
         * 2017年9月5日 15:13:36
         * xj
         *
         * @param beginDateStr 开始日期
         * @param endDateStr   结束日期
         * @return long
         */
        public static long getDaySub(String beginDateStr, String endDateStr) {
            long day = 0;
            SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
            Date beginDate;
            Date endDate;
            try {
                beginDate = format.parse(beginDateStr);
                endDate = format.parse(endDateStr);
                day = (endDate.getTime() - beginDate.getTime()) / (24 * 60 * 60 * 1000);
            } catch (ParseException e) {
                logger.error(e.getMessage(), e);
            }
    
            return day;
        }
    
        /**
         * 获取指定月份的天数
         * <p>
         * 2017年9月6日 13:11:05
         * xj
         *
         * @param date 指定日期
         * @return Integer
         */
        public static Integer getMonthDays(String date) {
            Calendar a = Calendar.getInstance();
            a.setTime(Util.transformStringToDate(date, "yyyy-MM-dd"));
            //把日期设置为当月第一天
            a.set(Calendar.DATE, 1);
            //日期回滚一天,也就是最后一天
            a.roll(Calendar.DATE, -1);
            int maxDate = a.get(Calendar.DATE);
            return maxDate;
        }
    
        /**
         * 获得指定月份的,月末日期
         *
         * @param date 指定日期
         * @return String
         */
        public static String getMonthEndStringDateByMonth(String date, String dateFormat) {
            Calendar c = Calendar.getInstance();
            c.setTime(Util.transformStringToDate(date, dateFormat));
            c.set(Calendar.DAY_OF_MONTH, c.getActualMaximum(Calendar.DAY_OF_MONTH));
            return transformDateToString(c.getTime(), dateFormat);
        }
    
        /**
         * 比较日期大小
         * <p>
         * 2017年9月7日 16:15:53
         * xj
         *
         * @param DATE1      第一个时间
         * @param DATE2      第二个时间
         * @param dateFormat 日期格式
         * @return Integer null日期格式有误,1:第一个日期大,0:两个日期一样,-1:第二个日期大
         */
        public static Integer compareDate(String DATE1, String DATE2, String dateFormat) {
            DateFormat df = new SimpleDateFormat(dateFormat);
            try {
                Date dt1 = df.parse(DATE1);
                Date dt2 = df.parse(DATE2);
                if (dt1.getTime() > dt2.getTime()) {
                    return 1;
                } else if (dt1.getTime() < dt2.getTime()) {
                    return -1;
                } else {
                    return 0;
                }
            } catch (Exception e) {
                logger.error(e.toString(), e);
            }
            return null;
        }
    
    } // class 结束
    
    展开全文
  • util文件的作用

    千次阅读 2018-03-01 09:19:43
    经常在程序里见到 Util文件 ,例如,util.pyutil包中放一些常用的公共方法,提供一些实用的方法和数据结构,例如:1.日期类来产生和获取日期及时间;2.提供随机数类来产生各种类型的随机数;3.提供堆栈类表示堆栈...

    经常在程序里见到 Util文件 ,例如,util.py

    util包中放一些常用的公共方法,提供一些实用的方法和数据结构,例如:

    1.日期类来产生和获取日期及时间;


    2.提供随机数类来产生各种类型的随机数;


    3.提供堆栈类表示堆栈结构;

    4.提供哈希表来表示哈希结构;


    原文地址:点击打开链接

    展开全文
  • Java.util包简单总结

    万次阅读 多人点赞 2017-02-28 00:30:13
    java.util包粗略总结

    之前听一位老师讲过,学Java的程序员,lang包和util包至少是要过一遍的。
    很惭愧的是,从入门到现在,我还没完整的探究过这两个基础包。
    今天借着跟公司小伙伴分享的机会,把util包简单的梳理一遍。由于最近加班很多,此篇先做粗略总结,日后有时间再完善。

    1. util包的框架

    常用的集合类主要实现两个“super接口”而来:CollectionMap

    1.1 Collection有两个子接口:ListSet

    这里写图片描述

    List特点是元素有序,且可重复。实现的常用集合类有ArrayListLinkedList,和Vector(线程安全)。

    Set特点是元素无序,不可重复。实现的常用集合类有HashSetLinkedHashSetTreeSet(可排序)

    1.2 Map是key、value键值对的集合

    这里写图片描述

    特点是key值无序不可重复,value值可重复(这样表述其实不太准确,因为实际上key和value是绑定在一起的)。常用的有HashMapHashTable(线程安全),TreeMap(可排序)。

    1.3 其余重要接口和类

    上面是util包中的集合框架,一般Java教材里面都会讲到。但我们深入研究一下,会发现还有其余几个重要的内容:

    • Iterator:迭代接口
      集合类实现该接口后便具有了迭代功能。最简单的迭代实现是ArrayList,迭代过程其实就是数组的迭代。LinkedListLinkedHashSetLinkedHashMap迭代过程就是链表的迭代。这两者的迭代效率都很高,迭代时间与容器里的元素数目成正比。但HashSetHashMap迭代效率就略低了,因为采用了哈希表,所以元素是散列在数组中的,迭代时必须读完整个数组,迭代时间与容器的容量成正比。
    • Comparator:比较接口
      实现该接口后,集合内元素便可比较通过compare()方法实现元素排序
    • AbstractXXX:骨架类
      所谓骨架类,其实就是不同集合的核心代码实现,让继承这个抽象类的子类少干点活。例如AbstarctList代表“随机访问”集合(底层数组实现)的骨干代码实现。AbstractSequentialList代表“连续访问”(底层链表实现)集合的骨干代码实现。
    • Collections、Arrays
      集合工具类和数组工具类。Java中的工具类好像都喜欢在对应的接口或类名称后,加S来表示其工具类。

    接下来给一张比较完整的util包框架图:

    这里写图片描述

    2. 常用集合类原理

    2.1 ArrayList

    ArrayList的实现最简单,采用的顺序表,底层就是一个Object数组,初始容量为10,每当元素要超过容量时,重新创建一个更大的数组,并把原数据拷到新数组中来。

    2.2 LinkedList

    LinkedList采用双向链表。集合中的每一个元素都会有两个成员变量prevnext,分别指向它的前一元素和后一元素。

    ArrayListLinkedList的区别这里就不详细讨论了,其实就是顺序表和链表两种数据结构的区别。之前写的博文中已经提到(包括ArrayListLinkedList的详细实现):
    数据结构基础(一)线性表

    2.3 Vector

    Vector底层实现和ArrayList类似,区别在于在许多方法上加了synchronized关键字,来实现了多线程安全。但代价是性能的降低。由于加锁的是整个集合,所以并发情况下进行迭代会锁住很长时间。

    2.4 HashMap

    HashMap采用的是哈希表结构,用链表法来解决hash冲突。这里不详细讨论,之前的文章写过:
    HashMap原理解析

    2.5 HashTable

    HashTable的底层实现和HashMap类似,区别也是在许多方法上加了synchronized关键字,来实现了多线程安全。

    2.6 LinkedHashMap

    HashMap的基础上加了双链表,该集合中的每个元素也都保留了前一个元素和后一个元素的“指针”。这样便可以按照插入顺序来读取集合元素。也可设置为按照访问顺序来读取集合元素。
    由于要维护额外的双链表,LinkedHashMap增删操作会比HashMap慢,但迭代时会比HashMap快。

    2.7 TreeMap

    采用了红黑树数据结构,从而实现了有序集合。这个比较复杂,以后单独开出一篇来讨论,此处略。

    2.8 HashSet、LinkedHashSet、TreeSet

    Set和Map有千丝万缕的联系呀。例如HashSet底层实现其实就是一个固定value的HashMap。LinkedHashSet就是一个value固定的LinkedHashMapTreeSet就是一个value固定的TreeMap

    3. 集合的并发

    3.1 并发类的选择

    讲到并发的集合,一般都想到util包中的两个类:HashTableVector。然而实际使用情况中,并不推荐使用这两个类。

    首先,HashTableVector是从JDK1.0便存在的“古老”类,当时CollectionMap接口都还没。这样导致的问题是,当后来HashTableVector实现MapCollection接口时,出现了许多无用而重复的方法。例如Vector原本有一个addElement()的方法,当实现了Collection接口后,又出现了一个add()方法。而实际上,这两个方法一模一样。

    替代的这两个并发类的常见方法是Collections.synchronizedXXX(…),这个方法可以把ArrayListHashMap等集合变为线程安全的集合类。

    那么,VectorCollections.synchronizedXXX(…)的底层实现有什么区别呢?

    我们来看看两者的add()方法实现:

        //Vector
        public synchronized boolean add(E e) {
            modCount++;
            ensureCapacityHelper(elementCount + 1);
            elementData[elementCount++] = e;
            return true;
        }
    
        //Collections.SynchronizedList
        public void add(int index, E element) {
            synchronized (mutex) {list.add(index, element);}
        }

    可以看出, 两者实现多线程的方式都是对集合的方法加锁,区别在于,Vector是对方法加锁,锁的是本对象,而Collections.synchronizedXXX(…)是对一个变量加锁。区别并不大。

    那么,既然Collections.synchronizedXXX(…)比较好,用它创建出线程安全的集合类是不是就一劳永逸的满足我们所有的需求了呢?很不幸,不完全是。

    Collections.synchronizedXXX(…)HashTableVector在高并发时都有着很大的性能缺陷。因为它们的增、删、取都会锁住整个集合。想一想,一个线程在迭代十万个元素的Vector,其余线程对集合的操作时不时就阻塞了,受到了多大的影响啊。

    为了解决这两种方法在高并发下的性能的低下。我们查找一下Java的API,发现在java.util.concurrent里面有许多针对高并发设计的类,例如:CopyOnWriteArrayListConcurrentHashMap

    ConcurrentHashMap的优化原理在于,采用了Segment的机制:

    这里写图片描述

    可以看成,ConcurrentHashMap底层每一个Segment都是一个HashMap,这样增删取时只需要锁住一段的Segment,而不是整个集合。从而优化了高并发下的性能。

    CopyOnWriteArrayList主要是对高并发下的读、迭代做优化。实现原理在于每次add,remove操作都是重新创建一个新的数组,等操作结束再把引用指向新的数组。add,remove都是加了锁的,而get方法没有加锁,因为每次迭代时都是在旧的数组上迭代。所以CopyOnWriteArrayList适用于读多写少的并发场景。

    3.2 迭代fail-fast机制

    之前写的博文:Java迭代foreach原理解析(java.util.ConcurrentModificationException的原因)

    展开全文
  • 小程序 util 文件

    2018-11-16 11:24:12
    a_靖的通用 util 文件。博文地址 :https://blog.csdn.net/qq_35713752/article/details/77970370
  • 一个拿来即用的httputil工具类

    千次阅读 2019-05-31 14:55:35
    工作中难免会用httpclien进行数据的跨系统传输,这几天老在用,调别的系统的接口,今天就给大家分享出来我用的工具类吧,主要是后期我用的时候可以找到。 package com.cnlive.shenhe.utils; ... ...import org.apac...

     工作中难免会用httpclien进行数据的跨系统传输,这几天老在用,调别的系统的接口,今天就给大家分享出来我用的工具类吧,主要是后期我用的时候可以找到。

    package com.cnlive.shenhe.utils;
    
    import com.alibaba.fastjson.JSONObject;
    import org.apache.http.Header;
    import org.apache.http.HttpEntity;
    import org.apache.http.HttpStatus;
    import org.apache.http.NameValuePair;
    import org.apache.http.auth.AuthScope;
    import org.apache.http.auth.UsernamePasswordCredentials;
    import org.apache.http.client.CredentialsProvider;
    import org.apache.http.client.config.RequestConfig;
    import org.apache.http.client.config.RequestConfig.Builder;
    import org.apache.http.client.entity.UrlEncodedFormEntity;
    import org.apache.http.client.methods.CloseableHttpResponse;
    import org.apache.http.client.methods.HttpGet;
    import org.apache.http.client.methods.HttpPost;
    import org.apache.http.client.methods.HttpUriRequest;
    import org.apache.http.client.utils.URIBuilder;
    import org.apache.http.entity.ContentType;
    import org.apache.http.entity.StringEntity;
    import org.apache.http.entity.mime.MultipartEntityBuilder;
    import org.apache.http.entity.mime.content.FileBody;
    import org.apache.http.impl.client.BasicCredentialsProvider;
    import org.apache.http.impl.client.CloseableHttpClient;
    import org.apache.http.impl.client.HttpClients;
    import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
    import org.apache.http.message.BasicHeader;
    import org.apache.http.message.BasicNameValuePair;
    import org.apache.http.util.EntityUtils;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.util.CollectionUtils;
    import org.springframework.util.StringUtils;
    
    import java.io.*;
    import java.net.HttpURLConnection;
    import java.net.URI;
    import java.net.URISyntaxException;
    import java.net.URL;
    import java.nio.charset.UnsupportedCharsetException;
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    import java.util.Map.Entry;
    
    /**
     * http请求工具类
     *
     * @author liujiong
     */
    public class HttpUtil {
    
        private Logger logger = LoggerFactory.getLogger(HttpUtil.class);
    
        private static PoolingHttpClientConnectionManager pcm;//httpclient连接池
        private CloseableHttpClient httpClient = null; //http连接
        private int connectTimeout = 120000;//连接超时时间
        private int connectionRequestTimeout = 10000;//从连接池获取连接超时时间
        private int socketTimeout = 300000;//获取数据超时时间
        private String charset = "utf-8";
        private RequestConfig requestConfig = null;//请求配置
        private Builder requestConfigBuilder = null;//build requestConfig
    
        private List<NameValuePair> nvps = new ArrayList<>();
        private List<Header> headers = new ArrayList<>();
        private String requestParam = "";
    
        static {
            pcm = new PoolingHttpClientConnectionManager();
            pcm.setMaxTotal(50);//整个连接池最大连接数
            pcm.setDefaultMaxPerRoute(50);//每路由最大连接数,默认值是2
        }
    
        /**
         * 默认设置
         *
         * @author Liu Jiong
         * @createDate 2016年10月30日
         */
        private static HttpUtil defaultInit() {
            HttpUtil httpUtil = new HttpUtil();
            if (httpUtil.requestConfig == null) {
                httpUtil.requestConfigBuilder = RequestConfig.custom().setConnectTimeout(httpUtil.connectTimeout)
                        .setConnectionRequestTimeout(httpUtil.connectionRequestTimeout)
                        .setSocketTimeout(httpUtil.socketTimeout);
                httpUtil.requestConfig = httpUtil.requestConfigBuilder.build();
            }
            return httpUtil;
        }
    
        /**
         * 初始化 httpUtil
         */
        public static HttpUtil init() {
            HttpUtil httpUtil = defaultInit();
            if (httpUtil.httpClient == null) {
                httpUtil.httpClient = HttpClients.custom().setConnectionManager(pcm).build();
            }
            return httpUtil;
        }
    
        /**
         * 初始化 httpUtil
         */
        public static HttpUtil init(Map<String, String> paramMap) {
            HttpUtil httpUtil = init();
            httpUtil.setParamMap(paramMap);
            return httpUtil;
        }
    
        /**
         * 验证初始化
         */
        public static HttpUtil initWithAuth(String ip, int port, String username, String password) {
            HttpUtil httpUtil = defaultInit();
            if (httpUtil.httpClient == null) {
                CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
                credentialsProvider.setCredentials(new AuthScope(ip, port, AuthScope.ANY_REALM), new UsernamePasswordCredentials(username, password));
                httpUtil.httpClient = HttpClients.custom().setDefaultCredentialsProvider(credentialsProvider)
                        .setConnectionManager(pcm).build();
            }
            return httpUtil;
        }
    
        /**
         * 设置请求头
         */
        public HttpUtil setHeader(String name, String value) {
            Header header = new BasicHeader(name, value);
            headers.add(header);
            return this;
        }
    
        /**
         * 设置请求头
         */
        public HttpUtil setHeaderMap(Map<String, String> headerMap) {
            for (Entry<String, String> param : headerMap.entrySet()) {
                Header header = new BasicHeader(param.getKey(), param.getValue());
                headers.add(header);
            }
            return this;
        }
    
        /**
         * 设置请求参数
         */
        public HttpUtil setParam(String name, String value) {
            nvps.add(new BasicNameValuePair(name, value));
            return this;
        }
    
        /**
         * 设置请求参数
         */
        public HttpUtil setParamMap(Map<String, String> paramMap) {
            for (Entry<String, String> param : paramMap.entrySet()) {
                nvps.add(new BasicNameValuePair(param.getKey(), param.getValue()));
            }
            return this;
        }
    
        /**
         * 设置字符串参数
         */
        public HttpUtil setStringParam(String requestParam) {
            this.requestParam = requestParam;
            return this;
        }
    
        /**
         * 设置连接超时时间
         */
        public HttpUtil setConnectTimeout(int connectTimeout) {
            this.connectTimeout = connectTimeout;
            this.requestConfigBuilder = requestConfigBuilder.setConnectTimeout(connectTimeout);
            requestConfig = requestConfigBuilder.build();
            return this;
        }
    
        /**
         * http get 请求
         */
        public Map<String, String> get(String url) {
            Map<String, String> resultMap = new HashMap<>();
            //获取请求URI
            URI uri = getUri(url);
            if (uri != null) {
                HttpGet httpGet = new HttpGet(uri);
                httpGet.setConfig(requestConfig);
                if (!CollectionUtils.isEmpty(headers)) {
                    Header[] header = new Header[headers.size()];
                    httpGet.setHeaders(headers.toArray(header));
                }
    
                //执行get请求
                try {
                    CloseableHttpResponse response = httpClient.execute(httpGet);
                    return getHttpResult(response, url, httpGet, resultMap);
                } catch (Exception e) {
                    httpGet.abort();
                    resultMap.put("result", e.getMessage());
                    logger.error("获取http GET请求返回值失败 url======" + url, e);
                }
            }
            return resultMap;
        }
    
        /**
         * http post 请求
         */
        public Map<String, String> post(String url) {
            HttpPost httpPost = new HttpPost(url);
            httpPost.setConfig(requestConfig);
            if (!CollectionUtils.isEmpty(headers)) {
                Header[] header = new Header[headers.size()];
                httpPost.setHeaders(headers.toArray(header));
            }
            if (!CollectionUtils.isEmpty(nvps)) {
                try {
                    httpPost.setEntity(new UrlEncodedFormEntity(nvps, charset));
                } catch (UnsupportedEncodingException e) {
                    logger.error("http post entity form error", e);
                }
            }
            if (!StringUtils.isEmpty(requestParam)) {
                try {
                    httpPost.setEntity(new StringEntity(requestParam, charset));
                } catch (UnsupportedCharsetException e) {
                    logger.error("http post entity form error", e);
                }
            }
            Map<String, String> resultMap = new HashMap<>();
            //执行post请求
            try {
                CloseableHttpResponse response = httpClient.execute(httpPost);
                return getHttpResult(response, url, httpPost, resultMap);
            } catch (Exception e) {
                httpPost.abort();
                resultMap.put("result", e.getMessage());
                logger.error("获取http POST请求返回值失败 url======" + url, e);
            }
            return resultMap;
        }
    
        /**
         * post 上传文件
         */
        public Map<String, String> postUploadFile(String url, Map<String, File> fileParam) {
            HttpPost httpPost = new HttpPost(url);
            httpPost.setConfig(requestConfig);
            if (!CollectionUtils.isEmpty(headers)) {
                Header[] header = new Header[headers.size()];
                httpPost.setHeaders(headers.toArray(header));
            }
    
            MultipartEntityBuilder builder = MultipartEntityBuilder.create();
            if (fileParam != null) {
                for (Entry<String, File> entry : fileParam.entrySet()) {
                    //将要上传的文件转化为文件流
                    FileBody fileBody = new FileBody(entry.getValue());
                    //设置请求参数
                    builder.addPart(entry.getKey(), fileBody);
                }
            }
    
            if (!CollectionUtils.isEmpty(nvps)) {
                for (NameValuePair nvp : nvps) {
                    String value = nvp.getValue();
                    if (!StringUtils.isEmpty(value)) {
                        builder.addTextBody(nvp.getName(), value, ContentType.create("text/plain", charset));
                    }
                }
            }
            httpPost.setEntity(builder.build());
            Map<String, String> resultMap = new HashMap<>();
            //执行post请求
            try {
                CloseableHttpResponse response = httpClient.execute(httpPost);
                return getHttpResult(response, url, httpPost, resultMap);
            } catch (Exception e) {
                httpPost.abort();
                resultMap.put("result", e.getMessage());
                logger.error("获取http postUploadFile 请求返回值失败 url======" + url, e);
            }
            return resultMap;
        }
    
        /**
         * 获取请求返回值
         */
        private Map<String, String> getHttpResult(CloseableHttpResponse response, String url, HttpUriRequest request, Map<String, String> resultMap) {
            String result = "";
            int statusCode = response.getStatusLine().getStatusCode();
            resultMap.put("statusCode", statusCode + "");
            HttpEntity entity = response.getEntity();
            if (entity != null) {
                try {
                    result = EntityUtils.toString(entity, charset);
                    EntityUtils.consume(entity);//释放连接
                } catch (Exception e) {
                    logger.error("获取http请求返回值解析失败", e);
                    request.abort();
                }
            }
            if (statusCode != 200) {
                result = "HttpClient status code :" + statusCode + "  request url===" + url;
                logger.info("HttpClient status code :" + statusCode + "  request url===" + url);
                request.abort();
            }
            resultMap.put("result", result);
            return resultMap;
        }
    
        /**
         * 获取重定向url返回的location
         */
        public String redirectLocation(String url) {
            String location = "";
            //获取请求URI
            URI uri = getUri(url);
            if (uri != null) {
                HttpGet httpGet = new HttpGet(uri);
                requestConfig = requestConfigBuilder.setRedirectsEnabled(false).build();//设置自动重定向false
                httpGet.setConfig(requestConfig);
                if (!CollectionUtils.isEmpty(headers)) {
                    Header[] header = new Header[headers.size()];
                    httpGet.setHeaders(headers.toArray(header));
                }
    
                try {
                    //执行get请求
                    CloseableHttpResponse response = httpClient.execute(httpGet);
                    int statusCode = response.getStatusLine().getStatusCode();
                    if (statusCode == HttpStatus.SC_MOVED_PERMANENTLY || statusCode == HttpStatus.SC_MOVED_TEMPORARILY) {//301 302
                        Header header = response.getFirstHeader("Location");
                        if (header != null) {
                            location = header.getValue();
                        }
                    }
                    HttpEntity entity = response.getEntity();
                    if (entity != null) {
                        EntityUtils.consume(entity);
                    }
                } catch (Exception e) {
                    logger.error("获取http GET请求获取 302 Location失败 url======" + url, e);
                    httpGet.abort();
                }
            }
            return location;
        }
    
        /**
         * 获取输入流
         */
        public InputStream getInputStream(String url) {
            //获取请求URI
            URI uri = getUri(url);
            if (uri != null) {
                HttpGet httpGet = new HttpGet(uri);
                httpGet.setConfig(requestConfig);
                if (!CollectionUtils.isEmpty(headers)) {
                    Header[] header = new Header[headers.size()];
                    httpGet.setHeaders(headers.toArray(header));
                }
                //执行get请求
                try {
                    CloseableHttpResponse response = httpClient.execute(httpGet);
                    int statusCode = response.getStatusLine().getStatusCode();
                    if (statusCode != 200) {
                        logger.info("HttpClient status code :" + statusCode + "  request url===" + url);
                        httpGet.abort();
                    } else {
                        HttpEntity entity = response.getEntity();
                        if (entity != null) {
                            InputStream in = entity.getContent();
                            return in;
                        }
                    }
                } catch (Exception e) {
                    logger.error("获取http GET inputStream请求失败 url======" + url, e);
                    httpGet.abort();
                }
            }
            return null;
        }
    
        private URI getUri(String url) {
            URI uri = null;
            try {
                URIBuilder uriBuilder = new URIBuilder(url);
                if (!CollectionUtils.isEmpty(nvps)) {
                    uriBuilder.setParameters(nvps);
                }
                uri = uriBuilder.build();
            } catch (URISyntaxException e) {
                logger.error("url 地址异常", e);
            }
            return uri;
        }
    
    
        /**
         * from请求
         * @param url
         * @param params
         * @return
         */
        public static String form(String url, Map<String, String> params) {
            URL u = null;
            HttpURLConnection con = null;
            // 构建请求参数
            StringBuffer sb = new StringBuffer();
            if (params != null) {
                for (Entry<String, String> e : params.entrySet()) {
                    sb.append(e.getKey());
                    sb.append("=");
                    sb.append(e.getValue());
                    sb.append("&");
                }
                sb.substring(0, sb.length() - 1);
            }
            // 尝试发送请求
            try {
                u = new URL(url);
                con = (HttpURLConnection) u.openConnection();
                 POST 只能为大写,严格限制,post会不识别
                con.setRequestMethod("POST");
                con.setDoOutput(true);
                con.setDoInput(true);
                con.setUseCaches(false);
                con.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
                OutputStreamWriter osw = new OutputStreamWriter(con.getOutputStream(), "UTF-8");
                osw.write(sb.toString());
                osw.flush();
                osw.close();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (con != null) {
                    con.disconnect();
                }
            }
    
            // 读取返回内容
            StringBuffer buffer = new StringBuffer();
            try {
                //一定要有返回值,否则无法把请求发送给server端。
                BufferedReader br = new BufferedReader(new InputStreamReader(con.getInputStream(), "UTF-8"));
                String temp;
                while ((temp = br.readLine()) != null) {
                    buffer.append(temp);
                    buffer.append("\n");
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
    
            return buffer.toString();
        }
    
    
        public static void main(String[] args) {
            /*Map<String, String> map = new HashMap<>();
            JSONObject param = new JSONObject();
            param.put("activity_id","60:video:comets:10011#2");
            param.put("state",3);
            param.put("attr_tags","");
            param.put("msg","");
    
            map.put("param",param.toJSONString());
            String form = form("http://yp5ntd.natappfree.cc/CnInteraction/services/commentForHd/auditCallBackNew", map);
            System.out.println(form);*/
    
    
            JSONObject params = new JSONObject();
            params.put("video_id","60_8be004799c424688949704814ea0d16d");
            params.put("state",3+"");
            params.put("attr_tags","");
            params.put("msg","");
            HttpUtil httpUtil = HttpUtil.init();
            httpUtil.setParam("param",params.toJSONString());
            String URL ="http://abcd.com/v1/ShenHeInfo/shenheNotify?platform=AUDIT&token=94cead75c";
            Map<String, String> post = httpUtil.post(URL);
            System.out.println(post.get("result"));
        }
    }
    

     

    展开全文
  • Util

    2019-07-08 21:13:40
    public class MyUtil { private final RxJavas rxJavas; private static class Holder { private static MyUtil myUtil = new MyUtil(); } public static MyUtil getInstance() { return Holder.myUtil;...
  • util 是一个Node.js 核心模块,提供常用函数的集合,用于弥补核心JavaScript 的功能 过于精简的不足。util.inherits(constructor, superConstructor)是一个实现对象间原型继承 的函数。 JavaScript 的面向对象特性...
  • java.util包详解

    万次阅读 多人点赞 2007-01-30 11:56:00
    介绍Java的实用工具类库java.util包。在这个包中,Java提供了一些实用的方法和数据结构。本章介绍Java的实用工具类库java.util包。在这个包中,Java提供了一些实用的方法和数据结构。例如,Java提供日期(Data)类、...
  • Py之utils:Python库之utils的简介、安装、使用方法之详细攻略 目录 utils的简介 utils的安装 ... Python Utils is a collection of small Python functions and classes which make common patte...
  • java.util中,util是什么意思?

    千次阅读 2014-08-20 16:41:13
    [size=large]util是utiliy的缩写,意为多用途的,工具性质的包。 这个包中主要存放了:集合类(如ArrayList,HashMap等),随机数产生类,属性文件读取类,定时器类等类。 这些类极大方便了Java编程,日常java编程...
  • 一般是由于分页的时候,只会对最近的数据分页,就近原则,参考代码一目了然,豁然开朗,茅塞顿开 //开始分页 PageHelper.startPage(pageEncapsulation.getPageNo() + 1, pageEncapsulation.getPageSize(), true);...
  • 在部署Dynamic Web Project时,如果正确配置web.xml或者标注时,仍然出现以上异常的话,可以尝试以下内容讲解的方法: 首先,双击eclipse中的servers,位置如下图“1”所指。检查位置"2"...
  • ArrayList是一个很常用的集合类,底层是一个数组,只不过ArrayList封装了数组,实现了一些好用的方法例如add()方法,size()方法,get()方法等一系列的方法,并且实现了动态的扩容数组。 new ArrayList();...
  • java.util.Collection java集合框架总结

    万次阅读 2018-09-20 15:15:08
    原文 ...java.util.Collection(以下简称Collection)的子接口有List Set Queue,他们各自都有一个抽象实现类AbstractCollection、AbstractList、AbstractSet、AbstractQue...
  • 前言 二十多天的实训结束了,虽然环境emmmm有点坑,好多人都感冒了,我也没能逃过一劫. 不过总体来说还行, 第一次尝试跟学校里不一样的,7个人一起做项目. 不过也因此对于github的使用不再局限于之前的将其作为云服务...
  • 最近在做一些组件的封装,使用了java.util.concurrent线程池,就好奇想知道他是如何管理线程,以及重用的?于是追踪了一下源码,基本了解了他得处理机制,所以在此总要记录一下。最近也没写什么文章,感觉人也懒了,...
  • 正常来说,这个小功能一个下午不到就可以完成,但是因为涉及到一些很小的细节问题不能及时解决,所以花了我几天的时间,我都开始崩溃和怀疑人生了。所以我写个博客来记录一下遇到的问题还有是如何解决的。
  • 使用以下命令中的其中一个即可 1. gradlew compileDebug --stacktrace 2. gradlew compileDebug --stacktrace -info ...gradlew compileDebug --stacktrace -debug ...gradlew compileDebugSources --stacktrace -...
  • 解决java.util.concurrent.RejectedExecutionException

    万次阅读 多人点赞 2014-08-29 15:48:02
    昨晚12:00运行自动化测试脚本时遇到了java.util.concurrent.RejectedExecutionException这个异常,从异常名称里很容易分析出是提交的任务被线程池拒绝了。查看源码发现是在Activity里,AsyncTask是在自定义的线程池...
  • 1. java.util.concurrent - Java 并发工具包 2. 阻塞队列 BlockingQueue 3. 数组阻塞队列 ArrayBlockingQueue 4. 延迟队列 DelayQueue 5. 链阻塞队列 LinkedBlockingQueue 6. 具有优先级的阻塞队列 ...
  • java.util.concurrent.ExecutionException: org.apache.catalina.LifecycleException: Failed to start component [StandardEngine[Catalina].StandardHost[localhost].StandardContext[/recommender]] at jav
  • 1、错误描述java.lang.ClassCastException: java.util.ArrayList cannot be cast to java.util.Map at service.impl.BillServiceImpl.exportBillExcel(BillServiceImpl.java:336) at sun.reflect....
  • 其中接口 java.util.Observer 用来指定观察者,观察者必须实现 void update(Observable o, Object arg) 方法。 而 java.util.Observable 用来指定观察物(被观察者、可被观察的),并且提供了一系列的方法。读者...
  • 在eclipse中执行命令jetty:run,出现下面的异常2017-02-27 15:50:37.636:INFO:oejs.Server:jetty-8.1.2.v20120308 2017-02-27 15:50:38.228:WARN:oejw.WebAppContext:Failed startup of context o.m.j.p....
  • [?]  | New  | Browse  | Search  | Reports  ...First Last Prev Next This bug is not in your last search results. ...Bug 142996 - [65cat]java.util.concurrent.TimeoutExcepti
  • at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149) at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624) at java.lang.Thread.run...
  • java.lang.NoSuchMethodException: java.util.List.() at java.lang.Class.getConstructor0(Unknown Source) ~[na:1.8.0_66] at java.lang.Class.getDeclaredConstructor(Unknown Source) ~[na:1.8.0_66] at org.spr...
  • 先贴出异常 服务器的CPU使用率一直保持在10%左右,...是java进程跑死的,只能找java进程下哪些线程高cpu使用率 问题线程已经找到 USER %CPU PRI SCNT WCHAN USER SYSTEM TID TIME [root@27a2a017-029b-48d8-...
  • Java 8 流的新类 java.util.stream.Collectors 实现了 java.util.stream.Collector 接口,同时又提供了大量的方法对流 ( stream ) 的元素执行 map and reduce 操作,或者统计操作。 1、 Collectors.averagingDouble...
  • 缘由:高级计算机网络大作业--router出错功能块:定时向邻居router发送Hello包错误Exception in thread "Timer-1" java.util.ConcurrentModificationException  at java.util.HashMap$HashIterator.nextEntry...

空空如也

1 2 3 4 5 ... 20
收藏数 1,983,786
精华内容 793,514
关键字:

util