6时间&异常

时间序列中的异常 考虑一个 ARIMA 过程生成的时间序列 Yt=θ(B)α(B)ϕ(B)at,t=1,2,⋯ ,n Y_t = \frac{\theta(B)}{\alpha(B)\phi(B)}a_t, \qquad t = 1, 2, \cdots, n Yt​=α(B)ϕ(B)θ(B)​at​,t=1,2,⋯,n 其中θ(B)\theta(B)θ(B)和ϕ(B)\phi(B)ϕ(B)的所有根都在单位圆外,α... 阅读详情

今日目标

1、能够熟练使用Date类和SimpleDateFormat类中的常见方法

2、能够了解Jdk1.8新提供的日历类的使用

3、能够理解什么是异常

知识点

  1. 时间日期类
  2. JDK8时间类
  3. 异常

1.时间日期类

1.1 时间概述(视频01) (5‘’)

  1. 北京时间需要在世界标准时间加上8小时
  2. 计算机中时间原点(UNIX操作系统,C语言的诞生日)
    在这里插入图片描述

​ 1970年1月1日 00:00:00

3.时间换算单位

​ 1秒 = 1000毫秒

1.2 时间日期类-Date构造方法(视频02) (7‘’)

  1. 什么是Date类

    Date 代表了一个特定的时间,精确到毫秒

2.Date类构造方法

方法名说明
public Date()创建 Date对象,默认存储当前时间,单位毫秒
public Date(long date)创建 Date对象,并将其初始化为表示从标准基准时间起指定的毫秒数

示例代码

package com.itheima.mydate;

import java.util.Date;

public class DateDemo1 {
    public static void main(String[] args) {
        //public Date()		创建一个Date对象,表示默认时间
        //public Date(long date)	创建一个Date对象,表示指定时间

        //那么这个时间就表示电脑中的当前时间。
        Date date1 = new Date();
        System.out.println(date1);

        //从计算机的时间原点开始,过了指定毫秒的那个时间。
        Date date2 = new Date(0L);
        System.out.println(date2);//Thu Jan 01 08:00:00 CST 1970
        //从时间原点开始,过了0毫秒。
        //因为我们是在中国,我们是在东八区需要+8小时。

        //1970年1月1日 上午的10点
        Date date3 = new Date(2 * 3600L * 1000);
        System.out.println(date3);
    }
}

1.3 时间日期类-Date成员方法(应用)(视频03) (4‘’)

  • 常用方法

    方法名说明
    public long getTime()获取从1970年1月1日 00:00:00到该日期对象代表时间的毫秒值
    public void setTime(long time)设置时间,给的是毫秒值
  • 示例代码

    package com.itheima.mydate;
    
    import java.text.SimpleDateFormat;
    import java.util.Date;
    
    public class DateDemo2 {
        public static void main(String[] args) {
            //public long getTime()			获取时间对象的毫秒值
              //public void setTime(long time)		设置时间,传递毫秒值
    
            //method1();
            //method2();
    
      }
    
        private static void method2() {
            Date date1 = new Date();
            date1.setTime(0L);
            System.out.println(date1);
        }
    
        private static void method1() {
            //把当前时间封装成一个date对象
            Date date1 = new Date();
            
            //获取这个date对象的毫秒值 --- 获取当前时间的毫秒值
            long time = date1.getTime();
            System.out.println(time);
    		
            long time2 = System.currentTimeMillis();
            System.out.println(time2);
        }
    }
    

1.4 SimpleDateFormat类(应用)(视频04) (12‘’)

(共2点)

1.SimpleDateFormat类有什么作用?

​ SimpleDateFormat可以对Date对象,进行格式化和解析

2.如何使用?

1.常用的模式字母及应对关系如下:

HH:24小制,hh:12小时制

在这里插入图片描述

2.SimpleDateFormat类构造方法

方法名说明
public SimpleDateFormat()构造一个SimpleDateFormat,使用默认模式和日期格式
public SimpleDateFormat(String pattern)构造一个SimpleDateFormat使用给定的模式

3.SimpleDateFormat类的常用方法

  • 格式化(从Date到String)

​ public final String format(Date date):将日期格式化成日期/时间字符串

  • 解析(从日期/时间字符串String到Date)

​ public Date parse(String source):从给定字符串的开始解析文本以生成日期

示例代码(公历日期标准格式为;2007年2月6日;或:2007-02-06)

//将Date转换成固定格式的字符串
public class DateDemo3 {
    public static void main(String[] args) {
        //当前时间的Date对象
        Date date = new Date();

        //创建了一个日期格式。
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        String result1 = sdf.format(date);
        System.out.println(result1);
    }
}
//将固定格式的字符串转换成Date
public class DateDemo4 {
    public static void main(String[] args) throws ParseException {
        String s = "2048-01-01";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		
        Date date = sdf.parse(s);
        System.out.println(date);
    }
}

自由练习-8分钟 - (parse&format方法)

1.5 时间日期类练习 (应用) (视频05)(9’’)

  • 需求

    秒杀开始时间是2020年11月11日 00:00:00,结束时间是2020年11月11日 00:10:00,用户小贾下单时间是2020年11月11日 00:03:47,用户小皮下单时间是2020年11月11日 00:10:11,判断用户有没有成功参与秒杀活动

  • 实现步骤

    1. 判断下单时间是否在开始到结束的范围内
    2. 把字符串形式的时间变成毫秒值
  • 代码实现

    ```java``

  package com.itheima.mydate;
  
  import java.text.ParseException;
  import java.text.SimpleDateFormat;
import java.util.Date;
  
  public class DateDemo5 {
    public static void main(String[] args) throws ParseException {
          //开始时间:2020年11月11日 0:0:0
          //结束时间:2020年11月11日 0:10:0
  
          //小贾2020年11月11日 0:03:47
          //小皮2020年11月11日 0:10:11
  
          //1.判断两位同学的下单时间是否在范围之内就可以了。
          //2.要把每一个时间都换算成毫秒值。
  
          String start = "2020年11月11日 0:0:0";
          String end = "2020年11月11日 0:10:0";
  
          String jia = "2020年11月11日 0:03:47";
          String pi = "2020年11月11日 0:10:11";
  
          SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
          long startTime = sdf.parse(start).getTime();
          long endTime = sdf.parse(end).getTime();
  	
          long jiaTime = sdf.parse(jia).getTime();
          long piTime = sdf.parse(pi).getTime();
  
          if(jiaTime >= startTime && jiaTime <= endTime){
              System.out.println("小贾同学参加上了秒杀活动");
          }else{
              System.out.println("小贾同学没有参加上秒杀活动");
          }
  
          System.out.println("------------------------");
  
          if(piTime >= startTime && piTime <= endTime){
              System.out.println("小皮同学参加上了秒杀活动");
          }else{
              System.out.println("小皮同学没有参加上秒杀活动");
          }
      }
  }

小结

1北京时间需要在世界标准时间加上8小时

2 计算机中时间原点 1970年1月1日 00:00:00

3时间换算单位 1秒 = 1000毫秒

4.Date类

​ 这个类是干什么的? 时间类、 Date 代表了一个特定的时间,精确到毫秒

​ 如何创建时间对象? new Date()

​ 常用方法: getTime()

  1. SimpleDateFormat类

    ​ 这个类是干什么的? 定义日期的格式,用于格式转换

    ​ 如何创建时间对象? new SimpleDateFormat(“日期模式”)

    ​ 常用方法:

    ​ format(Date date) 将Date转换成字符串

    ​ parse(String source) 将字符串转换成Date ```

