2017

1 正则表达式
(1)符合一定规则的字符串
(2)正则表达式组成规则
A:  字符 
x   字符x  举例：'a'表示字符a
\\  反斜线字符 \
\n  换行符('\u000A')
\r  回车符('\u000D')

B:  字符类
[abc]    a、b或者c(简单类)
[^abc]   任何字符，除了a、b或c
[a-zA-Z] a到z 或A到Z 两头的字母包括在内(范围)
[0-9] 0到9的字符都包括

C:预定义字符类
.     任何字符。 我的就是.字符本身，怎么表示？ \.
\d    数字：[0-9]
\D    非数字：[^0-9]
\w    单词字符：[a-zA-Z_0-9]
          在正则表达式里面组成单词的东西必须有这些东西组成

D:边界匹配器
^    行的开头   
$    行的结尾
\b   单词边界
        就是不是单词字符的地方
        举例：hello78？asdf；ads          ？ 和； 是单词边界

E：Greedy 数量词
X? X，一次或一次也没有
X* X， 零次或多次
X+ X，一次或多次
X{n} X，恰好n次
X{n,} X，至少n次
X{n,m} X，至少n次，但是不超过m次

2  正则表达式的判断功能

  String 类的public boolean matches(String regex)

  需求：判断手机号码是否满足需求
  分析：
    A:键盘录入手机号码
    B:定义手机号码的规则
       13436799954
       13123456789
       18123456789
       18987564231
    C:调用功能，判断即可
    D:输出结果
  
    Scanner sc = new Scanner(System.in);
    System.out.println("请输入你的手机号码：");
    String phone = sc.nextLine();
    //定义手机号码的规则
    String regex = "1[38]\\d{9}";//1开头然后是3或者8 然后0-9 9次
    //调用功能，判断即可
    boolean flag = phone.matches(regex);

   例子：邮箱校验案例
       [e-mail]
       [e-mail]
       [e-mail]
       [e-mail]
     
     //开头任意字母或数组 次数1次以上（+） 然后是@ 然后任意字母或数字 次数2-6   然后. 然后任意字母或数字 次数2-3次

     String regex = "[a-zA-Z_0-9]+@[a-zA-Z_0-9]{2,6}\\.[a-zA-Z_0-9]{2,3}"

3 正则表达式的分割功能
   String类的public String[] split(String regex)
       根据给定正则表达式的匹配拆分此字符串
   举例： 
      百合网，世纪佳缘，珍爱网
   搜索好友：
        性别：女
        范围:"18-24"
        age>=18 && age<=24
   //定义一个年龄搜索范围
   String ages = "18-24";
   //定义规则
   String regex = "-";
   //调用方法
   String[] strArray = ages.split(regex);
   //遍历
   for(int x=0;x<strArray.length;x++){
          System.out.println(strArray[x]);
     }
   //输出 18  24

   //如何得到int类型的呢？
   int startAge = Integer.parseInt(strArray[0]);
   int endAge = Integer.parseInt(strArray[1]);
   
   //键盘录入年龄
   Scanner sc = new Scanner(System.in);
   System.out.println("请输入你的年龄:");
   int age = sc.nextInt();
   if(age>=startAge && age <=endAge){
         System.out.println("符合要求");
     }else{
         System.out.println("不符合要求");
      }
   // 输入30 不符合要求   输入20 符合要求
-----------------------
分割功能练习
A---------------------- 
  //定义一个字符串
  String s1 = "aa,bb,cc";
  //直接分割
  String[] str1Array = s1.split(",");
  for(int x = 0;x<str1Array.length;x++){
       System.out.println(str1Array[x]);
    }
  //输出 aa
         bb 
         cc
B-----------------------
  String s2 = "aa.bb.cc";
  String[] str2Array = s2.split("\\.");
  for(int x = 0;x<str2Array.length;x++){
       System.out.println(str2Array[x]);
    }
  //输出 aa
         bb 
         cc
C------------------------
  String s3 = "aa bb                 cc";
  String[] str3Array = s3.split(" +"); //空格+
  for(int x = 0;x<str3Array.length;x++){
       System.out.println(str3Array[x]);
    }
  //输出 aa
         bb 
         cc
**D------------------------
  // 硬盘上的路径，我们应该用\\替代
  String s4 = "E:\\JavaSE\\day14\\avi";
  String[] str4Array = s4.split("\\\\"); //\\\\代表\\
  for(int x = 0;x<str4Array.length;x++){
       System.out.println(str4Array[x]);
    }
   
