1、正则(了解)
1、基本的正则表达式(看懂即可)
字符类 [abc] a、b 或 c(简单类) [^abc] 任何字符,除了 a、b 或 c(否定) [a-zA-Z] a 到 z 或 A 到 Z,两头的字母包括在内(范围) [0-9] 0到9的字符都包括 [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](减去) |
|
[abc] a、b 或 c(简单类) |
|
[^abc] 任何字符,除了 a、b 或 c(否定) |
|
[a-zA-Z] a到 z 或 A到 Z,两头的字母包括在内(范围) |
|
[0-9] 0到9的字符都包括 |
|
[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](减去) |
|
预定义字符类 . 任何字符 \d 数字:[0-9] \D 非数字: [^0-9] \s 空白字符:[ \t\n\x0B\f\r] //空格,\t:制表符,\n:换行,\x0B:垂直制表符,\f:翻页,\r:回车 \S 非空白字符:[^\s] \w 单词字符:[a-zA-Z_0-9] \W 非单词字符:[^\w] |
|
. 任何字符 |
|
\d 数字:[0-9] |
|
\D 非数字: [^0-9] |
|
\s 空白字符:[ \t\n\x0B\f\r] //空格,\t:制表符,\n:换行,\x0B:垂直制表符,\f:翻页,\r:回车 |
|
\S 非空白字符:[^\s] |
|
\w 单词字符:[a-zA-Z_0-9] |
|
\W 非单词字符:[^\w] |
|
Greedy 数量词 X? X,一次或一次也没有 X* X,零次到多次 X+ X,一次到多次 X{n} X,恰好 n 次 X{n,} X,至少 n 次 X{n,m} X,至少 n 次,但是不超过 m 次 |
|
X? X,一次或一次也没有 |
|
X* X,零次到多次 |
|
X+ X,一次到多次 |
|
X{n} X,恰好 n 次 |
|
X{n,} X,大于等于n次 |
|
X{n,m} X, 大于等于n小于等于m |
|
2、常见对象(Pattern和Matcher的概述)(了解)
* A:Pattern和Matcher的概述* B:模式和匹配器的典型调用顺序* 通过JDK提供的API,查看Pattern类的说明* 典型的调用顺序是* Pattern p = Pattern.compile("a*b");* Matcher m = p.matcher("aaaaab");* boolean b = m.matches();
需求:把一个字符串中的手机号码获取出来
package com.heima.regex;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Demo8_Pattern {
public static void main(String[] args) {
//demo1();
//demo2();
demo3();
}
//匹配查找邮箱
private static void demo3() {//[1][\\d&&[012678]][\\d]{9}
String s = "我的邮箱是smhjx2006@163.com,我曾经用过hmsykt2015@sina.com.cn,我还用过hmsykt0902@qq.com";
//String regex = "[a-zA-Z0-9_]+@[a-zA-Z0-9]+(\\.[a-zA-Z]+)+";//较为精确的匹配。
String regex = "\\w+@\\w+(\\.\\w+)+";
Pattern p = Pattern.compile(regex);
Matcher matcher = p.matcher(s);
while(matcher.find()){
System.out.println(matcher.group());
}
}
//匹配查找手机号
private static void demo2() {
String s = "我的手机是18511866260,我曾用过18987654321,还用过18812345678";
String regex = "1[3578]\\d{9}";
Pattern p = Pattern.compile(regex);
Matcher m = p.matcher(s);
/*boolean b1 = m.find();
System.out.println(b1);
System.out.println(m.group());
boolean b2 = m.find();
System.out.println(b2);
System.out.println(m.group());*/
while(m.find())
System.out.println(m.group());
}
}
3、案例(掌握)
1、我有如下一个字符串:”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
/*String str = "";
for (int i = 0; i < arr.length; i++) {
if(i == arr.length - 1) {
str = str + arr[i]; //27 38 46 50 91
}else {
str = str + arr[i] + " "; //27 38 46 50
}
}
System.out.println(str);*/
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);
}
}
2、需求:我我....我...我.要...要要...要学....学学..学.编..编编.编.程.程.程..程
将字符串还原成:“我要学编程”。
public static void main(String[] args) {
String str= "我我....我...我.要...要要...要学....学学..学.编..编编.编.程.程.程..程";
//第一步 去掉所有的.
String str1 = str.replaceAll("\\.+", "");
//第二步 叠词去重 \\1+表示第一组(.)中的数据出现1次或多次,翻译过来就是说任意字符出现一次或多次
String str2 = str1.replaceAll("(.)\\1+", "$1");
System.out.println(str2);
}
(.)\\1+:(.) 第一个字符是任意字符,并且我把它放到组里面,方便以后直接调用这个组
1+:刚才那个字符出现1次或者多次$1:调用刚才定义的组什么是组???怎么数?组:就是一个括号括起来的东西怎么数从左往右数(
2、Math(看到方法名知道意思即可)
1、Math中的常量
E,PI
比任何其他值都更接近 e(即自然对数的底数)的 double 值。
2、Math中的方法
abs()绝对值
ceil 大于等于参数的最小整数,返回double
floor 小于等于参数的最大整数,返回double
round() 四舍五入
random() 随机数
max(x,y) 获取两个数中的最大值
//求绝对值
pubilc static int abs(int num)
public long abs(long num)
public float abs(float num)
pbulic double abs(doble num)
//ceil:天花板
public static double ceil(double num)//返回大于等于参数的最小整数 ,返回值是double 类型
//floor :底板
public static double floor(double num)//返回小于等于参数的最大整数 ,返回值是double 类型
//round :四舍五入
public static int round(float num)//
public static long round(double num)//四舍五入
//最大值
public static double max(double num1, double num2);
public static float max(float num1, float num2)
public static int max(int num1, int num2)
public static long max(long num1, long num2)
//随机数
public static double random();
3、System(了解)
1 public static void gc() 调用后执行垃圾回收
2 public static void exit(int status) 非0表示异常退出,1表示正常退出
3 public static long currentTimeMillis() 获取当前时间的毫秒值(掌握)
4 pubiic static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 数组拷贝
4、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)案例:
package com.heima.otherclass;
import java.math.BigInteger;
public class Demo4_BigInteger {
public static void main(String[] args) {
//long num = 123456789098765432123L;
//String s = "123456789098765432123";
BigInteger bi1 = new BigInteger("100");
BigInteger bi2 = new BigInteger("2");
System.out.println(bi1.add(bi2)); //+
System.out.println(bi1.subtract(bi2)); //-
System.out.println(bi1.multiply(bi2)); //*
System.out.println(bi1.divide(bi2)); ///(除)
BigInteger[] arr = bi1.divideAndRemainder(bi2); //取除数和余数
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
5、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)
* D:案例演示
* BigDecimal类的构造方法和成员方法使用
案例:
package com.heima.otherclass;
import java.math.BigDecimal;
public class Demo5_BigDecimal {
/**
十进制表示1/3
0.3333333333333333333333333333333333333333
*/
public static void main(String[] args) {
//System.out.println(2.0 - 1.1);
/*BigDecimal bd1 = new BigDecimal(2.0); //这种方式在开发中不推荐,因为不够精确
BigDecimal bd2 = new BigDecimal(1.1);
System.out.println(bd1.subtract(bd2));*/
/*BigDecimal bd1 = new BigDecimal("2.0"); //通过构造中传入字符串的方式,开发时推荐
BigDecimal bd2 = new BigDecimal("1.1");
System.out.println(bd1.subtract(bd2));*/
BigDecimal bd1 = BigDecimal.valueOf(2.0); //这种方式在开发中也是推荐的
BigDecimal bd2 = BigDecimal.valueOf(1.1);
System.out.println(bd1.subtract(bd2));
}
}
6、Date类的概述和方法使用(掌握)
A:Date类的概述(是java.util包下的,别导错了)* 类 Date 表示特定的瞬间,精确到毫秒。B:构造方法* public Date()* public Date(long date)C:成员方法* public long getTime()* public void setTime(long time)D:练习1、通过Date日期对象获取毫秒值Date date = new Date();long time = date.getTime();2、通过毫秒值创造Date日期对象long time = 1222L;//毫秒值Date date = new Date(time);
7、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)
public static void main(String[] args)throws Exception {
/*
* 把日期对象转换成字符串
*/
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");
String strDate = format.format(new Date());
System.out.println(strDate);
/*
* 把字符串转换成日期对象
*/
SimpleDateFormat f = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");
Date date = f.parse("2016-04-28 23:19:34:716");
System.out.println(date);
}
*D:算一下你来到这个世界多少天?
package com.heima.test;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Test2 {
/**
* * A:案例演示
* 需求:算一下你来到这个世界多少天?
* 分析:
* 1,将生日字符串和今天字符串存在String类型的变量中
* 2,定义日期格式化对象
* 3,将日期字符串转换成日期对象
* 4,通过日期对象后期时间毫秒值
* 5,将两个时间毫秒值相减除以1000,再除以60,再除以60,再除以24得到天
* @throws ParseException
*/
public static void main(String[] args) throws ParseException {
//1,将生日字符串和今天字符串存在String类型的变量中
String birthday = "1983年07月08日";
String today = "2015年9月22日";
//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 );
}
}
8、Calendar类的概述和获取日期的方法(掌握)
* A:Calendar类的概述* Calendar 类是一个抽象类,它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等日历字段之间的转换提供了一些方法,并为操作日历字段(例如获得下星期的日期)提供了一些方法。* B:成员方法* 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)3、注意事项1、get(Calendar.MONTH)的值的范围是0-11,不是1-12//外国人的1是中国的7
//外国人的0-6是中国的周1-5
int week = calendar.get(Calendar.DAY_OF_WEEK)==1?7: calendar.get(Calendar.DAY_OF_WEEK)-1;2、日期处理过程中能使用Calendar就不使用Date
import java.util.Calendar;
public class CalendarDemo {
public static void main(String[] args) {
Calendar c = Calendar.getInstance(); // 父类引用指向子类对象
/*
* get方法测试
*/
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));// 周日是第一天,周六是最后一天
/*
* add方法测试
*/
c.add(Calendar.MONTH, -1); // 对指定的字段进行向前减或向后加
printTime(c);
/*
* set方法测试
*/
c.set(Calendar.YEAR, 2000); // 修改指定字段
c.set(2000, 7, 8);
printTime(c);
}
/**
* 打印年月日 星期
* @param c
*/
public static void printTime(Calendar c) {
int year = c.get(Calendar.YEAR);
int month = c.get(Calendar.MONDAY)+1;
int day = c.get(Calendar.DAY_OF_MONTH);
int week = c.get(Calendar.DAY_OF_WEEK)==1?7: c.get(Calendar.DAY_OF_WEEK)-1;
System.out.println(year+"年"+month+"月"+day+"日星期"+week);
}
}
C 案例键盘录入任意一个年份,判断该年是闰年还是平年(掌握)
package com.heima.test;
import java.util.Calendar;
import java.util.Scanner;
public class Test3 {
/**
* * A:案例演示
* 需求:键盘录入任意一个年份,判断该年是闰年还是平年
* Calendar c = Calendar.getInstance();
*
* 分析:
* 1,键盘录入年Scanner
* 2,创建Calendar c = Calendar.getInstance();
* 3,通过set方法设置为那一年的3月1日
* 4,将日向前减去1
* 5,判断日是多少天,如果是29天返回true否则返回false
*/
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入年份,判断该年份是闰年还是平年:");
//int year = sc.nextInt();
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;
}
}
8、今天必须掌握的内容。以及常见的笔试题和面试题(学完这个就可以放心学习后面的知识了)
1、基本的正则表达式和数量词要能看懂
2、获取当前时间的毫秒值的两种方式
3、日期格式化类的使用(日期转字符串,字符串转日期)
日期转字符串 String str = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS").format(new Date());
字符串转日期 Date date =new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS").parse("2018-09-09 11:11:11:111");
4、笔试题:判断平年闰年
5、笔试题:我我....我...我.要...要要...要学....学学..学.编..编编.编.程.程.程..程
将字符串还原成:“我要学编程
思路:1、去掉所有的...reaplaceAll("\\.","");
2、替换叠词 replaceAll("(.)\\1+","$1")
6、我有如下一个字符串:”91 27 46 38 50”,请写代码实现最终输出结果是:”27 38 46 50 91”
7、写一个正则表达式,可以匹配尾号5连的手机号。
规则: 第1位是1,第二位可以是数字358其中之一,后面6位任意数字,最后5位为任意相同的数字,
第1位是1,第二位可以是数字358其中之一,后面6位任意数字,最后5位为任意相同的数字
package com.heima.stringStringBuilderStringBuffer;
/**
* 写一个正则表达式,可以匹配尾号5连的手机号。
* 规则: 第1位是1,第二位可以是数字3458其中之一,后面6位任意数字,最后5位为任意相同的数字。
* 例如:18601088888、13912366666
* @author JX
*
*/
public class Test3 {
public static void main(String[] args) {
String regex = "[1][3458]\\d{4}(\\d)\\1{4}";
String phone1 = "18601088888";
String phone2 = "13912366666";
System.out.println(phone1.matches(regex));
System.out.println(phone2.matches(regex));
}
}
8、模拟用户注册
1、用户录入手机号
2、校验用户录入的手机号,1、长度是否11位,2、是否全是数字
3、将手机号后四位截取出来通过Random类加密,生成一个0-99999之间的数字作为验证码打印到控制台
/**
* 8、模拟用户注册 1、用户录入手机号 2、校验用户录入的手机号,1、长度是否11位,2、是否全是数字
* 3、将手机号后四位截取出来通过Random类加密,将加密后的数字作为校验码打印在控制台
*
* @param args
*/
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入手机号");
String phone = sc.nextLine();
//校验成功
if(phone.length()==11 && phone.matches("[0-9]{11,}")){
String num = phone.substring(7);//后四位
Random r = new Random(Long.parseLong(num));
int yzm = r.nextInt(100000);//验证码
System.out.println("验证码是:"+yzm);
}else{
System.out.println("请输入正确的手机号");
}
}
9、用正则判断一个数字(该数字的长度至少为7)的末尾是不是相同的7位数
public class Test {
public static void main(String[] args) {
System.out.println("7777777".matches(".*(\\d)\\1{6}"));
}
}