Java基础（15）Arrays类、基本类型包装类、正则表达式

77 阅读 0 评论 51 点赞

我是靠谱客的博主糟糕小霸王，最近开发中收集的这篇文章主要介绍Java基础（15）Arrays类、基本类型包装类、正则表达式，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

1.Arrays类

1. Arrays类的概述：针对数组进行操作的工具类，提供了排序、查找等功能
2. 常用方法
（1）public static String toString(int[ ] a)：返回指定数组内容的字符串表示形式
（2）public static void sort(int[ ] a)：对指定的 int 型数组按数字升序进行排序
（3）public static int binarySearch(int[ ] a,int key)：使用二分搜索法来搜索指定的 int 型数组，以获得指定的值
（4）public static boolean equals(int[ ] a1,int[ ] a2)：如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。此外，如果两个数组引用都为 null，则认为它们是相等的
（5）public static int[ ] copyOf(int[ ] original,int newLength)：复制旧数组中的元素到一个新数组中，新的数组长度是newLength，从0开始复制旧数组
（6）public static int[ ] copyOfRange(int[] original, int from, int to) ：将指定数组的指定范围复制到一个新数组（含头不含尾）

import java.util.Arrays;
import java.util.Comparator;
public class TestDemo01 {
public static void main(String[] args) {
//public static String toString(int[] a)：返回指定数组内容的字符串表示形式
int[] arr = {1,2,3,5,6,7,8};
String str = Arrays.toString(arr);
System.out.println(str);
//[1, 2, 3, 5, 6, 7, 8]
int[] arr2 = null;
System.out.println(Arrays.toString(arr2));
// null
//public static void sort(int[] a)： 对指定的 int 型数组按数字升序进行排序
int[] arr3 = {11,34,523,123,12,76,88,97};
Arrays.sort(arr3);
System.out.println(Arrays.toString(arr3));
//[11, 12, 34, 76, 88, 97, 123, 523]
//指定一段范围进行排序
int[] arr4 = {11,34,523,123,12,76,88,97};
Arrays.sort(arr4,2,6);
System.out.println(Arrays.toString(arr4));
//[11, 34, 12, 76, 123, 523, 88, 97]
//降序排列
Integer[] arr5 = {11,34,523,123,12,76,88,97};
Arrays.sort(arr5, new Comparator<Integer>() {
@Override
public int compare(Integer a, Integer b) {
return b-a;
}
});
System.out.println(Arrays.toString(arr5));
//[523, 123, 97, 88, 76, 34, 12, 11]
}
}
=======================================================================
import java.util.Arrays;
public class TestDemo02 {
public static void main(String[] args) {
//public static int binarySearch(int[] a,int key)：使用二分搜索法来搜索指定的 int 型数组，以获得指定的值
int[] arr = {12,23,34,45,56,67,78,89};
int index = Arrays.binarySearch(arr, 34);
System.out.println(index);
//2
//public static boolean equals(int[ ] a1,int[ ] a2)：如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。
// 此外，如果两个数组引用都为 null，则认为它们是相等的
int[] arr2 = {11,22,33,44};
int[] arr3 = {11,22,33,44};
boolean b = Arrays.equals(arr2, arr3);
System.out.println(b);
//true
//public static int[ ] copyOf(int[ ] original,int newLength)：复制旧数组中的元素到一个新数组中，
//新的数组长度是newLength，从0开始复制旧数组
int[] arr4 = {11,22,33,44,55,66};
int[] newArr4 = Arrays.copyOf(arr4, arr4.length);
System.out.println(Arrays.toString(newArr4));
//[11, 22, 33, 44, 55, 66]
//public static int[ ] copyOfRange(int[] original, int from, int to) ：将指定数组的指定范围复制到一个新数组（含头不含尾）
int[] arr5 = {11,22,33,44,55,66,77};
int[] newArr5 = Arrays.copyOfRange(arr5, 2, 6);
System.out.println(Arrays.toString(newArr5));
//[33, 44, 55, 66]
}
}

2.基本类型包装类

1. 基本类型包装类的概述：Java为了对基本数据类型进行更多的操作，引入基本类型包装类，针对每一种基本数据类型提供了对应的类类型
2. 基本类型及其包装类

byte —> Byte
short —> Short
int —> Integer
long —> Long
float —> Float
double —> Double
char —> Character
boolean —> Boolean

3. Integer类
（1）Integer类的概述：Integer类在对象中包装了一个基本类型int的值

（2）构造方法

public Integer(int value)：构造一个新分配的 Integer 对象，它表示指定的 int 值
public Integer(String s)：构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值（要一个字面上是数字的字符串，否则就会报错）

