不是因为坚持只是因为喜欢
不是因为坚持只是因为喜欢

Java中的日期处理

简单介绍下java中日期处理时需要用到的几个类：Date、Calendar、SimpleDateFormat
几个概念：

  1. 时间戳
    时间戳指格林威治时间1970年01月01日00时00分00秒(北京时间1970年01月01日08时00分00秒)起至现在的总秒数。

Date类

类 Date 表示特定的瞬间，精确到毫秒。Date类中的很多方法都被废弃，比如对年月日时分秒等日期数据获取和操作都放在了Calendar中

常用方法

  1. boolean after(Date when)
    测试此日期是否在指定日期之后。
  2. boolean before(Date when)
    测试此日期是否在指定日期之前。
  3. Object clone()
    返回此对象的副本。
  4. int compareTo(Date anotherDate)
    比较两个日期的顺序。
  5. boolean equals(Object obj)
    比较两个日期的相等性。
  6. void setTime(long time)
    根据时间戳获取Date对象
  7. void setTime(long time)
    设置时间戳
  8. void getTime()
    获取时间戳

Calendar类

Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等 日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。瞬间可用毫秒值来表示，它是距历元（即格林威治标准时间 1970 年 1 月 1 日的 00:00:00.000，格里高利历）的偏移量。

该类还为实现包范围外的具体日历系统提供了其他字段和方法。这些字段和方法被定义为 protected。

与其他语言环境敏感类一样，Calendar 提供了一个类方法 getInstance，以获得此类型的一个通用的对象。Calendar 的 getInstance 方法返回一个 Calendar 对象，其日历字段已由当前日期和时间初始化

常用方法

  1. abstract void add(int field, int amount)
    根据日历的规则，为给定的日历字段添加或减去指定的时间量。
    例如，要从当前日历时间减去 5 天，可以通过调用以下方法做到这一点：
    add(Calendar.DAY_OF_MONTH, -5);
  2. public boolean after(Object when)
    判断此 Calendar 表示的时间是否在指定 Object 表示的时间之后，返回判断结果。此方法等效于：
    when instanceof Calendar && compareTo((Calendar)when) > 0；//Calendar源码
    即当且仅当 when 是一个 Calendar 实例时，且“compareTo((Calendar)when) > 0”true时，after方法才返回 true。否则该方法返回 false。
  3. public boolean before(Object when)
    判断此 Calendar 表示的时间是否在指定 Object 表示的时间之前，返回判断结果。此方法等效于：
    return when instanceof Calendar && compareTo((Calendar)when) < 0;
    即当且仅当 when 是一个 Calendar 实例时，且“compareTo((Calendar)when) < 0”返回true时，after方法才返回 true。否则该方法返回 false。
  4. int get(int field)
    注意事项：
    Calendar用0表示一月份；
    HOUR_OF_DAY表示24进制，HOUR表示AM或者PM的小时，是十二进制表示；
    DAY_OF_WEEK从周日开始算起
    例如：
    System.out.println(“现在是”+now.get(Calendar.YEAR)+”年”);
    System.out.println(“现在是”+now.get(Calendar.MONTH)+”月”);
    System.out.println(“现在是”+now.get(Calendar.DAY_OF_MONTH)+”日”);
    System.out.println(“现在是”+now.get(Calendar.HOUR_OF_DAY)+”时”);
    System.out.println(“现在是”+now.get(Calendar.MINUTE)+”分”);
    System.out.println(“现在是”+now.get(Calendar.SECOND)+”秒”);
  5. public int getActualMaximum(int field)
    给定此 Calendar 的时间值，返回指定日历字段可能拥有的最大值。
  6. public static Calendar getInstance()
    使用默认时区和语言环境获得一个日历。返回的 Calendar 基于当前时间，使用了默认时区和默认语言环境。
  7. public final Date getTime()
    返回一个表示此 Calendar 时间值（从 历元至现在的毫秒偏移量）的 Date 对象。
  8. public long getTimeInMillis()
    返回此 Calendar 的时间值，以毫秒为单位。获取时间戳
  9. public final void clear()
    将此 Calendar 的所日历字段值和时间值（从 历元至现在的毫秒偏移量）设置成未定义。这意味着 isSet() 对于所有的日历字段都将返回 false，并且日期和时间计算会将这些字段作为从未设置的字段对待。 Calendar 实现类可能对日期/时间计算使用字段的特定默认值。例如，如果未定义 YEAR 字段值，则 GregorianCalendar 会使用 1970。
  10. 三个set方法
    void set(int year, int month, int date)
    设置日历字段 YEAR、MONTH 和 DAY_OF_MONTH 的值。
    void set(int year, int month, int date, int hourOfDay, int minute)
    设置日历字段 YEAR、MONTH、DAY_OF_MONTH、HOUR_OF_DAY 和 MINUTE 的 值。
    void set(int year, int month, int date, int hourOfDay, int minute, int second)
    设置字段 YEAR、MONTH、DAY_OF_MONTH、HOUR、MINUTE 和 SECOND 的值。
  11. public void setLenient(boolean lenient)
    指定日期/时间解释是否是宽松的。对于宽松的解释，可以将诸如 “February 942, 1996” 之类的日期视为等同于 1996 年 1 月 1 日后的第 941 天。而对于严格的（non-lenient）解释，这样的日期会导致抛出异常。默认情况下是宽松的。
  12. void setTime(Date date)
    使用给定的 Date 设置此 Calendar 的时间。
  13. void setTimeInMillis(long millis)
    用给定的 long 值设置此 Calendar 的当前时间值。

SimpleDateFormat类

日期和时间格式由日期和时间模式 字符串指定。在日期和时间模式字符串中，未加引号的字母 ‘A’ 到 ‘Z’ 和 ‘a’ 到 ‘z’ 被解释为模式字母，用来表示日期或时间字符串元素。文本可以使用单引号 (‘) 引起来，以免进行解释。
例子：
Java中的日期处理_第1张图片

常用方法

  1. public SimpleDateFormat(String pattern)
    用给定的模式和默认语言环境的日期格式符号构造 SimpleDateFormat。
  2. String format(Date date)
    将一个 Date 格式化为日期/时间字符串。
  3. Date parse(String source)
    从给定字符串的开始解析文本，以生成一个日期。

公共方法类


import com.hikvision.exception.BusinessException;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.time.DateFormatUtils;
import org.apache.commons.lang3.time.DateUtils;
import org.apache.poi.util.SystemOutLogger;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.sql.Timestamp;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.regex.Pattern;

public class DateUtil {

    private static Logger logger = LoggerFactory.getLogger(DateUtil.class);

    public static final String DEFAULT_DATETIME_FORMAT = "yyyy-MM-dd HH:mm:ss";

    public static final String DEFAULT_LASTDATETIME_FORMAT = "yyyy-MM-dd 23:59:59";

    public static final String DEFAULT_BGNDATETIME_FORMAT = "yyyy-MM-dd 00:00:00";

    public static final String DEFAULT_DATETIME24_FORMAT = "yyyy-MM-dd HH:mm:ss.SSS";

    private static final String DEFAULT_DATEMOBAN_FORMAT = "MM-dd HH:mm";

    private static final String DEFAULT_DATEFULLTIME_FORMAT = "yyyyMMddHHmmss";

    private static final long MILLISECONDS_A_DAY = 24 * 3600 * 1000;

    private static final long MILLISECONDS_A_HOUR = 3600 * 1000;

    private static final long MILLISECONDS_A_second = 1000;

    public static final String DEFAULT_DATE_FORMAT = "yyyy-MM-dd";

    public static final String YEAR_MONTH_FORMAT = "yyyy/MM";

    public static final String DEFAULT_YEAR_MONTH_FORMAT1 = "yyyy-MM";

    private static final String MILLISECOND_FORMAT = "yyyyMMddHHmmssSSS";

    public static final String DEFAULT_DATEFULLDATE_FORMAT = "yyyyMMdd";

    public static final String DEFAULT_YEAR_MONTH_FORMAT = "yyyyMM";

    public static final String DEFAULT_YEAR_FORMAT = "yyyy";

    public static final String DEFAULT_MONTH_FORMAT = "MM";

    public static final String DEFAULT_Day_FORMAT = "dd";

    //验证日期字符串，有效日期范围1900-1-1到2099-12-31.
    private static final Pattern pattern = Pattern
            .compile("(?:(?:19|20)\\d{2})-(?:0?[1-9]|1[0-2])-(?:0?[1-9]|[12][0-9]|3[01])");


    /**
     * @return String
     * @Description:获取当前时间的30天后的时间
     */
    public static Date getPreMonth() {
        Date now = addDays(new Date(), 30);
        SimpleDateFormat format = new SimpleDateFormat(DEFAULT_DATETIME_FORMAT);
        Date afterMonth = null;
        try {
            afterMonth = format.parse(format.format(now.getTime()));
        } catch (ParseException e) {
            logger.error("解析日期失败:方法,getPreMonth()", e);
        }
        return afterMonth;
    }

    /**
     * @return String
     * @Description: 将时间转化格式为  yyyy-MM-dd HH:mm:ss 的字符串
     */
    public static String getDefaultTimeStr(Date date) {
        SimpleDateFormat format = new SimpleDateFormat(DEFAULT_DATETIME_FORMAT);
        return format.format(date);
    }