2.JDK8时间日期类

2.1 JDK8时间类-初体验(视频6) (7’’)

需求

​ 定义一个时间,String start = ""2020年11月11日 00:00:00;

​ 将这个时间+1天,再按照原来的格式进行输出


```java
//jdk8以前的写法
private static void JDKMethod() throws ParseException {
    //定义时间格式
    String s = "2020年11月11日 00:00:00";
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");

    //转换成Date
    Date date = sdf.parse(s);

    //将时间+1天
    long time = date.getTime();
    time = time + (1000 * 60 * 60 * 24);
    Date newDate = new Date(time);

    //转换成String
    String result = sdf.format(newDate);
    System.out.println(result);
}
//jdk8写法
private static void JDK8Method() {
    //定义时间格式
    String s = "2020年11月11日 00:00:00";
    DateTimeFormatter pattern = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");

    //转换成LocalDateTime
    LocalDateTime localDateTime = LocalDateTime.parse(s, pattern);

    //将时间+1天
    LocalDateTime newLocalDateTime = localDateTime.plusDays(1);

    //转换成String
    String result = newLocalDateTime.format(pattern);
    System.out.println(result);
}

2.2 JDK8时间类-获取时间对象 (应用) (视频7) (6’’)

1.jdk8中新增的时间类有哪些?

  • LocalDate 表示日期(年月日)
  • LocalTime 表示时间(时分秒)
  • LocalDateTime 表示时间+ 日期 (年月日时分秒)(最常用)

2 如何创建LocalDateTime对象? (应用)

方法说明

方法名说明
public static LocalDateTime now()获取当前系统时间相当于new Date()
public static LocalDateTime of (年, 月 , 日, 时, 分, 秒)使用指定年月日和时分秒初始化一个LocalDateTime对象 new Date(1000L);指定一下时间

示例代码

package com.itheima.jdk8date;

import java.time.LocalDateTime;

public class JDK8DateDemo2 {
    public static void main(String[] args) {
        LocalDateTime now = LocalDateTime.now();
        System.out.println(now);


        LocalDateTime localDateTime = LocalDateTime.of(2020, 11, 11, 11, 11, 11);
        System.out.println(localDateTime);
    }
}

2.3 LocalDateTime获取方法 (了解)(视频8)(8’’)

  • 方法说明

    方法名说明
    public int getYear()获取年
    public int getMonthValue()获取月份(1-12)
    public int getDayOfMonth()获取月份中的第几天(1-31)
    public int getDayOfYear()获取一年中的第几天(1-366)
    public DayOfWeek getDayOfWeek()获取星期
    public int getHour()获取小时
    public int getMinute()获取分钟

| public int getSecond() | 获取秒 |

  • 示例代码

    package com.itheima.jdk8date;
    
    import java.time.DayOfWeek;
    import java.time.LocalDateTime;
    import java.time.Month;
    
    public class JDK8DateDemo3 {
        public static void main(String[] args) {
            LocalDateTime localDateTime = LocalDateTime.of(2020, 11, 11, 11, 11, 20);
            //public int getYear()           获取年
            int year = localDateTime.getYear();
            System.out.println("年为" +year);
            
            //public int getMonthValue()     获取月份(1-12)
            int month = localDateTime.getMonthValue();
            System.out.println("月份为" + month);
    
            Month month1 = localDateTime.getMonth();
            //System.out.println(month1);
    
            //public int getDayOfMonth()     获取月份中的第几天(1-31)
          	int day = localDateTime.getDayOfMonth();
            System.out.println("日期为" + day);
    
            //public int getDayOfYear()      获取一年中的第几天(1-366)
            int dayOfYear = localDateTime.getDayOfYear();
            System.out.println("这是一年中的第" + dayOfYear + "天");
    
            //public DayOfWeek getDayOfWeek()获取星期
            DayOfWeek dayOfWeek = localDateTime.getDayOfWeek();
            System.out.println("星期为" + dayOfWeek);
    
            //public int getMinute()        获取分钟
            int minute = localDateTime.getMinute();
            System.out.println("分钟为" + minute);
            
            //public int getHour()           获取小时
            int hour = localDateTime.getHour();
            System.out.println("小时为" + hour);
        }
    }
    

2.4 LocalDateTime转换方法 (了解)(视频9) (3’’)

方法说明

方法名说明
public LocalDate toLocalDate ()转换成为一个LocalDate对象
public LocalTime toLocalTime ()转换成为一个LocalTime对象

示例代码

public class JDK8DateDemo4 {
    public static void main(String[] args) {
        LocalDateTime localDateTime = LocalDateTime.of(2020, 12, 12, 8, 10, 12);
        
        //public LocalDate toLocalDate ()    转换成为一个LocalDate对象
        LocalDate localDate = localDateTime.toLocalDate();
        System.out.println(localDate);

        //public LocalTime toLocalTime ()    转换成为一个LocalTime对象
        LocalTime localTime = localDateTime.toLocalTime();
        System.out.println(localTime);
    }
}

2.5 JDK8时间类-格式化和解析 (应用)(视频10) (7’’)

方法说明

方法名说明
public String format (指定格式)把一个LocalDateTime格式化成为一个字符串
public static LocalDateTime parse (准备解析的字符串, 解析格式)把一个日期字符串解析成为一个LocalDateTime对象
public static DateTimeFormatter ofPattern(String pattern)使用指定的日期模板获取一个日期格式化器DateTimeFormatter对象

示例代码

package com.itheima.jdk8date;


import java.time.Instant;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

public class JDK8DateDemo5 {
    public static void main(String[] args) {
        //method1();
        //method2();
    }
	
  //public static LocalDateTime parse (准备解析的字符串, 解析格式) 把一个日期字符串解析成为一个LocalDateTime对象
  private static void method2() {
        
        String s = "2020年11月12日 13:14:15";
        DateTimeFormatter pattern = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");
        LocalDateTime parse = LocalDateTime.parse(s, pattern);
        System.out.println(parse);
    }
	
    //public String format (指定格式)   把一个LocalDateTime格式化成为一个字符串
    private static void method1() {
        LocalDateTime localDateTime = LocalDateTime.of(2020, 11, 12, 13, 14, 15);
        DateTimeFormatter pattern = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");
        
        String s = localDateTime.format(pattern);
        System.out.println(s);
    }
}

自由练习-8分钟

2.6 jdk8时间类-plus (了解)(视频11) (6‘’)

方法说明

方法名说明
public LocalDateTime plusYears (long years)添加或者减去年
public LocalDateTime plusMonths(long months)添加或者减去月
public LocalDateTime plusDays(long days)添加或者减去日
public LocalDateTime plusHours(long hours)添加或者减去时
public LocalDateTime plusMinutes(long minutes)添加或者减去分
public LocalDateTime plusSeconds(long seconds)添加或者减去秒
public LocalDateTime plusWeeks(long weeks)添加或者减去周

示例代码

/**
 * JDK8 时间类添加或者减去时间的方法
 */
public class JDK8DateDemo6 {
    public static void main(String[] args) {
        //public LocalDateTime plusYears (long years)   添加或者减去年

        LocalDateTime localDateTime = LocalDateTime.of(2020, 11, 11, 13, 14, 15);
        //LocalDateTime newLocalDateTime = localDateTime.plusYears(1);
        //System.out.println(newLocalDateTime);

        LocalDateTime newLocalDateTime = localDateTime.plusYears(-1);
        System.out.println(newLocalDateTime);
    }
}

2.7 jdk8时间类-minus (了解)(视频12)(3‘’)

方法说明

方法名说明
public LocalDateTime minusYears (long years)减去或者添加年
public LocalDateTime minusMonths(long months)减去或者添加月
public LocalDateTime minusDays(long days)减去或者添加日
public LocalDateTime minusHours(long hours)减去或者添加时
public LocalDateTime minusMinutes(long minutes)减去或者添加分
public LocalDateTime minusSeconds(long seconds)减去或者添加秒
public LocalDateTime minusWeeks(long weeks)减去或者添加周

示例代码

package com.itheima.jdk8date;

import java.time.LocalDateTime;

/**
 * JDK8 时间类减少或者添加时间的方法
 */
public class JDK8DateDemo7 {
    public static void main(String[] args) {
      //public LocalDateTime minusYears (long years)  减去或者添加年
        LocalDateTime localDateTime = LocalDateTime.of(2020, 11, 11, 13, 14, 15);
        //LocalDateTime newLocalDateTime = localDateTime.minusYears(1);
      //System.out.println(newLocalDateTime);

        LocalDateTime newLocalDateTime = localDateTime.minusYears(-1);
        System.out.println(newLocalDateTime);

    }
}

2.8 LocalDateTime修改方法 (了解)(视频13) (4‘’)

方法说明

方法名说明
public LocalDateTime withYear(int year)直接修改年
public LocalDateTime withMonth(int month)直接修改月
public LocalDateTime withDayOfMonth(int dayofmonth)直接修改日期(一个月中的第几天)
public LocalDateTime withDayOfYear(int dayOfYear)直接修改日期(一年中的第几天)
public LocalDateTime withHour(int hour)直接修改小时
public LocalDateTime withMinute(int minute)直接修改分钟
public LocalDateTime withSecond(int second)直接修改秒

示例代码

/**
 * JDK8 时间类修改时间
 */
public class JDK8DateDemo8 {
    public static void main(String[] args) {
        //public LocalDateTime withYear(int year)   修改年
        LocalDateTime localDateTime = LocalDateTime.of(2020, 11, 11, 13, 14, 15);
       // LocalDateTime newLocalDateTime = localDateTime.withYear(2048);
       // System.out.println(newLocalDateTime);

        LocalDateTime newLocalDateTime = localDateTime.withMonth(20);
        System.out.println(newLocalDateTime);

    }
}

2.9 Period (了解)(视频14) (9‘’)

  • 方法说明

    方法名说明
    public static Period between(开始时间,结束时间)计算两个“时间"的间隔
    public int getYears()获得这段时间的年数
    public int getMonths()获得此期间的总月数
    public int getDays()获得此期间的天数
    public long toTotalMonths()获取此期间的总月数
  • 示例代码

计算两个时间的间隔

package com.itheima.jdk8date;

import java.time.LocalDate;
import java.time.Period;  
public class JDK8DateDemo9 {
      public static void main(String[] args) {
        //public static Period between(开始时间,结束时间)  计算两个"时间"的间隔  
   LocalDate localDate1 = LocalDate.of(2020, 1, 1);
      LocalDate localDate2 = LocalDate.of(2048, 12, 12);
      Period period = Period.between(localDate1, localDate2);
      System.out.println(period);//P28Y11M11D
  
    //public int getYears()         获得这段时间的年数
      System.out.println(period.getYears());//28
      //public int getMonths()        获得此期间的月数
      System.out.println(period.getMonths());//11
      //public int getDays()          获得此期间的天数
      System.out.println(period.getDays());//11
  
      //public long toTotalMonths()   获取此期间的总月数
      System.out.println(period.toTotalMonths());//347  
  }
}

2.10 Duration (了解)(视频14) (9‘’)

  • 方法说明

    方法名说明
    public static Duration between(开始时间,结束时间)计算两个“时间"的间隔
    public long toSeconds()获得此时间间隔的秒
    public int toMillis()获得此时间间隔的毫秒
    public int toNanos()获得此时间间隔的纳秒
  • 示例代码

计算两个时间的间隔

package com.itheima.jdk8date;

import java.time.Duration;
import java.time.LocalDateTime;

/**
 *  计算两个时间的间隔
 */

public class JDK8DateDemo10 {
    public static void main(String[] args) {
        //public static Duration between(开始时间,结束时间)  计算两个“时间"的间隔

        LocalDateTime localDateTime1 = LocalDateTime.of(2020, 1, 1, 13, 14, 15);
        LocalDateTime localDateTime2 = LocalDateTime.of(2020, 1, 2, 11, 12, 13);
        Duration duration = Duration.between(localDateTime1, localDateTime2);
        System.out.println(duration);//PT21H57M58S
        //public long toSeconds()	       获得此时间间隔的秒
        System.out.println(duration.toSeconds());//79078
        //public int toMillis()	           获得此时间间隔的毫秒
        System.out.println(duration.toMillis());//79078000
        //public int toNanos()             获得此时间间隔的纳秒
        System.out.println(duration.toNanos());//79078000000000
        
        
        //计算年龄
        String birtthday="1995-01-01 00:00:00";
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        LocalDateTime birthdayTime = LocalDateTime.parse(birtthday, dateTimeFormatter);
        
        //计算活了多少天
        Duration between = Duration.between( birthdayTime,LocalDateTime.now());
        long days = between.toDays();
        System.out.println(days);
        //计算活了多少岁
        Period period = Period.between(
                birthdayTime.toLocalDate(),
                LocalDateTime.now().toLocalDate());
        System.out.println("活了"+period.getYears()+"岁,零"+period.getMonths()+"月,零"+period.getDays()+"天");
    }
}

2.11 jdk8时间类-小结(视频15) (4‘’)

创建时间对象(now, of )

将日期类转换成字符串(format)
将字符串转换成日期类(parse)

获取时间对象中的年,月,日,时,分,秒 (get开头)
增加或减少时间的方法(plus开头,minus开头)
修改时间(with开头)
计算间隔(until方法)

这么多类、这么多方法,要疯

记不住啊

关键要会观察、会查询帮助文档

3.异常

3.1 异常的体系结构和分类(记忆)(视频16)(9’’)

1.什么是异常?

异常就是程序出现了不正常的情况(其实就是: 代码报错了)

**注意:**语法错误不算在异常体系中

2.异常的体系结构

在这里插入图片描述

//除RuntimeException之外的异常
public class ExceptionDemo1 {
  public static void main(String[] args)  {
//        int [] arr = {1,2,3,4,5};
//        System.out.println(arr[10]);//ArrayIndexOutOfBoundsException


//        String s = null;
//        System.out.println(s.equals("嘿嘿"));//NullPointerException

      SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
      sdf.parse("2048-1月1日");//ParseException
  }
}

3.编译时异常和运行时异常的区别(记忆)

  • 编译时异常

    • 都是Exception类及其子类
    • 必须显式处理(手动处理),否则程序就会发生错误,无法通过编译
  • 运行时异常

    • 都是RuntimeException类及其子类
    • 无需显式处理(手动处理),也可以和编译时异常一样处理
  • 图示
    在这里插入图片描述

3.2 JVM默认处理异常的方式(理解)(视频17)(4’’)

异常处理 : 并不是把异常解决掉,而是把发生异常的信息(什么地方出现了什么异常) 展示出来

在这里插入图片描述

1.如果程序出现了问题,我们没有做任何处理,最终JVM会做默认的处理,处理方式有如下两个步骤:

  • 把异常的名称,错误原因及异常出现的位置等信息输出在了控制台

  • 程序停止执行

在这里插入图片描述

package com.itheima.exce;


public class ExceptionDemo2 {
    public static void main(String[] args){
        //思考:控制台为什么会有这样的红色字体呢? 是谁打印的?
        int [] arr = {1,2,3,4,5};
        System.out.println(arr[10]);//当代码出现了异常,那么就在这里创建了一个异常对象.
                                    //new ArrayIndexOutOfBoundsException();
                                    //首先会看,程序中有没有自己处理异常的代码.
                                    //如果没有,交给本方法的调用者处理.
                                    //最终这个异常会交给虚拟机默认处理.
                                    //JVM默认处理异常做了哪几件事情:
                                    //1,将异常信息以红色字体展示在控制台上.
                                    //2,停止程序运行. --- 哪里出现了异常,那么程序就在哪里停止,下面的代码不执行了.
        System.out.println("嘿嘿嘿,我最帅");


    }
}

3.3throws方式处理异常(应用)(视频18) (5’’)

1.定义格式

public void 方法() throws 异常类名 {
    
}

示例代码

package com.itheima.exce;
import java.text.ParseException;
import java.text.SimpleDateFormat;

public class ExceptionDemo6 {
    public static void main(String[] args) throws ParseException {
        method1(); //此时调用者也没有处理.还是会交给虚拟机处理.
        method2(); //还是继续交给调用者处理.而main方法的调用者是虚拟机还是会采取虚拟机默认处理异常的方法.
    }

    //告诉调用者,你调用我,有可能会出现这样的异常哦.
    //如果方法中没有出现异常,那么正常执行
    //如果方法中真的出现了异常,其实也是将这个异常交给了调用者处理.
    private static void method1() /*throws NullPointerException*/ {
        int [] arr = null;
        for (int i = 0; i < arr.length; i++) {//出现的空指针异常,还是由虚拟机创建出来的.
            System.out.println(arr[i]);
        }
    }

    //告诉调用者,你调用我,有可能会出现这样的异常哦.
    //如果方法中没有出现异常,那么正常执行
    //如果方法中真的出现了异常,其实也是将这个异常交给了调用者处理.
    private static void method2() throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
        sdf.parse("2048-10月10日");
    }
}

3.4 throws方式处理异常-注意事项(应用)(视频19) (2’’)

简单来说: 编译时的异常,必须声明由谁处理,最多让jvm来处理. 运行时异常可以不声明

package com.itheima.exce;


import java.text.ParseException;
import java.text.SimpleDateFormat;

public class ExceptionDemo6 {
    public static void main(String[] args) throws ParseException {
        method1(); //此时调用者也没有处理.还是会交给虚拟机处理.
        method2(); //还是继续交给调用者处理.而main方法的调用者是虚拟机还是会采取虚拟机默认处理异常的方法.
    }

    //告诉调用者,你调用我,有可能会出现这样的异常哦.
    //如果方法中没有出现异常,那么正常执行
    //如果方法中真的出现了异常,其实也是将这个异常交给了调用者处理.
    //如果声明的异常是一个运行时异常,那么声明的代码可以省略
    private static void method1() /*throws NullPointerException*/ {
        int [] arr = null;
        for (int i = 0; i < arr.length; i++) {//出现的空指针异常,还是由虚拟机创建出来的.
            System.out.println(arr[i]);
        }
    }

    //告诉调用者,你调用我,有可能会出现这样的异常哦.
    //如果方法中没有出现异常,那么正常执行
    //如果方法中真的出现了异常,其实也是将这个异常交给了调用者处理.
    //如果声明的异常是一个编译时异常,那么声明的代码必须要手动写出.
    private static void method2() throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
        sdf.parse("2048-10月10日");
    }
}

3.5 throw抛出异常 (应用) (视频20) (10’’)

1.格式

​ throw new 异常();

2.注意

​ 这个格式是在方法内的,表示当前代码手动抛出一个异常,下面的代码无法再执行了

3.抛出处理异常的意义

1.在方法中,当传递的参数有误时,没有继续运行的必要了,采取抛出处理,表示该方法结束

  1. 告诉调用者方法中出现了问题

4.throws和throw的区别

throws (抛出现有异常)throw (主动制造异常)
用在方法声明后面,跟的是异常类名用在方法体内,跟的是异常对象名
可以声明多个异常只能有一个

示例代码

package com.itheima.exce;
public class ExceptionDemo7 {
    public static void main(String[] args) {
        System.out.println("家里有一个貌美如花的老婆");
      	System.out.println("还有一个当官的兄弟");
        System.out.println("自己还有一个买卖");
        System.out.println("这样的生活你要不要?");
        throw new RuntimeException(); //当代码执行到这里,就创建一个异常对象
                                    //该异常创建之后,暂时没有手动处理.抛给了调用者处理
                                    //下面的代码不会再执行了.
        //System.out.println("武大郎的标准生活");
    }


}
 package com.itheima.exce;
  public class ExceptionDemo8 {
      public static void main(String[] args) {
          //int [] arr = {1,2,3,4,5};
          int [] arr = null;
          printArr(arr);//就会 接收到一个异常.
                          //我们还需要自己处理一下异常.
      }
 private static void printArr(int[] arr) {
      if(arr == null){
          //调用者知道成功打印了吗?
          //System.out.println("参数不能为null");
          throw new NullPointerException(); //当参数为null的时候
                                              //手动创建了一个异常对象,抛给了调用者.
      }else{
          for (int i = 0; i < arr.length; i++) {
              System.out.println(arr[i]);
          }
      }
  }
}

3.6 try-catch自己处理异常(应用)(视频21) (5’’)

  • 定义格式

    try {
    	可能出现异常的代码;
    } catch(异常类名 变量名) {
    	异常的处理代码;
    }
    

    idea快捷键 ctrl + alt + t 自动生成try{}catch(){}代码

  • 执行流程

    • 程序从 try 里面的代码开始执行
    • 出现异常,就会跳转到对应的 catch 里面去执行
    • 执行完毕之后,程序还可以继续往下执行
  • 示例代码

    package com.itheima.exce;
    
    
    public class ExceptionDemo9 {
        public static void main(String[] args) {
    
            //好处:为了能让代码继续往下运行.
            int [] arr = null;
            try{
                //有肯能发现异常的代码
                printArr(arr);
            }catch (NullPointerException e){
                //如果出现了这样的异常,那么我们进行的操作
                System.out.println("参数不能为null");
            }
    
    
            System.out.println("嘿嘿嘿,我最帅!!!");
    
        }
    
        private static void printArr(int[] arr) {
            if(arr == null){
                throw new NullPointerException();
            }else{
                for (int i = 0; i < arr.length; i++) {
                    System.out.println(arr[i]);
                }
            }
        }
    }
    

3.7 try-catch常见问题(视频22)(15‘’)

  1. 如果 try 中没有遇到问题,怎么执行?

    会把try中所有的代码全部执行完毕,不会执行catch里面的代码

  2. 如果 try 中遇到了问题,那么 try 下面的代码还会执行吗?

​ 那么直接跳转到对应的catch语句中,try下面的代码就不会再执行了
​ 当catch里面的语句全部执行完毕,表示整个体系全部执行完全,继续执行下面的代码

  1. 如果出现的问题没有被捕获,那么程序如何运行?

​ 那么try…catch就相当于没有写.那么也就是自己没有处理.
​ 默认交给虚拟机处理.

  1. 同时出现多个异常怎么处理?

    出现多个异常,那么就写多个catch就可以了.
    注意点:如果多个异常之间存在子父类关系.那么父类一定要写在下面

package com.itheima.exce;

import java.util.Scanner;

public class ExceptionDemo10 {
    public static void main(String[] args) {
        //1.如果 try 中没有遇到问题,怎么执行? --- 会把try中所有的代码全部执行完毕,不会执行catch里面的代码
        //2.如果 try 中遇到了问题,那么 try 下面的代码还会执行吗?
                            //那么直接跳转到对应的catch语句中,try下面的代码就不会再执行了
                            //当catch里面的语句全部执行完毕,表示整个体系全部执行完全,继续执行下面的代码
        //3.如果出现的问题没有被捕获,那么程序如何运行?
                             //那么try...catch就相当于没有写.那么也就是自己没有处理.
                             //默认交给虚拟机处理.
        //4.同时有可能出现多个异常怎么处理?
                            //出现多个异常,那么就写多个catch就可以了.
                            //注意点:如果多个异常之间存在子父类关系.那么父类一定要写在下面
        // method1();
    try {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你的年龄");
        String line = sc.nextLine();
        int age = Integer.parseInt(line);//格式化异常
        
        System.out.println(age);
        System.out.println(2 / 0); //数学异常
    } catch (Exception e) {
        //以后我们针对于每种不同的异常,有可能会有不同的处理结果.
    }
    System.out.println("测试456");
}

private static void method1() {
    try {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你的年龄");
        String line = sc.nextLine();
        int age = Integer.parseInt(line);//格式化异常
        System.out.println(age);
        
        System.out.println(2 / 0); //数学异常
    } catch (NumberFormatException e) {
        System.out.println("格式化异常出现了");
    }catch (ArithmeticException e) {
        System.out.println("数学运算异常出现了");
    }
    System.out.println("测试456");
}

3.8 Throwable中的常见方法(应用)(视频23)(4’’)

  • 常用方法

    方法名说明
    public String getMessage()返回此 throwable 的详细消息字符串
    public String toString()返回此可抛出的简短描述
    public void printStackTrace()把异常的错误信息输出在控制台
  • 示例代码

    package com.itheima.exce;
    
    
    public class ExceptionDemo11 {
        //public String getMessage​()    返回此 throwable 的详细消息字符串
        //public String toString​()      返回此可抛出的简短描述
      //public void printStackTrace​() 把异常的错误信息输出在控制台(字体为红色的)
        public static void main(String[] args) {
    
            try {
                int [] arr = {1,2,3,4,5};
                System.out.println(arr[10]);//虚拟机帮我们创建了一个异常对象 new ArrayIndexOutOfBoundsException();
            } catch (ArrayIndexOutOfBoundsException e) {
                /*String message = e.getMessage();
              System.out.println(message);*/
               /* String s = e.toString();
                System.out.println(s);*/
               e.printStackTrace();
          }
    
            System.out.println("嘿嘿嘿");
    
      }
    }
    

3.9 异常的练习 (应用) (视频24)(11’’)

在这里插入图片描述

  • 需求

    键盘录入学生的姓名和年龄,其中年龄为18 - 25岁,超出这个范围是异常数据不能赋值.需要重新录入,一直录到正确为止

  • 实现步骤

    1. 创建学生对象
    2. 键盘录入姓名和年龄,并赋值给学生对象
    3. 如果是非法数据就再次录入
  • 代码实现

    学生类

    package com.itheima.exce;
    
    public class Student {
      private String name;
        private int age;
    
      public Student() {
        }
    
        public Student(String name, int age) {
            this.name = name;
          this.age = age;
        }
    
        public String getName() {
          return name;
        }
    
        public void setName(String name) {
          this.name = name;
        }
    
        public int getAge() {
          return age;
        }
    
        public void setAge(int age) {
            if(age >= 18 && age <= 25){
                this.age = age;
            }else{
                //自定义异常的目的:为了让异常信息更加的见名知意
                throw new RuntimeException("年龄超出了范围");
              
            }
        }
    
        @Override
        public String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
      }
    }
    
     package com.itheima.exce;
    
      
    import java.util.Scanner;
      
      public class ExceptionDemo12 {
          public static void main(String[] args) {
              // 键盘录入学生的姓名和年龄,其中年龄为 18 - 25岁,
              // 超出这个范围是异常数据不能赋值.需要重新录入,一直录到正确为止。
      
              Student s = new Student();
      
              Scanner sc = new Scanner(System.in);
              System.out.println("请输入姓名");
              String name = sc.nextLine();
              s.setName(name);
             while(true){
                 System.out.println("请输入年龄");
                 String ageStr = sc.nextLine();
                 
                 
                 try {
                     int age = Integer.parseInt(ageStr);
                     s.setAge(age);
                     break;
                 } catch (NumberFormatException e) {
                     System.out.println("请输入一个整数");
                     continue;
                 } catch (AgeOutOfBoundsException e) {
                     System.out.println(e.toString());
                     System.out.println("请输入一个符合范围的年龄");
                     continue;
                 }
                 /*if(age >= 18 && age <=25){
                   s.setAge(age);
                     break;
                 }else{
                     System.out.println("请输入符合要求的年龄");
                     continue;
                 }*/
             }
              System.out.println(s);
      
          }
      }
    

3.10 自定义异常(应用)(视频25)(6’’)

1.什么是自定义异常?

当Java中提供的异常不能满足我们的需求时,我们可以自定义异常

2.为什么要自定义异常?

有一个原则 :异常类要与业务相关(见名知意)

3.实现步骤

  1. 定义异常类
  2. 写继承关系
  3. 提供空参/带参构造

4.代码实现

异常类

public class AgeOutOfBoundsException extends RuntimeException {
    public AgeOutOfBoundsException() {
    }

    public AgeOutOfBoundsException(String message) {
        super(message);
    }
}

学生类

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age >= 18 && age <= 25){
            this.age = age;
        }else{
            //如果Java中提供的异常不能满足我们的需求,我们可以使用自定义的异常
            throw new AgeOutOfBoundsException("年龄超出了范围");
        }
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

测试类

public class ExceptionDemo12 {
    public static void main(String[] args) {
        // 键盘录入学生的姓名和年龄,其中年龄为 18 - 25岁,
        // 超出这个范围是异常数据不能赋值.需要重新录入,一直录到正确为止。

        Student s = new Student();

        Scanner sc = new Scanner(System.in);
        System.out.println("请输入姓名");
        String name = sc.nextLine();
        s.setName(name);
       while(true){
           System.out.println("请输入年龄");
           String ageStr = sc.nextLine();
           try {
               int age = Integer.parseInt(ageStr);
               s.setAge(age);
               break;
           } catch (NumberFormatException e) {
               System.out.println("请输入一个整数");
               continue;
           } catch (AgeOutOfBoundsException e) {
               System.out.println(e.toString());
               System.out.println("请输入一个符合范围的年龄");
               continue;
           }
           /*if(age >= 18 && age <=25){
               s.setAge(age);
               break;
           }else{
               System.out.println("请输入符合要求的年龄");
               continue;
           }*/
       }
        System.out.println(s);

    }
}

异常小结

​ 1.什么是异常

​ 异常就是程序出现了不正常的情况

​ 2.异常的分类

​ Error & 编译期异常 & 运行时异常

​

​ 3.如何捕获异常

​ 通过try…catch来捕获

​ 4.故意制造一个异常

​ throw new 异常类()

​ 5.声明异常(甩锅)

​ throws

​

​ 6.为什么要自定义异常

​ 在实际开发过程中有很多异常是jdk没有帮我们定义好的,比如age负数或超出范围异常,

​ 因此我们需要根据实际的业务自定义异常,从而达到见名知意

​ 7.如何自定义异常

​ 继承RuntimeException,调用父类中的空参/带参构造方法

如何处理时间序列异常值?理解、检测和替换时间序列中的异常值 (欢迎来到异常值是与正常行为有显著偏差的观察结果。时间序列可能会因某些异常和非重复事件而出现异常值。这些异常值会影响时间序列分析,并误导从业者得出错误的结论或有缺陷的预测。因此,识别和处理异常值是确保时间序列建模可靠性的关键步骤。在时间序列中,异常值通常分为两种类型:加性异常值和创新异常值。 阅读详情

相关推荐

时间序列异常值检测方法

本博客将介绍几种常用的时间序列异常值处理方法,包括基于统计学的传统方法,如Z-score、IQR(四分位距)法,以及基于机器学习的更先进技术,如孤立森林(Isolation Forest)。我们将详细探讨这些方法的优缺点,应用场景及其在实际项目中的适用性。此外,本博客还会结合代码示例,演示如何使用Python处理时间序列中的异常值,

u012121721的博客 2209

6-66.时间

【代码】6-66.时间。

weixin_73121626的博客 1136

C#程序突然崩溃怎么办?5分钟学会分析Dump文件(Visual Studio 2022实战)

本文详细介绍了在C#程序崩溃或无响应时,如何捕获并分析Dump文件以快速定位问题。通过Visual Studio 2022实战演示,重点讲解了配置符号服务器、解读调用堆栈与内存状态,以及针对CPU飙高、内存泄漏等典型场景的分析方法,帮助开发者高效进行故障诊断。

docker8compose的博客 476

7. 输入一个时间(小时 : 分钟: 秒),输出该时间经过 5 分 30 秒后的时间

输入一个时间(小时 : 分钟: 秒),输出该时间经过 5 分 30 秒后的时间一、思路:   split的用法。二、代码:hour, minute, second = input('请输入一个时间( h:m:s): \n').split(':') hour = int(hour) minute = int(minute) second = int(second) second = second +...

CruiseZhang 1万+

洛谷 P5736 【深基7.例2】质数筛

题目描述 输入 n(n\le100)n(n≤100) 个不大于 100000 的整数。要求全部储存在数组中,去除掉不是质数的数字,依次输出剩余的质数。 输入格式 无 输出格式 无 输入输出样例 输入 #1 复制 5 3 4 5 6 7 输出 #1 复制 3 5 7 板子题,使用一下线性筛 #include &lt;iostream&gt; #include &lt;cstdio&gt; #include &lt;cstring&gt; #include &lt;algorithm&gt; using n

qq_37978559的博客 1119

避开PSRR仿真三大坑:用Cadence psspxf分析分频器时,这些设置错了白忙活

本文深入探讨了使用Cadence psspxf工具进行分频器PSRR仿真时常见的三大技术陷阱,包括扰动信号参数设置、收敛性优化和后处理信号提取。通过详细的参数推荐和实战技巧,帮助工程师避免仿真误差,提升PSRR分析效率与准确性,特别适用于16分频器等数字-模拟混合电路设计。

weixin_29258297的博客 304

C++中的try catch

先来看一个简单的程序:

认知 行动 坚持 7590

Unity3D赛车游戏+脚本基础

本章主要介绍Unity的基础开发流程以及涉及到的概念。这个过程需要我们学会编写一些游戏脚本,在这讲的过程中我们会完成一个赛车小游戏,因此,在讲述这些基本概念和流程的时候,会同时涉及到一点脚本的开发基础.在游戏,电影和动画中,都有一个渲染的帧率,电影是24帧/s,游戏大概是30帧/s(当然也有60帧/s的)。在unity里面1秒钟,Update方法执行了30次。1秒钟有30帧,帧与帧之所消耗的时间是不一样的,那么我如何知道上一帧用了多少时间?Time.deltaTime就是为了解决这个问题。

m0_58367586的博客 7660

【初学python】:输入秒数,输出对应小时/分钟/秒

初学python:输入秒数,输出对应小时/分钟/秒

qq_45713510的博客 1万+

在 SAP BTP ABAP 环境里直连 ABAP On-Premise OData

摘要 SAP BTP ABAP Environment 2311版本后,OData集成链路迎来重大改进:Service Consumption Model升级为v2版本,通过压缩模型到单一类减少对象数量;通信管理推荐采用Communication Arrangement替代传统Destination,提供更清晰的治理边界。新版支持同时生成OData v2/v4消费模型,并通过标准工厂类创建代理。配置需关注四层对象:Outbound Service声明协议入口,Scenario定义认证方式,System描述通

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 1923

YOLO26改进策略【Neck】| ICCV2025 反向卷积 Converse2D 数学逆运算提重构 + 特征域建模降伪影,提升多尺度目标检测精度

本文记录的是利用Converse2D 算子改进 YOLO26 的上采样。(Converse 2D Convolution)通过正则化最小二乘闭式解与深度化空间建模结合,实现YOLO26特征提取与上采样阶段的卷积逆运算及特征精准重构。本文利用算子,通过闭式解的非迭代计算还原卷积下采样后的原始特征,再通过可学习核与自适应正则化参数稳定逆问题求解,同时依托圆形填充与插值初始估计保留特征高频细节,对YOLO26中不同尺度检测目标的特征进行针对性重构强化、抑制卷积/转置卷积带来的伪影与信息损失干扰,在特征融合与上采样

Limiiiing的博客 661

PTA(四十四)面向对象程序设计 实验六 Fill-in-Blank - P 未做

下面程序定义栈类模板StackTemplate,创建栈对象存储斐波那契数列的前10项数值,并以后进先出的方式取出元素并输出,输出结果为:55 34 21 13 8 5 3 2 1 1。其中void push(const T&amp; i)函数为添加元素、T pop()函数为取出栈顶元素,int fibonacci(int n)函数为计算斐波那契数列的第n项值。在计算斐波那契数列值、添加元素和取出元素的过程中要进行上溢(OverFlow)或者下溢(UnderFlow)的异常处理。请补充空白处的代码(每空1分)

m0_50997138的博客 467

GNN-图卷积模型-直推式-2016:GCN【消息传递(前向传播):聚合函数+更新函数】【聚合函数:mean(邻域所有节点取平均值)】【训练更新函数的参数】【空域+频域】【同质图】

图神经网络(GNN):GCN【开山之作】

u013250861的博客 2056

Primavera P6 EPPM R18.8.X Patch/Update(补丁/更新)

内容纯干货,全部摘自于ORACLE服务支持网站 Oracle Support,涉及的内容也全为原版英文,需要的朋友可以找工具翻译,内容不包含对应的具体patch(补丁更新)文件

Oracle Primavera P6 & Unifier 项目(协同)管理 1753

基于Python的上市公司年报PDF文本抓取与财务风险分析系统

随着大数据时代的到来,金融数据分析已成为投资决策和风险管理的重要工具。上市公司年报包含了丰富的财务信息和经营数据,通过对这些数据的提取和分析,可以评估公司的财务状况和潜在风险。本文将详细介绍如何使用Python构建一个完整的上市公司年报文本抓取与财务风险分析系统,涵盖PDF文本提取、数据清洗、财务指标计算和风险分析等全流程。

2201_76125261的博客 314

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

时间序列中的异常检测&孤立森林&异常可视化-lstm-arivm

指标值的突然上升或下降是一种异常行为,这两种情况都需要注意。如果我们在建模之前就有异常行为的信息,那么异常检测可以通过监督学习算法来解决,但在没有反馈的情况下,最初很难识别这些点。因此,我们可以使用孤立森林(Isolation Forest)、支持向量机和LSTM等算法将其建模为一个无监督问题。下面使用孤立森林识别异常点。 这里的数据是一个用例(如收益、流量等),每天有12个指标。我们必须首先确定在用例级别上是否存在异常。然后,为了获得更好的可操作性,我们深入到单个指标,并识别其中的异常情况。 现在

沐阳的博客 6872

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

时间序列中的6大类10种异常值处理方法(从根源上提高预测精度)

本文介绍的内容是在时间序列中异常值处理的方法,当我进行时间序列分析建模收集数据的过程中,往往都存在着一些特数据情况导致数据中存在着一些异常值,这些异常值往往会导致模型识别到不正常的模式从而无法准确的预测, (我试验过一个数据集清楚之后MAE的精度甚至能提升0.1左右),所以对于异常值的检测和处理对于时间序列来说是十分重要的,本篇文章需要配合我的另一篇文章配合阅读,另一篇文章介绍了如何进行异常值检测,所以本文篇文章下面来介绍当我们检测出异常值之后如何进行异常值处理。

Snu77的博客 1万+

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

6-3 时间检测pta异常

本题要求输入小时、分钟和秒数,并将其输出。针对时间表示中出现的异常进行处理。例如小时数不应超过23,分钟不应超过59,秒数不应超过59。此外,以上三个变量均应大于等于0。在这里解释接口参数。在这里解释接口参数。例如:其中 h, m和 s 都是用户传入的参数,分别表示时、分、秒,函数应输出对应时间。本题要求输入小时、分钟和秒数,并将其输出。针对时间表示中出现的异常进行处理。/* 请在这里填写答案 */

2301_79963929的博客 927

基于Python的时间序列异常值检测

今天我们介绍几种常用的异常值检测方法,其中3sigma,z-score,箱体法(box)都是从数据值本身的单一维度去分析和判断异常值,从而有一定的局限性, 而多维度异常值判断法更注重从数据特征的各个维度去分析和判断异常值,显然多维度异常值判断法更为科学和精准。

weixin_42608414的博客 8274

登堂入室LSTM:使用LSTM进行简单的时间序列异常检测

登堂入室LSTM LSTM进行时间序列异常检测 示例数据下载 点击此处 此数据是1949 到 1960 一共 12 年,每年 12 个月的航班乘客数据,一共 144 个数据,单位是 1000。我们使用它来进行LSTM时间序列预测的实验。 数据如图所示 第一列为时间 第二列为数据 编写代码 头文件 import numpy import matplotlib.pyplot as plt from ...

小EZ的博客 2万+

[ java基础 ] 异常&日期时间类

异常 异常 :指的是程序在执行过程中,出现的非正常的情况,最终会导致JVM的非正常停止。 在Java等面向对象的编程语言中,异常本身是一个类,产生异常就是创建异常对象并抛出了一个异常对 象。Java处理异常的方式是中断处理。 注意:异常指的并不是语法错误,语法错了,编译不通过,不会产生字节码文件,根本不能运行. 异常体系 Throwable体系: Error:严重错误Error,无法通过处理的错误,只能事先避免,好比绝症。 Exception:表示异常,异常产生后程序员可以通过代码的方式纠正,使程序继续运

jason_bone_的博客 732

Day15 Java学习笔记之《时间日期类&异常&Optional》

文章目录1. 时间日期类1.1 Date类(应用)1.2 Date类常用方法(应用)1.3 SimpleDateFormat类(应用)1.4 时间日期类练习 (应用)2. JDK8时间日期类2.1 JDK8新增日期类 (理解)2.2 LocalDateTime创建方法 (应用)2.3 LocalDateTime获取方法 (应用)2.4 LocalDateTime转换方法 (应用)2.5 LocalDateTime格式化和解析 (应用)2.6 LocalDateTime增加或者减少时间的方法 (应用)2.7

weixin_46146855的博客 712

时间序列的异常检测与预测方法总结

以上就是全部内容了,如有问题,欢迎评论区一起交流。

心流的博客 8599

时间序列异常值处理方法

时间序列数据中的异常值处理是数据清洗中的重要环节,影响着模型的准确性和稳定性。常见的异常值检测方法包括统计法(如标准差法、IQR法)、基于模型的检测法(如ARIMA、SVR)以及机器学习方法(如孤立森林、DBSCAN)。处理异常值的方法包括替换法(均值填充、插值法)、删除法以及修正法(平滑处理、趋势修正)。针对不同类型的异常,选择合适的处理方法有助于提高数据质量和预测模型的表现。

u012121721的博客 1822

zjkal/time-helper 时间异常检测:异常时间点识别

在日常业务系统中,时间数据的准确性往往被忽视,但时间异常却可能导致严重的业务问题。想象一下这些场景: - 用户注册时间显示为1970年(Unix时间戳起始时间) - 订单创建时间比当前时间还要晚 - 日志记录的时间出现大幅度跳跃 - 节假日出现了异常的业务活动 这些时间异常不仅影响数据质量,更可能隐藏着系统漏洞、数据篡改或业务异常。`zjkal/time-helper` 作为一个功能强大的PH...

gitblog_00279的博客 713

日期类&异常

java日期类,异常,抛出捕获,自定义异常,练习题

a123hsbhbsbd的博客 1701
上一篇: 5常用API总结
下一篇: 7集合-List Collection集合 List集合 数据结构 List集合的实现类
InLoadwetrust
博客等级 码龄6年 11粉丝 84原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

InLoadwetrust

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值