1.知识点

1.1java api中的类型

java开头的包—java标准库中的提供好的内容
Javax开头的包—java标准库中提供好的支持拓展的api内容—x表示拓展的意思
org开头的包—-是java标准库支持的第三方的api内容

1.2补充：

网站的结尾有很多的方式：
.com——————-国际顶级域名
.cn———————-中国的国家顶级域名
.com.cn—————国际顶级域名中的中国顶级域名
.org———————第三方非盈利组织的域名—如阿帕奇—apach
.net———————互联网机构的网站
.gov——————-政府类型的网站

2.API常用类

2.1Date类：

  • 日期时间类：主要用于处理时间和日期的

  • 计算机中的时间：
  • 计算机的元年：1970年1月1号零时零分零秒—科学家定义的时间，用于定义计算机的时间，一个标记
  • 所以说，在计算机中计算时间的时候都是从这个时间开始的
  • 毫秒：1秒=1000毫秒
  • 毫秒的作用：可以对时间和日期进行计算

  • 世界时间：
  • 获取的地方—英国的格林威治小镇，中国的时间获取—陕西
  • 中国的时区在冬区：+8区，时间要比世界时间快8个小时

  • 日期类：
  • Date类是简单的一个操作日期的类，代表的是一个瞬间—-是一个动态值
  • 以毫秒为单位，距离1970年1月1号零时零分零秒到现在的时间的毫秒值
  • 处理这个值来实现年月日时分秒，星期，月份等等的获取

  • Date类方法

  • A：构造方法：

    1. public Date()            //返回当前时间
    1. public Date(long date)    //返回指定毫秒值的日期对象

  • B：普通方法：

  • public long getTime() //获取当前时间对象的毫秒值

  • public void setTime(long time) //设置时间毫秒值

    2.1.1Date对象转换为String案例

    DateFormat类是一个时间/日期格式类—抽象类，它语言无关的方式进行解析事件和日期

  • 格式化的类—SimpleDateFormat—-是DateFormat的子类—-普通类，用于解析日期格式


  • public final String format（Date date）：将一个Date格式化为时间/日期的字符串

  • 在创建SimpleDateFormat的时候，可以指定生成的的字符串的模板，规则可以查看api文档
  • 模板是一个字符串，代表转换的规则，特殊的字母代表组成部分 ```java package com.igeek_02;

/**

  • @author Lynn
  • @create 2020-12-04-10:00 */

import java.text.DateFormat; import java.text.SimpleDateFormat; import java.util.Date;

public class DateFormat2StringDemo { public static void main(String[] args) { //声明一个规则—字符串的模板—表示年月日时分秒 /**

  1.      * hh--表示12小时制的时间
  2.      * HH--表示24小时制的时间
  3.      */
  4.     String rule="yyyy年MM月dd日 HH:mm:ss";
  5.     //使用格式化的类来操作
  6.     DateFormat format=new SimpleDateFormat(rule);
  8.     //准备转换的数据
  9.     Date d=new Date();
  10.     //转换
  11.     String dNow=format.format(d);
  13.     //打印
  14.     System.out.println(d);
  15.     System.out.println(dNow);
  16. }

}

  1. <a name="iCwKC"></a>
  2. #### 2.1.2 String转换为Date对象
  3. **public Date parse（String source）throws ParseException--需要抛出一个异常**
  4. ```java
  5. package com.igeek_02;
  7. /**
  8.  * @author Lynn
  9.  * @create 2020-12-04-10:15
  10.  */
  12. import java.text.DateFormat;
  13. import java.text.ParseException;
  14. import java.text.SimpleDateFormat;
  15. import java.util.Date;
  17. /**
  18.  * String转换为Date对象
  19.  * public Date parse（String source）throws ParseException--需要抛出一个异常
  20.  */
  21. public class String2DateFormatDemo {
  22.     public static void main(String[] args) throws ParseException {
  23.         //声明一个规则--字符串的模板--表示年月日时分秒
  24.         /**
  25.          * hh--表示12小时制的时间
  26.          * HH--表示24小时制的时间
  27.          */
  28.         String rule="yyyy年MM月dd日 HH:mm:ss";
  29.         //使用格式化的类来操作--直接声明子类
  30.         SimpleDateFormat format=new SimpleDateFormat(rule);
  32.         //准备转换的数据
  33.         String sTime="2020年12月4日 10:19:50";
  34.         //转换
  35.         Date dTime=format.parse(sTime);
  37.         //打印
  38.         System.out.println(sTime);//2020年12月4日 10:19:50
  39.         System.out.println(dTime);//Fri Dec 04 10:19:50 CST 2020
  40.     }
  41. }

2.2Calendar

