正则表达式相关

正则表达式：

---

-用于描述字符串的内容格式，使用它通常用于匹配一个字符串是否符合要求
-正则表达式语法：
   1.[]:
   [abc]:这个字符可以是a或b或c
   [a-z]：表示任意一个小写字母
   [a-zA-Z]：表示任意一个字母
   [a-zA-Z0-9]：表示任意一个字母数字
   [a-zA-Z0-9_]：表示任意一个数字字母下划线
   [^abc]：该字符只要不是a或b或c
   2.预定义字符
   .:表示任意一个字符，没有范围限制
   \d:表示任意一个数字，等同于[0-9]
   \w:表示任意一个单词字符，等同于[a-zA-Z0-9_]-----单词字符指字母、数字、下划线
   \s:表示任意一个空白字符
   \D:表示不是数字
   \W:不是单词字符
   \S:不是空白字符
   \.：表示其中一个.，因为.是特殊字符
   3.量词：
   ?:表示前面的内容出现0-1次
        例如: [abc]? 可以匹配:a或b或c或什么也不写
    +:表示前面的内容最少出现1次
        例如: [abc]+ 可以匹配: b或aaaaaaaaa...或abcabcbabcbabcba...
            但是不能匹配:什么都不写或abcfdfsbbaqbb34bbwer...
    *:表示前面的内容出现任意次(0-多次)---匹配内容与+-一致， 只是可以一次都不写
        例如: [abc]* 可以四配:b或aaaaaa...或abcabcba...或什么都不写
            但是不能匹配: abcfdfsbbaqbb34bbwer...
    {n} :表示前面的内容出现n次
        例如: [abc]{3} 可以匹配:aaa或bbb或aab或abc或bbc
            但是不能匹配: aaaa 或aad
    {n, m}:表示前面的内容出现最少n次最多m次
        例如： [abc]{3,5} 可以匹配：aaa或abcdab或者abcc
    4.（）用于分组，是将括号内的内容看做一个整体
        例如：(abc){3}表示abc整体出现3次，可以匹配abcdefabc
            但是不能匹配aaa或abcabc
            （abc|def）{3}表示abc或def整体出现3次，
            可以匹配：abcabcabc或defdefdef或abcdefabc
            但是不能匹配abcdef或者abcdfbdef

object：对象/东西

---

-是所有类的鼻祖
-object中有几个经常被子类重写的方法:toString()和equals
注意：string、stringbuilder等都重写tostring（）来返回字符串内容了
-调用object类的equals（）时默认比较的还是==（即比较地址），没有参考意义，所以常常需要重写equals来比较值
string已经重写equals来比较字符串内容，但是stringbuilder没有
重写的基本原则：原则上要比较两个对象的属性值是否相同
    两个对象必须是同一类型的，若类型不同则返回false

补充

---

1.包装类
-java定义了八个包装类，目的就是为了解决基本类型不能直接参与面向对象开发的问题，使得基本类型可以通过包装类的形式来存在
-包括：Integer、Character、Byte、Short、Long、Float、Double、Boolean，其中Character和Boolean是直接继承自object的，而其余6个包装类继承自java.lang.Number类.

2.jdk1.5推出了一个新的特性：自动拆装箱，当编译器编译时若发现是基本类型与包装类型之间互相赋值，将自动补充代码来完成转换工作，这个过程称为自动拆装箱
3.将数组转换成字符串
-Arrays.toString（数组名）------将某个数组转换为字符串                                                                                                                  

Integer i1 =new Integer(5);
Integer i2 =new Integer(5);
System.out.println(i1==i2); //false,因为==是比较地址

//Integer.valueOf()会复用-128到127范围内的数据
Integer i3 =Integer.valueOf(500);
Integer i4 =Integer.valueOf(500);
System.out.println(i3==i4); //false,因为==是比较地址

Integer i33 =Integer.valueOf(5);
Integer i44 =Integer.valueOf(5);
System.out.println(i33==i44); //true，Integer.valueOf()会复用-128到127范围内的数据

//触发自动装箱特性，会被编译为Integer i =Integer.valueOf(5);
Integer i =5; //从基本类型到包装类型---装箱

//触发自动拆箱特性，会被编译为：int j = i.intValue();
int j = i; //包装类型到基本类型

演示包装类的常用操作

---

1.可以通过包装类来获取基本类型的取值范围
2.包装类型可以将字符串转换为对应的基本类型