public class TestDemo01 {
public static void main(String[] args) {
int num = 100;
Integer integer1 = new Integer(num);
System.out.println(integer1);
//100
String s = "200";
Integer integer2 = new Integer(s);
System.out.println(integer2);
//200
}
}

（3）Integer的10进制转2进制、8进制、16进制

static String toBinaryString(int i) ：以二进制（基数 2）无符号整数形式返回一个整数参数的字符串表示形式
static String toHexString(int i) ：以十六进制（基数 16）无符号整数形式返回一个整数参数的字符串表示形式
static String toOctalString(int i) ：以八进制（基数 8）无符号整数形式返回一个整数参数的字符串表示形式

public class TestDemo02 {
public static void main(String[] args) {
int num = 100;
String str1 = Integer.toBinaryString(num);
System.out.println(str1);
//1100100
String str2 = Integer.toHexString(num);
System.out.println(str2);
//64
String str3 = Integer.toOctalString(num);
System.out.println(str3);
//144
}
}

（4）String和int类型的相互转换

int —> String
①用 “” 进行拼接
②public static String valueOf(int i)：String类
③int —> Integer —> toString —> String：Integer类
String —> int
① String —> Integer —> intValue()：int intValue() ：以 int 类型返回该 Integer 的值
②public static int parseInt(String s)：static int parseInt(String s) ：将字符串参数作为有符号的十进制整数进行解析

public class TestDemo03 {
public static void main(String[] args) {
//int ---> String
int num = 100;
String s1 = num + "";
System.out.println(s1);
String s2 = String.valueOf(num);
System.out.println(s2);
Integer integer = new Integer(num);
String s3 = integer.toString();
System.out.println(s3);
//String ---> int
String str = "200";
Integer integer1 = new Integer(str);
int i1 = integer1.intValue();
System.out.println(i1);
int i2 = Integer.parseInt(str);
System.out.println(i2);
}
}

（5）自动拆箱与自动装箱

自动装箱：把基本类型转换为包装类类型
自动拆箱：把包装类类型转换为基本类型
注意：在使用时，如果Integer x = null，代码就会出现空指针异常NullPointerException。建议先判断是否为null，然后再使用

public class TestDemo04 {
public static void main(String[] args) {
//自动装箱
Integer num = 200;
System.out.println(num);
//200
//自动拆箱
Integer a = new Integer(300);
int sum = a + 1;
System.out.println(sum);
//301
Integer ii = 100;
//自动装箱
ii += 200;
//自动拆箱，自动装箱
}
}

（6）一道练习题

public class TestDemo05 {
public static void main(String[] args) {
Integer i1 = new Integer(127);
Integer i2 = new Integer(127);
System.out.println(i1 == i2);
//false
System.out.println(i1.equals(i2));
//true
System.out.println("-----------");
Integer i3 = new Integer(128);
Integer i4 = new Integer(128);
System.out.println(i3 == i4);
//false
System.out.println(i3.equals(i4));
//true
System.out.println("-----------");
【重点，两个128(或者大于128)是false】
Integer i5 = 128;
Integer i6 = 128;
System.out.println(i5 == i6);
//false
System.out.println(i5.equals(i6));
//true
System.out.println("-----------");
【重点，两个127(或者小于127)是true】
Integer i7 = 127;
Integer i8 = 127;
System.out.println(i7 == i8);
//true
System.out.println(i7.equals(i8));
//true
}
}

3.正则表达式

1. 正则表达式的概述：是指一个用来描述或者匹配一系列符合某个句法规则的字符串的单个字符串。其实就是一种规则。有自己特殊的应用
2. 正则表达式的组成规则

（1）字符类

[a]：匹配单个字符
[a,b,c]：匹配列表中任意一个字符
[a-z]：匹配所有小写字母
[A-Z]：匹配所有大写字母
[0-9]：匹配0~9的数字
[^a,b,c]：任何字符，除了a，b，c
[a-zA-Z0-9]：a到z，A到Z，0-9

（2）预定义字符类

. ：匹配任意单个字符
… ：匹配任意两个字符（两个点）
. ：匹配 . 这个字符（两个）
| ：或者的意思
w：单词字符：[a-zA-Z0-9]（两个）
d ：数字：[0-9]（两个）
s ：匹配空格字符（两个）

（3）数量词

X? :X有一次或者一次也没有。""空串代表没有
X* ：X出现零次或多次( >= 1)
X+ ：X出现一次或者多次
X{n} ：X恰好出现n次
X{n,} ：X至少出现n次
X{n,m} ：X出现n次到m次之间

3. 正则表达式的判断功能
String类的功能：public boolean matches(String regex)

