常用类库

最新推荐文章于 2023-05-21 10:18:01 发布

通天云计算

最新推荐文章于 2023-05-21 10:18:01 发布

阅读量608

点赞数

分类专栏：大数据

本文链接：https://blog.csdn.net/WYJ____/article/details/102947479

版权

大数据专栏收录该内容

45 篇文章 1 订阅

订阅专栏

1.API

2.Object类

3.String类

4.StringBuilder类

5.Arrays类

6.包装类

7.Math类

8.Random类

9.Date类

10.SimpleDateFormat

11.Calendar类

12.BigDecimal类

13.正则表达式

一、API

1.概念

API(Application Programming Interface)，应用程序编程接口。

Java API是一本程序员的字典，是JDK中提供给我们使用的类的说明文档。这些类将底层的代码实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可。所以我们可以通过查询API的方式，来学习Java提供的类，并得知如何使用它们。

2.API下载网盘链接

链接：https://pan.baidu.com/s/15LLkDYLcyDk3zruMQlIBwg
提取码：sk4g

3.手动生成API

1.编写一个java文件，包含两块内容。文档注释（/** */），文档注释内容：@author @version（@author @version写在文档的最前面） @param @return；自己写的方法（使用注释@param和@return）。

2.doc进入文件的目录下

3.执行生成文档命令。javadoc -d 生成的文档名称 -author -version 源代码文件

二、Object类

1. Object类型的概述

Object类是所有类型的顶层父类，所有类型的直接或者间接的父类；所有的类型中（包括数组）都含有Object类中的所有方法。随意定义一个类型，不手动显式定义其父类，那么这个类的父类就是Object类。

Object类的构造方法：Object()

1、可以自己创建对象。

2、让子类访问，所有子类都会直接或者间接的访问到这个顶层父类的构造方法。

3、Object类在执行构造方法时，不去访问自己的父类，因为没有父类了。

2. Object类的常见方法

1. hashCode方法。

哈希码：java语言中，Object对象有个特殊的方法：hashCode()，hashCode()表示的是JVM虚拟机为这个Object对象分配的一个int类型的数值，JVM会使用对象的hashCode值来提高对HashSet、HashMap、Hashtable哈希表存取对象的使用效率。

生成数字的原则：

同一个对象多次调用hashCode方法，必须返回相同的整数（程序多次运行不要求哈希码值保持一致）。

使用equals方法判断相同的两个对象，必须返回相同的整数（equals方法是用于决定两个对象是否相同的方法）。

使用equals方法判断不相同的两个对象，尽量返回不相同的整数（不做强制要求）。

Object类型的hashCode，确实会根据不同的对象生成不同的整数。

示例代码

class Test
{
	public static void main(String[] args) 
	{
		User u1 = new User();
		int num = u1.hashCode();  // 获取对象的哈希码值,暂时可以认为是对象在内存的地址
		System.out.println(num);  //366712642

		int num2 = u1.hashCode();
		System.out.println(num2); //366712642
		
		User u2 = u1;
		System.out.println(u2.hashCode()); //366712642
		
		User u3 = new User();
		System.out.println(u3.hashCode());//1829164700
	}
}
class User
{

}

2. getClass方法。

返回当前对象的运行时类。

运行时类：真正创建对象所使用的那个类型。

返回值：class类型对象，就是加载到方法区的那个字节码文件。

代码示例

class Test
{
	public static void main(String[] args) 
	{
		Object obj = new Object();
		System.out.println(obj);//java.lang.Object@15db9742

		Class clazz1 = obj.getClass();
		System.out.println(clazz1);//class java.lang.Object
		System.out.println(clazz1.getName());//java.lang.Object

		Person p1 = new Person();
		Class clazz2 = p1.getClass();
		System.out.println(clazz2);//class Person

	}
}
class Person extends Object
{
	public Person(){
	}
}

class Animal extends Object
{
	public Animal(){
	}
}
class Dog extends Animal
{
	public Dog(){	
	}
}

3. toString方法。

返回当前对象的字符串表示。Object类型中，这个方法的实现：全类名 + @ + 哈希码值的十六进制表示。简称这个内容为：对象的地址值。

示例代码

class Test
{
	public static void main(String[] args) 
	{
		User u1 = new User();
		System.out.println(u1.toString());//User@15db9742
		System.out.println(u1);//User@15db9742 如果不写，系统默认加上
	}
}
class User
{

}

对象返回这样一个地址值的字符串，没有什么意义，因此对于子类而言，需要重写父类的这个方法。

示例代码

class Test
{
	public static void main(String[] args) 
	{
		User u1 = new User();
		System.out.println(u1.toString());//0       null    0
		
	}
}
class User
{
	int id;
	String name;
	int age;
	public String toString() {
		return id+"\t"+name+"\t"+age;
	}
}

4. equals方法

用于比较两个对象是否相等的方法，比较的就是“调用者”和“参数”这两个对象。

性质：

自反性：自己和自己相等。

对称性：A和B相等，那么B就和A相等。A.equals(B)为true，那么B.equals(A)也为true。

传递性：A.equals(B)为true，并且B.equals(C)为true，那么A.equals(C)也为true。

一致性：A多次调用equals方法用于和B对象比较，应该返回相同的判断结果。

在Object类型中，比较的是两个引用是否指向了同一个对象。如果是，才返回true。相当于是在比较两个对象的地址值是否相同。

示例代码

class Test
{
	public static void main(String[] args) 
	{
			User u1 = new User(1,"aa",18);
			User u2 = new User(1,"aa",18);
			boolean b = u1.equals(u2);
			System.out.println(b);//false
		
	}
}
class User{
	private int id;
	private String name;
	private int age;
	
	public User(){	
	}
	
	public User(int id, String name, int age) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	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;
	}	
}

实际应用中，比较两个对象的内存地址，没有什么意义。因此在自定义的子类中，都要重写这个方法。

示例代码

class Test
{
	public static void main(String[] args) 
	{
			User u1 = new User(1,"aa",18);
			User u2 = new User(1,"aa",18);
			boolean b = u1.equals(u2);
			System.out.println(b);//true
		
	}
}
class User{
	private int id;
	private String name;
	private int age;
	
	public User(){	
	}
	
	public User(int id, String name, int age) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	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;
	}	

	//重写equals方法
	public boolean equals(Object obj){
    //定义规则： User类对象的  id name age 都相同时，就返回true 其他返回false
		
    // this 和 参数obj的比较
		User u = (User)obj;  // 强转
		if(this.id==u.getId() && this.name.equals(u.getName()) && this.age==u.getAge()){
			return true;
		}else{
			return false;
		}
	}
}

3. ==和equals方法的区别

相同点：==和equals都是用于比较数据是否相等的方式。

不同点：

1、比较内容的不同：

==可以比较任意数据类型，既可以比较基本数据类型，也可以比较引用数据类型。

equals方法只能比较引用数据类型。

2、比较规则不同：

