正则表达式及常用类

最新推荐文章于 2022-08-01 09:57:40 发布

故意的是吧

最新推荐文章于 2022-08-01 09:57:40 发布

阅读量312

点赞数

分类专栏： JAVA 文章标签：正则表达式

JAVA 专栏收录该内容

30 篇文章 0 订阅

订阅专栏

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]

\w 单词字符：[a-zA-Z_0-9]

在正则表达式里面组成单词的东西必须有这些东西组成

D:边界匹配器

^ 行的开头

$ 行的结尾

\b 单词边界

就是不是单词字符的地方。

举例：hello world?haha;xixi

E:Greedy 数量词

X? X，一次或一次也没有

X* X，零次或多次

X+ X，一次或多次

X{n} X，恰好 n 次

X{n,} X，至少 n 次

X{n,m} X，至少 n 次，但是不超过 m 次

(3)常见功能：(分别用的是谁呢?)

A:判断功能

String类的public boolean matches(String regex)

B:分割功能

String类的public String[] split(String regex)

C:替换功能

String类的public String replaceAll(String regex,String replacement)

D:获取功能

Pattern和Matcher

Pattern p = Pattern.compile("a*b");

Matcher m = p.matcher("aaaaab");

find():查找存不存在

group():获取刚才查找过的数据

(4)案例

A:判断电话号码和邮箱

B:按照不同的规则分割数据

C:把论坛中的数字替换为*

D:获取字符串中由3个字符组成的单词

#######################################################################################

2:Math(掌握)

(1)针对数学运算进行操作的类

(2)常见方法(自己补齐)

A:绝对值

B:向上取整

C:向下取整

D:两个数据中的大值

E:a的b次幂

F:随机数

G:四舍五入

H:正平方根

(3)案例：

A:猜数字小游戏

B:获取任意范围的随机数

import java.util.Scanner;

public class Test_2 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入起始数：");
		int start = sc.nextInt();
		System.out.println("请输入结尾数：");
		int end = sc.nextInt();
		int num = getRandom(start, end);
		System.out.println(num);
	}

	public static int getRandom(int start, int end) {
		return (int) (Math.random() * (end - start + 1)) + start;
	}
}

#####################################################################################

3:Random(理解)

(1)用于产生随机数的类

(2)构造方法:

A:Random() 默认种子，每次产生的随机数不同

B:Random(long seed) 指定种子，每次种子相同，随机数就相同

(3)成员方法:

A:int nextInt() 返回int范围内的随机数

B:int nextInt(int n) 返回[0,n)范围内的随机数

import java.util.Random;

public class Test_2 {
	public static void main(String[] args) {
		Random r = new Random();
		for (int i = 0; i < 10; i++) {
			System.out.println(r.nextInt(100));
		}
	}
}

4:System(掌握)

(1)系统类,提供了一些有用的字段和方法。不能被实例化

(2)成员方法(自己补齐)

A:运行垃圾回收器

public static void gc()

B:退出jvm

public static void exit(int status)

终止当前正在运行的 Java 虚拟机。参数用作状态码；根据惯例，非 0 的状态码表示异常终止。

C:获取当前时间的毫秒值

public static long currentTimeMillis()

public class Test_2 {
	public static void main(String[] args) {
		long start = System.currentTimeMillis();
		for (int i = 0; i < 100000; i++) {
			System.out.println(i);
		}
		long end = System.currentTimeMillis();
		System.out.println("共用时：" + (end - start) + "毫秒");
	}
}

输出for循环运行消耗的时间。

D:数组复制

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

从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。

import java.util.Arrays;

public class Test_2 {
	public static void main(String[] args) {
		int[] arr = { 11, 22, 33, 44, 55 };
		int[] arr2 = { 1, 2, 3, 4, 5 };
		// 从原数组1号坐标开始复制两个元素到新数组中，从坐标2开始
		System.arraycopy(arr, 1, arr2, 2, 2);
		System.out.println(Arrays.toString(arr));
		System.out.println(Arrays.toString(arr2));
	}
}

输出：