    /**
     * @return String
     * @Description: 将时间转化格式为  MM-dd HH:mm 的字符串
     */
    public static String getDefaultMOBANTimeStr(Date date) {
        SimpleDateFormat format = new SimpleDateFormat(DEFAULT_DATEMOBAN_FORMAT);
        return format.format(date);
    }


    /**
     * @return String
     * @Description: 将时间转化格式为  yyyy-MM-dd 23:59:59 的字符串
     */
    public static String getDefaultLastTimeStr(Date date) {
        SimpleDateFormat format = new SimpleDateFormat(DEFAULT_LASTDATETIME_FORMAT);
        return format.format(date);
    }

    /**
     * @return String
     * @Description: 将时间转化格式为  yyyy-MM-dd 00:00:00的字符串
     */
    public static String getDefaultBGNTimeStr(Date date) {

        SimpleDateFormat format = new SimpleDateFormat(DEFAULT_BGNDATETIME_FORMAT);
        return format.format(date);
    }

    /**
     * 将时间转化格式为  yyyy-MM-dd 的字符串
     * @param date
     * @return
     */
    public static String getDefaultTime2DateStr(Date date) {
        SimpleDateFormat format = new SimpleDateFormat(DEFAULT_DATE_FORMAT);
        return format.format(date);
    }

    /**
     * 月份运算
     *
     * @param date    时间
     * @param amount  相加或相减的月份
     * @param pattern 时间格式
     * @return
     */
    public static Date gapMonth(Date date, int amount, String pattern) throws ParseException {
        Date endDate = DateUtils.addMonths(date, amount);
        Date overDate = DateUtils.parseDate(DateFormatUtils.format(endDate, pattern), DEFAULT_DATETIME_FORMAT);
        return overDate;
    }

    /**
     * 年份运算
     *
     * @param date    时间
     * @param amount  相加或相减的月份
     * @param pattern 时间格式
     * @return
     */
    public static Date gapYear(Date date, int amount, String pattern) throws ParseException {
        Date endDate = DateUtils.addYears(date, amount);
        Date overDate = DateUtils.parseDate(DateFormatUtils.format(endDate, pattern), DEFAULT_DATETIME_FORMAT);
        return overDate;
    }

    /**
     * 获取精确到秒的时间戳
     * @param date date
     * @return date为空则返回null
     */
    public static String getSecondTimestamp(Date date){
        if (null != date) {
            return String.valueOf(date.getTime()/1000);
        }
        return null;
    }


