java实现的日期时间转换工具类完整示例

本文实例讲述了java实现的日期时间转换工具类。分享给大家供大家参考,具体如下:

最基础的东西,总结一下,下次用的时候就方便一些了。废话不多说,直接贴代码:

package com.incar.base.util;
import com.incar.base.exception.BaseRuntimeException;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.*;
import java.time.temporal.ChronoField;
import java.time.temporal.ChronoUnit;
import java.time.temporal.WeekFields;
import java.util.*;
/**
 * Created by Administrator on 2017/4/11.
 */
public class DateUtil {
 public final static String DATE_FORMAT_DAY = "yyyy-MM-dd";
 public final static String DATE_FORMAT_SECOND = "yyyy-MM-dd HH:mm:ss";
 private final static int[] DATE_UNIT_ARR = new int[]{Calendar.MILLISECOND, Calendar.SECOND, Calendar.MINUTE, Calendar.HOUR_OF_DAY,
   Calendar.DATE, Calendar.MONTH, Calendar.YEAR};
 public static Calendar calendar = null;
 public static DateFormat dateFormat = null;
 public static Date date = null;
 /**
  * 将日期转为 字符串
  * @param date
  * @param format
  * @return
  */
 public static String dateToString(Date date, String format) {
  if (date == null) {
   return null;
  }
  return new SimpleDateFormat(format).format(date);
 }
 /**
  * 将日期转换为 字符串(转换的时间按照当前登录用户的时区)
  *
  * @param date
  * @param format
  * @param timeZone
  * @return
  */
 public static String dateToString(Date date, String format, String timeZone) {
  if (date == null) {
   return null;
  }
  //1、格式化日期
  return getTimeZoneSimpleDateFormat(format, timeZone).format(date);
 }
 /**
  * 获取当前登录用户的 日期格式化对象
  *
  * @param timeZone
  * @param format
  * @return
  */
 private static SimpleDateFormat getTimeZoneSimpleDateFormat(String format, String timeZone) {
  //1、获取对应时区的格式化器
  SimpleDateFormat simpleDateFormat = new SimpleDateFormat(format);
  simpleDateFormat.setTimeZone(TimeZone.getTimeZone(timeZone));
  return simpleDateFormat;
 }
 /**
  *将字符串转为日期(转换的时间按照当前登录用户的时区)
  * @param dateStr
  * @param format
  * @return
  */
 public static Date stringToDate(String dateStr, String format, String timeZone) {
  if (dateStr == null || format == null) {
   return null;
  }
  try {
   return getTimeZoneSimpleDateFormat(format, timeZone).parse(dateStr);
  } catch (ParseException e) {
   throw BaseRuntimeException.getException(e);
  }
 }
 /**
  *将字符串转为日期
  * @param dateStr
  * @param format
  * @return
  */
 public static Date stringToDate_CTT(String dateStr, String format) {
  if (dateStr == null || format == null) {
   return null;
  }
  try {
   return getTimeZoneSimpleDateFormat(format, "CTT").parse(dateStr);
  } catch (ParseException e) {
   throw BaseRuntimeException.getException(e);
  }
 }
 /**
  * 获取最近在当前日期之前的最后一个日期单位
  *
  * @param date
  * @param calendarUnit 只支持 DateUtil.DATE_UNIT_ARR
  * @return
  */
 public static Date getFloorDate(Date date, int calendarUnit) {
  if (date == null) {
   return null;
  }
  Calendar calendar = Calendar.getInstance();
  calendar.setTime(date);
  for (int i = 0; i <= DATE_UNIT_ARR.length - 1; i++) {
   if (DATE_UNIT_ARR[i] > calendarUnit) {
    if (Calendar.DATE == DATE_UNIT_ARR[i]) {
     calendar.set(DATE_UNIT_ARR[i], 1);
    } else {
     calendar.set(DATE_UNIT_ARR[i], 0);
    }
   }
   if (DATE_UNIT_ARR[i] == calendarUnit) {
    break;
   }
  }
  return calendar.getTime();
 }
 /**
  * 获取最近在当前日期之后的第一个日期单位
  *
  * @param date
  * @param calendarUnit 只支持 DateUtil.DATE_UNIT_ARR
  * @return
  */
 public static Date getCeilDate(Date date, int calendarUnit) {
  if (date == null) {
   return null;
  }
  Calendar calendar = Calendar.getInstance();
  calendar.setTime(date);
  for (int i = 0; i <= DATE_UNIT_ARR.length - 1; i++) {
   if (DATE_UNIT_ARR[i] > calendarUnit) {
    if (Calendar.DATE == DATE_UNIT_ARR[i]) {
     calendar.set(DATE_UNIT_ARR[i], 1);
    } else {
     calendar.set(DATE_UNIT_ARR[i], 0);
    }
   }
   if (DATE_UNIT_ARR[i] == calendarUnit) {
    calendar.add(DATE_UNIT_ARR[i], 1);
    break;
   }
  }
  return calendar.getTime();
 }
 /**
  * 将开始时间、结束时间 根据日期单位划分成 时间段
  *
  *
  * @param startDate
  * @param endDate
  * @param calendarUnit Calendar.MONTH,Calendar.DATE
  * @param dateNum  指定的单位日期数量
  * @return 每一个数组第一个为开始时间,第二个为结束时间; 第一个元素结束时间总是等于第二元素开始时间
  */
 public static List<Date[]> splitDate(Date startDate, Date endDate, int calendarUnit, int dateNum) {
  List<Date[]> returnList = new ArrayList<>();
  if (startDate.getTime() > endDate.getTime()) {
   return null;
  }
  Calendar c1 = Calendar.getInstance();
  Calendar c2 = Calendar.getInstance();
  c1.setTime(startDate);
  c2.setTime(endDate);
  Calendar curC1 = Calendar.getInstance();
  Calendar curC2 = null;
  curC1.setTime(startDate);
  while (curC2 == null || curC2.before(c2)) {
   if (curC2 == null) {
    curC2 = Calendar.getInstance();
    curC2.setTime(startDate);
    curC2.add(calendarUnit, dateNum);
   } else {
    curC1.add(calendarUnit, dateNum);
    curC2.add(calendarUnit, dateNum);
   }
   returnList.add(new Date[]{curC1.getTime(), curC2.getTime()});
  }
  //设置最后一个区间的截至日期为endDate
  returnList.get(returnList.size() - 1)[1] = endDate;
  return returnList;
 }
 /**
  * 获取开始时间结束时间按照 日期单位 形成多个日期区间
  * 分割出来的时间区间以
  * 第一个区间开始时间为传入开始时间
  * 最后一个区间结束时间为传入结束时间
  * @param startDate
  * @param endDate
  * @param unit 1:代表按日;2:代表按周;3:代表按月
  * @return
  */
 public static List<Date[]> rangeDate(Date startDate, Date endDate, int unit){
  List<Date[]> returnList=new ArrayList<>();
  LocalDateTime ldt1= LocalDateTime.ofInstant(startDate.toInstant(),ZoneId.of("+8"));
  LocalDateTime ldt2= LocalDateTime.ofInstant(endDate.toInstant(),ZoneId.of("+8"));
  switch (unit){
   case 1:{
    LocalDateTime start= ldt1.with(ChronoField.SECOND_OF_DAY,0);
    LocalDateTime end= ldt1.with(ChronoField.SECOND_OF_DAY, ChronoUnit.DAYS.getDuration().getSeconds()-1);
    while(true){
     returnList.add(new Date[]{Date.from(start.toInstant(ZoneOffset.of("+8"))),Date.from(end.toInstant(ZoneOffset.of("+8")))});
     if(!ldt2.isBefore(start)&&!ldt2.isAfter(end)){
      break;
     }else{
      start=start.plusDays(1);
      end=end.plusDays(1);
     }
    }
    break;
   }
   case 2:{
    int dayOfWeek=ldt1.get(ChronoField.DAY_OF_WEEK);
    LocalDateTime start= ldt1.plusDays(1-dayOfWeek).with(ChronoField.SECOND_OF_DAY,0);
    LocalDateTime end= ldt1.plusDays(7-dayOfWeek).with(ChronoField.SECOND_OF_DAY, ChronoUnit.DAYS.getDuration().getSeconds()-1);
    while(true){
     returnList.add(new Date[]{Date.from(start.toInstant(ZoneOffset.of("+8"))),Date.from(end.toInstant(ZoneOffset.of("+8")))});
     if(!ldt2.isBefore(start)&&!ldt2.isAfter(end)){
      break;
     }else{
      start=start.plusWeeks(1);
      end=end.plusWeeks(1);
     }
    }
    if(returnList.size()>0){
     Date[] firstEle=returnList.get(0);
     Date[] lastEle=returnList.get(returnList.size()-1);
     firstEle[0]=Date.from(ldt1.with(ChronoField.SECOND_OF_DAY,0).toInstant(ZoneOffset.of("+8")));
     lastEle[1]=Date.from(ldt2.with(ChronoField.SECOND_OF_DAY,0).toInstant(ZoneOffset.of("+8")));
    }
    break;
   }
   case 3:{
    LocalDateTime temp=ldt1;
    while(true) {
     int dayOfMonth = temp.get(ChronoField.DAY_OF_MONTH);
     int max = temp.getMonth().maxLength();
     LocalDateTime start = temp.plusDays(1 - dayOfMonth).with(ChronoField.SECOND_OF_DAY, 0);
     LocalDateTime end = temp.plusDays(max - dayOfMonth).with(ChronoField.SECOND_OF_DAY, ChronoUnit.DAYS.getDuration().getSeconds() - 1);
     returnList.add(new Date[]{Date.from(start.toInstant(ZoneOffset.of("+8"))),Date.from(end.toInstant(ZoneOffset.of("+8")))});
     if(!ldt2.isBefore(start)&&!ldt2.isAfter(end)){
      break;
     }else{
      temp=temp.plusMonths(1);
     }
    }
    if(returnList.size()>0){
     Date[] firstEle=returnList.get(0);
     Date[] lastEle=returnList.get(returnList.size()-1);
     firstEle[0]=Date.from(ldt1.with(ChronoField.SECOND_OF_DAY,0).toInstant(ZoneOffset.of("+8")));
     lastEle[1]=Date.from(ldt2.with(ChronoField.SECOND_OF_DAY,0).toInstant(ZoneOffset.of("+8")));
    }
    break;
   }
  }
  return returnList;
 }
 /**
  * 计算两个时间相差多少日期单位(不足一个日期单位的的按一个日期单位算)
  *
  * @param d1 开始时间
  * @param d2 结束时间
  * @return 相差日期单位数
  */
 public static int getDiff(Date d1, Date d2, int calendarUnit) {
  double diff;
  switch (calendarUnit) {
   case Calendar.DATE: {
    diff = 1000 * 60 * 60 * 24;
    break;
   }
   case Calendar.HOUR_OF_DAY: {
    diff = 1000 * 60 * 60;
    break;
   }
   case Calendar.MINUTE: {
    diff = 1000 * 60;
    break;
   }
   case Calendar.SECOND: {
    diff = 1000;
    break;
   }
   default: {
    throw BaseRuntimeException.getException("[DateUtil.getDiff],Calendar Unit Not Support!");
   }
  }
  Long begin = d1.getTime();
  Long end = d2.getTime();
  Double res = (end - begin) / diff;
  return (int) Math.ceil(res);
 }
 /**
  * 会改变参数值
  * 格式化日期参数开始日期和结束日期
  * 格式规则为:
  * 开始日期去掉时分秒
  * 结束日期设置为当天 23:59:59
  *
  * @param startDate
  * @param endDate
  */
 public static void formatDateParam(Date startDate, Date endDate) {
  if (startDate != null) {
   startDate.setTime(getFloorDate(startDate, Calendar.DATE).getTime());
  }
  if (endDate != null) {
   Date tempDate = getCeilDate(endDate, Calendar.DATE);
   Calendar endC = Calendar.getInstance();
   endC.setTime(tempDate);
   endC.add(Calendar.SECOND, -1);
   endDate.setTime(endC.getTimeInMillis());
  }
 }
 /**
  * 获取一个日期的数字表示形式
  * 例如:
  * 2018-3-12 15:13:12 888 表示成 20180312151312888
  *
  * @param date
  * @param calendarUnit 最小的日期单位
  * @return
  */
 public static Long getDateNum(Date date, int calendarUnit) {
  if (date == null) {
   return null;
  }
  StringBuffer sb = new StringBuffer();
  Calendar c = Calendar.getInstance();
  c.setTime(date);
  if (calendarUnit >= Calendar.YEAR) {
   sb.append(c.get(Calendar.YEAR));
  }
  if (calendarUnit >= Calendar.MONTH) {
   sb.append(FormatUtil.formatToString(c.get(Calendar.MONTH) + 1, "00"));
  }
  if (calendarUnit >= Calendar.DATE) {
   sb.append(FormatUtil.formatToString(c.get(Calendar.DATE), "00"));
  }
  if (calendarUnit >= Calendar.HOUR_OF_DAY) {
   sb.append(FormatUtil.formatToString(c.get(Calendar.HOUR_OF_DAY), "00"));
  }
  if (calendarUnit >= Calendar.MINUTE) {
   sb.append(FormatUtil.formatToString(c.get(Calendar.MINUTE), "00"));
  }
  if (calendarUnit >= Calendar.SECOND) {
   sb.append(FormatUtil.formatToString(c.get(Calendar.SECOND), "00"));
  }
  if (calendarUnit >= Calendar.MILLISECOND) {
   sb.append(FormatUtil.formatToString(c.get(Calendar.MILLISECOND), "000"));
  }
  return Long.parseLong(sb.toString());
 }
 /**
  * 判断两个日期是否相等
  *
  * @param d1
  * @param d2
  * @param calendarUnit 对比的最小日期单位
  * @return
  */
 public static boolean isEqual(Date d1, Date d2, int calendarUnit) {
  Calendar c1 = Calendar.getInstance();
  Calendar c2 = Calendar.getInstance();
  c1.setTime(d1);
  c2.setTime(d2);
  for (int i = DATE_UNIT_ARR.length - 1; i >= 0; i--) {
   if (calendarUnit >= DATE_UNIT_ARR[i]) {
    int v1 = c1.get(DATE_UNIT_ARR[i]);
    int v2 = c2.get(DATE_UNIT_ARR[i]);
    if (v1 != v2) {
     return false;
    }
   } else {
    break;
   }
  }
  return true;
 }
 /**
  * 获取当天初始时间
  *
  * @param date 时间
  * @return 初始时间 (yyyy-MM-dd 00:00:00)
  */
 public static Date getInitialTime(Date date) {
  DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd 00:00:00");
  String dateStr = dateFormat.format(date);
  try {
   return dateFormat.parse(dateStr);
  } catch (ParseException e) {
   e.printStackTrace();
  }
  return null;
 }
 /**
  * 获取当天最后时间
  *
  * @param date 时间
  * @return 最后时间 (yyyy-MM-dd 23:59:59)
  */
 public static Date getTerminalTime(Date date) {
  DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
  String dateStr = dateFormat.format(date);
  dateStr = dateStr + " 23:59:59";
  dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  try {
   return dateFormat.parse(dateStr);
  } catch (ParseException e) {
   e.printStackTrace();
  }
  return null;
 }
 public static String date2Str(Date date) {
  DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  return dateFormat.format(date);
 }
 /**
  * 计算两个时间间隔多少秒
  *
  * @param startDate
  * @param endDate
  * @return
  */
 public static Long intervalTime(Date startDate, Date endDate) {
  long a = endDate.getTime();
  long b = startDate.getTime();
  Long c = ((a - b) / 1000);
  return c;
 }
 /**
  * 检测一个日期是否在 小时之内,支持跨天的小时
  *
  * @param time
  * @param startDate
  * @param endDate
  * @return
  */
 public static boolean checkDateIn(Date time, Date startDate, Date endDate) {
  if (startDate == null || endDate == null || time == null) {
   return true;
  }
  return time.before(endDate) && time.after(startDate);
 }
 /**
  * 检测一个日期是否在 时分秒 之内,支持跨天的小时
  *
  * @param time
  * @param startHms
  * @param endHms
  * @return
  */
 public static boolean checkHmsIn(Date time, String startHms, String endHms) {
  if (startHms == null || endHms == null || time == null) {
   return true;
  }
  LocalTime startTime = LocalTime.of(
    Integer.valueOf(startHms.substring(0, 2)),
    Integer.valueOf(startHms.substring(2, 4)),
    Integer.valueOf(startHms.substring(4, 6))
  );
  LocalTime endTime = LocalTime.of(
    Integer.valueOf(endHms.substring(0, 2)),
    Integer.valueOf(endHms.substring(2, 4)),
    Integer.valueOf(endHms.substring(4, 6))
  );
  LocalTime curTime = LocalDateTime.ofInstant(time.toInstant(), ZoneId.of("+8")).toLocalTime();
  if (endTime.isAfter(startTime)) {
   return startTime.isBefore(curTime) && endTime.isAfter(curTime);
  } else {
   return (startTime.isBefore(curTime) && LocalTime.MAX.isAfter(curTime)) || (LocalTime.MIN.isBefore(curTime) && endTime.isAfter(curTime));
  }
 }
 /**
  * 功能描述:格式化日期
  *
  * @param dateStr 字符型日期:YYYY/MM/DD 格式
  * @return Date 日期
  */
 public static Date parseDate(String dateStr) {
  return parseDate(dateStr, "yyyy-MM-dd");
 }
 /**
  * 功能描述:格式化日期
  *
  * @param dateStr 字符型日期
  * @param format 格式
  * @return Date 日期
  */
 public static Date parseDate(String dateStr, String format) {
  try {
   dateFormat = new SimpleDateFormat(format);
   String dt = dateStr.replaceAll("-", "/");
   if ((!dt.equals("")) && (dt.length() < format.length())) {
    dt += format.substring(dt.length()).replaceAll("[YyMmDdHhSs]",
      "0");
   }
   date = (Date) dateFormat.parse(dt);
  } catch (Exception e) {
   return null;
  }
  return date;
 }
 public static Date stringParseDate(String date) throws ParseException {
  //获取的值为"19570323"
  //1、定义转换格式
  SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
  SimpleDateFormat formatter2 = new SimpleDateFormat("yyyyMMdd");
  //2、调用formatter2.parse(),将"19570323"转化为date类型 输出为:Sat Mar 23 00:00:00 GMT+08:00 1957
  Date parseDate = formatter2.parse(date);
  return parseDate;
 }
}

