【JavaSE学习笔记】常用类介绍04_System,Date,Math,Random,Pattern_sdf.parse(sdf.format(new date())) sat jul 07 00:00-优快云博客

常用类介绍04

System

1）概述

包含一些有用的类字段和方法，不能被实例化

经常用在：输出语句。。。。键盘录入中充当了标准输入流

InputStream（字节输入流） is = System.in;抽象类的多态

2）常用方法：public static void gc()：运行垃圾回收器

Object中的一个方法：finalize()方法，起动gc()，其实就是调用了finaliza()

//Person
class Person {
	private String name;
	private int age;

	public Person() {
		super();
	}

	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}

	@Override
	protected void finalize() throws Throwable {
		System.out.println("开始回收不用的垃圾对象：" + this);
		super.finalize();
	}

}

// 测试类
public class Demo01 {

	public static void main(String[] args) {
		Person p = new Person("张三", 20);
		System.out.println(p);// Person [name=张三, age=20]

		// 给对象赋一个值
		p = null;
		System.gc();
		// 开始回收不用的垃圾对象：Person [name=张三, age=20]

	}

}

3）System的另一个方法

public static void exit(int status)：终止当前正在运行的Java虚拟机

参数用作状态码：根据惯例，非0的状态码表示异常终止

// 测试类
public class Demo01 {

	public static void main(String[] args) {
		System.out.println("正在运行");
		
		System.exit(0);//终止Java虚拟机
		
		System.out.println("这句无法运行");
	}

}

public static long currentTimeMillis()：返回以毫秒为单位的当前时间

// 测试类
public class Demo01 {

	public static void main(String[] args) {
		long time = System.currentTimeMillis();
		System.out.println(time);// 1501243266110 每次运行结果不一样

		// 该方法一般用来去计算一些耗时的操作
		long start = System.currentTimeMillis();
		for (int i = 0; i < 10; i++) {
			System.out.println(i);
		}
		long end = System.currentTimeMillis();

		System.out.println("该循环耗时" + (end - start) + "ms");// 该循环耗时1ms
	}

}

4）和数组有关的方法

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

从指定数组中复制一段元素到另一个数组，粘贴从指定位置开始，到指定位置结束

import java.util.Arrays;

// 测试类
public class Demo01 {

	public static void main(String[] args) {
		int[] arr1 = { 11, 22, 33, 44, 55, 66 };
		int[] arr2 = { 4, 5, 6, 7, 8, 9, 0 };

		System.arraycopy(arr1, 1, arr2, 3, 3);
		//从第一个数组索引1开始，复制到第二数组索引3处，复制三个元素
		System.out.println("arr1:" + Arrays.toString(arr1));// arr1:[11, 22, 33, 44, 55, 66]
		System.out.println("arr2:" + Arrays.toString(arr2));// arr2:[4, 5, 6, 22, 33, 44, 0]
	}

}

Date

1）概述

表示特定的瞬间，精确到毫秒

2）构造方法

public Date()：分配Date对象并初始化次对象，以表示分配到他的时间
import java.util.Date;

// 测试类
public class Demo01 {

	public static void main(String[] args) {
		Date d = new Date();// 获取系统当前的日期时间
		System.out.println(d);// Fri Jul 28 20:13:48 CST 2017
	}

}
public Date(long date)：分配Date对象并初始化次对象，以表示自从标准基时间

被称为“历元（epoch）”，即1970年 1 月 1 日 00:00:00 GMT以来的指定毫秒数
import java.util.Date;

// 测试类
public class Demo01 {

	public static void main(String[] args) {
		// Date(long date):传递的是一个时间毫秒值
		long time = 1000 / 60 / 60;
		Date d = new Date(time);// 1970 年 1 月 1 日 00:00:00 GMT）
		System.out.println(d);// Thu Jan 01 08:00:00 CST 1970
	}

}

3）两个方法

public long getTime()：返回一个时间毫秒数（将Date转换成long时间毫秒数）
import java.util.Date;

// 测试类
public class Demo01 {

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

		long time = d.getTime();
		System.out.println(time);// 1501244350759
		System.out.println(System.currentTimeMillis());// 1501244350759
	}

}
public void setTime(long time)：设置次Date对象

以表示 1970 年 1 月 1 日 00:00:00 GMT 以后 time 毫秒的时间点
import java.util.Date;

// 测试类
public class Demo01 {

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