==在比较基本类型的时候，比较的是数据的值；比较引用类型时，比较的是地址值。

equals方法在重写之前，比较的是两个对象的地址值；在重写之后，按照重写的方式对比。

示例代码

class Test
{
	public static void main(String[] args) 
	{
		int x = 1;
		int y = 1;
		System.out.println(x==y); //true == 比较基本数据类型
		
		User u1 = new User();
		User u2 = new User();
		System.out.println(u1==u2); //false 比较引用数据类型，比较的是地址
		System.out.println(u1.equals(u2)); //false  比较引用数据类型，不能比较基本数据类型，比较的是地址
	}
}
class User
{
}

三、String类

1. 概述

String就是字符串类型，属于java.lang包，不需要导包。

所有的字符串常量（“Hello World”、”abc”）都属于String类型的对象。

字符串字面值属于常量，存储在方法区的常量池中。

String类型在创建之后就无法更改（是一个不可变的字符序列）。不可变的原因是String类型只提供了构造方法，没有提供set方法，因此只能在创建对象的时候，初始化成员变量，将来对象创建完成之后，无法通过方法来修改。

2. 常量池

任何好的编程语言的关键目标之一是高效的使用内存。随着应用程序的增长，String字面值占用大量的内存非常常见。对程序而言，全部String字面值中往往有大量的冗余，为了使Java更高效地使用内存，JVM留出一块特殊的内存区域，称为“String常量池”。当编译器遇到String字面值时，它检查该池内是否已经存在相同的String字面值。如果找到，则将新的字面值的引用指向现有的String，而不创建任何新的String字面值对象。

3. 常见的构造方法

1. String()：创建一个空字符串。

2. String(String original)：创建一个字符串对象，在堆内存中创建了一个参数的副本。如果创建字符串对象时，首先检查常量池中是否有该对象，如果有，不进行创建，进行指向;如果没有该字符串对象，才会在常量池中进行创建。

3. String(byte[] arr)：将一个字节数组转换成一个字符串。将我们不认识的字节数组，转换成我们认识的字符串，过程叫做【解码】。

4. String(byte[] arr, int offset, int length)：将字节数组的一部分转成字符串。

5. String(char[] arr)：将字符数组转成字符串。既不是编码，也不是解码，只不过把字符数组转成了字符串。

6. String(char[] arr, int offset, int length)：将字符数组的一部分转成字符串。

示例代码

class Test
{
	public static void main(String[] args) 
	{
		//byte[] b = new byte[]{};

		String str = new String(new byte[]{65,66,67,68,69});
		System.out.println(str);//ABCDE

		String str2 = new String(new byte[]{65,66,67,68,69},2,3);//从第几个元素开始，取几个
		System.out.println(str2);//CDE

		String str3 = new String(new char[]{'a','b','c','d','e'});
		System.out.println(str3);//abcde

		String str4 = new String(new char[]{'a','b','c','d','e'},2,3);
		System.out.println(str4);//cde	
	}
}

4. 内存图

5. new和不new的区别

String实质是字符数组，两个特点：1、该类不可被继承；2、不可变性(immutable)。

示例 String s1 = new String(“myString”); 和 String s1 = “myString”;。

第一种方式通过关键字new定义过程：
1. 在程序编译期，编译程序先去字符串常量池检查，是否存在“myString”,如果不存在，则在常量池中开辟一个内存空间存放“myString”；如果存在的话，则不用重新开辟空间，保证常量池中只有一个“myString”常量，节省内存空间。
2. 然后在内存堆中开辟一块空间存放new出来的String实例，在栈中开辟一块空间，命名为“s1”，存放的值为堆中String实例的内存地址，这个过程就是将引用s1指向new出来的String实例。
3. 你会发现String s1 = new String(“myString”); 这一句代码实际上可能创建了2个对象, 一个是String对象,存放在堆中, 一个是字符串常量对象,存放在串池中。

第二种方式直接定义过程：
在程序编译期，编译程序先去字符串常量池检查，是否存在“myString”，如果不存在，则在常量池中开辟一个内存空间存放“myString”；如果存在的话，则不用重新开辟空间。然后在栈中开辟一块空间，命名为“s1”，存放的值为常量池中“myString”的内存地址（相当于指向常量池中的“myString”）。

6. String类的方法介绍

（1）判断功能的方法

1. equals(Object obj)：判断调用者和参数对象描述的字符串内容是否相同。

2. equalsIgnoreCase(String otherStr)：忽略大小写判断两个字符串内容是否相同。

3. contains(String str)：判断调用者是否包含了str这个子串。

4. startsWith(String prefix)：判断调用者是否以prefix开头。

5. endsWith(String suffix)：判断调用者是否以suffix结尾。

6. isEmpty()：判断调用者是否是空串。

示例代码

class Test
{
	public static void main(String[] args) 
	{
                //equals判断调用者和参数对象描述的字符串内容是否相同
		String s1 = "aaa";
		String s2 = new String("aaa");
		System.out.println(s1.equals(s2));//true
  
                //equalsIgnoreCase忽略大小写判断两个字符串内容是否相同
		String str1 = "aaa";
		String str2 = "AAA";
		System.out.println(str1.equals(str2));//false
		System.out.println(str1.equalsIgnoreCase(str2));//true

                //contains判断调用者是否包含了str这个子串
		String str = "abcde";
		System.out.println(str.contains("ab"));//true
		System.out.println(str.contains("zxc"));//false

                //startsWith判断调用者是否以prefix开头
		String s = "abcdefg";
		System.out.println(s.startsWith("abc"));//true
		System.out.println(s.startsWith("zxc"));//false

                //endsWith判断调用者是否以suffix结尾
		System.out.println(s.endsWith("fg"));//true
		System.out.println(s.endsWith("zxc"));//false

                //isEmpty判断调用者是否是空串
		String ks1 = "";
		String ks2 = new String();
		String ks3 = new String("");
		String ks4 = " ";
		System.out.println(ks1.isEmpty());//true
		System.out.println(ks2.isEmpty());//true
		System.out.println(ks3.isEmpty());//true
		System.out.println(ks4.isEmpty());//false

	}
}

（2）获取功能的方法

1. length()：获取字符串字符的个数。

2. charAt(int index)：返回调用者字符串中索引为index的字符（和length方法结合之后可以遍历字符串）。

3. substring(int beginIndex)：获取一个字符串，内容是从当前字符串的beginIndex索引开始。

4. substring(int beginIndex, int endIndex)：获取一个指定索引范围的子串。

注意事项：1、包含头不包含尾，返回的结果中，不包含endIndex索引指向的字符；2、所有的方法都无法修改字符串对象本身，一般都是返回一个新的字符串对象。

5. indexOf(int ch)：返回ch字符在当前调用者字符串中，第一次出现的索引。

6. indexOf(int ch, int fromIndex)：从fromIndex索引开始寻找，找到ch字符在当前字符串中第一次出现的索引。

7. indexOf(String str)：返回的是str这个字符串在调用者字符串中第一次出现的索引。