int max=Integer.MAX_VALUE; //获取int的最大值
int min=Integer.MIN_VALUE; //获取int的最小值
System.out.println("int的最大值为"+max+"最小值为"+min);

long max1 =Long.MAX_VALUE;
long min1 =Long.MIN_VALUE;
System.out.println("long的最大值为"+max1+"最小值为"+min1);

网页中输入：用户名，年龄（23），商品价格（5.32）
从网页中获取的数据--其实是字符串类型

String s1 ="38";
int age = Integer.parseInt(s1); //将字符串s1转化成int类型
System.out.println(age); //38--int

String s2 = "123.456";
double price = Double.parseDouble(s2); //将字符串s2转换为double类型
System.out.println(price); //123.456----double类型

匹配的演示：

---

boolean matches（string regex）：匹配
使用给定的正则表达式（regex）验证当前字符串的格式是否符合要求，符合则返回true,否则返回false
        邮箱正则表达式：
        [a-zA-Z0-9]+@[a-zA-Z0-9]+(\.[a-zA-Z0-9]+)+
        注意：\.中的这个\是正则表达式中的转义符
            \\.中的第一个\，是在转义正则表达式中的\

 String email = "wangkj@tedu.cn";
        String regax = "[a-zA-Z0-9]+@[a-zA-Z0-9]+(\\.[a-zA-Z0-9]+)+";
        //使用regex匹配email是否符合格式要求
        boolean match = email.matches(regax);
        if(match){
            System.out.println("是正确的邮箱格式");
        }else {
            System.out.println("不是正确的邮箱格式");
        }

输出引用变量时会默认调用Object类的toString()方法
该方法返回的字符串格式为：类的全称@地址
但通常这个返回结果对我们的开发没有任何意义
我们真正想输出的应该是对象的属性值
因此常常需要重写toString()来返回具体的属性值

        Point p = new Point(100,200);
        System.out.println(p);//相当于System.out.println(p.toString());
                                //默认调用Object类的toString()
        System.out.println(p.toString());

        Point p1 = new Point(100,200);
        Point p2 = new Point(100,200);
        System.out.println(p1==p2); //false ,比较的是地址

        //若想比较字符串内容相同，比较equals
        System.out.println(p1.equals(p2)); //true,比较的是内容
        /*
        调用Object类的equals（），内部还是在使用==比较地址，没有实际意义
        若想比较对象的属性值是否相同，我们认为object的equals（）并不能满足，常常需要重写equals
         */

        String s1=new String("hello");
        String s2=new String("hello");
        System.out.println(s1.equals(s2)); //true

        StringBuilder builder1=new StringBuilder("hello");
        StringBuilder builder2=new StringBuilder("hello");
        System.out.println(builder1.equals(builder2)); //false:
                                                        // string已经重写equals来比较字符串内容，但是stringbuilder没有
                                                        //重写的基本原则：原则上要比较两个对象的属性值是否相同
                                                                        //两个对象必须是同一类型的，若类型不同则返回false

        System.out.println(s1.equals(builder1)); //false,类型不同

String replaceAll（String regax,String s）：替换
将当前字符串中满足正则表达式（regex）的部分给替换成给定的字符串（s）

String line ="abc123def456ghi78";
        line =line.replaceAll("[0-9]+","#NUMBER#");
        System.out.println(line);

String[] split(String regex):拆分
将当前字符串按照满足正则表达式的部分进行拆分，将拆分出的以String[]形式来返回
 

 String line = "abc123def456ghi";
        String[] data = line.split("[0-9+]"); //按照数字拆，数字拆没了
        //Arrays.toString
        //Arrays.toString(数组名)-----将某个数组转换成字符串
        System.out.println(Arrays.toString(data)); //[abc, , , def, , , ghi]
                                                    // 将data数组转换成字符串并输出

        line ="123.456.78";
        data =line.split("\\."); //按.拆
        System.out.println(Arrays.toString(data)); //[123,456,78]

        //最开始就是可拆分项（.），那么数组的第一个元素为空字符串
        // 如果连续两个（两个以上）可拆分项，那么中间也会拆出一个空字符
        // 如果末尾连续多个可拆分项，那么拆出的空字符串被忽略
        line ="...123..456.78.............";
        data =line.split("\\."); //按.拆
        System.out.println(Arrays.toString(data)); //[, , , 123, , 456, 78]