util_utils - CSDN
精华内容
参与话题
  • Util工具类

    万次阅读 2017-10-30 14:52:23
    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-10-10 11:13:41
    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的原因)

    展开全文
  • java.util中,util是什么意思?

    千次阅读 2014-08-20 16:41:32
    [size=large]util是utiliy的缩写,意为多用途的,工具性质的包。 这个包中主要存放了:集合类(如ArrayList,HashMap等),随机数产生类,属性文件读取类,定时器类等类。 这些类极大方便了Java编程,日常java编程...
    [size=large]util是utiliy的缩写,意为多用途的,工具性质的包。
    这个包中主要存放了:集合类(如ArrayList,HashMap等),随机数产生类,属性文件读取类,定时器类等类。
    这些类极大方便了Java编程,日常java编程中,经常要用到这些类。[/size]
    展开全文
  • Java util

    2020-07-21 09:58:43
    NULL 博文链接:https://cici9898-007.iteye.com/blog/1235060
  • iostat中 %util高 应用延迟高

    千次阅读 2016-08-19 17:10:52
    经过长时间监控,发现iostat 中的%util居高不下,一直在98%上下,说明带宽占用率极高,遇到了瓶颈。 且读写速度很慢,经过排查,发现是HBA卡出现问题,更换后,用dd if命令测试,磁盘的读写速度均得到了10倍以上的...
  • 一个拿来即用的httputil工具类

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

    2020-07-30 23:31:51
    a_靖的通用 util 文件。博文地址 :https://blog.csdn.net/qq_35713752/article/details/77970370
  • java.util包详解

    万次阅读 多人点赞 2007-02-15 16:43: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...
  • 在部署Dynamic Web Project时,如果正确配置web.xml或者标注时,仍然出现以上异常的话,可以尝试以下内容讲解的方法: 首先,双击eclipse中的servers,位置如下图“1”所指。检查位置"2"...
  • 前言 二十多天的实训结束了,虽然环境emmmm有点坑,好多人都感冒了,我也没能逃过一劫. 不过总体来说还行, 第一次尝试跟学校里不一样的,7个人一起做项目. 不过也因此对于github的使用不再局限于之前的将其作为云服务...
  • 最近在做一些组件的封装,使用了java.util.concurrent线程池,就好奇想知道他是如何管理线程,以及重用的?于是追踪了一下源码,基本了解了他得处理机制,所以在此总要记录一下。最近也没写什么文章,感觉人也懒了,...
  • Spring使用util Schema

    千次阅读 2016-03-12 22:09:58
    spring-beans-3.0.xsd是Spring的内核,其它的Schema大多都用于简化某些方面的配置
  • JavaScript工具类:util.js用法实例

    千次阅读 2019-08-01 11:14:59
    _util.isEmpty() console.log(_util.isEmpty(undefined)); // true console.log(_util.isEmpty(null)); // true console.log(_util.isEmpty('')); // true console.log(_util.isEmpty([])); /...
  • 解决java.util.concurrent.RejectedExecutionException

    万次阅读 多人点赞 2017-06-29 22:07:21
    昨晚12:00运行自动化测试脚本时遇到了java.util.concurrent.RejectedExecutionException这个异常,从异常名称里很容易分析出是提交的任务被线程池拒绝了。查看源码发现是在Activity里,AsyncTask是在自定义的线程池...
  • 转载请注明出处:http://blog.csdn.net/l1028386804/article/details/51538611 注:升级glib库解决问题请参加链接:... 配置完hadoop启动的时候出现如下警告信息: WARN util.NativeCodeLoad...
  • 正常来说,这个小功能一个下午不到就可以完成,但是因为涉及到一些很小的细节问题不能及时解决,所以花了我几天的时间,我都开始崩溃和怀疑人生了。所以我写个博客来记录一下遇到的问题还有是如何解决的。
  • 概述 步骤 声明命名空间和schema 配置Bean 配置一个Map 配置一个Set 配置一个List 配置一个Properties ...在spring的配置文件中util命名空间类似于java.util包类对应,util命名空间提供了集合相关的配置,在使用
  • Cause: org.jetbrains.plugins.gradle.tooling.util.ModuleComponentIdentifierImpl.getModuleIdentifier() 究其原因,是gradle版本导致的。从它的报错也能看出,跟我们自己写的代码无关。 怎么改呢? 凡应用gradle...
1 2 3 4 5 ... 20
收藏数 1,926,290
精华内容 770,516
关键字:

util