学习Java API（二）：基础知识点一文通?

推荐阅读

智能化校园：深入探讨云端管理系统设计与实现（一）
智能化校园：深入探讨云端管理系统设计与实现（二）

---

---

正则表达式

正则表达式定义了字符串的模式。
正则表达式可以用来搜索、编辑或处理文本。

正则表达式语法

点在正则表达式 有特殊含义，但在java字符串中无特殊含义，所以需要转义字符

//一个字符串其实就是一个简单的正则表达式
例如 Hello World 正则表达式匹配 "Hello World" 字符串。
//.（点号）也是一个正则表达式，它匹配任何一个字符如："a" 或 "1"。

[abc] -----------abc中任意一个字符
[^abc] ----------除了abc 中任意字符
[a-z]------------a,b,c......z中任意字母
[a-zA-Z0-9]------a-z,A-Z,0-9中任意字符
[a-z&&[^bc]]-----a-z中除了bc外其他任意字符

x|y--------------匹配 x 或 y。
//例如，'z|food' 匹配"z"或"food"。'(z|f)ood' 匹配"zood"或"food"。

单词字符即数字，字母，下划线。

.-----任意字符
\d--------任意一个数字字符
\w--------单词字符
\s--------匹配任何空白字符，包括空格、制表符、换页符等。与 [ \f\n\r\t\v] 等效。 
\D--------非数字字符
\W---------非单词字符
\S--------非空白字符


X？-----------表示0个或者1个 // [A-Z]? 随便写一个或者不写   B或者不写
X* -----------表示0个或者任意多个X
X+ -----------表示1个或者任意多个X（>=1）
X{n}----------表示n个X
X{n,}-----------表示n个到任意多个X（>=X）
X{n,m}--------表示n个到m个X

捕获组和分组

捕获组是把多个字符当一个单独单元进行处理的方法，它通过对括号内的字符分组来创建。

捕获组是通过从左至右计算其开括号来编号。若在表达式（（A）（B（C））），有四个这样的组：
((A)(B(C)))
(A)
(B(C))
(C)

分组
分组：（）圆括号表示分组，可以将一系列正则表达式看成一个整体，分组时可以使用“|”表示使用“或”关系

[ABC]{3}//BBC   AAB  AAA可以，BCD 不行
(ABC){3}//ABCABCABC
（ABC|DEF）{3}//ABCDEFABC

matches 和 lookingAt 方法

matches 和 lookingAt 方法都用来尝试匹配一个输入序列模式。它们的不同是 matches 要求整个序列都匹配，而lookingAt 不要求。
lookingAt 方法虽然不需要整句都匹配，但是需要从第一个字符开始匹配。

/**
 * 字符串支持正则表达式方法
 * boolean matches(String regex)
 * 根据给定的正则表达式验证当前字符串是否满足格式要求，满足true 否则false
 */
public class String {
    public static void  main(String args[]){
        /**
         * 电子邮箱
         * [a-zA-Z0-9_]+@[a-zA-Z0-9_]+(\.[a-zA-Z0-9_]+)+
         */
        String regex="[a-zA-Z0-9_]+@[a-zA-Z0-9_]+(\\.[a-zA-Z0-9_]+)+";//点在正则表达式 有特殊含义，但在java字符串中无特殊含义，所以需要转义字符
        System.out.println(regex);
    }
}//[a-zA-Z0-9_]+@[a-zA-Z0-9_]+(\.[a-zA-Z0-9_]+)+


/**
 * 验证是否为手机号
 */
System.out.println("请输入手机号");
Scanner scanner=new Scanner(System.in);
String line=scanner.nextLine();
//(\+86|0086)?\s*1[0-9]{10}，也可以是这种
String a="1[0-9]{10}";
if (line.matches(a)){
    System.out.println("yes");
}else {
    System.out.println("no");
}

split方法

/**
 * 字符串支持正则表达式方法二
 * String[] split(String regex)
 * 将当前字符串按照满足正则表达式的部分进行拆分，返回拆分的每段内容
 */
String str="abcdef4ghijk123456zvdsf";

String regex ="[0-9]+";
String[] array=str.split(regex);
System.out.println("len:"+array.length);
for (int i=0;i<array.length;i++){
    System.out.println(array[i]);
}
//len:3
//abcdef
//ghijk
//zvdsf

匹配规则少了一个加号，那么每个数字中间都要匹配了一次，所以输出结果多了空白字符，如果匹配时是这种情况“abcq344jkfji1234”,那么后面1234之间不会在匹配了，只匹配一次

String str="abcdef4ghijk123456zvdsf";