    /**
     * @return Date
     * @Description:当前时间加上days天
     */
    public static Date addDays(Date date, int days) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        cal.add(Calendar.DATE, days);
        return cal.getTime();
    }

    public static Date addMinutes(Date date, int minute) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        cal.add(Calendar.MINUTE, minute);
        return cal.getTime();
    }
    //添加指定秒速
    public static Date addSecond(Date date, int second) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        cal.add(Calendar.SECOND, second);
        return cal.getTime();
    }

    public static Date parseDate(String s) throws ParseException {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        return format.parse(s);
    }
    public static Date parseDate(String s,String format) throws ParseException {
        if(StringUtil.isNullOrEmpty(format)){
            format = DEFAULT_DATE_FORMAT;
        }
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        return sdf.parse(s);
    }

    /**
     * 按 yyyy-MM-dd HH:mm:ss 转换时间
     */
    public static Date parseDateFromStr(String s) throws ParseException {
        SimpleDateFormat format = new SimpleDateFormat(DEFAULT_DATETIME_FORMAT);
        return format.parse(s);
    }

    /**
     * 按 yyyyMMddHHmmss 转换时间
     */
    public static Date parseDateFromStrs(String s) throws ParseException {
        SimpleDateFormat format = new SimpleDateFormat(DEFAULT_DATEFULLTIME_FORMAT);
        return format.parse(s);
    }

    /**
     * 当前时间加上days月
     */
    public static Date addMonths(Date date, int months) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        cal.add(Calendar.MONTH, months);
        return cal.getTime();
    }

    /**
     * 获取当前月的最大日期
     *
     * @return
     */
    public static Date getMaxDate() {
        Calendar cal = Calendar.getInstance();
        cal.set(Calendar.DATE, cal.getActualMaximum(Calendar.DATE));
        return cal.getTime();
    }

    /**
     * 获取当前年份
     *
     * @return
     */
    public static int getYear() {
        Calendar cal = Calendar.getInstance();
        return cal.get(Calendar.YEAR);
    }

    /**
     * 获取当前月
     *
     * @return
     */
    public static int getMonth() {
        Calendar cal = Calendar.getInstance();
        return cal.get(Calendar.MONTH) + 1;
    }

    /**
     * 获取当前月的最小日期
     *
     * @return
     */
    public static Date getMinDate() {
        Calendar cal = Calendar.getInstance();
        cal.set(Calendar.DATE, cal.getActualMinimum(Calendar.DATE));
        return cal.getTime();
    }

    /**
     * 获取指定月的最小时间
     *
     * @param date
     * @return
     */
    public static Date getMinDateByMonth(Date date) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        cal.set(Calendar.DATE, cal.getActualMinimum(Calendar.DATE));
        return cal.getTime();
    }

    /**
     * 获取指定月的最大时间
     *
     * @param date
     * @return
     */
    public static Date getMaxDateByMonth(Date date) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        cal.set(Calendar.DATE, cal.getActualMaximum(Calendar.DATE));
        return cal.getTime();
    }


    /**
     * 取得某月的的最后一天
     *
     * @param year
     * @param month
     * @return
     */
    public static Date getLastDayOfLastMonth(int year, int month) {
        Calendar cal = Calendar.getInstance();
        cal.set(Calendar.YEAR, year);// 年
        cal.set(Calendar.MONTH, month - 1);// 月，因为Calendar里的月是从0开始，所以要减1
        cal.set(Calendar.DATE, 1);// 日，设为一号
        cal.add(Calendar.DATE, -1);// 下一个月减一为本月最后一天
        return cal.getTime();// 获得月末是几号
    }

    /**
     * 当前时间加上years年
     */
    public static Date addYears(Date date, int years) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        cal.add(Calendar.YEAR, years);
        return cal.getTime();
    }

    /**
     * 获得指定格式的日期时间字符串
     *
     * @param format
     * @return
     */
    public static String datetime(String format) {
        SimpleDateFormat formatter = new SimpleDateFormat(format);
        return formatter.format(new Date());
    }

    /**
     * @return
     * @Description: 获取当天时间最后一秒(毫秒)
     */
    public static Date getEndTime() {
        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String date = getCurrentDate() + " 23:59:59";
        Date time = null;
        try {
            time = formatter.parse(date);
        } catch (ParseException e) {
            logger.error("获取当天时间的结束时间: ", e);
        }
        return time;
    }

    /**
     * 获得指定格式的日期时间字符串
     *
     * @param date
     * @param format
     * @return
     */
    public static String datetime(Date date, String format) {
        SimpleDateFormat formatter = new SimpleDateFormat(format);
        return formatter.format(date);
    }

    /**
     * 获得指定格式的日期时间字符串
     *
     * @param date   日期字符串
     * @param format
     * @return
     */
    public static String datetime(String date, String format) {
        SimpleDateFormat formatter = new SimpleDateFormat(format);
        return formatter.format(date);
    }

    /**
     * 获得指定格式的当前日期字符串
     *
     * @param date
     * @param format
     * @return
     */
    public static String date(Date date, String format) {
        if (date == null) {
            return "";
        }

        return (new SimpleDateFormat(format)).format(date);
    }

    /**
     * 获得指定格式的当前日期字符串
     *
     * @param dateStr
     * @param format
     * @return
     */
    public static String date(String dateStr, String format) {
        SimpleDateFormat formatter = new SimpleDateFormat(format);
        return formatter.format(dateStr);
    }

    /**
     * 获得"yyyy-MM-dd"格式的当前日期字符串
     *
     * @return
     */
    public static String getNowDateStr() {
        return getNowDatetimeStr(DEFAULT_DATE_FORMAT);
    }

    /**
     * 获得"yyyy-MM-dd HH:mm:ss"格式的当前日期时间字符串
     *
     * @return
     */
    public static String getNowDatetimeStr() {
        return getNowDatetimeStr(DEFAULT_DATETIME_FORMAT);
    }

    /**
     * 获得"yyyyMMddHHmmss"格式的当前日期时间字符串
     *
     * @return
     */
    public static String getNowDateminStr() {
        return getNowDatetimeStr(DEFAULT_DATEFULLTIME_FORMAT);
    }

    /**
     * 将当前时间转成毫秒
     *
     * @return String
     */
    public static String getMillSecondStr() {
        Calendar cal = Calendar.getInstance();
        return datetime(cal.getTime(), MILLISECOND_FORMAT);
    }

    /**
     * 获得当前日期时间字符串
     *
     * @param format 日期格式
     * @return 日期时间字符串
     */
    public static String getNowDatetimeStr(String format) {
        Calendar cal = Calendar.getInstance();
        return datetime(cal.getTime(), format);
    }

    /**
     * 只取当前时间的日期部分，小时、分、秒等字段归零
     */
    public static Date dateOnly(Date date) {
        return new Date(date.getTime() / MILLISECONDS_A_DAY);
    }

    /**
     * 获取某个日期最大时间，yyyy-MM-dd 23:59:59
     * @param date
     * @return
     */
    public static Date dateMaxTime(Date date) {
        Date date1 = dateOnlyExt(date);
        Calendar c = Calendar.getInstance();
        c.setTime(date1);
        c.add(Calendar.DATE, 1);
        c.add(Calendar.SECOND, -1);
        date = c.getTime();
        return date;
    }

    /**
     * 只取当前时间的日期部分，小时、分、秒等字段归零
     */
    public static Date dateOnlyExt(Date date) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        cal.set(Calendar.HOUR_OF_DAY, 0);
        cal.set(Calendar.MINUTE, 0);
        cal.set(Calendar.SECOND, 0);
        cal.set(Calendar.MILLISECOND, 0);
        return cal.getTime();
    }

    /**
     * 只取当前时间的日期部分，小时、分、秒等字段归零
     */
    public static Date dateMinTime(Date date) {
        return dateOnlyExt(date);
    }

    /**
     * 把类似2007-2-2 7:1:8的时间串变为标准的2007-02-02 07:01:08
     *
     * @param dateTimeStr 未校正日期值
     * @return 日期对象
     */
    public static String getStandDateTimeStr(String dateTimeStr) {
        if (dateTimeStr == null || "".equals(dateTimeStr)) {
            return "";
        }

        dateTimeStr = dateTimeStr.replaceAll("\\s+", "|");
        String[] a = dateTimeStr.split("\\|");
        List list = Arrays.asList(a);
        String datetime = "";
        int count = 1;
        for (int i = 0; i < list.size(); i++) {
            String temp = (String) list.get(i);
            StringTokenizer st;
            if (i == 0)
                st = new StringTokenizer(temp, "-");
            else
                st = new StringTokenizer(temp, ":");
            int k = st.countTokens();
            for (int j = 0; j < k; j++) {
                String sttemp = (String) st.nextElement();
                if (count == 1) {
                    datetime = sttemp;
                } else {
                    if ((sttemp.equals("0")) || (sttemp.equals("00")))
                        sttemp = "0";
                    else if ((Integer.valueOf(sttemp).intValue()) < 10)
                        sttemp = sttemp.replaceAll("0", "");
                    if (count < 4) {
                        if ((Integer.valueOf(sttemp).intValue()) < 10)
                            datetime = datetime + "-0" + sttemp;
                        else
                            datetime = datetime + "-" + sttemp;
                    }
                    if (count == 4) {
                        if ((Integer.valueOf(sttemp).intValue()) < 10)
                            datetime = datetime + " 0" + sttemp;
                        else
                            datetime = datetime + " " + sttemp;
                    }
                    if (count > 4) {
                        if ((Integer.valueOf(sttemp).intValue()) < 10)
                            datetime = datetime + ":0" + sttemp;
                        else
                            datetime = datetime + ":" + sttemp;
                    }
                }
                count++;
            }
        }

        try {
            @SuppressWarnings("unused")
            Date test = getDateFromStr(datetime); // 测试能否格式化成时间
            return datetime;
        } catch (Exception e) {
            return "";
        }
    }

    /**
     * 把标准的2007-02-02 07:01:08格式转换成日期对象
     *
     * @param datetime 日期,标准的2007-02-02 07:01:08格式
     * @return 日期对象
     */
    @SuppressWarnings("deprecation")
    public static Date getDateFromStr(String datetime) {
        if (datetime == null || "".equals(datetime)) {
            return new Date();
        }

        String nyr = datetime.trim();

        if (nyr.indexOf(" ") > 0) {
            nyr = nyr.substring(0, nyr.indexOf(" "));
        } else {
            nyr = nyr.substring(0, nyr.length());
        }

        StringTokenizer st = new StringTokenizer(nyr, "-");
        Date date = new Date();
        String temp = "";
        int count = st.countTokens();
        for (int i = 0; i < count; i++) {
            temp = (String) st.nextElement();
            // if(!(temp.equals("0")))
            // temp.replaceAll("0", "");
            if (i == 0)
                date.setYear(Integer.parseInt(temp) - 1900);
            if (i == 1)
                date.setMonth(Integer.parseInt(temp) - 1);
            if (i == 2)
                date.setDate(Integer.parseInt(temp));
        }

        if (datetime.length() > 10) {
            String sfm = datetime.substring(11, 19);
            StringTokenizer st2 = new StringTokenizer(sfm, ":");
            count = st2.countTokens();
            for (int i = 0; i < count; i++) {
                temp = (String) st2.nextElement();
                // if(!(temp.equals("0")))
                // temp.replaceAll("0", "");
                if (i == 0)
                    date.setHours(Integer.parseInt(temp));
                if (i == 1)
                    date.setMinutes(Integer.parseInt(temp));
                if (i == 2)
                    date.setSeconds(Integer.parseInt(temp));
            }
        }
        return date;
    }

    /**
     * 返回两个日期相差天数
     *
     * @param startDate 起始日期对象
     * @param endDate   截止日期对象
     * @return
     */
    public static int getQuot(Date startDate, Date endDate) {
        long quot = (endDate.getTime() - startDate.getTime()) / MILLISECONDS_A_DAY ;
        Long abs = Math.abs(quot);
        return abs.intValue();
    }

    /**
     * 返回两个日期相差天数
     *
     * @param startDateStr 起始日期字符串
     * @param endDateStr   截止期字符串
     * @param format       时间格式
     * @return
     */
    public static int getQuot(String startDateStr, String endDateStr,
                              String format) {
        long quot = 0;
        format = (format != null && format.length() > 0) ? format
                : DEFAULT_DATE_FORMAT;
        SimpleDateFormat ft = new SimpleDateFormat(format);
        try {
            Date date1 = ft.parse(endDateStr);
            Date date2 = ft.parse(startDateStr);
            quot = date1.getTime() - date2.getTime();
            quot = quot / MILLISECONDS_A_DAY;
        } catch (ParseException e) {
            logger.error("获取两个日期相差天数异常: ", e);
        }
        return (int) quot;
    }

    /**
     * 返回日期字符串："yyyy-MM-dd HH:mm" 格式。
     *
     * @param date
     * @return
     */
    public static final String getDateTime(Date date) {
        if (date == null)
            return "";
        DateFormat ymdhmsFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm");
        return ymdhmsFormat.format(date);
    }

    /**
     * 按给定格式返回时间的字符串
     *
     * @param date
     * @param pattern
     * @return
     */
    public static final String getDateTime(Date date, String pattern) {
        if (date == null)
            return "";
        DateFormat ymdhmsFormat = new SimpleDateFormat(pattern);
        return ymdhmsFormat.format(date);
    }

    /**
     * 返回两个日期相差的小时
     *
     * @param startDate
     * @param endDate
     * @return
     */
    public static int getQuotHours(Date startDate, Date endDate) {
        long quot = 0;
        quot = endDate.getTime() - startDate.getTime();
        quot = quot / MILLISECONDS_A_HOUR;
        return (int) quot;
    }

    /**
     * 返回两个日期相差的秒数
     *
     * @param startDate
     * @param endDate
     * @return
     */
    public static int getQuotSeconds(Date startDate, Date endDate) {
        long quot = 0;
        quot = endDate.getTime() - startDate.getTime();
        quot = quot / MILLISECONDS_A_second;
        return (int) quot;
    }

    /**
     * 将字符串转换为日期型 格式为: yyyy-MM-dd
     *
     * @param dateTime
     * @return
     */
    public static Date getDateTime(String dateTime) {
        return getDateTime(dateTime, "yyyy-MM-dd");
    }

    /**
     * @param dateTime
     * @return
     * @Description: "yyyy-mm-dd hh24：mm:ss.fff";
     */
    public static Date getDate24Time(String dateTime) {
        return getDateTime(dateTime, DEFAULT_DATETIME24_FORMAT);
    }

    public static Date getDateTime(String dateTime, String formatPattern) {
        try {
            if (StringUtils.isNotBlank(dateTime)
                    && StringUtils.isNotBlank(formatPattern)) {
                SimpleDateFormat format = new SimpleDateFormat(formatPattern);
                return format.parse(dateTime);
            }
        } catch (ParseException e) {
            throw new BusinessException("解析日期失败！日期格式:" + formatPattern, e);
        }

        return null;
    }

    /**
     * 将字符串转换为日期型 格式为: yyyy-MM-dd HH:mm:ss
     *
     * @param dateTime
     * @return
     */
    public static Date getDateDetailTime(String dateTime) {
        try {
            if (StringUtils.isNotBlank(dateTime)) {
                SimpleDateFormat format = new SimpleDateFormat(
                        "yyyy-MM-dd HH:mm:ss");

                return format.parse(dateTime);
            }
        } catch (ParseException e) {
            logger.error("解析日期失败！", e);
        }

        return null;
    }

    /**
     * 取当前的时间戳，在页面上保证URL唯一，防止缓存
     *
     * @return
     */
    public static long getDtSeq() {
        return System.currentTimeMillis();
    }

    /**
     * 判断是否在参数日期的最大值和最小值之间
     *
     * @param min
     * @param compare
     * @return
     */
    public static boolean isBetween(Date min, Date compare) {
        Boolean ret = false;
        Date minDate = DateUtil.dateOnlyExt(min);
        Date maxDate = DateUtil.dateOnlyExt(DateUtil.addDays(min, 1));
        if (compare.after(minDate) && compare.before(maxDate)) {
            ret = true;
        }
        return ret;
    }

    /**
     * @param min
     * @param compare
     * @return
     * @Description: 比较2个时间的时间差
     */
    public static Long compare(Date min, Date compare) {
        return (compare.getTime() - min.getTime()) / 1000;
    }

    public static Date getDate(int year, int month, int day) {
        Calendar cal = Calendar.getInstance();
        cal.set(year, month - 1, day);
        return cal.getTime();
    }

    /**
     * 获取本月/上月/本季度的月初和月末.
     *
     * @param monthRange 取值范围{cm:本月，pm:上月，sm:本季度}
     * @return Map{firstDay:yyyy-MM-dd, lastDay:yyyy-MM-dd}
     */
    public static Map getFLDayMap(String monthRange) {
        return getFLDayMap(monthRange, DEFAULT_DATE_FORMAT);
    }

    /**
     * 获取本月/上月/本季度的月初和月末.
     * @param monthRange 取值范围{cm:本月，pm:上月，sm:本季度}
     * @param pattern
     * @return Map{firstDay:yyyy-MM-dd, lastDay:yyyy-MM-dd}
     */
    public static Map getFLDayMap(String monthRange,
                                                  String pattern) {
        Map rs = new LinkedHashMap();

        SimpleDateFormat df = new SimpleDateFormat(pattern);
        GregorianCalendar calendar = new GregorianCalendar();
        calendar.setTime(new Date());

        if (StringUtils.isBlank(monthRange)) {
            monthRange = "cm";
        }

        if (!"sm".equals(monthRange)) {
            if ("pm".equals(monthRange)) {
                calendar.add(Calendar.MONTH, -1);
            }

            calendar.set(Calendar.DAY_OF_MONTH, 1);
            rs.put("firstDay", df.format(calendar.getTime()));

            calendar.set(Calendar.DAY_OF_MONTH,
                    calendar.getActualMaximum(Calendar.DAY_OF_MONTH));
            rs.put("lastDay", df.format(calendar.getTime()));

            return rs;
        }

        /*
         * 本季度的月初和月末
         */
        int[][] seasons = {{2, 4}, // 春季
                {5, 7}, // 夏季
                {8, 10}, // 秋季
                {11, 1} // 冬季
        };
        int cm = calendar.get(Calendar.MONTH) + 1;

        for (int[] im : seasons) {
            if (cm >= im[0] && cm <= im[1]) {
                calendar.set(Calendar.MONTH, im[0] - 1);
                calendar.set(Calendar.DAY_OF_MONTH, 1);
                rs.put("firstDay", df.format(calendar.getTime()));

                calendar.set(Calendar.MONTH, im[1] - 1);
                calendar.set(Calendar.DAY_OF_MONTH,
                        calendar.getActualMaximum(Calendar.DAY_OF_MONTH));
                rs.put("lastDay", df.format(calendar.getTime()));

                break;
            }
        }

        return rs;
    }

    /**
     * 获取某日期的年份字符串
     * @param date
     * @return 字符串类型的年份
     */
    public static String getYearString(Date date) {
        return DateUtil.date(date, DEFAULT_YEAR_FORMAT);
    }

    /**
     * 获取某日期的年份数字
     * @param date
     * @return 数字类型的年份
     */
    public static int getYearInteger(Date date) {
        return Integer.parseInt(DateUtil.date(date, DEFAULT_YEAR_FORMAT));
    }

    /**
     * 获取某日期的月份字符串
     * @param date
     * @return
     */
    public static String getMonthString(Date date) {
        return DateUtil.date(date, DEFAULT_MONTH_FORMAT);
    }

    public static String getDayString(Date date) {
        return DateUtil.date(date, DEFAULT_Day_FORMAT);
    }


    /**
     * 获取某日期的月份数字
     * @param date
     * @return 数字类型的月份
     */
    public static int getMonthInteger(Date date) {
        return Integer.parseInt(DateUtil.date(date, DEFAULT_MONTH_FORMAT));
    }

    /**
     * 取得当前月的的最后一天
     * @param year
     * @param month
     * @return
     */
    public static Date getLastDayOfCurMonth(int year, int month) {
        Calendar cal = Calendar.getInstance();
        cal.set(Calendar.YEAR, year);// 年
        cal.set(Calendar.MONTH, month);// 月，因为Calendar里的月是从0开始，所以要减1
        cal.set(Calendar.DATE, 1);// 日，设为一号
        // cal.add(Calendar.MONTH, 1);// 月份加一，得到下个月的一号
        cal.add(Calendar.DATE, -1);// 下一个月减一为本月最后一天
        return cal.getTime();// 获得月末是几号
    }

    /**
     * 取得当前月的的第一天
     * @param year
     * @param month
     * @return
     */
    public static Date getFirstDayOfCurMonth(int year, int month) {
        Calendar cal = Calendar.getInstance();
        cal.set(Calendar.YEAR, year);// 年
        cal.set(Calendar.MONTH, month - 1);// 月，因为Calendar里的月是从0开始，所以要减1
        cal.set(Calendar.DATE, 1);// 日，设为一号
        // cal.add(Calendar.MONTH, 1);// 月份加一，得到下个月的一号
        cal.add(Calendar.DATE, 0);// 下一个月减一为本月最后一天
        return cal.getTime();// 获得月末是几号
    }

    /** */
    /**
     * 取得某天所在周的第一天
     * @param date
     * @return
     */
    public static Date getFirstDayOfWeek(Date date) {
        Calendar c = new GregorianCalendar();
        c.setFirstDayOfWeek(Calendar.MONDAY);
        c.setTime(date);
        c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek());
        return c.getTime();
    }

    /** */
    /**
     * 取得某天所在周的最后一天
     * @param date
     * @return
     */
    public static Date getLastDayOfWeek(Date date) {
        Calendar c = new GregorianCalendar();
        c.setFirstDayOfWeek(Calendar.MONDAY);
        c.setTime(date);
        c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek() + 6);
        return c.getTime();
    }

    /**
     * 验证日期是否有效，有效日期范围1900-1-1到2099-12-31.
     */
    public static boolean isValidDate(String ds) {
        if (StringUtils.isBlank(ds))
            return false;
        return pattern.matcher(ds).matches();
    }

    /**
     * 验证日期是否有效，有效日期范围1900-1-1到2099-12-31.
     */
    public static boolean isValidDate(Date d) {
        if (d == null)
            return false;
        return pattern.matcher(date(d, DEFAULT_DATE_FORMAT)).matches();
    }

    /**
     * 根据年月得到当月的天数
     *
     * @param date(格式：yyyy-MM)
     * @return
     */
    public static int getActualDays(String date) {
        Calendar rightNow = Calendar.getInstance();
        SimpleDateFormat simpleDate = new SimpleDateFormat(YEAR_MONTH_FORMAT); //如果写成年月日的形式的话，要写小d，如："yyyy/MM/dd"
        try {
            rightNow.setTime(simpleDate.parse(date)); //要计算你想要的月份，改变这里即可
        } catch (ParseException e) {
            logger.error("解析日期失败！", e);
        }
        int days = rightNow.getActualMaximum(Calendar.DAY_OF_MONTH);
        return days;
    }

    /**
     * 根据年月得到当月的天数组成的年月日格式yyyyMMdd
     *
     * @param date(格式：yyyy-MM)
     * @return
     */
    public static String getActualDate(String date) {
        StringBuffer sb = new StringBuffer(date);
        int days = getActualDays(date);

        return sb.append(days).toString().replaceAll("/", "");
    }

    /**
     * 根据年月得到日期为第一天的日期格式yyyyMM01
     *
     * @param date(格式：yyyy-MM)
     * @return
     */
    public static String getFirstDate(String date) {
        StringBuffer sb = new StringBuffer(date);
        int days = getActualDays(date);

        return sb.append(days).toString().replaceAll("/", "");
    }

    /**
     * 比较2个日期的前后
     *
     * @param date1
     * @param date2
     * @return -1代表第一个日期小，1代表第一个日期大，0代表两个日期相等
     * @Description: 比较2个时间的前后
     */
    public static int compareDate(Date date1, Date date2) {
        Date dt1 = dateOnlyExt(date1);
        Date dt2 = dateOnlyExt(date2);
        if (dt1.getTime() > dt2.getTime()) {
            return 1;
        } else if (dt1.getTime() < dt2.getTime()) {
            return -1;
        } else {
            return 0;
        }

//      Calendar c1=Calendar.getInstance();
//      Calendar c2=Calendar.getInstance();
//      c1.setTime(dt1);
//      c2.setTime(dt2);
//      int result=c1.compareTo(c2);
//      if(result==0) //c1等于c2
//          return 0;
//      else if(result<0)//c1小于c2
//          return -1;
//      else    //c1大于c2
//          return 1;
    }

    /**
     * @param pattern
     * @return
     * @Description: 获取当前日期
     */
    public static String getCurrentDate(String pattern) {
        return date(new Date(), pattern);
    }

    /**
     * @return
     * @Description: 获取当前日期
     */
    public static String getCurrentDate() {
        return getCurrentDate(DEFAULT_DATE_FORMAT);
    }

    /**
     * @return
     * @Description: 获取当前时间
     */
    public static String getCurrentDateTime() {
        return getCurrentDate(DEFAULT_DATETIME_FORMAT);
    }


    /**
     * @param dateTime 格式为"yyyyMM"的字符串
     * @return foreYearMonth 返回前一个月的日期(格式"yyyyMM")
     * @Description: 获取某一日期的前一个月的日期(只取年月"yyyyMM")
     */
    public static String getForeYearMonth(String dateTime) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMM");
        String foreYearMonth = "";
        try {
            Date rtime = sdf.parse(dateTime);
            Calendar cal = Calendar.getInstance();
            cal.setTime(rtime);
            cal.add(Calendar.MONTH, -1);
            foreYearMonth = sdf.format(cal.getTime());
            ;
        } catch (ParseException e) {
            logger.error("日期计算异常！", e);
        }
        return foreYearMonth;
    }

    /**
     * @param year 某一年 ("yyyy")
     * @return foreYear 其前一年
     * @Description: 获取某一年的前一年("yyyy")
     * @date 2017年5月6日 下午5:07:18
     */
    public static String getForeYear(String year) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy");
        String foreYear = "";
        try {
            Date rtime = sdf.parse(year);
            Calendar cal = Calendar.getInstance();
            cal.setTime(rtime);
            cal.add(Calendar.YEAR, -1);
            foreYear = sdf.format(cal.getTime());
        } catch (ParseException e) {
            logger.error("年份计算异常！", e);
        }
        return foreYear;
    }

    /**
     * @param dateTime 格式("yyyyMMdd")
     * @return
     * @Description: 判断某个日期是否是这个月的最后一天
     */
    public static boolean getIsTheMonthEnd(String dateTime) {

        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
        Date rtime = new Date();
        try {
            rtime = sdf.parse(dateTime);
        } catch (ParseException e) {
            logger.error("日期判断异常！", e);
        }

        Calendar cal = Calendar.getInstance();
        cal.setTime(rtime);
        int monthLastDay = cal.getActualMaximum(Calendar.DAY_OF_MONTH);//获取当前月最后一天的数字,如20
        int dateInMonth = cal.get(Calendar.DAY_OF_MONTH);//获取指定日期的当前月数字,如20
        if (monthLastDay == dateInMonth) {
            return true;
        } else {
            return false;
        }

    }

    /**
     * @param date 年月  如:201704
     * @return 返回某月的最后一天的日期值 如:20
     * @Description: 获取某月的最后一天的日期值 如:20
     */
    public static int getTheMonthEndDay(String date) {

        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMM");
        Date rtime = new Date();
        try {
            rtime = sdf.parse(date);
        } catch (ParseException e) {
            logger.error("日期格式化异常！", e);
        }

        Calendar cal = Calendar.getInstance();
        cal.setTime(rtime);
        int monthLastDay = cal.getActualMaximum(Calendar.DAY_OF_MONTH);//获取当前月最后一天的数字,如20

        return monthLastDay;
    }

    /**
     * @param date 年月 如:201704
     * @param pre  前缀 如:2017
     * @param back 后缀 如:日
     * @return 返回该月自定义数组
     * @Description: 根据年月生成该月的自定义数组
     */
    public static List getTheMonthDayList(String date, String pre, String back) {

        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMM");
        Date rtime = new Date();
        try {
            rtime = sdf.parse(date);
        } catch (ParseException e) {
            logger.error("日期格式化异常！", e);
        }

        Calendar cal = Calendar.getInstance();
        cal.setTime(rtime);
        int monthLastDay = cal.getActualMaximum(Calendar.DAY_OF_MONTH);//获取当前月最后一天的数字,如20
        List dateList = new ArrayList();
        for (int i = 1; i <= monthLastDay; i++) {
            String j = "";
            if (i < 10) {
                j = "0" + i;
            } else {
                j = "" + i;
            }
            dateList.add(pre + j + back);
        }
        return dateList;
    }


    /**
     * @param bit  集合大小
     * @param pre  数据前缀
     * @param back 数据后缀
     * @return
     * @Description: 获取自定义大小和样式的数据集合
     */
    public static List getTheAutoList(int bit, String pre, String back) {

        List dateList = new ArrayList();
        for (int i = 1; i <= bit; i++) {
            String j = "";
            if (i < 10) {
                j = "0" + i;
            } else {
                j = "" + i;
            }
            dateList.add(pre + j + back);
        }
        return dateList;
    }

    /**
     * @param year
     * @return 返回日期数组 格式为:yyyyMMdd
     * @Description: 获取当年的日期数组(格式yyyy)
     */
    public static List getTheYearDaysList(int year) {

        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
        Calendar calBegin = Calendar.getInstance();

        Date dBegin = getYearFirstDay(year);// 获取指定年份的第一天
        calBegin.setTime(dBegin);// 使用给定的 Date 设置此 Calendar 的时间

        Date dEnd = getYearLastDay(year);//获取指定年份的最后一天

        List dateList = new ArrayList();
        dateList.add(sdf.format(dBegin));
        // 测试此日期是否在指定日期之后
        while (dEnd.after(calBegin.getTime())) {
            calBegin.add(Calendar.DAY_OF_MONTH, 1);
            dateList.add(sdf.format(calBegin.getTime()));
        }

        return dateList;

    }

    /**
     * @param year
     * @return
     * @Description: 获取某年第一天日期
     */
    public static Date getYearFirstDay(int year) {
        Calendar calendar = Calendar.getInstance();
        calendar.clear();
        calendar.set(Calendar.YEAR, year);
        Date currYearFirst = calendar.getTime();
        return currYearFirst;
    }

    /**
     * @param year
     * @return
     * @Description: 获取某年最后一天日期
     */
    public static Date getYearLastDay(int year) {
        Calendar calendar = Calendar.getInstance();
        calendar.clear();
        calendar.set(Calendar.YEAR, year);
        calendar.roll(Calendar.DAY_OF_YEAR, -1);
        Date currYearLast = calendar.getTime();

        return currYearLast;
    }

    /**
     * @Description: 获取Timestamp 时间对应格式化的时间字符串
     * @param  s s
     * @return
     * @throws ParseException
     */
    public static String getTimestampStr(Timestamp s) throws ParseException {
        SimpleDateFormat format = new SimpleDateFormat(DEFAULT_DATETIME_FORMAT);
        String dateStr="";

        try {
             dateStr=format.format(s);
        } catch (Exception e) {
            logger.error("Timestamp日期格式化错误",e);
        }
        return dateStr;
    }


    /**
     * @Description: 根据Timestamp时间获取对应格式的时间字符串 
     * @param s
     * @param sf 格式 如:M月d日 HH:mm 或 yyyy年M月
     * @return
     */
    public static String getFormatMonthDateTimeStr(Timestamp s, String sf) {
        SimpleDateFormat sdf = new SimpleDateFormat(DEFAULT_DATETIME_FORMAT);
        SimpleDateFormat sdfmdt = new SimpleDateFormat(sf);
        String returnString = null;
        try {
            String tsStr=getTimestampStr(s);
            Date datetime=sdf.parse(tsStr);
            //组装格式为:8月8日 08：20 或 2017年8月
            returnString=sdfmdt.format(datetime);
        } catch (Exception e) {
            logger.error("getFormatMonthDateTimeStr:日期格式化错误",e);
        }
        return returnString;
    }

    /**
     * 
     * @Description: 将时间字符串转为特定的格式
     * @param dateTime
     * @param formatPattern
     * @return
     */
    public static Date formatDateTime(String dateTime, String formatPattern) {
        try {
            if (StringUtils.isNotBlank(dateTime)
                    && StringUtils.isNotBlank(formatPattern)) {
                SimpleDateFormat format = new SimpleDateFormat(formatPattern);
                return format.parse(dateTime);
            }
        } catch (ParseException e) {
            logger.error("DateUtil::formatDateTime::字符串转日期对象异常", e);
        }

        return null;
    }

    /**
     * 获取格林尼日时间
     * @return
     */
    public static Date getDate1970(){
        Calendar c = Calendar.getInstance();
        c.setTimeInMillis(0);
        return c.getTime();
    }

}
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(java基础知识)

        

            

                
    
                    
  • JAVA相关知识
                        M_灵均