		d.setTime(System.currentTimeMillis());
		System.out.println(d);// Fri Jul 28 20:20:03 CST 2017
	}

}

4）Date和String类的相互转换

中间转换要用的一个桥梁(SimpleDateFormat)

作用：SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类

它允许进行格式化（日期->文本）、解析（文本->日期）

要使用DateFormat这个类：但是个抽象类，使用子类进行实例化SimpleDateFormat
/*SimpleDateFormat类的使用
		 *构造方法
		 *public SimpleDateFormat()用默认的模式和默认的语言环境的日期格式符号构造
		 *public SimpleDateFormat(String pattern)：创建格式化/解析器对象，提供一个参数：，模式
		 *以下的模式：				模式的表示方法
		 *Year			年			y------2017----yyyy
		 *Month			月			M
		 *Number		天			d
		 *小时						H
		 *分钟						m
		 *秒							s
		 */
Date日期对象-->以字符串表示的String（格式化）

public final String format(Object obj)格式化一个对象以生成一个字符串
import java.text.SimpleDateFormat;
import java.util.Date;

// 测试类
public class Demo01 {

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

		SimpleDateFormat sdf = new SimpleDateFormat("yyyy.MM.dd HH：mm:ss");
		String s = sdf.format(d);
		System.out.println(s);// 2017.07.28 20：32:32
	}

}
String（日期的文本格式）-->Date日期对象（解析）

public Object parseObject(String source)解析字符串的文本，生成Date

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

// 测试类
public class Demo01 {

	public static void main(String[] args) throws ParseException {

		String s = "2018-7-7";
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		Date d = sdf.parse(s);// 会抛出一个解析异常
		System.out.println(d);// Sat Jul 07 00:00:00 CST 2018
	}

}

5）制作一个日期转换工具类，并测试（可以自行尝试生成API文档）

API命令：javadoc -d 目录名 -author -version DateUtil.java

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

/**
 * Date对象和字符串转换的一个工具类
 * 
 * @author wpf
 *
 */
public class DateUtil {
	/**
	 * 私有的构造方法：为了不让创建对象
	 */
	private DateUtil() {
	}

	/**
	 * 日期格式化方法
	 * 
	 * @param d：日期对象
	 * @param format：日期的一种格式
	 * @return 返回一个字符串类型表示的日期
	 */
	public static String dateToString(Date d, String format) {
		return new SimpleDateFormat(format).format(d);
	}

	/**
	 * 日期解析方法
	 * 
	 * @param s：日期文本表现形式
	 * @param format：日期的一种格式
	 * @return 返回一个日期对象
	 * @throws ParseException：使用parse时，会抛出解析异常：parseException
	 */
	public static Date stringToDate(String s, String format) throws ParseException {
		return new SimpleDateFormat(format).parse(s);
	}
}

//测试类

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

// 测试类
public class Demo01 {

	public static void main(String[] args) throws ParseException {
		Date d1 = new Date();

		String s1 = DateUtil.dateToString(d1, "yyyy年MM月dd日");
		System.out.println(s1);// 2017年07月28日

		String s2 = "2017-10-1";
		Date d2 = DateUtil.stringToDate(s2, "yyyy-MM-dd");
		System.out.println(d2);// Sun Oct 01 00:00:00 CST 2017
	}

}

6）练习

键盘录入你的出生日期，算一下你来到这个世界多少天？

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

// 测试类
public class Demo01 {

	public static void main(String[] args) throws ParseException {
		Scanner sc = new Scanner(System.in);

		System.out.println("请输入您的出生年月日(xxxx.xx.xx)");
		String birth = sc.nextLine();

		// 解析日期
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy.MM.dd");
		Date d = sdf.parse(birth);// 抛出异常

		// 通过日期对象得到一个毫秒值
		long birthTime = d.getTime();

		// 获取当前系统时间的一个毫秒值
		long nowTime = System.currentTimeMillis();

		long time = nowTime - birthTime;

		// 计算天数
		long day = time / 1000 / 60 / 60 / 24;

		System.out.println("您已经来到这个世界" + day + "天");
	}

}

Math

1）概述

包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数

2）字段

public static final double PI

// 测试类
public class Demo01 {
	public static void main(String[] args) {
		// 圆周率
		System.out.println(Math.PI);// 3.141592653589793
	}
}

public static final double E

// 测试类
public class Demo01 {
	public static void main(String[] args) {
		// 自然对数的底数
		System.out.println(Math.E);// 2.718281828459045
	}
}

