JAVA学习笔记12_Java语言基础（正则表达式 ）

###14.01_常见对象(正则表达式的概述和简单使用)
* A:正则表达式
    * 是指一个用来描述或者匹配一系列符合某个语法规则的字符串的单个字符串。其实就是一种规则。有自己特殊的应用。
    * 作用:比如注册邮箱,邮箱有用户名和密码,一般会对其限制长度,这个限制长度的事情就是正则表达式做的

###14.02_常见对象(字符类演示)

* A:字符类

中括号 【】 代表单个字符

    * [abc] a、b 或 c（简单类） 

String regex = "[abc]";					//[]代表单个字符
		System.out.println("a".matches(regex));
		System.out.println("b".matches(regex));
		System.out.println("c".matches(regex));

    * [^abc] 任何字符，除了 a、b 或 c（否定） 

		String regex = "[^abc]";
		System.out.println("a".matches(regex));//false
		System.out.println("b".matches(regex));
		System.out.println("c".matches(regex));
		System.out.println("d".matches(regex));//true
		System.out.println("1".matches(regex));
		System.out.println("%".matches(regex));
		System.out.println("10".matches(regex));		//10代表1字符和0字符,不是单个字符 false

    * [a-zA-Z] a到 z 或 A到 Z，两头的字母包括在内（范围）

String regex = "[a-zA-Z]";
		System.out.println("a".matches(regex));
		System.out.println("A".matches(regex));
		System.out.println("z".matches(regex));
		System.out.println("Z".matches(regex));
		System.out.println("1".matches(regex));
		System.out.println("%".matches(regex));

    *[a-d[m-p]] a 到 d 或 m 到 p：[a-dm-p]（并集） 
    *[a-z&&[def]] d、e 或 f（交集） 
    *[a-z&&[^bc]] a 到 z，除了 b 和 c：[ad-z]（减去） 
    *[a-z&&[^m-p]] a 到 z，而非 m 到 p：[a-lq-z]（减去） 

    * [0-9] 0到9的字符都包括

###14.03_常见对象(预定义字符类演示)
* A:预定义字符类
         . 任何字符

\d 数字：[0-9] 

String regex = "\\d";					//\代表转义字符,如果想表示\d的话,需要\\d
System.out.println("0".matches(regex));
System.out.println("a".matches(regex));
System.out.println("9".matches(regex));

\D 非数字： [^0-9] 

\s 空白字符：[ \t\n\x0B\f\r] 

String regex = "\\s";
System.out.println(" ".matches(regex));
System.out.println("	".matches(regex)); 				//一个tab键 true
System.out.println("    ".matches(regex)); 				//四个空格 false

\S 非空白字符：[^\s] 
\w 单词字符：[a-zA-Z_0-9] 
\W 非单词字符：[^\w] 
###14.04_常见对象(数量词)
* A:Greedy 数量词 
    * X? X，一次或一次也没有
    * X* X，零次或多次
    * X+ X，一次或多次
    * X{n} X，恰好 n 次 
    * X{n,} X，至少 n 次 
    * X{n,m} X，至少 n 次，但是不超过 m 次 

String regex = "[abc]{5,15}";
System.out.println("abcba".matches(regex));
System.out.println("abcbaabcabbabab".matches(regex));
System.out.println("abcb".matches(regex));
System.out.println("abcbaabaabcbaaba".matches(regex));

###14.05_常见对象(正则表达式的分割功能)
* A:正则表达式的分割功能
    * String类的功能：public String[] split(String regex)
* B:案例演示

String s = "金三胖.郭美美.李dayone";
String[] arr = s.split("\\.");				//通过正则表达式切割字符串
		
for (int i = 0; i < arr.length; i++) {
	System.out.println(arr[i]);
}

结果：

金三胖
郭美美
李dayone

###14.06_常见对象(把给定字符串中的数字排序)
* A:案例演示
    * 需求：我有如下一个字符串:”91 27 46 38 50”，请写代码实现最终输出结果是：”27 38 46 50 91”

package com.heima.test;

import java.util.Arrays;

public class Test1 {