8. indexOf(String str, int fromIndex)：从fromIndex索引开始寻找，找到str字符串在当前字符串中第一次出现的索引（注意：无论从哪个位置开始找，所有字符的索引都不会变化）。

9. lastIndexOf：和IndexOf基本一样，只不过是从后往前找，所有字符和字符串的索引也都不会发生变化，返回指定字符最后一次出现的索引。

示例代码

class Test
{
	public static void main(String[] args) 
	{
		//1.length获取字符串长度（由多少个字符组成）
		String str1 = "abc";

		int x = str1.length();
		System.out.println(x);//3

		//2 charAt 获取某个位置上的字符
		String str2 = "abcde";

		char c = str2.charAt(1);
		System.out.println(c);//b

		//3 substring 截取子串
		String str3 = "abcdfg";

		String result1 = str3.substring(2);
		System.out.println(result1);//cdfg

		String result2 = str3.substring(2,4);
		System.out.println(result2);//cd

		//4 indexOf 查找位置
		String str4 = "abcdebcd";
		int idx1 = str4.indexOf("bc");
		System.out.println(idx1);//1

		int idx2 = str4.indexOf("bc",3);
		System.out.println(idx2);//5

		int idx3 = str4.indexOf("bc",-3);
		System.out.println(idx3);//1  第二个参数为负数，相当于0

		int idx4 = str4.indexOf("zx");
		System.out.println(idx4);//-1  找不到时，返回-1

		//5 lastIndexOf 查找位置  从后向前找
		String str5 = "abcdebcd";

		int idx6 = str5.lastIndexOf("bc");
		System.out.println(idx6);//5

		int idx7 = str5.lastIndexOf("bc",3);
		System.out.println(idx7);//1

		int idx8 = str5.lastIndexOf("zx");
		System.out.println(idx8);//-1 找不到时返回-1

	}
}

（3）转换功能的方法

1. getBytes()：将当前字符串，转成字节数组。

2. toCharArray():将字符串转成字符数组。

3. toUpperCase()：将当前的字符串，转成全大写形式。

4. toLowerCase()：将当前的字符串，转成全小写形式。

5. concat(String str)：将当前调用者，和参数str进行拼接，返回拼接后的长字符串（不常用，因为更多使用的是运算符+）。

6. valueOf家族：可以将任意数据类型的数据，转换成字符串。

示例代码

class Test
{
	public static void main(String[] args) 
	{
		// 1 getBytes  将字符串转换成字节数组
		String str1 = "abcd";
		byte[] b = str1.getBytes();
		for(byte bb:b){
			System.out.print(bb+" ");
		}//97 98 99 100

		// 2 toCharArray 将字符串转成字符数组
		String str2 = "abcd";
		char[] cc = str2.toCharArray();
		for(char c:cc){
			System.out.print(c+" ");
		}//a b c d

		// 3 toUpperCase 小写转大写
		String str3 = "abcd";
		String s3 = str3.toUpperCase();
		System.out.print(s3);//ABCD

		//4 toLowerCase 大写转小写
		String str4 = "ABCD";
		String s4 = str4.toLowerCase();
		System.out.println(s4);//abcd

		//5 concat 用来拼接字符串  和 +的作用相同 . 不同点： + 可以加任何类型   而concat只能拼接字符串
		String str5 = "aaa";
		String s5 = "bbb";
		String ss5 = str5.concat(s5);
		System.out.println(ss5);//aaabbb

		//6 valueOf 将其他类型转换成字符串   静态方法
		int x = 100;
		String str6 = String.valueOf(x);
		System.out.println(str6+2);//1002

	}
}

练习：键盘录入一个大小写混杂的纯英文字符串。将字符串转换成首字母大写，其他字母全部小写。

import java.util.Scanner;
class Test
{
	public static void main(String[] args) 
	{
		Scanner sc = new Scanner(System.in);
		String str = sc.nextLine();  // 首字母转大写，其他小写
		
		String s1 = str.substring(0,1); //截取首字母
		String s2 = str.substring(1);   //截取其他
		
		String result = s1.toUpperCase()+s2.toLowerCase();
		System.out.println(result);
	}
}

（4）其他方法

1. replace(String oldStr, String newStr)：将调用者中的旧串替换成新串。

2. trim()：去掉字符串左右两边的空格、制表符。

3. split():字符串拆分。

示例代码

class Test
{
	public static void main(String[] args) 
	{
		//1.replace：将调用者中的旧串替换成新串
		String str1 = "abcdef";
		String s1 = str1.replace("a","b");
		System.out.println(s1);//bbcdef

		// 2.trim 去首尾空格
		String str2 = "  aaa  bbb        ";
		String s2 = str2.trim();
		System.out.println(s2);//aaa  bbb

		// 3.split 字符串拆分   拆成数组
		String str3 = "aaa#bbb#ccc#ddd";
		String[] s3 = str3.split("#");
		for(String s:s3){
			System.out.println(s);//aaabbbcccddd
		}
	}
}

四、StringBuilder类

1. 概述

StringBuilder是一个可变的字符序列，因为在类中提供了修改私有成员变量的方法。常用的方法是append和insert，就是在StringBuilder对象本身上，进行修改操作。

StringBuilder底层和String类型一样，也是维护了一个字符数组，数组是私有的，外界无法直接访问，因此在StringBuilder或者String中对数组进行操作的公有方法的封装。

2. 构造方法

（1）StringBuilder的构造方法：

1. StringBuilder()：创建一个生成器，初始容量为16个字符。

2. StringBuilder(int capacity)：创建一个生成器，初始容量为capacity大小。

3. StringBuilder(String str)：创建一个生成器，初始值就是str这些字符，初始大小是str+16。

（2）获取容积的方法：

1.capacity()：获取当前生成器的容器大小。

2. length()：获取当前生成器中的字符个数。

示例代码

class Test
{
	public static void main(String[] args) 
	{
		StringBuilder sb1 = new StringBuilder();
		int length1 = sb1.length();
		System.out.println(length1);//0
		int capacity1 = sb1.capacity();
		System.out.println(capacity1);//16

		StringBuilder sb2 = new StringBuilder("abc");
		int length2 = sb2.length();
		System.out.println(length2);//3
		int capacity2 = sb2.capacity();
		System.out.println(capacity2);//19  //获取容量  这种初始化方式     用字符串的长度+16
		
	}
}

3. 添加

1. append(任意类型)：可以将任意数据类型，转成字符，添加到生成器中。

2. insert(int index, 任意数据类型)：可以将任意数据类型，添加到指定的位置。

注意事项：1、index的范围是0~当前缓冲区的大小；2、插入数据之后，数据本身的索引就是参数中指定的index。

示例代码

class Test
{
	public static void main(String[] args) 
	{
		StringBuilder sb = new StringBuilder("abc");
		sb.append("xyz");
		System.out.println(sb);//abcxyz
		sb.insert(1,"hello");
		System.out.println(sb);//ahellobcxyz
	}
}