PS:这里再为大家推荐几款关于日期与时间计算的在线工具供大家参考使用:

在线日期/天数计算器:
http://tools.jb51.net/jisuanqi/date_jisuanqi

在线万年历日历:
http://tools.jb51.net/bianmin/wannianli

在线阴历/阳历转换工具:
http://tools.jb51.net/bianmin/yinli2yangli

Unix时间戳(timestamp)转换工具:
http://tools.jb51.net/code/unixtime

更多关于java相关内容感兴趣的读者可查看本站专题:《java日期与时间操作技巧汇总》、《Java数据结构与算法教程》、《Java操作DOM节点技巧总结》和《Java缓存操作技巧汇总》

希望本文所述对大家java程序设计有所帮助。

(0)

相关推荐

  • Java Number类原理实例解析

    这篇文章主要介绍了Java Number类原理解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 Number类 内置数据类型:byte.int.long.double等 包装类:Integer.Long.Byte.Double.Float.Short. ​ 这种由编译器特别支持的包装称为装箱,所以当内置数据类型被当作对象使用的时候,编译器会把内置类型装箱为包装类.相似的,编译器也可以把一个对象拆箱为内置类型.Number 类属于 java.l

  • Java实现的分页工具类与用法示例

    本文实例讲述了Java实现的分页工具类与用法.分享给大家供大家参考,具体如下: 今天闲来没事,写了一个页面的分页工具类,具有很好的兼容性与实用性哦. 不管怎么样,先来瞧一瞧: package com.bw.utils; /** * 分页工具类 * * @author H.ros * */ public class PageUtils2 { // 当前页(从页面获取的当前页码,未计算) private int currentPage; // 前一页 private int prevPage; //

  • java获取包下被指定注解的类过程解析

    方案一: 采用reflections 框架(此框架依赖com.google.guava) 1.reflections框架地址:https://github.com/ronmamo/reflections 2.项目依赖 <dependency> <groupId>org.reflections</groupId> <artifactId>reflections</artifactId> <version>0.9.11</versi

  • javaweb 国际化:DateFormat,NumberFormat,MessageFormat,ResourceBundle的使用

    Javaweb 国际化 DateFormat:格式化日期的工具类,本身是一个抽象类: NumberFormat:格式化 数字 到 数字字符串,或货币字符串的字符类; MessageFormat: 可以格式化模式字符串,模式字符串: 带占位符的字符串: "Date: {0}, Salary: {1}",可以通过 format 方法会模式字符串进行格式化 ResourceBundle:资源包类,在类路径(src)下需要有对应的资源文件: baseName.properties. 其中 ba

  • Java NumberFormat格式化float类型的bug

    首先,这个NumberFormat这个类,可以格式化各种数字.你只要稍微设置一下,结果还是很理性的. 但是,他有那么一丢丢的bug,不知道你知道不? /** * 2.3F经过格式化,竟然变成2.99啦.what the fuck . * float类型的时候,值是2.3,但是一经变成Double,值就变成2.99999啦. * 这个format的参数是double类型的.所以,在传入参数的时候,就变成了对2.299999952316284进行操作.返回就过就是2.99 */ private st

  • Java NumberFormat 类的详解及实例

     Java NumberFormat 类的详解及实例 概要: NumberFormat 表示数字的格式化类, 即:可以按照本地的风格习惯进行数字的显示. 此类的定义如下: public abstract class NumberFormat extends Format MessageFormat .DateFormat .NumberFormat 是 Format 三个常用的子类,如果要想进一步完成一个好的国际化程序,则肯定需要同时使用这样三个类完成,根据不同的国家显示贷币的形式. 此类还是在

  • Java正则相关的Pattern和Matcher类及遇到的坑

    此篇文章是记录我在学习Java正则表达式时候学到的和遇到的坑. 先来说说 Matcher 里面的三个方法(取的结果以group()方法为例子) matches():整个匹配,只有整个字符序列完全匹配成功,才返回True,否则返回False.但如果前部分匹配成功,将移动下次匹配的位置.举个例子如果字符串为"a123",正则表达式为"\w\d\d\d",则matches()方法才返回true,换言之,就是要匹配的字符串需要跟正则表达式一一对应,字母对应字母,数字对应数字

  • Java原生服务器接收上传文件 不使用MultipartFile类

    由于工作中 使用 MultipartFile 与现有的一些上传文件组件冲突 所以使用其他的接收上传文件的方法. 首先我把 MultipartFile 类的配置文件注释掉. <!-- <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver"> <property name="defaul

  • java实现的日期时间转换工具类完整示例

    本文实例讲述了java实现的日期时间转换工具类.分享给大家供大家参考,具体如下: 最基础的东西,总结一下,下次用的时候就方便一些了.废话不多说,直接贴代码: package com.incar.base.util; import com.incar.base.exception.BaseRuntimeException; import java.text.DateFormat; import java.text.ParseException; import java.text.SimpleDat

  • Java实现的进制转换工具类完整示例

    本文实例讲述了Java实现的进制转换工具类.分享给大家供大家参考,具体如下: import java.nio.charset.Charset; /** * 十六进制(简写为hex或下标16)在数学中是一种逢16进1的进位制,一般用数字0到9和字母A到F表示(其中:A~F即10~15).<br> * 例如十进制数57,在二进制写作111001,在16进制写作39.<br> * 像java,c这样的语言为了区分十六进制和十进制数值,会在十六进制数的前面加上 0x,比如0x20是十进制的

  • Java对象和Json文本转换工具类的实现

    目录 安装 下载源码 编译源码 添加依赖 Java对象 基本数据类型 数组 列表 字典 类 Java对象转换为Json文本 基本数据类型 数组 列表 字典 类 Json文本转换为Java对象 基本数据类型 数组 列表 字典 类 Json 是一个用于 Java 对象 和 Json 文本 相互转换的工具类. 安装 下载源码 git clone https://github.com/njdi/durian.git 编译源码 cd durian/ 切换至最新版本(Tag),如:0.4, git chec

  • 基于Java实现进制转换工具类的示例代码

    目录 背景 原理 十进制A转换为N进制R N进制R转换为十进制A 应用 延伸 背景 最近有个发送短信的功能,需要在短信中带有详情链接,链接中带有对应信息且要有校验功能,然而短信是按字数收费的,所以链接要尽可能的短.链接中带有数字类型参数,就想到通过低进制转高进制可以减少参数长度. 原理 低进制转换到高进制的时候可能会减少位数,例如二进制是满二进一,十进制是满十进一. 二进制:101001101 转换为对应的四进制为:11031 转换为对应的八进制为:515 转换为对应的十进制为:333 转换为对

  • Android开发之Activity管理工具类完整示例

    本文实例讲述了Android开发之Activity管理工具类.分享给大家供大家参考,具体如下: 这个工具类是对Activity的一些管理,非常适用 package com.maobang.imsdk.util; import java.util.Stack; import android.app.Activity; import android.app.ActivityManager; import android.content.Context; import android.graphics

  • Java实现操作JSON的便捷工具类完整实例【重写Google的Gson】

    本文实例讲述了Java实现操作JSON的便捷工具类.分享给大家供大家参考,具体如下: 对于JSON数据格式的处理,自开发Java以来,已用过多种JSON的开源工具,用得最好,也用得最High的恐怕要属Google的Gson了. 特别为它写了一个工具类,放入常备工具中,方便使用.下面是为GSON 1.5版本重写的工具类. 依赖包: slf4j-api-1.6.0.jar slf4j-log4j12-1.6.0.jar log4j-1.2.15.jar gson-1.5.jar /** * Copy

  • Java实现的图片上传工具类完整实例

    本文实例讲述了Java实现的图片上传工具类.分享给大家供大家参考,具体如下: package com.gcloud.common; import javax.imageio.ImageIO; import java.awt.image.BufferedImage; import java.io.*; /** * 图片上传工具类 * Created by charlin on 2017/9/10. */ public class UploadImageUtil { private String f

  • Android开发之拼音转换工具类PinyinUtils示例

    本文实例讲述了Android开发之拼音转换工具类PinyinUtils.分享给大家供大家参考,具体如下: 1.首先下载pinyin4j-2.5.0.jar,拷贝到工程的lib目录里 官网下载地址:https://sourceforge.net/projects/pinyin4j/ 或者点击此处本站下载. 2.创建工具类:PinyinUtils /** * 拼音转换工具 * * @描述 TODO * @项目名称 App_imooc * @包名 com.android.imooc.quickInde

  • java字符串与日期类型转换的工具类

    常用的字符串转date,和日期转字符串的方法,具体内容如下 package com.cq2022.zago.base.util; import java.text.DateFormat; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; import java.util.GregorianCalendar; import javax.xml.datatype.Dat

  • Android开发之媒体播放工具类完整示例

    本文实例讲述了Android开发之媒体播放工具类.分享给大家供大家参考,具体如下: package com.maobang.imsdk.util; import android.media.MediaPlayer; import android.net.Uri; import android.util.Log; import java.io.FileInputStream; import java.io.IOException; import com.maobang.imsdk.app.IMAp

随机推荐