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 | 用于表示二进制补码二进制形式的 int值的字节数。 |
static int | 一个持有最大值一个 int可以有2 31 -1。 |
static int | 的常量保持的最小值的 int可以具有,-2 31。 |
static int | 用于表示二进制补码二进制形式的 int值的位数。 |
static 类<Integer> | 类原始类型 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使用默认模式和日期格式符号为默认的 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
}
}
}