javajvm开发语言
                        
    JAVA基础知识说一下对象创建的过程？类加载检查：当Java虚拟机（JVM）遇到一个类的new指令时，它首先检查这个类是否已经被加载、链接和初始化。如果没有，JVM会通过类加载器（ClassLoader）加载这个类。分配内存：JVM为新对象分配内存。这个内存分配是在堆（Heap）上进行的，堆是JVM用来存储对象实例的地方。分配内存的大小在类加载时就已经确定，因为类的结构（包括字段和方法）已经确定。
    
                    
    • 
                    
  • Java学习路线：从零基础到高级开发者的完整指南
                        何遇mirror
java
                        
    初学者入门指南1.环境搭建安装JDK:下载并安装最新版本的JDK（JavaDevelopmentKit）。配置环境:设置JAVA_HOME环境变量，并将bin目录添加到PATH中。选择IDE:使用Eclipse、IntelliJIDEA或其他任何你喜欢的Java集成开发环境。2.Java基础知识HelloWorld:编写你的第一个Java程序。基本语法:学习变量、数据类型（原始类型、包装类型）、运
    
                    
    • 
                    
  • java基础知识
                        阿拉伯的劳伦斯292
java开发语言
                        
    1.java简介跨平台性：Java语言的“一次编写，到处运行”特性是这一语言的重要优势,java程序编译成字节码，可以在安装了Java虚拟机（JVM，javavirtualmachine）的不同操作系统上运行面向对象：java是一门完全的面向对象编程语言，支持继承，抽象，封装和多态的特性内存管理：java通过垃圾回收器（GarbageCollector）自动管理内存，这就不用开发者手动释放内存了，
    
                    
    • 
                    
  • 给Java新手的一些建议——Java知识点归纳(Java基础部分)
                        灬佐手边

                        
    写这篇文章的目的是想总结一下自己这么多年来使用java的一些心得体会，主要是和一些java基础知识点相关的，所以也希望能分享给刚刚入门的Java程序员和打算入Java开发这个行当的准新手们，希望可以给大家一些经验，能让大家更好学习和使用Java。image.png主要内容为J2SE相关的部分，经过这么多年的Java开发，以及结合平时面试Java开发者的一些经验，我觉得对于J2SE方面主要就是要掌握
    
                    
    • 
                    
  • 《Java基础知识》Java Lambda表达式
                        Limingmingaa