4 正则表达式的替换功能
  String类的public String repalceAll(String regex,String replacement)
  使用给定的replacement 替换此字符串所有匹配给定的正则表达式的子字符串

  //定义一个字符串
  String s = "hello12345world6221123456789java";
  //我要去除所有的数字，用*给替换掉
  String regex = "\\d+";
  String ss = "*"; //给一个*  当把+去掉时，有多少的数字给多少的*
  String result = s.replaceAll(regex,ss);
  
  //直接去掉数字，不给*
  String regex = "\\d+";
  String ss = ""; 
  String result = s.replaceAll(regex,ss);

5 获取功能
   Pattern 和Matcher类的使用
   模式和匹配器的基本使用顺序

  //模式和匹配器的典型调用顺序
  //把正则表达式编译成模式对象
  Pattern p = Pattern.compile("a*b");
  //通过模式对象得到匹配器对象，这个时候需要的是被匹配的字符串
  Matcher m = p.matcher("aaaab");
  //调用匹配器对象的功能
  boolean b = m.matches();
  System.out.println(b);
  //输出：true
  
  //这个是判断功能，但是如果做判断，这样就有点麻烦，我们直接用字符串的方法做
  String s = "aaaab";
  String regex = "a*b";
  boolean bb = s.matches(regex);
  System.out.println(bb);
  //输出：true
----------------------
  获取功能： 获取下面这个字符串中由三个字符串组成的单词
  da jia ting shuo guo mei ,jin tian shi ge hao tian qi,ke yi chu qu wan l 。
  
  //定义字符串
  String s ="  da jia ting shuo guo mei ,jin tian shi ge hao tian qi,ke yi chu qu wan l 。";
  //规则
  String regex ="\\w{3}\\b"; //\\b 表示没有边界
  //把规则编译成模式对象
  Pattern p = Pattern.compile(regex);
  //通过模式对象得到匹配器对象
  Matcher m = p.matcher(s);
------------------------------------
  //调用匹配器对象的功能
  //通过find方法 就是查找有没有满足条件的子串
  // public boolean find()
  boolean flag = m.find();
  System.out.println(flag);
  //如何得到值呢？
  //public String group()
  String ss = m.group();
  System.out.println(ss);

  // 再来一次
  flag = m.find();
  System.out.println(flag);
  ss = m.group();
  System.out.println(ss);

  //输出 true 
         jia  guo mei jin shi hao chu wan
-------------------标准代码--------------------------
  while(m.find()){
    System.out.println(m.group());
}
  //输出： jia guo mei jin shi hao chu wan 
-----------注意：一定要先find(),然后才能group()-------
     String ss = m.group();
     System.out.println(ss);

6 Math 类概述及其成员方法
  用于数学运算的类
(1)成员变量：
public static final int double PI  π
public static final int double E   自然对数 2.7....
(2)成员方法：
public static int abs(int a):绝对值
public static double ceil(double a)：向上取整
public static double floor(double a)：向下取整
public static int max(int a,int b)：最大值(min最小值)
public static double pow(double a,double b):a的b次幂
public static double random():随机数[0.0 ,1.0)
public static int round(float a):四舍五入(参数为double的自学)
public static double sqrt(double a):返回正平方根

***7 面试题
  需求：请设计一个方法，可以实现任意范围内的随机数
  分析：
    A:键盘录入两个数据
        int start;
        int end;
    B:想办法获取在start和end之间的随机数(int)
    C:输出这个随机数
    public static int getRandom(int start,int end){
        int number = (int)(Math.random()*(end-start+1))+start;  //+1 是因为 例如范围在200-300  但它取不到300所以，用加1 然后int转换一下
        return number;
    }

8 Random 类
  产生随机数
构造方法：
   public Random():没有给种子，用的是默认种子，是当前时间的毫秒值
   public Random(long seed):给出指定的种子
  **给定种子后，每次得到的随机数都是相同的
成员方法：
   public int nextInt():返回的是int范围内的随机数
   public int nextInt(int n):返回的是(0,n)范围内的随机数
--------------------------------------
   Random r = new Random();
   for(int x = 0;x < 10;x++){
     int num = r.nextInt(100);
     System.out.println(num);
  }
  //返回0到100的随机数 10个
--------------------------------------
   Random r = new Random(1111);
   for(int x = 0;x < 10;x++){
     int num = r.nextInt(100);
     System.out.println(num);
  }
  //45 8 98  54 21....第一次输出
  //45 8 98  54 21....第二次输出

9 System类中垃圾回收的方法gc()

(1)System 类包中一些有用的类字段和方法。它不能被实例化。 

public static void gc(): 运行垃圾回收器

public static void exit(int status):终止当前正在运行的java虚拟机，参数用作状态码：根据惯例，非0的状态码表示异常终止---0表示正常终止。

public static long currentTimeMillis():返回当前时间与协调世界1970年1月1日午夜之间的时间差（以毫秒为单位）------为什么以1970年----(1)因为UNIX系统认为1970年1月1日是时间纪元(2)32位操作系统最大存68年的时间数据，所以综合考虑下取得这个时间。