3）成员方法（比较简单，简单介绍几个，自己测试）

public static int abs(int a):绝对值
public static double ceil(double a):向上取整
public static double floor(double a):向下取整
public static double pow(double a, double b):a的b次幂
public static int max(int a,int b):求最大值
public static double random():获取一个随机数:[0.0,1.0)
public static long round(double a):四舍五入
public static double sqrt(double a):正平方根

4）练习

设计一个方法，可以实现获取任意范围内的随机数

分析:

1)键盘可以录入两个数据

int start

int end

2)想办法获取这两个数据之间的随机数

写一个功能实现,最终返回的是一个int类型

3)输出结果

import java.util.Scanner;

// 测试类
public class Demo01 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);

		System.out.println("请输入随机数范围的起止数(空格隔开)：");
		int start = sc.nextInt();
		int end = sc.nextInt();
		
		for (int i = 0; i < 10; i++) {
			int number = getRandom(start, end);
			System.out.println(number);
		}
	}

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

Random

1）概述

产生一个随机数的类

2）构造方法

public Random()：创建一个新的随机数生成器

import java.util.Random;

// 测试类
public class Demo01 {
	public static void main(String[] args) {
		Random r = new Random();
		System.out.println(r);// java.util.Random@c0fa1f5
	}
}

public Random(long seed)：使用单个long种子创建一个新的随机数生成器

// 测试类
public class Demo01 {
	public static void main(String[] args) {
		Random r = new Random(100);
		System.out.println(r);// java.util.Random@c0fa1f5
	}
}

3）成员方法：

public int nextInt()：指定的范围是int类型的本身的范围

import java.util.Random;

// 测试类
public class Demo01 {
	public static void main(String[] args) {
		Random r = new Random();
		for (int i = 0; i < 10; i++) {
			int num = r.nextInt();
			System.out.println(num);// 得到的值是int类型范围
		}
	}
}

public int nextInt(int n)：获取的随机数是[0,n)之间的值

import java.util.Random;

// 测试类
public class Demo01 {
	public static void main(String[] args) {
		Random r = new Random();
		for (int i = 0; i < 10; i++) {
			int num = r.nextInt(100);
			System.out.println(num);// 获取0~100(取不到这个末尾值)
		}
	}
}

Pattern

1）正则表达式概述

可以提高执行率，减少代码的书写量

2）常用语法

字符

x 字符x：a表示字符'a'

\\ 反斜线字符

\t 制表符（'\u0009'）

\n 换行符（'\u000A'）

\r 回车符（'\u000D'）

字符类

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

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

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

[a-zA-Z_0-9] 里面包含大写字母或者小写字母或者数字字符

预定义字符

. 任何字符 \. 转义 (本身就表示一个.)
\d 数字：[0-9] 0-9]--->\d(不正确) \\d(代码中正确的写法)
\w 单词字符：[a-zA-Z_0-9] java语言单词组成的一些规则需要\\w

边界匹配器

^ 行的开头
$ 行的结束
\b 单词边界

Greedy数量词

X? X，一次或一次也没有 :x出现1次或者0次
X* X，零次或多次 :x出现0次或多次
X+ X，一次或多次 :x出现1次或多次
X{n} X，恰好 n 次 :x恰好出现n
X{n,} X，至少 n 次 :x至少出现n次
X{n,m} X，至少 n 次，但是不超过 m 次

3）练习

校验用户输入的QQ是否符合的规则

规则:5-15位的一个数字

并且不能以0开头

import java.util.Scanner;

// 测试类
public class Demo01 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);

		System.out.println("请输入QQ号码：");
		String qq = sc.nextLine();

		boolean b = checkQQ(qq);
		System.out.println(b);
	}

	public static boolean checkQQ(String qq) {
		// public static boolean matches(String regex,)编译给定正则表达式并尝试将给定输入与其匹配。
		return qq.matches("[1-9]\\d{3,14}");
	}
}

4）练习

使用正则表达式校验手机号码

import java.util.Scanner;

// 测试类
public class Demo01 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);

		System.out.println("请输入手机号码：");
		String phoneNum = sc.nextLine();

		boolean b = checkPhone(phoneNum);
		System.out.println(b);
	}

	public static boolean checkPhone(String phoneNum) {
		return phoneNum.matches("[1][3578]\\d{9}");
	}
}

5）练习