	/**
	 * 分析:
	 * 1,将字符串切割成字符串数组
	 * 2,将字符串转换成数字并将其存储在一个等长度的int数组中
	 * 3,排序
	 * 4,将排序后的结果遍历并拼接成一个字符串
	 */
	public static void main(String[] args) {
		String s = "91 27 46 38 50";
		//1,将字符串切割成字符串数组
		String[] sArr = s.split(" ");
		//2,将字符串转换成数字并将其存储在一个等长度的int数组中
		int[] arr = new int[sArr.length];
		for (int i = 0; i < arr.length; i++) {
			arr[i] = Integer.parseInt(sArr[i]); 	//将数字字符串转换成数字
		}
		
		//3,排序
		Arrays.sort(arr);
		
		//4,将排序后的结果遍历并拼接成一个字符串27 38 46 50 91
		StringBuilder sb = new StringBuilder();
		for (int i = 0; i < arr.length; i++) {
			if(i == arr.length - 1) {
				sb.append(arr[i]);
			}else {
				sb.append(arr[i] + " ");
			}
		}
		
		System.out.println(sb);
	}

}

###14.07_常见对象(正则表达式的替换功能)
* A:正则表达式的替换功能
    * String类的功能：public String replaceAll(String regex,String replacement)
* B:案例演示

String s = "wo111ai222heima";
String regex = "\\d";			//   \\d代表的是任意数字
		
String s2 = s.replaceAll(regex, "");
System.out.println(s2);

输出：

woaiheima

###14.08_常见对象(正则表达式的分组功能)
* A:正则表达式的分组功能
    * 捕获组可以通过从左到右计算其开括号来编号。例如，在表达式 ((A)(B(C))) 中，存在四个这样的组： 
* 
        1     ((A)(B(C))) 
        2     (A 
        3     (B(C)) 
        4     (C) 
    
        组零始终代表整个表达式。
B:案例演示

   

//叠词 快快乐乐,高高兴兴
		String regex = "(.)\\1(.)\\2";					//\\1代表第一组又出现一次	\\2代表第二组又出现一次
		System.out.println("快快乐乐".matches(regex));
		System.out.println("快乐乐乐".matches(regex));
		System.out.println("高高兴兴".matches(regex));
		System.out.println("死啦死啦".matches(regex));

//叠词 死啦死啦,高兴高兴
		String regex2 = "(..)\\1";
		System.out.println("死啦死啦".matches(regex2));
		System.out.println("高兴高兴".matches(regex2));
		System.out.println("快快乐乐".matches(regex2));

String s = "sdqqfgkkkhjppppkl";
String regex = "(.)\\1+";					//+代表第一组出现一次到多次
String[] arr = s.split(regex);

for (int i = 0; i < arr.length; i++) {
	System.out.println(arr[i]);
}		

String s = "我我....我...我.要...要要...要学....学学..学.编..编编.编.程.程.程..程";
String s2 = s.replaceAll("\\.+", "");//去掉所有的点
String s3 = s2.replaceAll("(.)\\1+", "$1");	//$1代表第一组中的内容
System.out.println(s3);

###14.09_常见对象(Pattern类和Matcher类的概述)
* A:Pattern和Matcher的概述
* B:模式和匹配器的典型调用顺序
    * 通过JDK提供的API，查看Pattern类的说明

    * 典型的调用顺序是 
    * Pattern p = Pattern.compile("a*b");
    * Matcher m = p.matcher("aaaaab");
    * boolean b = m.matches();

Pattern p = Pattern.compile("a*b");					//获取到正则表达式
Matcher m = p.matcher("aaaaab");					//获取匹配器
boolean b = m.matches();						//看是否能匹配,匹配就返回true		
System.out.println(b);

###14.10_常见对象(正则表达式的获取功能)
* A:正则表达式的获取功能
    * Pattern和Matcher的结合使用
* B:案例演示
    group之前一定要先找到，也就是先find

String s = "我的手机是18988888888,我曾用过18987654321,还用过18812345678";
String regex = "1[3578]\\d{9}";		
Pattern p = Pattern.compile(regex);
Matcher m = p.matcher(s);				
while(m.find())
	System.out.println(m.group());
}