public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length):从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组指定的位置结束----------命名规范不正确，因为很久以前的关系，目前用的人较多，改了之后比较麻烦，所以就没改了。

(2)---System.gc()----------------------
@Override
protected void finalize() throws Throwable{
      System.out.println("当前的对象被回收了"+this);
      super.finalize();
}

Person p = new Person("林下",60);
System.out.println(p);
p =null;//让p不再指定堆内容
System.gc();
//输出：Person[name=林下，age=60]
        当前的对象被回收了Person[name=林下，age=60]

    在没有明确指定资源清理的情况下，java提高了默认机制来清理该对象的资源，就是调用object类的finalize()方法。------------相当于c++中的析构函数，与构造函数相反。
----**从程序的运行结果可以发现，执行System.gc()前，系统会自动调用finalize()方法清除对象占有的资源，通过super.finalize()方法可以实现从下到上的finalize()方法的调用，即先释放自己的资源，再去释放父类的资源。**----
    但是，不要在程序中频繁的调用垃圾回收，因为每一次执行垃圾回收，jvm都会强制启动垃圾回收器运行，这会耗费更多的系统资源，会与正常的java程序运行争抢资源，只有在执行大量的对象的释放，才调用垃圾回收最好。
(3)---System.exit(0)----------------------
 System.out.println("11111111");
 System.exit(0);
 System.out.println("22222222")；
 /输出 11111111
(4)---System.currentTimeMillis()----------
  //可以得到实际目前时间，但意义不大，
  //那么，它到底有很么用呢？
  //要求：统计这段程序的运行时间
  long start =System.currentTimeMillis();
  for(int x =0;x<10000;x++){
      System.out.println("helloworld!");
   }
  long end =System.currentTimeMillis();
(5)---System.arraycopy(Object src,int srcPos,Object dest,int destPos,int length)---------------
src - 源数组
srcPos - 源数组中的起始位置
dest - 目标数组
destPos - 目标数组的起始位置
length - 要复制的数组元素的数量

//定义数组
  int[] arr = {11,22,33,44,55};
  int[] arr2 ={6,7,8,9,10}
  System.arraycopy(arr,1,arr2,2,2)；
  System.out.println(Arrays.toString(arr));
  System.out.println(Arrays.toString(arr2));
  //输出 {11,22,33,44,55}
         {6,7,22,33,10}

10 BigInteger
   BigInteger：可以让超过Integer范围内的数据进行运算
-------------------------
  测试
  Integer i = new Integer(100);
  System.out.println(i);         //输出100
  //System.out.println(Integer.MAX_VALUE);// 输出2147483647
  Integer ii = new Integer(2147483647);
  System.out.println(ii);        //输出2147483647
  Integer iii = new Integer(2147483648);
  System.out.println(iii);       //报错 因为Integer最大范围是2147483647
---------------------------
  BigInteger bi = new BigInteger("2147483648");
  System.out.println("bi:"+bi);
  //bi:2147483648

11 BigInteger 的加减乘除
public BigInteger add(BigInteger val)  ： 加
public BigInteger subtract(BigInteger val) ：减
public BigInteger multiply(BigInteger val) ： 乘
public BigInteger divide(BigInteger val) ：除
public BigInteger[] divideAndRemainder(BigInteger val)：返回商和余数的数组--------返回一个BigDecimal数组，返回数组包含两个元素，第一个元素为两数相除的商，第二个元素为余数

12 BigDecimal
   由于在运算的时候，float类型和double类型很容易失去精度，为了能精确的表示，计算浮点数，java提供了BigDecimal
   BigDcimal：可以解决精度问题
   例如：
   System.out.println(0.09 + 0.01);
   System.out.println(1.0 - 0.32);
   System.out.println(1.015 * 100);
   System.out.println(1.301 / 100);
   //输出： 0.099999999999...
            0.679999999999...
            101.4999999999... 
            0.013009999999...
   System.out.println(1.0 - 0.12);
   //输出   0.88  (正好)


13 BigDecimal 的加减乘除
构造方法：
     public BigDecimal(String val)

成员方法：
public BigDecimal add(BigDecimal augend)
public BigDecimal subtract(BigDecimal subtrahend)
public BigDecimal multiply(BigDecimal multiplicand)
public BigDecimal divide(BigDecimal divisor)
public BigDecimal divide(BigDecimal divisor,int scale,
     int roundingMode)

  BigDecimal bd1 = new BigDecimal("0.09");
  BigDecimal bd2 = new BigDecimal("0.01");
  System.out.println("add:"+bd1.add(bd2));
  //输出0.1

  BigDecimal bd1 = new BigDecimal("1.301");
  BigDecimal bd2 = new BigDecimal("100");
  System.out.println("divide:"+bd1.divide(bd2));
  System.out.println("divide:"+bd1.divide(bd2,3,BigDecimal.ROUND_HALF_UP))
  System.out.println("divide:"+bd1.divide(bd2,8,BigDecimal.ROUND_HALF_UP))
  //输出 0.01301
         0.013
         0.01301000