Calendar：日历api
因为Date这个api有大批量的方法被java弃用了（过时），因为Date中的很多的方法

  • 不能够完美的兼容世界的时间差

  • Calendar类就替代了Date类

  • Calendar类将各种时间的属性信息以字段的形式计算下来—可以将世界本地的时间信息做一个记录

  • 语法：
  • 创建Calendar类的时候，不使用构造函数，使用另一个实例化的方法，支持语言的敏感问题
  • 静态方法：getInstance();
  • 获取当前时间：Calendar now=Calendar.getInstance(); ```java package com.igeek_01;

/**

  • @author Lynn
  • @create 2020-12-04-10:26 */

import java.util.Calendar;

public class CalendarDemo { public static void main(String[] args) { //创建Calendar类 Calendar c=Calendar.getInstance(); System.out.println(c);//获取到的是具体的本地的时间信息

  1.     //获取值
  2.     int year=c.get(Calendar.YEAR);
  3.     System.out.println(year);
  4.     //月份需要+1
  5.     int month=c.get(Calendar.MONTH)+1;
  6.     System.out.println(month);
  7.     int day=c.get(Calendar.DAY_OF_MONTH);
  8.     System.out.println(day);
  10.     //设置年月日
  11.     //月份-1--返回到系统的时间
  12.     c.set(2008,8-1,8);
  13.     System.out.println(c);
  14. }

}

  1. <a name="Ewrrr"></a>
  2. ### 2.3 Math
  3. ```java
  4. package com.igeek_01;
  6. /**
  7.  * @author Lynn
  8.  * @create 2020-12-04-11:08
  9.  */
  11. /**
  12.  * Math是一个数学工具类--静态的
  13.  * 直接通过类名来调用
  14.  *
  15.  * Math中的所有方法都是静态方法
  16.  */
  17. public class MathDemo {
  18.     public static void main(String[] args) {
  19.         //访问静态常量
  20.         System.out.println(Math.PI);
  21.         System.out.println(Math.E);
  23.         //访问静态方法
  24.         //求绝对值
  25.         System.out.println(Math.abs(-102));
  26.         System.out.println(Math.abs(0));
  28.         //向下和向上取整，四舍五入
  29.         //浮点数类型
  30.         System.out.println(Math.ceil(1.2));
  31.         System.out.println(Math.floor(1.9));
  32.         //四舍五入--整型
  33.         System.out.println(Math.round(1.8));
  35.         //求平方
  36.         //第一个参数是数字，第二个参数是幂
  37.         System.out.println(Math.pow(4,3));
  39.         //求平方根
  40.         //浮点型
  41.         System.out.println(Math.sqrt(100));
  42.     }
  43. }

2.4 System

public static void exit(int status)：让操作系统终止该java程序 0代表正常终止
public static void gc()：暗示java虚拟机回收不使用的对象(垃圾)
public static String getProperty(String key) ：查找制定的系统属性 , 系统属性参照API

  1. /**
  2.  * @author Lynn
  3.  * @create 2020-12-04-11:19
  4.  */
  6. /**
  7.  * 系统类的api
  8.  * 包含了很多的系统信息--我们平时看不到，但是在系统中是不停运行的
  9.  *
  10.  * 字符：
  11.  * out：用于控制系统的输出
  12.  * in：用于控制系统的输入
  13.  *
  14.  * public static void exit(int status):让系统终止该java程序，0代表终止
  15.  * public static void gc():告知java虚拟机回收不使用的对象（垃圾）--没有被指向的对象
  16.  * public static void getProperty(String key):查找指定的系统属性，系统属性参考api
  17.  */
  18. public class SystemDemo {
  19.     public static void main(String[] args) {
  20.         //系统输出信息和错误输出
  21.         System.out.println("I Love java");
  22.         System.err.println("我就是个Bug");
  24.         //获取指定的系统
  25.         System.out.println(System.getProperty("os.name"));
  27.         System.gc();//没有直接回收对象，只是告知系统有回收的垃圾，然后系统会调用
  28.         //一个方法finalize()，这个方法执行之后才会正式回收垃圾
  30.         //终止java程序
  31.         System.exit(0);
  33.         //测试终止
  34.         System.out.println("能看到我吗");
  35.     }
  36. }

3.包装类