4. 删除

1. deleteCharAt(int index) ：删除指定索引的字符。

2. delete(int start, int end)：删除指定范围的字符，被删除的部分包含头不包含尾。

示例代码

class Test
{
	public static void main(String[] args) 
	{
		StringBuilder sb = new StringBuilder("abcdefg");
		sb.deleteCharAt(1);
		System.out.println(sb);//acdefg

		StringBuilder sb2 = new StringBuilder("abcdefg");
		sb2.delete(1,3);
		System.out.println(sb2);//adefg
		
	}
}

5. 替换和反转

1. replace(int start, int end ,String str)：将字符串缓冲区中的从start开始到end-1这部分内容，替换成str。

2. reverse()：将原有字符序列进行反转。

示例代码

class Test
{
	public static void main(String[] args) 
	{
		StringBuilder sb = new StringBuilder("abcdefg");
		sb.replace(1,3,"hello");
		System.out.println(sb);//ahellodefg

		StringBuilder sb2 = new StringBuilder("abcdefg");
		sb2.reverse();
		System.out.println(sb2);//gfedcba
		
	}
}

练习：定义一个方法，接收一个String类型的字符串，返回该字符串的反转形式。

class Test
{
	public static void main(String[] args) 
	{
		String str = "abc";
		String result = fanzhuan(str);
		System.out.println(result);//cba
	}
	public static String fanzhuan(String str){
		StringBuilder sb = new StringBuilder(str);
		sb.reverse();
		return sb.toString();
	}
}

6. String和StringBuilder拼接字符串的区别

使用String类型拼接字符串：时间和空间上都非常浪费。

1、创建一个StringBuilder的存储空间，大小为第一个字符串的长度+16（第一个对象）。

2、将第一个字符串添加到缓冲区中。

3、将第二个字符串添加到缓冲区中。

4、将缓冲区对象转成字符串对象（创建了一个新的字符串对象）（第二个对象）。

5、返回该字符串对象。

使用StringBuilder拼接字符串：时间和空间上都非常节省，无论循环多少次，都只创建两个对象。

1、创建一个新的StringBuilder的存储空间。

2、在StringBuilder的基础上进行添加，不创建新的字符串。

3、循环完成后，将StringBuilder转成String。

练习：定义一个方法，接收一个int[]类型的数组，返回该数组的字符串表示形式。

class Test
{
	public static void main(String[] args) 
	{
		int[] aa = {1,2,3,4,5};
		//String str = arrStr(aa);
		String str = arrStr2(aa);
		System.out.println(str);	//[1,2,3,4,5]
	}
	public static String arrStr(int[] aa){
		StringBuilder sb = new StringBuilder("[");
		for(int i=0;i<aa.length;i++){
			sb.append(aa[i]).append(i==aa.length-1?"]":",");
		}
		return sb.toString();
	}
	public static String arrStr2(int[] aa){
		String result = "[";
		for (int i = 0; i < aa.length; i++) {
			result += aa[i] + (i == aa.length - 1 ? "]" : ", ");//String 使用+拼接字符串时,底层会转换成StringBuilder。拼完后再转成String。这样做内存中会创建更多的对象，而且转换过程也比较耗时。
		}
		return result;
	}
}

7. String和StringBuilder的相互转换

String转成StringBuilder

1. StringBuilder的构造方法。

2. append方法。

StringBuilder转成String类型

1. toString的方法。

2. 使用String的构造方法。

示例代码

class Test
{
	public static void main(String[] args) 
	{
		String str = "abc";
		StringBuilder sb = new StringBuilder(str);
		String result = sb.toString();
	}
}

8. String和StringBuilder作为方法的参数

1. String作为方法的参数进行传递，无法修改原值。在被调用的方法中，修改引用指向的对象，和主方法中的引用无关。

2. StringBuilder作为方法的参数进行传递，如果在被调用的方法中，修改的是StringBuilder的引用，那么不会改变原有对象中的数据。

3. StringBuilder作为方法的参数进行传递，如果在被调用的方法中，通过该引用修改了对象的数据，那么原值就会发生改变。

9. String和StringBuilder的区别

相同点：都是用于描述字符串。

不同点：

1. String是不可变的字符序列，没有提供修改私有成员的方法；StringBuilder是可变的字符序列，因为提供了修改成员变量的方法。

2. String长度本身也不可以变化，StringBuilder长度可以变化，可以认为StringBuilder就像一个可以伸缩的容器，用于存储字符。

10. StringBuffer和StringBuilder的区别

相同点：都是字符串的缓冲区，都是字符串的生成器，都是可变的字符序列。

不同点：

1. 出现版本不同：

StringBuffer在jdk1.0出现的。

StringBuilder在jdk1.5出现的。

2. 线程安全性不同：

StringBuffer是线程安全的，在多线程环境下仍然保证数据安全。

StringBuilder是线程不安全，在多线程环境下无法保证数据安全。

3. 效率不同：

StringBuffer效率低。

StringBuilder效率高。

五、Aarrays工具类

Arrays类为数组操作的工具类，提供了大量对数组进行操作的静态方法。

1.toString()

作用：把数组变成字符串格式

代码示例

import java.util.Arrays;

public class Test {

	public static void main(String[] args) {
		int[] arr = {1,2,3,4,5};
		System.out.println(Arrays.toString(arr));//[1, 2, 3, 4, 5]
	}
}

2.sort()

作用：对数组的元素进行排序

代码示例

import java.util.Arrays;

public class Test {

	public static void main(String[] args) {
		int[] arr = {4,5,1,3,2};
		Arrays.sort(arr);
		System.out.println(Arrays.toString(arr));//[1, 2, 3, 4, 5]
		
		String[] ss = {"aaaxxx","bbb","abc","baa","xyz"};
		Arrays.sort(ss);
		System.out.println(Arrays.toString(ss));//[aaaxxx, abc, baa, bbb, xyz]
	}
}

3.binarySearch()

作用：二分查找，查找某个值在数组的索引位置

注：要使用binarySearch必须先对数组进行排序，如果不排序，结果是不正确的。如果它包含在数组中，则返回搜索键的索引，否则返回-1。

代码示例

import java.util.Arrays;

public class Test {

	public static void main(String[] args) {
		int[] arr = {1,2,3,4,5,6,7,8,9};
		
		int index = Arrays.binarySearch(arr, 5);
		System.out.println(index);//4
		
		int index2 = Arrays.binarySearch(arr, 0);
		System.out.println(index2);//-1

	}
}

4.fill()

作用：将指定的值分配给指定的数组的每个元素

代码示例

import java.util.Arrays;

public class Test {

	public static void main(String[] args) {
		int[] arr = {1,2,3,4,5,6,7,8,9};
		Arrays.fill(arr, 1);
		System.out.println(Arrays.toString(arr));//[1, 1, 1, 1, 1, 1, 1, 1, 1]
	}
}

5.equals()

作用：如果指定的两个数组相等，则返回true，否则返回false。