使用正则规则校验邮箱

import java.util.Scanner;

// 测试类
public class Demo01 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);

		System.out.println("请输入邮箱：");
		String email = sc.nextLine();
		
		boolean b = email.matches("\\w+@\\w{2,6}(\\.\\w{1,2}[mn])");
		System.out.println(b);
	}

}

6）String中有一个方法和正则表达式有关

public String[] split(String regex)：根据给定正则表达式的匹配拆分此字符串

// 测试类
public class Demo01 {
	public static void main(String[] args) {
		String s1 = "aa,bb,cc";

		String[] arr1 = s1.split(",");
		for (int i = 0; i < arr1.length; i++) {
			System.out.print(arr1[i]);
		}
		System.out.println();// aabbcc

		String s2 = "aa.bb.cc";

		String[] arr2 = s2.split("\\.");
		for (int i = 0; i < arr2.length; i++) {
			System.out.print(arr2[i]);
		}
		System.out.println();// aabbcc

		String s3 = "aa   bb                 cc";

		String[] arr3 = s3.split(" +");
		for (int i = 0; i < arr3.length; i++) {
			System.out.print(arr3[i]);
		}
		System.out.println();// aabbcc

	}

}

7）练习

我有如下一个字符串:"91 27 46 38 50"

请写代码实现最终输出结果是："27 38 46 50 91"

import java.util.Arrays;

// 测试类
public class Demo01 {
	public static void main(String[] args) {
		/*
		 * 1)定义一个字符串:"91 27 46 38 50" 
		 * 2)把字符串用切割功能,返回一个字符串数组 
		 * 3)字符串数组-->int数组
		 * 4)Arrays数组工具类中的有个sort 
		 * 5)将int数组转换成字符串 
		 * 6)构造字符串缓冲区:StringBuilder sb =new StingBuilder(); 
		 * 7)把字符串缓冲区对象转换成字符串,输出结果
		 */
		// 定义一个字符串
		String s = "91 27 46 38 50";
		// 切割字符串
		String[] arr1 = s.split(" ");
		// 将字符串数组转换成int类型数组
		int[] arr2 = new int[arr1.length];
		// 遍历,将里面的元素转换成int类型:Integer的parsInt()方法
		for (int i = 0; i < arr2.length; i++) {
			arr2[i] = Integer.parseInt(arr1[i]);
		}

		// 使用数组工具类对数组进行升序排序
		Arrays.sort(arr2);
		// 构造字符串缓冲区,单线程中使用StringBuilder
		StringBuilder sb = new StringBuilder();
		// 遍历int类型数组
		for (int i = 0; i < arr2.length; i++) {
			sb.append(arr2[i]).append(" ");
		}
		// 将StingBuilder类型转换成字符串类型
		String s2 = sb.toString().trim();

		System.out.println(s2);// 27 38 46 50 91
	}

}

8）String类中另一个和正则相关的方法

public String replaceAll(String regex, String replacement)：

使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。

就是游戏中，你去喷别人，敏感词都被**和谐掉了
// 测试类
public class Demo01 {
	public static void main(String[] args) {
		String s = "helloworld123456Java78290";
		// 只显示字母
		String regex = "\\d+";
		String ss = "*";

		String s2 = s.replaceAll(regex, ss);
		System.out.println(s2);// helloworld*Java*

	}

}

9）模式对象和匹配器对象的应用顺序

public static Pattern compile(String regex)：将给定的正则表达式编译成要给模式对象

public Matcher matcher(CharSwquence input)：创建匹配给定输入与此模式的匹配器

public boolean matches()：尝试将整个区域与模式匹配（主要的，前两个了解）

import java.util.regex.Matcher;
import java.util.regex.Pattern;

// 测试类
public class Demo01 {
	public static void main(String[] args) {
		// 模式和匹配器对象的典型的顺序
		// 将正则规则编译成要给模式对象,(会返会一个模式对象)
		Pattern p = Pattern.compile("a*b");// a出现0次或多次
		// 使用模式对象去调用一个matcher()返回一个匹配器对象
		Matcher m = p.matcher("aaaab");

		// 然后再调用匹配器对象的一些功能
		boolean b = m.matches();

		System.out.println(b);// true

		// 最终是一个判断功能,使用之前的方式:
		String regex = "a*b";
		String s = "aaaab";
		boolean b1 = s.matches(regex);
		System.out.println(b1);// true
	}

}