基本包装类型：

  • 基本包装类型是对象类型—-其实就是在基本类型的外层套上一个壳子，把基本类型封装成了
  • 对象类型—目的是为了调用包装类型中的属性和方法

  • java是一门oop的语言，八大基本类型是基本类型，在java中时bug的存在，以为八大基本类型使用
  • 的非常频繁，所以java就保留了这个类型。

  • 由于java是纯面向对象的编程语言，所以需要把基本类型包装成对象类型后才可以调用方法和属性-
  • 符合面向对象的语法。

  • 自动拆包装箱这个特性是jdk5.0推出的，包装类型是一直存在的

  • 汇总包装类的转换：

  • byte——-Byte
  • short——Short
  • int———Integer
  • long——-Long
  • float——Float
  • double—-Double
  • char——-Character
  • boolean—Boolean

  • 每一个基本类型包装成为对象类型后就有了自己的方法和属性的调用 ```java package com.igeek_baozhuanglei01;

/**

  • @author Lynn
  • @create 2020-12-07-9:23 */

import java.util.ArrayList;

public class PrimaryDemo { public static void main(String[] args) { //定义一个基本类型 int i=10; //将基本类型封装成包装类型—这个操作从jdk5.0开始就自动操作了 Integer ii=new Integer(i); //将包装类型拆箱为基本类型 int iii=ii.intValue(); System.out.println(iii);

  1.     //演示自动拆包装箱
  2.     Integer i1=200;
  3.     System.out.println(i1);
  4.     String s1="hello";
  5.     System.out.println(s1);
  7.     //集合可以直接保存基本类型--这个基本类型已经自动转换为包装类型
  8.     ArrayList<Integer> list=new ArrayList<>();
  9.     list.add(1);
  10.     /*list.add('a');
  11.     list.add(1.01);*/
  13.     /*//定义一个包装类型
  14.     Integer ii=new Integer(10);
  16.     //尝试调用方法和属性
  17.     System.out.println(ii.MAX_VALUE);
  18.     System.out.println(ii.MIN_VALUE);*/
  19. }

}

  1. <a name="f9O6f"></a>
  2. # 4.正则表达式
  3. 正则表达式：
  5. - 是一个第三方的规则，主要是用来匹配字符串的格式，**不是java中的内容**--
  6. - 几乎所有的编程语言都会为正则表达式预留接口，用于支持正则表达式的使用
  7. - <br />
  8. - 具体的语法可以参阅文档，在平时使用中通常会去网上查找，正则表达式没有完美的，
  9. - 其实就是一个匹配的规则
  10. - <br />
  11. - 网站：[http://tool.chinaz.com/regex/](http://tool.chinaz.com/regex/)
  12. - 我们学习的要求是能够看懂并且做修改
  13. - <br />
  14. - 模拟写一个正则表达式：
  15. - 步骤：
  16. - 1.明确正确的匹配结果
  17. - 2.利用正则表达式的语法去写
  19. 举例：
  21. - QQ号：
  22. - 要求：
  23. - 1.QQ号长度
  24. - 2.不能以0开头
  25. - 3.只能是数字
  26. - 结果分析：
  27. - [1-9]([0-9]{5,11})
  28. - [1-9]---以1-9数字开头
  29. - ()用于分组
  30. - [0-9]{5,11}---任何一个数字可以出现5-11次
  31. - <br />
  32. - 手机号码：
  33. - 0?(13|14|15|17|18|19)[0-9]{9}
  34. - 0?---出现一次或者0次
  35. - (13|14|15|17|18|19)--分组--手机号的开头两个数字
  36. - [0-9]{9}--从第三个数字开始就可以随便写，有9个数字
  37. - <br />
  38. - java中对正则表达式是支持的，regex--匹配字符串的规则
  39. - <br />
  40. - 这里使用方法是字符串中的：
  41. - Boolean match（String regex）:
  42. - 被匹配的字符串调用的方法，接收正则表达式字符串，如果匹配则返回true，否则返回false
  43. - <br />
  44. - String[] split（String regex）：
  45. - 根据正则表达式的匹配来返回字符串类型的数组，如果符合就匹配为分隔符，讲一个完整地字符串
  46. - 通过这些分隔符切割为不同的字符串
  47. ```java
  48. package com.igeek_zhengze01;
  50. /**
  51.  * @author Lynn
  52.  * @create 2020-12-07-10:21
  53.  */
  55. public class PegexDemo {
  56.     public static void main(String[] args) {
  57.         //验证手机号
  58.         String phone="15527590889";
  59.         //准备一个正则表达式
  60.         String regex="0?(13|14|15|17|18|19)[0-9]{9}";
  61.         //进行匹配
  62.         boolean flag=phone.matches(regex);
  63.         System.out.println(flag);
  65.         System.out.println("----------------------------------------");
  67.         String s="Lilei       love       Hanmeimei";
  68.         //准备一些规则
  69. //        String sRegex=",";//切割失败
  70. //        String sRegex="[ ,]";//匹配的是空格或者，--空格保留
  71.         String sRegex=" ";//根据空格切割--空格保留
  72. //        String sRegex=" +";//匹配一个或者多个空格--空格全部替换掉了
  74.         //尝试切割
  75.         String[] arr=s.split(sRegex);
  76.         //遍历数组
  77.         for (int i = 0; i < arr.length ; i++) {
  78.             System.out.println(arr[i]);
  79.         }
  80.     }
  81. }