代码示例

import java.util.Arrays;

public class Test {

	public static void main(String[] args) {
		int[] arr1 = {1,2,3,4,5};
		int[] arr2 = {1,2,3,4,5};
		int[] arr3 = {1,1,1,1,1};
		
		boolean b1 = Arrays.equals(arr1, arr2);
		System.out.println(b1);//true
		
		boolean b2 = Arrays.equals(arr1, arr3);
		System.out.println(b2);//false
		
	}
}

6.copyOf()

作用：从指定的数组拷贝指定长度的数据。

代码示例

import java.util.Arrays;

public class Test {

	public static void main(String[] args) {
		int[] arr1 = {1,2,3,4,5};
		int[] arr2 = Arrays.copyOf(arr1, 3);
		System.out.println(Arrays.toString(arr2));//[1, 2, 3]
	}
}

六、包装类

1.为什么会有包装类

java语言一直宣称自己是完全面向对象的语言，但对于基本数据类型并没有做到面向对象。

int x = 100 在方法调用时，在桟内存为基本数据类型变量分配空间。

对应每个基本数据类型，都有一个对象类型与之对应，为之服务。

byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Chracter
boolean	Boolean

2.包装类的作用

包装类是基本数据类型与引用类型之间的桥梁

3.Integer示例

（1）成员属性

static int	BYTES 用于表示二进制补码二进制形式的 int值的字节数。
static int	MAX_VALUE 一个持有最大值一个 int可以有2 31 -1。
static int	MIN_VALUE 的常量保持的最小值的 int可以具有，-2 31。
static int	SIZE 用于表示二进制补码二进制形式的 int值的位数。
static 类<Integer>	TYPE 类原始类型 int的类实例。

代码示例

public class Test {
	public static void main(String[] args) {
		System.out.println(Integer.BYTES);//4
		System.out.println(Integer.MAX_VALUE);//2147483647
		System.out.println(Integer.MIN_VALUE);//-2147483648
		System.out.println(Integer.SIZE);//32
		System.out.println(Integer.TYPE);//int
	}
}

（2）构造方法

Integer(int value)

构造一个新分配的 Integer对象，该对象表示指定的 int值。

Integer(String s)

构造一个新分配 Integer对象，表示 int由指示值 String参数。

代码示例

public class Test {
	public static void main(String[] args) {
		Integer integer = new Integer(20);
		System.out.println(integer);//20

		//字符串转为Integer
		Integer integer2 = new Integer("123");
		System.out.println(integer2);//123
	}
}

（3）成员方法

xxxValue()：可以将Integer类型的对象，转化成其他的基本数据类型。

static int	parseInt(String s) 将字符串参数解析为带符号的十进制整数。
static int		parseInt(String s, int radix) 将字符串参数解析为第二个参数指定的基数中的有符号整数。（第二个参数代表字符串数值的进制）
static String		toBinaryString(int i) 在基数2中返回整数参数的字符串表示形式为无符号整数。
static String		toOctalString(int i) 在基数8中返回整数参数的字符串表示形式为无符号整数。
static String		toHexString(int i) 返回整数参数的字符串表示形式，作为16位中的无符号整数。
static Integer		valueOf(int i) 返回一个 Integer指定的 int值的 Integer实例。

代码示例

public class Test {
	public static void main(String[] args) {

		//将字符串解析为带符号的十进制整数
		int x = Integer.parseInt("120");
		System.out.println(x);//120
		//第二个参数代表字符串数值的进制
		int y = Integer.parseInt("1001",2);
		System.out.println(y);//9

		//十进制转为二进制
		String str = Integer.toBinaryString(9);
		System.out.println(str);//1001

	}
}

（4）Integer、int、String类型相互转换总结

//Integet和int相互转化
public class Test {

	public static void main(String[] args) {
		//Integer转int
		Integer i = new Integer(123);//intValue
		int d = i.intValue();
		System.out.println(d);
		
		//int转Integer
		Integer integer2 = Integer.valueOf(111);//valueOf
		System.out.println(integer2);	
		
		Integer integer = new Integer(111);//构造方法
		System.out.println(integer);
	}
}

//Integet和String相互转化
public class Test {

	public static void main(String[] args) {
		//Integer -> String
		Integer i = 100;
		
		String s = i.toString();//toString
		System.out.println(s);
		
		String s2 = String.valueOf(i);
		System.out.println(s2);
		
		
		//String -> Integer
		Integer integer = Integer.valueOf("111");//valueOf
		System.out.println(integer);
		
		Integer integer2 = new Integer("111");//构造方法
		System.out.println(integer2);
		
	
	}

}

//int和String相互转化
public class Test {

	public static void main(String[] args) {
		//int -> String
		int number = 100;	

		String s1 = ""+number;
		System.out.println(s1);		

		String s2 = String.valueOf(number);
		System.out.println(s2);		

		String s3 = Integer.toString(number);
		System.out.println(s3);
		
		
		//String -> int
		String ss = "111";
		
		Integer ii = new Integer(ss);
		int x = ii.intValue();
		System.out.println(x);
		
		int y = Integer.parseInt(ss);
		System.out.println(ss);
	}

}

（5）自动拆箱和装箱

jdk1.5之后，提供了一个很有趣的特性：自动进行“装箱”和“拆箱”。就是在int和Integer之间，double和Double之间等，进行相互转换的时候，可以不显示的写出代码，java就会自动替我们完成转换。

装箱：将基本数据类型进行包装变成了引用数据类型

拆箱：将引用数据类型编程基本数据类型。

代码示例

public class Test {
	public static void main(String[] args) {

		//自动装箱
		Integer i = 20;//代替了Integer i = new Integer(20);
		System.out.println(i);//20

		Integer integer = new Integer(20);
		//自动拆箱
		int result = integer + 20;
		System.out.println(result);//40

	}
}

七、Math类

作用：Math类封装了数学的功能（都是静态方法和静态属性）。

1.常用属性

static double

double值比其他任何一个都更接近 e ，自然对数的基数。

static double

double值比任何其他的更接近 pi ，圆周长与其直径的比率。

代码示例

public class Test {

	public static void main(String[] args) {
		System.out.println(Math.E);//2.718281828459045
		System.out.println(Math.PI);//3.141592653589793
	}
}

2.常用方法

static int

abs(int a)

返回值为 int绝对值。

代码示例

public class Test {

	public static void main(String[] args) {
		
		int a = -1;
		System.out.println(Math.abs(a));//1
	}
}

static double

cbrt(double a)

返回（开立方根）

代码示例

public class Test {

	public static void main(String[] args) {
		
		double a = 27;
		System.out.println(Math.cbrt(a));//3.0
	}
}

static double

sqrt(double a)

返回的正确舍入正平方根 double值。

代码示例

public class Test {

	public static void main(String[] args) {
		
		double a = 9;
		System.out.println(Math.sqrt(a));//3.0
	}
}

static double

ceil(double a)

返回a的向上取整

static double