###14.11_常见对象(Math类概述和方法使用)
* A:Math类概述
    * Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。 
* B:成员方法
    * 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)
    * public static double random()
    * public static int round(float a) 参数为double的自学
    * public static double sqrt(double a)

###14.12_常见对象(Random类的概述和方法使用)
* A:Random类的概述
    * 此类用于产生随机数如果用相同的种子创建两个 Random 实例，
    * 则对每个实例进行相同的方法调用序列，它们将生成并返回相同的数字序列。
* B:构造方法
    * public Random()
    * public Random(long seed)
* C:成员方法
    * public int nextInt()

    * public int nextInt(int n)(重点掌握)

Random r = new Random();	
		
for(int i = 0; i < 10; i++) {
		System.out.println(r.nextInt(100));			//要求掌握,生成在0到n范围内的随机数,包含0不包含n
}

###14.13_常见对象(System类的概述和方法使用)
* A:System类的概述
    * System 类包含一些有用的类字段和方法。 它不能被实例化。 
* B:成员方法

    * public static void gc()

public static void demo1() {
		for(int i = 0; i < 100; i++) {
			new Demo();
			System.gc();						//运行垃圾回收器,相当于呼喊保洁阿姨
		}
	}

}

class Demo {									
	@Override
	public void finalize() {
		System.out.println("垃圾被清扫了");
	}							
	

    * public static void exit(int status)

public static void demo2() {
		System.exit(1);							//非0状态是异常终止,退出jvm
		System.out.println("11111111111");
	}

    * public static long currentTimeMillis()

long start = System.currentTimeMillis();		//1秒等于1000毫秒
		for(int i = 0; i < 1000; i++) {
			System.out.println("*");
		}
		long end = System.currentTimeMillis();			//获取当前时间的毫秒值
		
		System.out.println(end - start);

    * pubiic static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 

int[] src = {11,22,33,44,55};
int[] dest = new int[8];
System.arraycopy(src, 0, dest, 0, src.length);		//将数组内容拷贝

###14.14_常见对象(BigInteger类的概述和方法使用)
* A:BigInteger的概述
    * 可以让超过Integer范围内的数据进行运算
* B:构造方法
    * public BigInteger(String val)
* C:成员方法
    * 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)

###14.15_常见对象(BigDecimal类的概述和方法使用)
* A:BigDecimal的概述
    * 由于在运算的时候，float类型和double很容易丢失精度
    * 所以，为了能精确的表示、计算浮点数，Java提供了BigDecimal
    * 不可变的、任意精度的有符号十进制数。
* B:构造方法
    * public BigDecimal(String val)
* C:成员方法
    * public BigDecimal add(BigDecimal augend)
    * public BigDecimal subtract(BigDecimal subtrahend)
    * public BigDecimal multiply(BigDecimal multiplicand)
    * public BigDecimal divide(BigDecimal divisor)


###14.16_常见对象(Date类的概述和方法使用)(掌握)

* A:Date类的概述

   Date类的概述是util包下的,不能导入sql包的

    * 类 Date 表示特定的瞬间，精确到毫秒。 
* B:构造方法
    * public Date()
    * public Date(long date)
* C:成员方法
    * public long getTime()
    * public void setTime(long time)

Date d1 = new Date();					//如果没有传参数代表的是当前时间
System.out.println(d1);
		
Date d2 = new Date(0);					//如果构造方法中参数传为0代表的是1970年1月1日
System.out.println(d2);					//通过毫秒值创建时间对象

Date d1 = new Date();	
System.out.println(d1.getTime());				//通过时间对象获取毫秒值
System.out.println(System.currentTimeMillis());	//通过系统类的方法获取当前时间毫秒值

Date d1 = new Date();	
d1.setTime(1000);								//设置毫秒值,改变时间对象
System.out.println(d1);

###14.17_常见对象(SimpleDateFormat类实现日期和字符串的相互转换)(掌握)
* A:DateFormat类的概述
    * DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。是抽象类，不能实例化，所以使用其子类SimpleDateFormat
* B:SimpleDateFormat构造方法
    * public SimpleDateFormat()
    * public SimpleDateFormat(String pattern)