14 Date类
   在jdk1.1之前，类Date有两个其他的函数，它允许把日期解释为年，月，日，小时，分钟，和秒值，它也允许格式化和解析日期字符串，不过，这些函数的API不易于实现国际化，从jdk1.1开始，应该使用Calendar类实现日期和事件字段之间转换，使用DateFormat类来格式化和解析日期字符串，Date中的相应方法已废弃。

   Date：表示特定的时间，精确到毫秒
   构造方法：
     Date():根据当前的默认毫秒值创建日期对象
     Dtate(long date):根据给定的毫秒值创建日期对象
   //创建对象
   Date d = new Date();
   System.out.println("d:"+d);
   //创建对象
   long time = System.currentTimeMillis();
   Date d2 = new Date(time);
   System.out.println("d2:"+d2);
   //输出： d:Wed Nov 12 15:32:47  CST2017
            d2:Wed Nov 12 15:32:47  CST2017

15 DateFormat类实现日期和字符串的相互转换
   Date---String(格式化)
         public final String format(Date date)
   String---Date(解析)
         public Date parse(String source)
 
   DateFormat：可以进行日期和字符串的格式化和解析，但是由于是抽象类，所以使用具体子类SimpleDateFormat

 SimpleDateFormat的构造方法：
   SimpleDateForamt();默认模式
   SimpleDateFormat(String pattern):给定的模式
    这个模式字符串该如何写呢？
    通过查看API，我们就找到了对应的模式
    年 Y
    月 M
    日 d    
    时 H
    分 m 
    秒 s
         2014年12月12日12:12:12
-----------------------------
   //Date -- String  
   //创建日期对象
   Date d = new Date();
   //创建格式化对象
   SimpleDateFormat sdf = new SimpleDateFormat();
   String s = sdf.format(d);
   System.out.println(s);
   //输出  14-11-12 下午3:49

    Date d = new Date();
   //创建格式化对象
   SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH：mm：ss");
   String s = sdf.format(d);
   System.out.println(s);
   //输出 2014年11月12日 15:54
------------------------------
   //String -- Date
   String str = "2008-08-08 12:12:12"
   //在把一个字符串解析为日期的时候，请注意格式必须和给定的字符串格式匹配
   SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd- HH：mm：ss");
   Date dd = sdf2.parse(str);
   System.out.println(dd);
   //输出 Fri Aug 08 12:12:12 CST 2008

16 Calendar

public static Calendar getInstance()
public int get(int field)
public void add(int field,int amount)：根据给定的日历字段和对应的时间，来对当前的日历字段进行操作

public final void set(int year,int month,int date)：设置当前日历的年月日

   Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等 日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。

  //某日历字段已由当前日期和时间初始化
   Calendar rightNow = Calendar.getInstance(); //子类对象
  //获取年
  int year = rightNow.get(Calendar.YEAR);
  //获取月
  int month = rightNow.get(Calendar.MONTH);
  //获取日
  int date = rightNow.get(Calendar.DATA);
  System.out.println(year+"年"+(month+1)+"月"+data+"日");
  //输出 2014年11月12日 

  //三年前的今天
  Calendar c = Calendar.getInstance();
  c.add(Calendar.YEAR,-3);
  //获取年
  int year = c.get(Calendar.YEAR);
  //获取月
  int month = c.get(Calendar.MONTH);
  //获取日
  int date = c.get(Calendar.DATA);
  System.out.println(year+"年"+(month+1)+"月"+data+"日");
  //输出： 2011年11月12日

  //五年后的十天前
  Calendar c = Calendar.getInstance();
  c.add(Calendar.YEAR,5);
  c.add(Calendar.DATE,-10);
  //获取年
  int year = c.get(Calendar.YEAR);
  //获取月
  int month = c.get(Calendar.MONTH);
  //获取日
  int date = c.get(Calendar.DATA);
  System.out.println(year+"年"+(month+1)+"月"+data+"日");
  //输出： 2016年11月2日

  c.set(2011,11,11);
  //获取年
  int year = c.get(Calendar.YEAR);
  //获取月
  int month = c.get(Calendar.MONTH);
  //获取日
  int date = c.get(Calendar.DATA);
  System.out.println(year+"年"+(month+1)+"月"+data+"日");
  //输出： 2011年11月11日