floor(double a)

返回小于或等于参数的最大（最接近正无穷大） double值，等于一个数学整数。

代码示例

public class Test {

	public static void main(String[] args) {	

		double a = 4.5;
		System.out.println(Math.ceil(a));//5.0
		System.out.println(Math.floor(a));//4.0
	}
}

static int

max(int a, int b)

返回两个 int值中的较大值。

static int

min(int a, int b)

返回两个 int的较小值。

代码示例

public class Test {

	public static void main(String[] args) {	

		int a = 1;
		int b = 2;
		System.out.println(Math.max(a, b));//2
		System.out.println(Math.min(a, b));//1
		
	}
}

static double

random()

返回值为 double值为正号，大于等于 0.0 ，小于 1.0 。

代码示例

public class Test {

	public static void main(String[] args) {	

		double a = Math.random();//0.6758339260785278
		System.out.println(a);
		
		int b = (int)(Math.random()*10+1);
		System.out.println(b);//8
		
	}
}

static int

round(float a)

返回参数中最接近的 int ，其中 int四舍五入为正无穷大。

代码示例

public class Test {

	public static void main(String[] args) {	

		long a = Math.round(4.5);
		System.out.println(a);//5
		
		long b = Math.round(3.4);
		System.out.println(b);//3
		
	}
}

八、Random类

1.作用

相对于Math的random方法只能产生0到1之间的随机数，java提供了一个功能更强大的随机数生产类Random类。

2.构造方法

Random()

创建一个新的饿随机数生成器

Random(long seed)

使用单个long种子创建一个新的随机数生成器

3.常用方法

boolean

nextBoolean()

返回下一个随机数，从这个随机数发生器的序列中均匀分布boolean值

代码示例

import java.util.Random;

public class Test {

	public static void main(String[] args) {	
		
	   Random r = new Random();
	   boolean b = r.nextBoolean();
	   System.out.println(b);//true
	}
}

int

nextInt()

返回下一个伪随机数，从这个随机数发生器的序列中均匀分布

代码示例

import java.util.Random;

public class Test {

	public static void main(String[] args) {	
		
	   Random r = new Random();
	   int a = r.nextInt();
	   System.out.println(a);//2034162537
	}
}

int

nextInt(int bound)

返回伪随机数，均匀分布int值介于0（包括）和指定值（不包括）

代码示例

import java.util.Random;

public class Test {

	public static void main(String[] args) {	
		
	   Random r = new Random();
	   int a = r.nextInt(10);
	   System.out.println(a);//9
	}
}

九、Date类

1.概述

Date表示日期的“逻辑值”，而不是日期显示的样式。样式另外的类SimpleDateFormat来控制。

2.构造方法

Date

系统当前时间

Date(long date)

创建一个距离1970-01-01 00:00:00 date毫秒的时间（因为有时差，所以得到的实验结果都是从08:00:00开始）

代码示例

import java.util.Date;

public class Test {

	public static void main(String[] args) {	
		Date d1 = new Date();
		System.out.println(d1);//Sun Nov 10 20:52:27 CST 2019
		
		Date d2 = new Date(3000);
		System.out.println(d2);//Thu Jan 01 08:00:03 CST 1970
		
		Date d3 = new Date(System.currentTimeMillis());
		System.out.println(d3);Sun Nov 10 20:52:27 CST 2019
	   
	}
}

3.常用方法

boolean

after(Date when)

测试此日期是否在指定日期之后。

boolean

before(Date when)

测试此日期是否在指定日期之前。

import java.util.Date;

public class Test {

	public static void main(String[] args) {	
		Date d1 = new Date();
		System.out.println(d1);//Sun Nov 10 20:52:27 CST 2019
		
		Date d2 = new Date(3000);
		System.out.println(d2);//Thu Jan 01 08:00:03 CST 1970
		
		System.out.println(d1.before(d2));//false
		System.out.println(d1.after(d2));//true
	   
	}
}

long

getTime()

返回自1970年1月1日以来，由此 Date对象表示的00:00:00 GMT的毫秒数。

void

setTime(long time)

设置此 Date对象以表示1970年1月1日00:00:00 GMT后的 time毫秒的时间点。

代码示例

import java.util.Date;

public class Test {

	public static void main(String[] args) {	
		Date d1 = new Date(3000);
		System.out.println(d1);//Thu Jan 01 08:00:03 CST 1970
		
		long time = d1.getTime();
		System.out.println(time);//3000
		
		Date d2 = new Date(0);
		System.out.println(d2);//Thu Jan 01 08:00:00 CST 1970
		
		d2.setTime(3000);
		System.out.println(d2);//Thu Jan 01 08:00:03 CST 1970
	}
}

十、SimpleDateFormat

1.概述

作用：把Date对象转化为年月日时分秒格式字符串。把字符串转化为Date对象。

2.构造方法

SimpleDateFormat()

构造一个 SimpleDateFormat使用默认模式和日期格式符号为默认的 FORMAT区域设置。

SimpleDateFormat(String pattern)

使用给定模式 SimpleDateFormat并使用默认的 FORMAT语言环境的默认日期格式符号。

3.常用方法

String

format(Date date)

将日期格式化成日期/时间字符串。

Date

parse(String source)

从给定字符串的开始解析文本以生成日期。


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

public class Test {

	public static void main(String[] args) throws ParseException{	
		
		SimpleDateFormat sdf = new SimpleDateFormat();
		String str = sdf.format(new Date());
		System.out.println(str);//19-11-10 下午9:31
		
		
		SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH-mm-ss");
		String str1 = sdf1.format(new Date());
		System.out.println(str1);//2019-11-10 21-31-05
		
		SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy:MM:dd HH:mm:ss");	
		Date date = sdf2.parse("2019:11:08 15:59:00");
		System.out.println(date.getTime());//1573199940000
		
	}
}

练习：键盘录入一个自己的生日，计算今天是自己出生的第几天


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

public class Test {

	public static void main(String[] args) throws ParseException{	
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入你的出生日期（xx年xx月xx日）：");
		String str = sc.next();
		
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
		
		Date d1 = sdf.parse(str);
		Date d2 = new Date();
		
		long d = d2.getTime() - d1.getTime();
		
		System.out.println(d/1000/60/60/24);
		
	}
}

十一、Calendar类

1.作用

Calendar是一个抽象类，表示日历，不能直接实例化，通常使用getInstance()方法来获取实例。

创建方式：Calendar calendar = Calendar.getInstance();

2.常用方法

Date

getTime()

返回Date类型时间

void

setTime()

使用给定的Date设置此日历时间

代码示例

import java.util.Calendar;
import java.util.Date;

public class Test {

	public static void main(String[] args) {	
		
		Calendar cal = Calendar.getInstance();//系统当前时间
		
		Date date = cal.getTime();
		System.out.println(date);//Sun Nov 10 22:31:57 CST 2019
		
		Date d = new Date(3000);
		cal.setTime(d);		
		System.out.println(cal.getTime());//Thu Jan 01 08:00:03 CST 1970
		
	}
}