[11, 22, 33, 44, 55]

[1, 2, 22, 33, 5]

5:BigInteger(理解)

(1)针对大整数的运算

(2)构造方法

BigInteger(String val)

import java.math.BigDecimal;

public class Test_2 {
	public static void main(String[] args) {
		BigDecimal bi = new BigDecimal("1234567890123");
		System.out.println(bi);
	}
}

输出：

1234567890123

A:BigInteger(String s)

(3)成员方法(自己补齐)

A:加

public BigInteger add(BigInteger val)

B:减

public BigInteger subtract(BigInteger val)

C:乘

public BigInteger multiply(BigInteger val)

D:除

public BigInteger divide(BigInteger val)

E:商和余数

public BigInteger[] divideAndRemainder(BigInteger val)

测试：

import java.math.BigDecimal;

public class Test_2 {
	public static void main(String[] args) {
		BigDecimal bi1 = new BigDecimal("11");
		BigDecimal bi2 = new BigDecimal("5");
		System.out.println("add:" + bi1.add(bi2));
		System.out.println("subtract:" + bi1.subtract(bi2));
		System.out.println("multiply:" + bi1.multiply(bi2));
		System.out.println("divide:" + bi1.divide(bi2));

		BigDecimal[] bis = bi1.divideAndRemainder(bi2);
		System.out.println("商：" + bis[0]);
		System.out.println("余数：" + bis[1]);
	}
}

输出：

add:16

subtract:6

multiply:55

divide:2.2

商：2

余数：1

6:BigDecimal(理解)

(1)浮点数据做运算，会丢失精度。所以，针对浮点数据的操作建议采用BigDecimal。(金融相关的项目)

float类型的数据存储和整数不一样导致的。它们大部分的时候，都是带有有效数字位。

BigDecimal类：不可变的、任意精度的有符号十进制数,可以解决数据丢失问题。

test：

public class Test_2 {
	public static void main(String[] args) {
		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);
		System.out.println(1.0 - 0.12);
	}
}

输出：

0.09999999999999999

0.6799999999999999

101.49999999999999

0.013009999999999999

0.88

(2)构造方法

public BigDecimal(String val)

(3)成员方法：

A:加

public BigDecimal add(BigInteger val)

B:减

public BigDecimal subtract(BigInteger val)

C:乘

public BigDecimal multiply(BigInteger val)

D:除

public BigDecimal divide(BigInteger val)

E:自己保留小数几位

public BigDecimal divide(BigDecimal divisor,int scale,int roundingMode)

商几位小数如何舍取

test：

import java.math.BigDecimal;

public class Test_2 {
	public static void main(String[] args) {
		BigDecimal bd1 = new BigDecimal("0.09");
		BigDecimal bd2 = new BigDecimal("0.01");

		System.out.println("add:" + bd1.add(bd2));
		System.out.println("subtract:" + bd1.subtract(bd2));
		System.out.println("multiply:" + bd1.multiply(bd2));
		System.out.println("divide:" + bd1.divide(bd2));
		System.out.println("divide2:" + bd1.divide(bd2, 3, BigDecimal.ROUND_HALF_UP));

	}
}

输出：

add:0.10

subtract:0.08

multiply:0.0009

divide:9

divide2:9.000

7:Date/DateFormat(掌握)

(1)Date是日期类，可以精确到毫秒。

A:构造方法

Date() 根据当前的默认毫秒值创建日期对象

import java.util.Date;

public class Test_2 {
	public static void main(String[] args) {
		Date d = new Date();
		System.out.println(d);
	}
}

输出：

Mon Mar 28 11:29:10 CST 2016

周一 3月28日时区

Date(long time) 根据给定的毫秒值创建日期对象

Test：

import java.util.Date;

public class Test_2 {
	public static void main(String[] args) {
		Date d = new Date();
		System.out.println(d);
		// 输出起始时间，因为北京是东八区，所以加8个小时
		System.out.println(new Date(0));
		long time = 1000 * 60 * 60;
		//从起始时间增加一小时
		Date d2 = new Date(time);
		System.out.println(d2);
	}
}

