正则表达式，Collection集合，迭代器

正则表达式

什么是正则表达式？

由一些特定的字符组成的字符串校验规则，称为：正则表达式

例：
[1-9][0-9]{4,14}

1. 第一位必须是1-9之间的数字，不能是0
2. 后续字符可以是0-9之间的任意数字
3. 限定后续数字的长度范围

• 最小4位(加上第一位总共5位)
• 最大14位(加上第一位总共15位)

正则表达式解决程序中什么问题？

正则表达式只能针对字符串进行格式校验 正则表达式在开发中的应用场景： 对用户输入的字符串数据进行校验（数据合法性。例：手机号码格式）

正则表达式怎么使用？（开发中基本都是CV）

import java.util.ArrayList;
import java.util.Scanner;
public class RegexDemo1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您的qq号码:");
        String qq = sc.next();
        //System.out.println(checkQQ(qq));
        System.out.println(checkQQ2(qq));
    }

//    private static boolean checkQQ(String qq) {
//        //1. QQ号码必须是5--15位长度
//
//        //判断：字符串长度小于5 或者 字符串长度大于15
//        if (qq.length() < 5 || qq.length() > 15) {
//            //为真： 返回false
//            return false;
//        }
//        //2 . 而且首位不能为0
//        if (qq.charAt(0) == '0') {
//            return false;
//        }
//        //3. 而且必须全部是数字
//        for (int i = 0; i < qq.length(); i++) {
//            char ch = qq.charAt(i);
//            if (ch < '0' || ch > '9') {
//                return false;
//            }
//        }
//        return true;
//    }


    // 正则表达式改进
    private static boolean checkQQ2(String qq) {
        return qq.matches("[1-9][0-9]{4,14}");
    }
}

正则表达式的语法：

1. [abc] ：代表a或者b，或者c字符中的一个。

2.[^abc]：代表除a,b,c以外的任何字符。

3.[a-z] ：代表a-z的所有小写字符中的一个。

4.[A-Z] ：代表A-Z的所有大写字符中的一个。

5.[0-9] ：代表0-9之间的某一个数字字符。

6.[a-zA-Z0-9]：代表a-z或者A-Z或者0-9之间的任意一个字符。

7.[a-dm-p]：a 到 d 或 m 到 p之间的任意一个字符

public class RegexDemo2 {
    
//    matches() 是 Java 字符串(String)类的一个方法，用于检查整个字符串是否与给定的正则表达式匹配。
    public static void main(String[] args) {
        //1 验证str是否以h开头，以d结尾，中间是a,e,i,o,u中某个字符
        System.out.println("had".matches("h[aeiou]d"));

        //2 验证str是否以h开头，以d结尾，中间不是a,e,i,o,u中的某个字符
        System.out.println("hwd".matches("h[^aeiou]d"));

        //3 验证str是否a-z的任何一个小写字符开头，后跟ad
        System.out.println("aad".matches("[a-z]ad"));

        //4 验证str是否以a-d或者m-p之间某个字符开头，后跟ad
        System.out.println("zad".matches("[a-dm-p]ad"));

    }
}

逻辑运算符

&& ：并且

| ：或者

要求字符串是除a、e、i、o、u外的其它小写字符开头，后跟ad：（ [a-z&&[^aeiou]]ad ）
要求字符串是aeiou中的某个字符开头，后跟ad（ [a|e|i|o|u]ad

预定义字符 : 简化字符类的书写

1. “.” ： 匹配任何字符。
2. “\d”：任何数字[0-9]的简写；
3. “\D”：任何非数字[^0-9]的简写；
4. “\s” ： 空白字符：[ \t\n\x0B\f\r] 的简写
5. “\S” ： 非空白字符：[^\s] 的简写
6. “\w” ：单词字符：[a-zA-Z_0-9]的简写
7. “\W”：非单词字符：[^\w]

import java.util.Arrays;

public class RegexDemo8 {
    public static void main(String[] args) {
        String str="上海.包含.程序员";

        //按照：. 切割字符串
        String[] split = str.split("\\.");

        System.out.println(Arrays.toString(split));//[上海, 包含, 程序员]
    }
}

? * + {n} {n,} {m,n}表达的意思

X? : 0次或1次

X* : 0次到多次

X+ : 1次或多次

X{n} : 恰好n次

X{n,} : 至少n次

X{n,m}: n到m次(n和m都是包含的)

如何用正则表达式表示一个字符类？

中括号表示表示一个字符

String类中出现正则的方法

public String[] split ( String regex ) 可以将当前字符串中匹配regex正则表达式的符号作为"分隔符"来切割字符串。

public String replaceAll ( String regex , String newStr ) 可以将当前字符串中匹配regex正则表达式的字符串替换为newStr。