public class TestDemo01 {
public static void main(String[] args) {
String regex1 = "[a]";
boolean b1 = "a".matches(regex1);
System.out.println(b1);
//true
String regex2 = "[a,b,c]";
boolean b2 = "d".matches(regex2);
System.out.println(b2);
//false
String regex3 = "[abc]";
boolean b3 = "a".matches(regex3);
System.out.println(b3);
//true
String regex4 = "[a-z]";
boolean b4 = "u".matches(regex4);
System.out.println(b4);
//true
String regex5 = "[A-Z]";
boolean b5 = "t".matches(regex5);
System.out.println(b5);
//false
String regex6 = "[0-9]";
boolean b6 = "99".matches(regex6);
System.out.println(b6);
//false
String regex7 = "[^a,b,c]";
boolean b7 = "g".matches(regex7);
System.out.println(b7);
//true
String regex8 = "[a-zA-Z0-9]";
boolean b8 = "r".matches(regex8);
System.out.println(b8);
//true
String regex9 = ".";
boolean b9 = "8".matches(regex9);
System.out.println(b9);
//true
String regex10 = "..";
boolean b10 = "i9".matches(regex10);
System.out.println(b10);
//true
System.out.println("----------------");
String regex11 = "a?b?";
boolean b11 = "a".matches(regex11);
System.out.println(b11);
//true
String regex12 = "[a-z]?";
boolean b12 = "T".matches(regex12);
System.out.println(b12);
//false
String regex13 = "[a-z0-9A-Z]*";
boolean b13 = "uzi666".matches(regex13);
System.out.println(b13);
//true
String regex14 = "b+c+";
boolean b14 = "bbbccc".matches(regex14);
System.out.println(b14);
//true
String regex15 = "[a-zA-Z0-9]+";
boolean b15 = "java666".matches(regex15);
System.out.println(b15);
//true
String regex16 = "a{3}";
boolean b16 = "aaa".matches(regex16);
System.out.println(b16);
//true
String regex17 = "[a-zA-Z0-9]{3,}";
boolean b17 = "fpx666".matches(regex17);
System.out.println(b17);
//true
String regex18 = "[a-z0-9]{5,12}";
boolean b18 = "fpx666".matches(regex18);
System.out.println(b18);
//true
}
}

4. 两个用正则表达式的例子
（1）采用正则表达式的方式来校验QQ号。要求1：必须是5 - 15 位数字。2：0 不能开头

//用普通方法
public class TestDemo02 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入QQ号");
String qqNum = sc.nextLine();
boolean b = checkQQNum(qqNum);
if(b == true){
System.out.println("qq号输入正确");
}else {
System.out.println("qq号输入错误");
}
}
private static boolean checkQQNum(String qqNum) {
boolean flag = false;
if(qqNum.length() >= 5 && qqNum.length() <= 15 && !(qqNum.startsWith("0"))){
for (int i = 0; i < qqNum.length(); i++) {
if(qqNum.charAt(i) >= '0' && qqNum.charAt(i) <= '9'){
flag = true;
}else {
flag = false;
}
}
}
return flag;
}
}
---------------------------------------------------------------
//用正则表达式
public class TestDemo03 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入你的QQ号");
String qqNum = sc.nextLine();
boolean b = checkQQNum(qqNum);
if (b == true) {
System.out.println("QQ号规则正确");
} else {
System.out.println("QQ号规则错误");
}
}
private static boolean checkQQNum(String qqNum) {
String regex = "[1-9][0-9]{4,14}";
boolean b = qqNum.matches(regex);
return b;
}
}

（2）效验手机号。要求1：1开头，一共11位。2：手机号第二位是3,4,5,6,7,8,9

import java.util.Scanner;
public class TestDemo04 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入你的手机号");
String num = sc.nextLine();
String regex = "[1][3,4,5,6,7,8,9][0-9]{9}";
boolean b = num.matches(regex);
System.out.println(b);
}
}

5. 正则表达式的分割功能
String类的功能：public String[] spilt(String regex)：按照正则表达式，来分割字符串，获取到的内容，放到数组当中

import java.util.Arrays;
public class TestDemo01 {
public static void main(String[] args) {
String name = "uzi=doinb=faker";
String[] str = name.split("=");
System.out.println(Arrays.toString(str));
//[uzi, doinb, faker]
}
}

6. 正则表达式的替换功能
String类的功能：public String replaceAll(String regex,String replacement)

public class TestDemo02 {
public static void main(String[] args) {
String s = "周淑怡没有胸";
String str = s.replaceAll("胸", "*");
System.out.println(str);
//周淑怡没有*
}
}