输出：

Mon Mar 28 11:59:39 CST 2016

Thu Jan 01 08:00:00 CST 1970

Thu Jan 01 09:00:00 CST 1970

B:成员方法

getTime()

获取时间，以毫秒为单位

setTime(long time) 设置时间

Test：

import java.util.Date;

public class Test_2 {
	public static void main(String[] args) {
		Date d = new Date();
		
		//获取时间
		long time=d.getTime();
		System.out.println(time);
		
		//设置时间
		System.out.println(d);
		d.setTime(1000);
		//增加一秒
		System.out.println(d);
	}
}

输出：

1459138107911

Mon Mar 28 12:08:27 CST 2016

Thu Jan 01 08:00:01 CST 1970

C:日期和毫秒值的相互转换

(2)DateFormat针对日期进行格式化和针对字符串进行解析的类，但是是抽象类，所以使用其子类SimpleDateFormat

SimpleDateFormat（）默认模式

A:SimpleDateFormat(String pattern) 给定模式

yyyy-MM-dd HH:mm:ss

Test：

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

public class Test_2 {
	public static void main(String[] args) {
		Date d = new Date();

		// 创建格式化对象
		SimpleDateFormat sdf = new SimpleDateFormat();

		SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");

		// 调方法默认格式化输出
		String s = sdf.format(d);

		String s2 = sdf2.format(d);
		System.out.println(s);
		System.out.println(s2);
	}
}

输出：

16-3-28 下午12:32

2016年03月28日 12:32:44

B:日期和字符串的转换

a:Date -- String

format()

b:String -- Date

parse()

test：

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

public class DateFormatDemo {
	public static void main(String[] args) throws ParseException {
		// Date -- String
		// 创建日期对象
		Date d = new Date();
		// 创建格式化对象
		// SimpleDateFormat sdf = new SimpleDateFormat();
		// 给定模式
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
		// public final String format(Date date)
		String s = sdf.format(d);
		System.out.println(s);
		
		
		//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);
	}
}

输出：

2016年03月28日 12:40:08

Fri Aug 08 12:12:12 CST 2008

C:案例：

制作了一个针对日期操作的工具类。

工具类：

package bao_01;

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

/**
 * 日起和字符串互换的工具类
 * @author super
 *
 */

public class DateUtil {
	private DateUtil(){}
	/**
	 * 方法用于日起转换成一个字符串
	 * @param d	被转换的日期对象
	 * @param format	传递来的要被转换的格式
	 * @return	格式化后的字符串
	 */
	public static String dateToString(Date d,String format){
		//SimpleDateFormat sdf=new SimpleDateFormat(format);
		return new SimpleDateFormat(format).format(d);
	}
	/**
	 * 将字符串转换成日期对象
	 * @param s	被解析的字符串
	 * @param format	要转化的格式
	 * @return	转换后的日期对象
	 * @throws ParseException	抛出异常
	 */
	public static Date stringToDate(String s,String format) throws ParseException{
		return new SimpleDateFormat(format).parse(s);
	}
}

Demo：

package bao_01;

import java.text.ParseException;
import java.util.Date;

public class Test {
	public static void main(String[] args) throws ParseException {
		Date d = new Date();
		// yyyy-MM-dd HH:mm:ss
		String s = DateUtil.dateToString(d, "yyyy-MM-dd HH:mm:ss");
		System.out.println(s);
		String s2 = DateUtil.dateToString(d, "yyyy-MM-dd");
		System.out.println(s2);
		String s3 = DateUtil.dateToString(d, "HH:mm:ss");
		System.out.println(s3);

		String ss = "2012-12-12 12:12:12";
		Date d2 = DateUtil.stringToDate(ss, "yyyy-MM-dd HH:mm:ss");
		System.out.println(d2);
		Date d3 = DateUtil.stringToDate(ss, "yyyy-MM-dd");
		System.out.println(d3);
		
		//报错，无法识别格式
		//Date d4 = DateUtil.stringToDate(ss, "HH:mm:ss");
		//System.out.println(d4);

	}
}