public class RegexDemo7 {
    public static void main(String[] args) {
        // 1 将以下字符串按照数字进行切割
        String str1 = "aa123bb24cc909dd";
        //通过正则表达式，匹配str1字符串中的数字，按照数字切换字符串
        String[] strs = str1.split("\\d+");

        System.out.println(Arrays.toString(strs));


        // 2 将下面字符串中的"数字"替换为"*“a
        String str2 = "我卡里有10000元，我告诉你卡的密码是123456，要保密哦";
        System.out.println(str2.replaceAll("\\d{3,}", "*"));
    }
运行结果：
    [aa, bb, cc, dd]
我卡里有*元，我告诉你卡的密码是*，要保密哦

Collection集合

集合有什么好处？

1. 大小可变（随意扩容）

2. 集合中可以存储多种不同类型数据

3. 底层使用数据结构（存取效率高）

集合：不能存储基本类型数据（如果要存储基本数据类型需要进行装箱）

ArrayList list = new ArrayList();

list.add(100);//自动装箱：

list.add( Integer.valueOf(100) )

Collection集合： 是一个接口

子接口： List 、 Set

子类： ArrayList

ArrayList集合对象可以使用传统的for循环，进行遍历

ArrayList集合有索引

Collection集合： 没有索引。 遍历集合使用专用方式：迭代器

Collection中有哪些常用的方法？

add,clear,remove,contains,isEmpty,size,toArray

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;

public class CollectionDemo1 {
    public static void main(String[] args) {
        //创建Collection集合（多态代码的体现）
        Collection coll = new ArrayList();

        //集合常用方法： 添加、删除、  获取 、 修改 、  判断
        //添加元素
        coll.add("Java");
        coll.add("MySQL");
        System.out.println(coll);

        //判断：集合是否包含mysql元素
        if(coll.contains("MySQL")){
            //为真：集合有中mysql元素
            //删除元素
            coll.remove("MySQL");
        }
        System.out.println(coll);

        System.out.println("集合的大小："+coll.size());
        //清空集合中所有的元素
        coll.clear();
        System.out.println(coll);


        coll.add("HTML");
        coll.add("JavaScript");

        //把集合转换为数组
        Object[] objects = coll.toArray();
        System.out.println(Arrays.toString(objects));
    }
}
运行结果：
[Java, MySQL]
[Java]
集合的大小：1
[]
[HTML, JavaScript]

迭代器

迭代器：Iterator

作用：用于集合的遍历

Iterator迭代器中常用方法：

boolean hasNext(); //检查迭代器对象中是否有下一个元素

Object next(); //利用迭代器，取出下一个元素

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class IteratorDemo1 {
    public static void main(String[] args) {
        //创建集合对象
        Collection<String> collection = new ArrayList<String>();

        //向集合中添加元素
        collection.add("Java");
        collection.add("MySQL");
        collection.add("Mybatis");
        collection.add("Spring");

        //使用迭代器：遍历集合
        //1、通过集合对象，获取到迭代器对象
        Iterator<String> it = collection.iterator();

        //2、while循环，判断迭代器对象中是否有下一个元素
        while (it.hasNext()) {
            //3、使用迭代器对象，取出下一个元素
            String str = it.next();//泛型好处：不需要进行强制类型转换

            System.out.println(str);
        }
    }
}
运行结果：
Java
MySQL
Mybatis
Spring

Iterator迭代器在使用中的细节：

1. 在迭代器完成集合的遍历后，不要在使用：next()方法

2. 在迭代器遍历集合的过程中，不能使用集合对象来增删元素

• 删除元素： 使用迭代器对象中的remove方法实现

• 增加元素： 不用考虑（解决方案：使用其他的集合对象。例：List集合）

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class IteratorDemo4 {
    public static void main(String[] args) {
        //创建集合对象
        Collection<String> collection = new ArrayList<String>();

        //向集合中添加元素
        collection.add("Java");
        collection.add("MySQL");
        collection.add("Mybatis");
        collection.add("Spring");

        //使用迭代器：遍历集合
        Iterator<String> it = collection.iterator();
        while (it.hasNext()) {
            String str = it.next();

            //操作元素
            if(str.equals("MySQL")){
                //不能使用集合对象：删除元素
                //collection.remove("MySQL");

                //在迭代器遍历过程中，要删除元素使用： 迭代器对象中的remove方法
                it.remove();
            }
        }

        System.out.println(collection);


    }
}
运行结果：
[Java, Mybatis, Spring]

增强for循环

什么是增强for？

就是基于普通的for循环，进行强化（底层使用：迭代器）

增强for的应用：

针对数组或集合，进行遍历

增强for的语法：

for( 元素类型 变量 : 容器 ){

//从容器中获取出一个元素，赋给变量

//下次：继承从容器中获取一个元素， 赋给变量

//…

//停止条件 ： 容器没有元素了}

public class ForeachDemo1 {
    public static void main(String[] args) {
        //定义数组
        int[] arr = {10,3,5,19,7,8};

        //使用增强for遍历数组
        for(int num : arr){

            if(num%2==0){
                System.out.println(num);
            }
        }
    }
}

import java.util.ArrayList;
import java.util.Collection;

public class ForeachDemo2 {
    public static void main(String[] args) {
        //创建集合对象
        Collection<String> collection = new ArrayList<String>();
        //向集合中添加元素
        collection.add("Java");
        collection.add("MySQL");
        collection.add("Mybatis");
        collection.add("Spring");

        //使用增强for遍历集合
        for (String str : collection) {

            if(str.length()>5){
                System.out.println(str);
            }
        }
    }
}
运行结果：
Mybatis
Spring