int

get(int field)

返回给定日历字段的值

void

set(int year,int month,int date)

设置日历中字段的值（设置时间到日历中，月份从0到11）

代码示例

import java.util.Calendar;
import java.util.Date;

public class Test {

	public static void main(String[] args) {	
		
		Calendar cal = Calendar.getInstance();//系统当前时间
		
		int year = cal.get(cal.YEAR);
		System.out.println(year);//2019
		int month = cal.get(cal.MONTH);
		System.out.println(month+1);//11 +1才是当前月份
		int day = cal.get(cal.DATE);
		System.out.println(day);//10
		int hour = cal.get(cal.HOUR);
		System.out.println(hour);//10
		int minute = cal.get(cal.MINUTE);
		System.out.println(minute);//42
		int second = cal.get(cal.SECOND);
		System.out.println(second);//5	
		int date = cal.get(cal.DAY_OF_WEEK);
		System.out.println(date);//1 获得的是这个星期的第几天，星期日是第一天
		
		cal.set(2020, 11, 11);
		System.out.println(cal.getTime());//Fri Dec 11 22:46:51 CST 2020
		
		
	}
}

abstract void

add(int field,int amount)

根据日历的规则，将指定的时间量添加或减去给定的日历字段

第一个参数是字段（月份，天，小时..），第二个参数是增量。

代码示例

import java.util.Calendar;

public class Test {

	public static void main(String[] args) {	
		
		Calendar cal = Calendar.getInstance();//系统当前时间
		
		cal.add(cal.MONTH, 0);//Sun Nov 10 23:06:08 CST 2019
		System.out.println(cal.getTime());
		
		cal.add(cal.DATE, 1);
		System.out.println(cal.getTime());//Mon Nov 11 23:06:08 CST 2019
		
	}
}

long

getTimeInMillis()

以毫秒为单位返回此日历的值

代码示例

import java.util.Calendar;

public class Test {

	public static void main(String[] args) {	
		Calendar cal = Calendar.getInstance();
		long d = cal.getTimeInMillis();
		System.out.println(d);//1573435590845
		
	}	
}

练习：判断闰年

import java.util.Calendar;
import java.util.Scanner;

public class Test {

	public static void main(String[] args) {	
		
		Calendar c = Calendar.getInstance();
		Scanner sc = new Scanner(System.in);
		int year = sc.nextInt();
		c.set(year,2,1);
		
		c.add(c.DAY_OF_MONTH, -1);
		if(c.get(c.DAY_OF_MONTH)==29){
			System.out.println("闰年");
		}
		else {
			System.out.println("平年");
		}
		
	}	
}

十二、BigDecimal类

1.作用

float、double两种浮点数类型运算不够精确，不仅是java语言，很多编程语言都有这样的问题。为了能够精确表示和计算浮点数，java提供了BigDecimal类。

2.用法

代码示例

import java.math.BigDecimal;

public class Test {

	public static void main(String[] args) {	
		
		double x = 0.1;
		double y = 0.2;
		double z1 = x + y;
		System.out.println(z1);//0.30000000000000004
		
		BigDecimal b1 = new BigDecimal(x+"");
		BigDecimal b2 = new BigDecimal(y+"");
		
		BigDecimal b3 = b1.add(b2);	
		System.out.println(b3);//0.3
		
		double result1 = b3.doubleValue();
		System.out.println(result1);//0.3
		
		double result2 = b1.subtract(b2).doubleValue();
		System.out.println(result2);//-0.1
		
		double result3 = b1.multiply(b2).doubleValue();
		System.out.println(result3);//0.02
		
		double result4 = b1.divide(b2).doubleValue();
		System.out.println(result4);//0.5	
		
	}
}

十三、正则表达式

1.概念

正则表达式是一个强大的字符串处理工具，可以对字符串进行查找、提取、分割、替换等工作。

其实正则表达式是一个非常简单而且实用的工具。

正则表达式是一个用来匹配字符串的模板

在java中定义的任何字符串都可以作为正则表达式使用。

2.判断字符串是和否匹配正则表达式的方式

（1）方式一

将一个字符串编译成Pattern对象。Pattern p = Pattern.compile(正则表达式);

使用Pattern对象创建Matcher对象 Matcher m = p.matcher(要匹配的字符串);

调用Matcher类的matches()方法 m.matches() 返回true表示匹配，返回false表示不匹配

示例代码

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

public class Test {

	public static void main(String[] args) {	
		String regex = "abc";  //正则表达式
		Pattern p = Pattern.compile(regex);//把regex这个字符串当成正则
		String str = "aaa";//字符串      要判断str这个字符串是否匹配 regex正则
		Matcher m = p.matcher(str);
		System.out.println(m.matches());//false
    }
}

（2）方式二

使用Pattern下的静态方法 matches()

Pattern.matches(正则，字符串)

示例代码

import java.util.regex.Pattern;

public class Test {

	public static void main(String[] args) {	
		String regex = "abc";
		String str = "abc";
		System.out.println(Pattern.matches(regex, str));//true
    }
}

（3）方式三

String类下提供了直接匹配的方法

str.matches(正则)

代码示例

public class Test {

	public static void main(String[] args) {	
		String regex = "abc";
		String str = "abcd";
		System.out.println(str.matches(regex));//false
    }
}

3.正则表达式的符号

（1）预定义字符类

.	任何字符（与行结束符可能匹配也可能不匹配）
\d	数字：[0-9]
\D	非数字： [^0-9]
\s	空白字符：[ \t\n\x0B\f\r]
\S	非空白字符：[^\s]
\w	单词字符：[a-zA-Z_0-9]
\W	非单词字符：[^\w]

示例代码

public class Test {

	public static void main(String[] args) {
		//method01();
		//method02();
		//method03();
		//method04();
		//method05();
		//method06();

	}
	private static void method01() {
		String regex = ".";
		System.out.println("a".matches(regex));//true
		System.out.println("ab".matches(regex));//false
		System.out.println("@".matches(regex));//true		
		System.out.println(".".matches(regex));//true
		System.out.println("a".matches("\\."));//false
	}
	
	private static void method02() {
		String regex = "\\d";
		System.out.println("1".matches(regex));//true
		System.out.println("a".matches(regex));//false
		System.out.println("12".matches(regex));//false		
	}

	private static void method03() {
		String regex = "\\D";
		System.out.println("1".matches(regex));//false
		System.out.println("A".matches(regex));//true
		System.out.println("12".matches(regex));//false	
	}

	private static void method04() {
		String regex = "\\s";
		System.out.println("".matches(regex));//false
		System.out.println(" ".matches(regex));//true
		System.out.println("  ".matches(regex));//false
		
	}
	
	private static void method05() {
		String regex = "\\w";
		System.out.println("_".matches(regex));//true
		System.out.println("1".matches(regex));	//true
	}
	