输出：

2016-03-28 13:00:45

2016-03-28

13:00:45

Wed Dec 12 12:12:12 CST 2012

Wed Dec 12 00:00:00 CST 2012

案例：你来到这个世界多少天了?

用工具类实现：

package bao_01;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/***
 * 
 * @author super
 *
 */
public class YearOld {
	private YearOld() {
	}

	public static long stringToDate(String s, String format) throws ParseException {
		//通过用户输入得到用户的出生日期
		Date d = new SimpleDateFormat(format).parse(s);
		//获取一个当前的日期
		Date dd = new Date();
		//用当前日期得到的毫米数减用户的，再计算出天数
		return (dd.getTime() - d.getTime()) / (1000 * 60 * 60 * 24);
	}
}

Demo：

package bao_01;

import java.text.ParseException;
import java.util.Scanner;

public class Test_2 {
	public static void main(String[] args) throws ParseException {
		Scanner sc=new Scanner(System.in);
		System.out.println("请输入你的出生年月日：");
		String s=sc.nextLine();
		long days=YearOld.stringToDate(s, "yyyy-MM-dd");
		int years=(int)days/365;
		System.out.println(days);
		System.out.println(years);
	}
}

输出：

请输入你的出生年月日：

1949-10-01

24285

8:Calendar(掌握)

(1)日历类，封装了所有的日历字段值，通过统一的方法根据传入不同的日历字段可以获取值。

(2)如何得到一个日历对象呢?

Calendar rightNow = Calendar.getInstance();

本质返回的是子类对象

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

public int get(int field):返回给定日历字段的值。日历类中的每个日历字段都是静态的成员变量，并且是int类型。

test：

import java.util.Calendar;

public class test_3 {
	public static void main(String[] args) {
		// 获取当前日历时间     子类对象
		Calendar now = Calendar.getInstance();
		// 获取年
		int year = now.get(Calendar.YEAR);
		// 获取月
		int month = now.get(Calendar.MONTH);
		// 获取日
		int day = now.get(Calendar.DATE);
		
		//因为MONTH从0开始，所以需要加一才是当前月
		System.out.println(year + "年" + (month+1) + "月" + day + "日");
	}
}

输出：

2016年3月29日

(3)成员方法

A:根据日历字段得到对应的值

B:根据日历字段和一个正负数确定是添加还是减去对应日历字段的值

C:设置日历对象的年月日

Test：

import java.util.Calendar;

public class test_3 {
	public static void main(String[] args) {
		// 获取当前日历时间 子类对象
		Calendar now = Calendar.getInstance();
		// 获取年
		int year = now.get(Calendar.YEAR);
		// 获取月
		int month = now.get(Calendar.MONTH);
		// 获取日
		int day = now.get(Calendar.DATE);

		// 因为MONTH从0开始，所以需要加一才是当前月
		System.out.println(year + "年" + (month + 1) + "月" + day + "日");

		// 年数增加20
		now.add(Calendar.YEAR, 20);
		year = now.get(Calendar.YEAR);
		System.out.println(year + "年" + (month + 1) + "月" + day + "日");

		// 设置年月日，因为month从0开始，所以输出的是比设定的增加一个月的月份
		now.set(2012, 12, 12);
		// 获取年
		year = now.get(Calendar.YEAR);
		// 获取月
		month = now.get(Calendar.MONTH);
		// 获取日
		day = now.get(Calendar.DATE);

		System.out.println(year + "年" + (month + 1) + "月" + day + "日");

	}
}

输出：

2016年3月29日

2036年3月29日

2013年1月12日

(4)案例：

计算任意一年的2月份有多少天?

import java.util.Calendar;

public class class4 {

	public static void main(String[] args) {
		Calendar rightNow = Calendar.getInstance();

		// 设置日历对象的年月日
		rightNow.set(1984, 2, 1);

		// 时间往前推一天
		rightNow.add(Calendar.DATE, -1);
		// 输出这一天
		System.out.println(rightNow.get(Calendar.DATE));
	}

}

输出：