* C:成员方法
    * public final String format(Date date)
    * public Date parse(String source)

Date d = new Date();				//获取当前时间对象
SimpleDateFormat sdf = new SimpleDateFormat();	//创建日期格式化类对象
System.out.println(sdf.format(d));	 	//18-3-30 下午6:46

Date d = new Date();							//获取当前时间对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");     //创建日期格式化类对象
System.out.println(sdf.format(d));				        //将日期对象转换为字符串  2018/03/30 18:48:58

String str = "2000年08月08日 08:08:08";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
Date d = sdf.parse(str);						//将时间字符串转换成日期对象
System.out.println(d);

###14.18_常见对象(你来到这个世界多少天案例)(掌握)
* A:案例演示

    * 需求：算一下你来到这个世界多少天?

                //1,将生日字符串和今天字符串存在String类型的变量中
		String birthday = "1983年07月08日";
		String today = "2088年6月6日";
		//2,定义日期格式化对象
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
		//3,将日期字符串转换成日期对象
		Date d1 = sdf.parse(birthday);
		Date d2 = sdf.parse(today);
		//4,通过日期对象后期时间毫秒值
		long time = d2.getTime() - d1.getTime();
		//5,将两个时间毫秒值相减除以1000,再除以60,再除以60,再除以24得到天
		System.out.println(time / 1000 / 60 / 60 / 24 );

###14.19_常见对象(Calendar类的概述和获取日期的方法)(掌握)
* A:Calendar类的概述
    * Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。
* B:成员方法
    * public static Calendar getInstance()
    * public int get(int field)

import java.util.Calendar;

	public static void demo1() {
		Calendar c = Calendar.getInstance();			//父类引用指向子类对象
		System.out.println(c.get(Calendar.YEAR));		//通过字段获取年
		System.out.println(c.get(Calendar.MONTH));		//通过字段后期月,但是月是从0开始编号的
		System.out.println(c.get(Calendar.DAY_OF_MONTH));//月中的第几天
		System.out.println(c.get(Calendar.DAY_OF_WEEK));//周日是第一天,周六是最后一天
		
		System.out.println(c.get(Calendar.YEAR) + "年" + getNum((c.get(Calendar.MONTH)+1)) 
				+ "月" + getNum(c.get(Calendar.DAY_OF_MONTH)) + "日" + getWeek(c.get(Calendar.DAY_OF_WEEK)));
	}
	
	/*
	 * 将星期存储表中进行查表
	 * 1,返回值类型String
	 * 2,参数列表int week
	 */
	
	public static String getWeek(int week) {
		String[] arr = {"","星期日","星期一","星期二","星期三","星期四","星期五","星期六"};	
		return arr[week];
	}
	
	/*
	 * 如果是个数数字前面补0
	 * 1,返回值类型String类型
	 * 2,参数列表,int num
	 */
	public static String getNum(int num) {
		return num > 9 ? "" + num : "0" + num;
	}
}

###14.20_常见对象(Calendar类的add()和set()方法)(掌握)
* A:成员方法
    * public void add(int field,int amount)
    * public final void set(int year,int month,int date)


###14.21_常见对象(如何获取任意年份是平年还是闰年)(掌握)
* A:案例演示

    * 需求：键盘录入任意一个年份，判断该年是闰年还是平年

            

                public static void main(String[] args) {
		    Scanner sc = new Scanner(System.in);
		    System.out.println("请输入年份,判断该年份是闰年还是平年:");
		    String line = sc.nextLine();				//录入数字字符串
		    int year = Integer.parseInt(line);		        	//将数字字符串转换成数字
		    boolean b = getYear(year);
		    System.out.println(b);
	        }

	private static boolean getYear(int year) {
		//2,创建Calendar c = Calendar.getInstance();
		Calendar c = Calendar.getInstance();
		//设置为那一年的3月1日
		c.set(year, 2, 1);
		//将日向前减去1
		c.add(Calendar.DAY_OF_MONTH, -1);
		//判断是否是29天
		return c.get(Calendar.DAY_OF_MONTH) == 29;
	}