	private static void method06() {
		String regex = "\\W";
		System.out.println("a".matches(regex));//false
		System.out.println("#".matches(regex));//true
	}

}

（2）Greedy 数量词

X?	X，一次或一次也没有
X*	X，零次或多次
X+	X，一次或多次（包括一次）
X{n}	X，恰好n次
X{n,}	X，至少n次
X{n,m}	X，至少n次，但是不超过m次

代码示例

public class Test {

	public static void main(String[] args) {
		//method01();
		//method02();
		//method03();
		method04();

	}

	private static void method01() {
		String regex = "a[xyz]?qq";
		System.out.println("axqq".matches(regex));//true
		System.out.println("aqq".matches(regex));//true
		System.out.println("axyzqq".matches(regex));//false		
	}
	
	private static void method02() {
		String regex = "a*[xyz]+11";
		System.out.println("axyz11".matches(regex));//true
		System.out.println("xyz11".matches(regex));//true
		System.out.println("aaaxyz11".matches(regex));//true	
	}
	
	private static void method03() {
		String regex = "a+[xyz]+qq";
		System.out.println("aaxqq".matches(regex));//true
		System.out.println("axyzqq".matches(regex));//true
		System.out.println("xyzqq".matches(regex));//false		
	}
		
	private static void method04() {
		String regex = "[abc]{3}[xyz]{2,}[123]{2,5}";
		System.out.println("abcxy123".matches(regex));//true
	}

}

（3）范围表示

[abc]	a、b 或 c（简单类）
[^abc]	任何字符，除了 a、b 或 c（否定）
[a-zA-Z]	a 到 z 或 A 到 Z，两头的字母包括在内（范围）
[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]（减去）

代码示例

public class Test {

	public static void main(String[] args) {
		

		System.out.println( "abc".matches("[abc]+") );//true
		System.out.println( "dshfshfu1".matches("[^abc]+") );//true
		System.out.println( "abcdsaA".matches("[a-z]{5,}") );//false
		System.out.println( "abcdsaA12".matches("[a-zA-Z]{5,}") );//false
		System.out.println( "abcdsaA12".matches("[a-zA-Z0-9]{5,}") );//true
		System.out.println( "abdxyz".matches("[a-c[x-z]]+"));//false
		System.out.println( "bcbcbc".matches("[a-z&&[b-c]]{5,}"));//true
		System.out.println( "tretrt".matches("[a-z&&[^b-c]]{5,}"));//true
	}
}

4.单词边界

\b 表示单词边界，除了\w中的字符外的其他字符都可以作为单词边界。

例如："hi.*" 和 "high" 匹配

"ahi.*" 和 "ahigh" 匹配

"a.hi.*"和 "axhigh" 匹配

但 "a.\\bhi.*" 和 "axhigh" 不匹配，为什么？

因为\b表示单词的边界，空格把 a 和high分成了两个单词。也就是说 high是另一个单词的开始处在边界上,所以就匹配。而x不会把a和high分成两个单词。

思考 "a.\\bhi.*" 和 "a,high" 是否匹配？

代码示例

public class Test {

	public static void main(String[] args) {
		
		String regex = "a.\\bhi.*";   // \b不会占位 所以要配置 .   除了\w[a-zA-Z_0-9]中的字符外的其他字符都可以作为单词边界
		System.out.println("axhigh".matches(regex));  //false
		System.out.println("a high".matches(regex));  //true
		System.out.println("a#high".matches(regex));  //true
		System.out.println("a$high".matches(regex));  //true
		System.out.println("a_high".matches(regex));  //false
		System.out.println("a9high".matches(regex));  //false
	}
}

5.正则表达式的分组

如果想匹配3个数字，正则表达式可以用如下写法: \d{3}。

但是：在实际应用中，往往需要重复多个字符，例如想重复ab两个字符，使用以下代码就不合适了[ab]{3}。如何解决这个问题？

使用分组：在正则表达式中，使用()来表示分组。(ab){3}。

分组：就是使用小括号将一些项包括起来，使其成为独立的逻辑域，那么就可以像处理一个独立单元一样去处理小括号的内容。

这种分组叫做捕获组，可以做反向引用。

什么是反向引用？

反向引用指的就是使用 \组号来表示引用前面哪一组中的内容。

代码示例

public class Test {

	public static void main(String[] args) {
		
		String regex1 = "(a)(b)(c)" ;// 分3组    分别为：(a)、(b)、(c) 组号为 1,2,3
		System.out.println("abc".matches(regex1));//true
		
		String regex2 = "((a)(b(c)))";//分组多少，数左括号的个数
		//第一组：((a)(b(c)))
		//第二组：(a)
		//第三组：(b(c))
		//第四组：(c)
		
		String regex3 = "((a)(b(c)))\\3+";
		System.out.println("abcbcbc".matches(regex3));//true
	}
}

6、正则的匹配功能

boolean

matches(String regex)

告诉这个字符串是否匹配给定的 regular expression 。

代码示例

public class Test {

	public static void main(String[] args) {
		                                  
			 String qq = "12345";              
			 String reg = "[1-9][0-9]{4,14}";  
			 boolean b = qq.matches(reg);      
			 System.out.println("b="+b);   //b=true                             
			
	}
}

7.正则的切割功能

String[]

split(String regex)

将此字符串分割为给定的 regular expression的匹配。

代码示例

import java.util.Arrays;

public class Test {

	public static void main(String[] args) {
		                                  
		String line = "ab0ca123a11bb";
		String[] strs = line.split("\\d+");
		System.out.println(Arrays.toString(strs));//[ab, ca, a, bb]                       
			
	}
}

8、正则的替换功能

String

replaceAll(String regex, String replacement)

用给定的替换替换与给定的 regular expression匹配的此字符串的每个子字符串。

代码示例

public class Test {

	public static void main(String[] args) {
		                                  
		String line = "ab11cc345h66";
		String replaceAll = line.replaceAll("\\d+", "**");//ab**cc**h**
		System.out.println(replaceAll);
	}
}

9、正则的获取功能（查找子串）

查找子串同样要由 Pattern 和 Matcher 来完成

Matcher 下的常用方法：

find() 是否包含匹配正则的子串

group() 取出子串

start() 符合条件子串的开始位置

end() 符合条件子串的结束位置

示例代码

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

public class Test {

	public static void main(String[] args) {
		         
		//\\b匹配是否为单词边界。
		String str = "aaa  abcd     axss  xssdf"; // 找到所有4个长度的子串
		String regex = "\\b[a-zA-Z]{4}\\b";
		
		Pattern p = Pattern.compile(regex);
		Matcher m = p.matcher(str);
		while(m.find()){
			System.out.println(m.group());//abcd  axss
		}
	}
}

通天云计算

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
常用类库

1.API2.Object类3.String类4.StringBuilder类5.Arrays类6.包装类7.Math类8.Random类9.Date类10.SimpleDateFormat11.Calendar类12.BigDecimal类13.正则表达式一、API1.概念 API(Application Prog...
复制链接

扫一扫

专栏目录