String regex ="[0-9]";
String[] array=str.split(regex);
System.out.println("len:"+array.length);
for (int i=0;i<array.length;i++){
    System.out.println(array[i]);
}

replaceFirst 和 replaceAll 方法

replaceFirst 和 replaceAll 方法用来替换匹配正则表达式的文本。不同的是，replaceFirst 替换首次匹配，replaceAll 替换所有匹配。

String str="ancbada12akjhfk23kjk";
str=str.replaceAll("\\d","#ad#");
System.out.println(str);

String imgName="1.jpg";
imgName=imgName.replaceAll(".+\\.", System.currentTimeMillis()+".");
System.out.println(imgName);

String regex="（|hh|wo|）";
String message="我笑了，你wo,你这个hh";
message=message.replaceAll(regex,"***");
System.out.println(message);

输出结果

appendReplacement 和 appendTail 方法

appendReplacement 和 appendTail 方法用于文本替换

 private static String REGEX = "a*b";
 private static String INPUT = "aabfooaabfooabfoobkkk";
 private static String REPLACE = "-";
 public static void main(String[] args) {
 Pattern p = Pattern.compile(REGEX);
 // 获取 matcher 对象
Matcher m = p.matcher(INPUT);
StringBuffer sb = new StringBuffer();
 while(m.find()){
 m.appendReplacement(sb,REPLACE);
 }
 m.appendTail(sb);
System.out.println(sb.toString());
//-foo-foo-foo-kkk

Object类

Java Object 类是所有类的父类，Java 的所有类都继承了 Object，子类可以使用 Object 的所有方法。
Object 类位于 java.lang 包中，编译时会自动导入，我们创建一个类时，如果没有明确继承一个父类，那么它就会自动继承 Object，成为 Object 的子类。就好比如：你碰见一个人，但是你不认识他，但他仍然属于人这一范畴中。一个类不知道他的属性和方法，不知道他的父类，就可以让它自动继承Object这一父类。

显式继承:
public class Test extends Object{
}
隐式继承:
public class Test {
}

Object toString() 方法

Object toString() 方法用于返回对象的字符串表示形式.
返回值
返回对象的字符串表示形式。
默认返回格式：对象的 class 名称 + @ + hashCode 的十六进制字符串。

object.toString()

重写toString方法
Object自身的toString的方法烦返回的是：类名@地址，这一字符串没啥实际意义，重写该方法后，返回字符串后没有严格的格式要求可根据需求而定，但是原则上需要字符串包含当前对象的属性信息，只有我们自己定义的类需要重写该方法，javaAPI 提供的类通常已经重写了该方法。

// toString() with array
// 创建数组
String[] array = { "Google", "baidu", "Taobao" };
System.out.println(array.toString());
 // 数组元素值返回一个字符串的表示形式
// Array 继承了 Object 类，所以可以直接使用 toString() 方法
System.out.println(array[1].toString()); // baidu

Object equals() 方法

Object equals() 方法用于比较两个对象是否相等

 // Object 类使用 equals() 方法
// 创建两个对象
Object obj1 = new Object();
Object obj2 = new Object();
 
// 判断 obj1 与 obj2 是否相等
// 不同对象，内存地址不同，不相等，返回 false
System.out.println(obj1.equals(obj2)); // false

// obj1 赋值给 obj3
// String 重写了 equals() 方法
// 对象引用，内存地址相同，相等，返回 true
Object obj3 = obj1;
System.out.println(obj1.equals(obj3)); // true

object 提供的equals方法内部就是“==”实现的，没有意义,equals比较不要求所有属性值一样,通常我们需要使用一个类的equals方法时需要写,equals方法作用 比较当前对象与给定对象内容是否一样.

StringDemo4 s=new StringDemo4(1,3);
String str=s.toString();
System.out.println(str);

StringDemo4 s1=new StringDemo4(1,3);
System.out.println(s==s1);//false
System.out.println(s.equals(s1));//true

equals与 == 区别
== 用于比较变量的值，可以应用任何类型，如果用于引用类型，比较的是两个引用变量中存储的值（地址信息），判断两个变量是否指向相同对象；
equals（）方法重写后可以用于比较两个对象内容是否相等，object中默认的equals方法比较规则同==。

Object hashCode() 方法

Object hashCode() 方法用于获取对象的 hash 值。
返回对象哈希值，是一个整数，表示在哈希表中的位置

object.hashCode()

如果两个对象相等，则它们的哈希值也是相等的

// Object 使用 hashCode()
Object obj1 = new Object();

// obj1 赋值给 obj2
Object obj2 = obj1;

// 判断两个对象是否相等
System.out.println(obj1.equals(obj2)); // true

// 获取 obj1 与 obj2 的哈希值
System.out.println(obj1.hashCode()); //1945604815
System.out.println(obj2.hashCode()); //1945604815

包装类

Number类

基本类型（byte short int long float double char boolean）是以值的形式直接存在，所以他们没有面向对象的特性，自然不继承object，不能使用多态，用object角度去接受基本类型。
为了解决这个问题，Java 语言为每一个内置数据类型提供了对应的包装类。所有的包装类（Integer、Long、Byte、Double、Float、Short）都是抽象类 Number 的子类

Integer 提供的一些常量
static int MAX_VALUE 值为 2^31-1的常量，表示int类型能表示的最大值
static int MIN_VALUE 值为 -2^31的常量，表示int类型能表示的最小值

xxxValue() 方法

xxxValue() 方法用于将 Number 对象转换为 xxx 数据类型的值并返回。
该方法不接受任何参数

Integer i=1;
System.out.println(i.doubleValue());//1.0
System.out.println(i.byteValue());//1

valueOf() 方法

valueOf() 方法用于返回给定参数的原生 Number 对象值，参数可以是原生数据类型, String等。该方法是静态方法。

static Integer valueOf(int i)
static Integer valueOf(String s)
static Integer valueOf(String s, int radix)//radix --在解析字符串 s 时使用的进制数，用于指定使用的进制数。

Integer x =Integer.valueOf(9);    
Double c = Double.valueOf(5); 
Float a = Float.valueOf("80"); 
Integer b = Integer.valueOf("444",16);   // 使用 16 进制 
System.out.println(x);//9
System.out.println(c);  //5.0 
System.out.println(a); //80.0
System.out.println(b); //1092          

equals() 方法

equals() 方法用于判断 Number 对象与方法的参数进是否相等。如 Number 对象不为 Null，且与方法的参数类型与数值都相等返回 True，否则返回 False。

Integer i=1;
Integer b=1;
Integer c=5;
Short a=1;
 System.out.println(i.equals(b));//true
System.out.println(i.equals(c));//false
System.out.println(i.equals(a));//false

Math 类

Math 包含了用于执行基本数学运算的属性和方法，如初等指数、对数、平方根和三角函数。
Math 的方法都被定义为 static 形式，通过 Math 类可以在主函数中直接调用。

System.out.println("90 度的正弦值：" + Math.sin(Math.PI/2));//90 度的正弦值：1.0
System.out.println(Math.PI); //3.141592653589793

sqrt() 方法

sqrt() 方法用于返回参数的算术平方根
返回参数的算术平方根。

double a=4.0;
System.out.println(Math.sqrt(c));//2.0

round() 方法

round() 方法返回一个最接近的 int、long 型值，四舍五入。round 表示"四舍五入"，算法为Math.floor(x+0.5) ，即将原来的数字加上 0.5 后再向下取整。

Math.round(11.5)//12
Math.round(-11.5)//-11
double d = 100.752
float f = 100;
System.out.println(Math.round(d));//101
System.out.println(Math.round(f));//100

parseXXX（String str）方法

包装类提供了一个静态方法parseXXX（String str），可以将给定字符串转换为对应的基本类型，前提是该字符串必须正确描述基本类型。

int x =Integer.parseInt("9");
double c = Double.parseDouble("5");
int s=Integer.parseInt("123.123");//报错，字符串类型不对
 System.out.println(x);//9
 System.out.println(c);//5.0

Character 类

Character 类用于对单个字符进行操作。
Character 类在对象中包装一个基本类型 char 的值

Character类提供了一系列方法来操纵字符。你可以使用Character的构造方法创建一个Character类对象

Character ch = new Character('a');

在某些情况下，Java编译器会自动创建一个Character对象

// 原始字符 'a' 装箱到 Character 对象 ch 中
Character ch = 'a';
 
// 原始字符 'x' 用 test 方法装箱
// 返回拆箱的值到 'c'
char c = test('x');

将一个char类型的参数传递给需要一个Character类型参数的方法时，那么编译器会自动地将char类型参数转换为Character对象。 这种特征称为装箱，反过来称为拆箱。
自动拆装箱是编译器认可，而不是虚拟机认可，编译器在将源程序编译时自动补齐代码来完成基本类型与包装类之间的转换。

int i=new Integer(0);
//在.class 文件中，编译器将其改为
int i=new Integer(0).intValue();

Integer a=12;
//在.class 文件中为
Integer a=Integer.valueOf(12);

转义序列

前面有反斜杠（\）的字符代表转义字符，它对编译器来说是有特殊含义的