javajava开发语言蓝桥杯
                        
    接触Lambda表达式的时候，第一感觉就是，这个是啥？我居然看不懂，于是开始寻找资料，必须弄懂它。先来看一个案例：​@FunctionalInterfacepublicinterfaceMyLamda{voidtest1(Stringy);}​​importdemo.knowledgepoints.Lambda.inf.MyLamda;publicclassLambdaTest{publicsta
    
                    
    • 
                    
  • Java基础知识——数组
                        _M00n

                        
    数组数组:一组数据的集合官方定义:在内存中通过连续的存储单元存储相同数据类型的有序集合代码表现:[]出现了那么数组出现了数据类型[]变量名初始化数组：变量名=new数据类型[数组的长度];arrs=newint[10];获取数组中的元素：数组变量[索引]索引从0开始到长度-1结束假设长度为10,啊那么根据索引获取元素比如a[10]就是a[0]-a[9]数组的长度：数组变量.lengthpublic
    
                    
    • 
                    
  • Java学习｜Java基础知识
                        进击的小白菜
javajava学习开发语言
                        
    目录类与对象继承封装多态高级话题实践项目类与对象定义与创建类:定义一组具有相同属性和行为的对象的模板。对象:根据类模板创建的实体。示例代码publicclassPerson{Stringname;intage;publicPerson(Stringname,intage){this.name=name;this.age=age;}publicvoidsayHello(){System.out.pr
    
                    
    • 
                    
  • Java基础知识（部分、随手记）
                        木木ᶻ
java
                        
    目录基础知识：基本框架：注释：关键字：字面量：（数据类型）变量：注意事项：计算机的存储规则：基础语法：标识符：键盘录入：IDEA项目结构的介绍算数运算符：判断和循环顺序结构分支结构if语句switch语句格式while循环循环结构数组数组的静态初始化数组的地址值和元素访问数组元素访问数组的动态初始化二维数组二维数组的动态初始化Arrays类方法方法的定义带返回值方法的调用注意事项：方法的重载：面向
    
                    
    • 
                    
  • JAVA基础知识点整理合集（附带思维导图超详细~~~）
                        Dd12.3
JavaSEjava后端
                        
    今天给大家分享一下我学习完JavaSE的思维导图，可以有助于朋友们对于Java基础语法的掌握，和记忆。详情请下载思维导图（全是干货呦~~~）打开思维导图的软件，各大应用商店皆可下载。
    
                    
    • 
                    
  • Java基础知识总结2
                        Pikl

                        
    PATH环境变量PATH环境变量。作用是指定命令搜索路径，在命令行下面执行命令如javac编译java程序时，它会到PATH变量所指定的路径中查找看是否能找到相应的命令程序。我们需要把jdk安装目录下的bin目录增加到现有的PATH变量中，bin目录中包含经常要用到的可执行文件如javac/java/javadoc等待，设置好PATH变量后，就可以在任何目录下执行javac/java等工具了。4，
    
                    
    • 
                    
  • [java][基础]Java基础知识
                        awonw
java
                        
    Java标识符java语言中，对于变量，常量，函数，语句块也有名字，我们统统称之为Java标识符命名约定1.类和接口名。每个字的首字母大写，含有大小写。例如，MyClass，HelloWorld，Time等。2.方法名。首字符小写，其余的首字母大写，含大小写。尽量少用下划线。例如，myName，setTime等。这种命名方法叫做驼峰式命名。3.常量名。基本数据类型的常量名使用全部大写字母，字与字之
    
                    
    • 
                    
  • java基础知识笔记
                        海带土豆
java笔记python
                        
    第一章：Java基础：1️⃣初识Java:1、常识知识：语言：人与人交流沟通的表达方式计算机语言：人与计算机之间进行信息交流沟通的一种特殊语言编程语言分类：编译型优点：执行效率高缺点：平台依赖重，跨平台不方便解释型优点：易于跨平台缺点：源代码在一般情况下不便于加密,执行效率相对没有那么高混合型：可编译可解释计算机语⾔发展历史第⼀代计算机语⾔：01010100010111000第⼆代汇编语⾔0000
    
                    
    • 
                    
  • Java基础知识——流
                        NHuan^_^
java开发语言
                        
    文章目录一、流的概念定义特性惰性执行不存储数据二、流的创建从集合创建从数组创建使用`Stream.of()`方法三、流的操作中间操作示例代码终端操作示例代码四、流的并行处理五、总结一、流的概念定义流是用于操作数据源（如集合、数组等）生成的元素序列的抽象数据结构。流就像花洒一样，通过不同的过滤器和形状来改变数据流的形式和处理方式。特性惰性执行流的中间操作（如filter,map等）不会立即执行，而是
    
                    
    • 
                    
  • Java基础知识总结（下）
                        Yonagi833
Java面经and八股java开发语言职场和发展程序人生spring
                        
    本文部分内容节选自JavaGuide,地址:https://javaguide.cn/java/basis/java-basic-questions-03.html基础（上）→基础（中）→基础（下）异常Java异常类层次图概览Exception和Error有什么区别？在Java中，所有的异常都有一个共同的祖先java.lang包中的Throwable类.Throwable类有两个重要的子类:Exc
    
                    
    • 
                    
  • JAVA基础知识-day08 String类&static关键字&Arrays类
                        小陈工

                        
    一、String类1.1概述：java.lang.String类代表字符串。Java程序中所有的字符串文字（例如"abc"）都可以被看作是字符串类的实例。类String包括用于检查各个字符串的方法，比如用于比较字符串，搜索字符串，提取子字符串等方法。1.2特点：1.2.1.字符串不变：字符串的值在创建后不能被更改。1.2.2.因为String对象是不可变的，所以它们可以被共享。1.3创建方法：1.
    
                    
    • 
                    
  • Java基础知识学习：深入理解Java中的类与对象，Java重要知识点概念性解释，结合实例讲解请看下一篇博文
                        码农超哥同学
Java编程java学习开发语言
                        
    引言：在Java编程语言中，类（Class）与对象（Object）是面向对象编程（OOP）的核心概念。类可以看作是创建对象的蓝图，而对象则是类的实例。本文将深入解释Java知识体系中的类与对象，帮助读者更好地理解这一基础但至关重要的概念。类的定义与组成类是具有相同属性和行为的一组对象的抽象描述。在Java中，类是通过关键字class来定义的。一个类通常包含以下几部分：属性（成员变量）：类的属性定义
    
                    
    • 
                    
  • Java基础知识
                        林坰
java基础知识面试初学者
                        
    一、标识符规范标识符必须以字母(汉字)、下划线、美元符号开头，其他部分可以是字母、下划线、美元符号，数字的任意组合。谨记不能以数字开头。java使用unicode字符集，汉字也可以用该字符集表示。因此汉字也可以用作变量名。关键字不能用作标识符。类名首字母需大写(Welcome)、方法和变量名遵循驼峰原则snRsfService()二、数据类型java的数据类型由8种基本数据类型和多种引用数据类型构
    
                    
    • 
                    
  • 【Java基础知识（1）】对象在内存中的存储
                        不是AI
Javajava开发语言
                        
    Java对象是如何在内存中存储的？在Java中，所有的对象被动态地分配在堆中。这和C++不同，C++允许对象被存储在堆或者栈中。参考Oracle官方文档：官方文档说明在Java中创建字符串对象的2种方法：1、使用String关键字；2、使用new关键字。（1）使用String关键字：使用双引号代表字符串。举例：Stringstr1="GFG";Stringstr2="GFG";该操作在内存中的表示
    
                    
    • 
                    
  • Java基础知识总结（第六篇）：枚举、注解和异常
                        随遇而安622&508
java基础知识java开发语言
                        
    声明:1.本文根据韩顺平老师教学视频自行整理，以便记忆2.若有错误不当之处,请指出系列文章目录Java基础知识总结（第一篇）：基础语法Java基础知识总结（第二篇）：流程控制语句(分支控制和循环控制)Java基础知识总结（第三篇）：数组、排序和查找Java基础知识总结（第四篇）：面向对象编程基础(类、对象、方法、包以及封装继承多态)Java基础知识总结（第五篇）：面向对象编程进阶(代码块，抽象类、
    
                    
    • 
                    
  • 使用Scanner关键字接受键盘录入的数据Java基础知识
                        Debug_EDM

                        
    Java中使用Scanner关键字来录入数据步骤1.导包由于scanner类不在lang包下，需要将其所在的包导入进来importjava.util.Scanner由于我们使用的集成开发工具，此步可以省略快捷键:导包ctrl+shift+o步骤2.直接创建扫描器对象Scannerscanner=newScanner(System.in);步骤3.使用创建好的扫描器录入数据录入的数据也分很多类型，比
    
                    
    • 
                    
  • Java基础知识点总结
                        小白不想上班

                        
    前言本文主要是我之前复习Java基础原理过程中写的Java基础知识点总结。Java的知识点其实非常多，并且有些知识点比较难以理解，有时候我们自以为理解了某些内容，其实可能只是停留在表面上，没有理解其底层实现原理。纸上得来终觉浅，绝知此事要躬行。笔者之前对每部分的内容对做了比较深入的学习以及代码实现，基本上比较全面地讲述了每一个Java基础知识点，当然可能有些遗漏和错误，欢迎读者指正。Java基础知
    
                    
    • 
                    
  • java基础知识
                        shixiaowei00
javapython开发语言
                        
    java基础知识注释注释的概念：注释的内容代码是不会执行的，可以帮助自己和别人看自己写的代码。Java的注释有三种：单行注释://+内容注释一行内容将上面那条代码注释掉后，程序就不会执行那行代码多行注释文档注释（不常用）标识符和关键字关键字关键字是系统本省就起好的名字，往后起名字都不能起关键字。比如给类名起名字就不能取关键字如上：if是一个关键字，但是当它成为类名时系统报错。标识符java所有的组
    
                    
    • 
                    
  • 学生管理系统（SSM简易版）总结
                        沈荣荣
SSM
                        
    技术准备为了完成这个项目，需要掌握如下技术：Java基础知识前端：HTML,CSS,JAVASCRIPT,JQUERYJ2EE：Tomcat,Servlet,JSP,Filter框架：Spring,SpringMVC,MyBatis,Spring与MyBatis整合,SSM整合数据库：MySQL开发工具：IDEA,Maven开发流程之前虽然已经使用Servlet+JSP完成了简单的开发，这次使用S
    
                    
    • 
                    
  • JAVA基础知识点02-数据类型转换、运算符
                        欧阳先生525

                        
    1.数据类型转换:1.boolean类型不参与类型转换2.自动类型提升大范围类型的变量变量名=小范围类型的数据;注意:参数计算的数据的数据类型存在多种,结果的数据类型会提升成为参与运算中的最大的数据类型如果参与运算的数据类型为short,byte,char,最终的结果提升成为int类型如果为byte,short,char类型赋值的时候,如果数据在其范围内常量就能够成功赋值强制类型转换小范围类型变量
    
                    
    • 
                    
  • Java基础知识总结（持续更新中）
                        Keven__Java
算法题Javajava开发语言算法eclipseidea
                        
    Java基础知识（持续更新）类型转化：数字、字符串、字符之间相互转化数字字符串//数字转字符串//method1intnumber=5;Stringstr=String.valueOf(number);//method2intnumber=5;Integeritr=number;//int装箱为对象，再调用对象的toString方法Stringstr=itr.toString();//或者直接St
    
                    
    • 
                    
  • Android java基础知识
                        嵌入式_笔记
Androidandroidjava开发语言
                        
    一.Androidjava基础知识第一个java程序HelloWorid：publicclassHello{publicstaticvoidmain(Stringargs[]){System.out.println("Hello,world!");}}运行结果：root@ubuntu:/home/topeet/guyilian#javacHello.javaroot@ubuntu:/home/to
    
                    
    • 
                    
  • JAVA基础知识
                        波波大人2018

                        
    1，JDK：JavaDevelopmentKit，java的开发和运行环境，java的开发工具和jre。2，JRE：JavaRuntimeEnvironment，java程序的运行环境，java运行的所需的类库+JVM(java虚拟机)。3，配置环境变量：让javajdk\bin目录下的工具，可以在任意目录下运行，原因是，将该工具所在目录告诉了系统，当使用该工具时，由系统帮我们去找指定的目录。环境
    
                    
    • 
                    
  • 黑马程序员——java基础知识之泛型、集合（Map、工具类等）
                        段黄军
黑马程序员技术博客工具程序员集合格式map
                        
    ——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！——-（一）、泛型1、泛型：JDK1.5版本以后出现新特性。用于解决安全问题，是一个类型安全机制。2、泛型有什么好处？①将运行时期出现问题ClassCastException，转移到了编译时期。，方便于程序员解决问题。让运行时问题减少，安全。，②避免了强制转换麻烦。3、泛型的格式泛型格式：通过就要定义泛型。其实中即可。例
    
                    
    • 
                    
  • 黑猴子的家：Java 8 -> Java 8 简述
                        黑猴子的家

                        
    code->Java8-project->githubhttps://github.com/liufengji/Java8-project.git1、本单元目标（1）JAVA8的引入（2）Lambda表达式的特点和使用★（3）函数式接口★（4）方法引用（5）构造器引用和数组引用（6）StreamAPI★（7）Optional类的使用2、Java基础知识图解3、JAVA8的引入2004年9月30日，
    
                    
    • 
                    
  • 【Mybatis】接口式编程连接mysql数据库
                        不会敲代码的谌
数据库mybatismysql
                        
    本文已参与「新人创作礼」活动，一起开启掘金创作之路。前言博主有一定的java基础知识，原本是由于最近的项目开发，需要使用安卓开发连接mysql数据库，于是被迫需要跳着学此框架主要写了博主遇到的一些问题和解决方法，前人踩坑，后人乘凉唉。若写的不好请勿吐槽。。安装mysql数据库用mysql数据库，肯定要先安装mysql数据库安装完成后，使用管理员权限打开cmd打开以后输入netstartmysql回
    
                    
    • 
                                
  • jquery实现的jsonp掉java后台
                                    知了ing
javajsonpjquery
                                    
     什么是JSONP？ 
 
先说说JSONP是怎么产生的： 
 
其实网上关于JSONP的讲解有很多，但却千篇一律，而且云里雾里，对于很多刚接触的人来讲理解起来有些困难，小可不才，试着用自己的方式来阐释一下这个问题，看看是否有帮助。 
 
1、一个众所周知的问题，Ajax直接请求普通文件存在跨域无权限访问的问题，甭管你是静态页面、动态网页、web服务、WCF，只要是跨域请求，一律不准； 
 
2、
    
                                
    • 
                                
  • Struts2学习笔记
                                    caoyong
struts2
                                    
    SSH : Spring + Struts2 + Hibernate 
三层架构(表示层,业务逻辑层,数据访问层) MVC模式 (Model View Controller) 
分层原则:单向依赖，接口耦合 
 
1、Struts2  =  Struts  + Webwork 
2、搭建struts2开发环境 
   a>、到www.apac
    
                                
    • 
                                
  • SpringMVC学习之后台往前台传值方法
                                    满城风雨近重阳
springMVC
                                    
    springMVC控制器往前台传值的方法有以下几种： 
1.ModelAndView 
   通过往ModelAndView中存放viewName：目标地址和attribute参数来实现传参： 
    
 ModelAndView mv=new ModelAndView(); 
 mv.setViewName="success
    
                                
    • 
                                
  • WebService存在的必要性？
                                    一炮送你回车库
webservice
                                    
    做Java的经常在选择Webservice框架上徘徊很久，Axis  Xfire Axis2 CXF ，他们只有一个功能，发布HTTP服务然后用XML做数据传输。 
是的，他们就做了两个功能，发布一个http服务让客户端或者浏览器连接，接收xml参数并发送xml结果。 
当在不同的平台间传输数据时，就需要一个都能解析的数据格式。 
但是为什么要使用xml呢？不能使json或者其他通用数据
    
                                
    • 
                                
  • js年份下拉框
                                    3213213333332132
java web ee
                                    
    
  <div id="divValue">test...</div>测试

 //年份 
    <select id="year"></select>
   <script type="text/javascript">
     window.onload = 
    
                                
    • 
                                
  • 简单链式调用的实现技术
                                    归来朝歌
方法调用链式反应编程思想
                                    
    在编程中，我们可以经常遇到这样一种场景：一个实例不断调用它自身的方法，像一条链条一样进行调用 
这样的调用你可能在Ajax中，在页面中添加标签： 
$("<p>").append($("<span>").text(list[i].name)).appendTo("#result"); 
  
也可能在HQ
    
                                
    • 
                                
  • JAVA调用.net 发布的webservice 接口
                                    darkranger
webservice
                                    
     /** 
	* @Title: callInvoke 
	* @Description: TODO(调用接口公共方法) 
	* @param @param url 地址
	* @param @param method 方法
	* @param @param pama 参数
	* @param @return
	* @param @throws BusinessException  
    
                                
    • 
                                
  • Javascript模糊查找 | 第一章 循环不能不重视。
                                    aijuans
Way
                                    
      最近受我的朋友委托用js+HTML做一个像手册一样的程序，里面要有可展开的大纲，模糊查找等功能。我这个人说实在的懒，本来是不愿意的，但想起了父亲以前教我要给朋友搞好关系，再加上这也可以巩固自己的js技术，于是就开始开发这个程序，没想到却出了点小问题，我做的查找只能绝对查找。具体的js代码如下： 
  
function search(){
	var arr=new Array("my
    
                                
    • 
                                
  • 狼和羊，该怎么抉择
                                    atongyeye
工作
                                    
    狼和羊，该怎么抉择 
 
在做一个链家的小项目，只有我和另外一个同事两个人负责，各负责一部分接口，我的接口写完，并全部测联调试通过。所以工作就剩下一下细枝末节的，工作就轻松很多。每天会帮另一个同事测试一些功能点，协助他完成一些业务型不强的工作。 
 
今天早上到公司没多久，领导就在QQ上给我发信息，让我多协助同事测试，让我积极主动些，有点责任心等等，我听了这话，心里面立马凉半截，首先一个领导轻易说
    
                                
    • 
                                
  • 读取android系统的联系人拨号
                                    百合不是茶
androidsqlite数据库内容提供者系统服务的使用
                                    
      
     联系人的姓名和号码是保存在不同的表中,不要一下子把号码查询来,我开始就是把姓名和电话同时查询出来的,导致系统非常的慢 
  
关键代码: 
  
  
1, 使用javabean操作存储读取到的数据 
package com.example.bean;

/**
 * 
 * @author Admini
    
                                
    • 
                                
  • ORACLE自定义异常
                                    bijian1013
数据库自定义异常
                                    
    实例： 
CREATE OR REPLACE PROCEDURE test_Exception
(
  ParameterA IN varchar2,
  ParameterB IN varchar2,
  ErrorCode  OUT varchar2  --返回值,错误编码
)
AS
  /*以下是一些变量的定义*/
  V1    NUMBER;
  V2    nvarc
    
                                
    • 
                                
  • 查看端号使用情况
                                    征客丶
windows
                                    
    一、查看端口 
在windows命令行窗口下执行： 
>netstat -aon|findstr "8080" 
显示结果： 
TCP     127.0.0.1:80         0.0.0.0:0    &
    
                                
    • 
                                
  • 【Spark二十】运行Spark Streaming的NetworkWordCount实例
                                    bit1129
wordcount
                                    
    Spark Streaming简介 
  NetworkWordCount代码 
  
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with

    
                                
    • 
                                
  • Struts2 与 SpringMVC的比较
                                    BlueSkator
struts2spring mvc
                                    
    1. 机制：spring mvc的入口是servlet，而struts2是filter，这样就导致了二者的机制不同。 2. 性能：spring会稍微比struts快。spring mvc是基于方法的设计，而sturts是基于类，每次发一次请求都会实例一个action，每个action都会被注入属性，而spring基于方法，粒度更细，但要小心把握像在servlet控制数据一样。spring
    
                                
    • 
                                
  • Hibernate在更新时，是可以不用session的update方法的(转帖）
                                    BreakingBad
Hibernateupdate
                                    
    地址：http://blog.csdn.net/plpblue/article/details/9304459 
public void synDevNameWithItil() 
{Session session = null;Transaction tr = null;try{session = HibernateUtil.getSession();tr = session.beginTran
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-观察者模式
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 



import java.util.ArrayList;
import java.util.List;
import java.util.Observable;
import java.util.Observer;

/**
 * “观
    
                                
    • 
                                
  • 重置MySQL密码
                                    chenhbc
mysql重置密码忘记密码
                                    
    如果你也像我这么健忘，把MySQL的密码搞忘记了，经过下面几个步骤就可以重置了（以Windows为例，Linux/Unix类似）： 
1、关闭MySQL服务 
2、打开CMD，进入MySQL安装目录的bin目录下，以跳过权限检查的方式启动MySQL 
mysqld --skip-grant-tables 
 3、新开一个CMD窗口，进入MySQL 
mysql -uroot 
 
    
                                
    • 
                                
  • 再谈系统论，控制论和信息论
                                    comsci
设计模式生物能源企业应用领域模型
                                    
     
                           再谈系统论，控制论和信息论 
 
 
    偶然看
    
                                
    • 
                                
  • oracle moving window size与 AWR retention period关系
                                    daizj
oracle
                                    
    转自： http://tomszrp.itpub.net/post/11835/494147 
 
晚上在做11gR1的一个awrrpt报告时,顺便想调整一下AWR snapshot的保留时间,结果遇到了ORA-13541这样的错误.下面是这个问题的发生和解决过程. 
 
SQL> select * from v$version; 
 
BANNER 
-------------------
    
                                
    • 
                                
  • Python版B树
                                    dieslrae
python
                                    
    话说以前的树都用java写的,最近发现python有点生疏了,于是用python写了个B树实现,B树在索引领域用得还是蛮多了,如果没记错mysql的默认索引好像就是B树... 
 
首先是数据实体对象,很简单,只存放key,value 
 

class Entity(object):
    '''数据实体'''
    
    def __init__(self,key,value)
    
                                
    • 
                                
  • C语言冒泡排序
                                    dcj3sjt126com
算法
                                    
    代码示例： 
# include <stdio.h>

//冒泡排序
void sort(int * a, int len)
{
	int i, j, t;

	for (i=0; i<len-1; i++)
	{
		for (j=0; j<len-1-i; j++)
		{
			if (a[j] > a[j+1])	// >表示升序 
    
                                
    • 
                                
  • 自定义导航栏样式
                                    dcj3sjt126com
自定义
                                    
    -(void)setupAppAppearance
{
    [[UILabel appearance] setFont:[UIFont fontWithName:@"FZLTHK—GBK1-0" size:20]];
    [UIButton appearance].titleLabel.font =[UIFont fontWithName:@"FZLTH
    
                                
    • 
                                
  • 11.性能优化-优化-JVM参数总结
                                    frank1234
jvm参数性能优化
                                    
    1.堆 
-Xms --初始堆大小 
-Xmx --最大堆大小 
-Xmn --新生代大小 
-Xss --线程栈大小 
-XX:PermSize  --永久代初始大小 
-XX:MaxPermSize  --永久代最大值 
-XX:SurvivorRatio --新生代和suvivor比例,默认为8 
-XX:TargetSurvivorRatio --survivor可使用
    
                                
    • 
                                
  • nginx日志分割 for linux
                                    HarborChung
nginxlinux脚本
                                    
    nginx日志分割 for linux   默认情况下，nginx是不分割访问日志的，久而久之，网站的日志文件将会越来越大，占用空间不说，如果有问题要查看网站的日志的话，庞大的文件也将很难打开，于是便有了下面的脚本        使用方法，先将以下脚本保存为 cutlog.sh，放在/root 目录下，然后给予此脚本执行的权限    
   
复制代码代码如下:   
chmo
    
                                
    • 
                                
  • Spring4新特性——泛型限定式依赖注入
                                    jinnianshilongnian
springspring4泛型式依赖注入
                                    
    Spring4新特性——泛型限定式依赖注入 
Spring4新特性——核心容器的其他改进 
Spring4新特性——Web开发的增强 
Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC  
Spring4新特性——Groovy Bean定义DSL 
Spring4新特性——更好的Java泛型操作API  
Spring4新
    
                                
    • 
                                
  • centOS安装GCC和G++
                                    liuxihope
centosgcc
                                    
    Centos支持yum安装，安装软件一般格式为yum install .......，注意安装时要先成为root用户。 
 
按照这个思路，我想安装过程如下： 
 
安装gcc：yum install gcc 
 
安装g++： yum install g++ 
 
实际操作过程发现，只能有gcc安装成功，而g++安装失败，提示g++ command not found。上网查了一下，正确安装应该
    
                                
    • 
                                
  • 第13章 Ajax进阶（上）
                                    onestopweb
Ajax
                                    
    index.html 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/
    
                                
    • 
                                
  • How to determine BusinessObjects service pack and fix pack
                                    blueoxygen
BO
                                    
    http://bukhantsov.org/2011/08/how-to-determine-businessobjects-service-pack-and-fix-pack/ 
  
The table below is helpful. Reference 
  BOE XI 3.x 
     12.0.0.
y  BOE XI 3.0   12.0.
x.
y  BO
    
                                
    • 
                                
  • Oracle里的自增字段设置
                                    tomcat_oracle
oracle
                                    
    　大家都知道吧，这很坑，尤其是用惯了mysql里的自增字段设置，结果oracle里面没有的。oh，no   　　我用的是12c版本的，它有一个新特性，可以这样设置自增序列，在创建表是，把id设置为自增序列   
create table t
(
id 　　 　　  number generated by default as identity (start with 1 increment b
    
                                
    • 
                                
  • Spring Security（01）——初体验
                                    yang_winnie
springSecurity
                                    
    Spring Security（01）——初体验 
 
    博客分类： spring Security 
 
Spring Security入门安全认证 
 
       首先我们为Spring Security专门建立一个Spring的配置文件，该文件就专门用来作为Spring Security的配置
    
                                
    •