2021-08-04 Java学习基础第五天总结

最新推荐文章于 2024-08-12 21:29:36 发布
最新推荐文章于 2024-08-12 21:29:36 发布
阅读量133 收藏
点赞数 1
分类专栏： 学习小结 Java学习心得 持之以恒 文章标签： java 泛型 数据结构 正则表达式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_57821294/article/details/119462776
版权

Java第五天基础学习

1.集合体系
2.迭代器
3.并发修改异常
4.增强for循环
5.泛型
6.可变参数
7.正则表达式
8.数据结构

集合体系：

单列集合：

Collection接口:

LIst:接口
特点：

1.元素存取顺序一致（有序）
2.有索引
3.可重复
常用实现类：
1.ArrayList:底层是数组实现，查询快，增删慢
2.LinkedList:底层是链表实现，增删快，查询慢

Set接口：
特点：
1.元素存取顺序不一致（无序）
2.无所引
3.不重复
常用实现类：
1.HashSet
2.TreeSer

双列集合：

Map接口

在这里插入图片描述
在这里插入图片描述

源码参考：

package _02Collection和List接口;

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

/*
    目标：掌握Collection的常用方法

    1.Collection接口中常用方法：
        boolean add(E e)  往集合中添加元素
        boolean remove(Object o) 删除指定元素
        void clear() 清空集合所有元素
        boolean contains(Object o) 判断集合中是否包含某个元素
        boolean  isEmpty() 判断集合是否为空（元素个数为0）
        int size()获取集合的元素个数

    2.List接口的特有方法：
        void add(int index, E element)  在指定索引出添加元素
        E remove(int index) 根据索引删除元素，返回被删元素
        E set(int index, E element) 替换指定索引处的元素，返回被替换的元素
        E get(int index)    获取指定索引处的元素
 */
public class Demo1 {
    public static void main(String[] args) {

        //coll对象只能访问Collection中的方法
        Collection<String> coll = new ArrayList<>();
        coll.add("柳岩");
        coll.add("刘亦菲");
        coll.add("王一博");

        //删除指定元素
        //System.out.println(coll.remove("王一博"));

        //void clear() 清空集合所有元素
        //coll.clear();

        //boolean contains(Object o) 判断集合中是否包含某个元素
        //System.out.println( coll.contains("柳岩") ); //调用元素类自带的equals方法，比较是否一样

        //boolean  isEmpty() 判断集合是否为空（元素个数为0）
        //System.out.println( coll.isEmpty() );

        //int size()获取集合的元素个数
        System.out.println(  coll.size() );

        System.out.println(coll);
    }
}


package _02Collection和List接口;

import java.util.ArrayList;
import java.util.List;

/*
        4.List接口的特有方法：
            void add(int index, E element)  在指定索引出添加元素
            E remove(int index) 根据索引删除元素，返回被删元素
            E set(int index, E element) 替换指定索引处的元素，返回被替换的元素
            E get(int index)    获取指定索引处的元素
 */
public class Demo2 {
    public static void main(String[] args) {

        List<String> list = new ArrayList<>();
        list.add("柳岩");
        list.add("刘亦菲");
        list.add("王一博");

        //在指定索引出添加元素
        //list.add(0,"马云");

        //根据索引删除元素，返回被删元素
       // System.out.println(  list.remove(0));

        //替换指定索引处的元素，返回被替换的元素
        //System.out.println( list.set(2,"马云") );

        //获取指定索引处的元素
        System.out.println( list.get(0) );
        System.out.println( list.get(1) );
        System.out.println( list.get(2) );

        for(int i=0; i<list.size(); i++){
            System.out.println( list.get(i) );
        }

        System.out.println(list);
    }
}

迭代器：

Iterator接口常用方法：
在这里插入图片描述

遍历集合步骤：

Collection<String> coll = new ArrayList<>();
        coll.add("马云");
        coll.add("马化腾");
        coll.add("刘强东");
        //获取迭代器
        Iterator<String> itr = coll.iterator();

        //遍历元素
        while (itr.hasNext()){ //询问有没有下一个元素
            String name = itr.next(); //获取下一个元素
            System.out.println(name);
        }`

使用注意：

1.每次调用next()方法获取集合元素之前，先调用hasNext()方法判断是否有元素，否则使用next()时容易有异常
2.迭代遍历过程中，不能使用集合对象的add或者remove方法增删集合元素，否则会有并发修改异常
3.遍历过程中，如果需要删除元素，可以使用迭代器自身的remove方法。

源代码参考：

package _03Iterator迭代器遍历集合;


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

/*
    目标：掌握迭代器遍历元素的步骤

    小结：迭代器遍历元素的步骤

        1.获取迭代器对象:   集合对象.iterator();
        2.循环判断是否有下一个元素： 迭代器对象.hasNext()
        3.如果有元素，调用 next() 方法，取出元素。
 */
public class Demo1 {
    public static void main(String[] args) {

        Collection<String> coll = new ArrayList<>();
        coll.add("马云");
        coll.add("马化腾");
        coll.add("李彦宏");
        coll.add("刘强东");

        //获取迭代器
        Iterator<String> itr = coll.iterator();

        //遍历元素
        while (itr.hasNext()){ //询问有没有下一个元素
            String name = itr.next(); //获取下一个元素
            System.out.println(name);
        }

        //System.out.println(itr.next()); //NoSuchElementException 遍历结束，不能再次获取元素

        //如果还想继续遍历，需要重新获取新的迭代器对象
        Iterator<String> itr2 = coll.iterator();
        while (itr2.hasNext()){ //询问有没有下一个元素
            String name = itr2.next(); //获取下一个元素
            System.out.println(name);
        }


    }
}

并发修改异常

package _04并发修改异常_了解;

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

/*
    目标：了解迭代器遍历的常见问题

    1.什么情况下会出现并发修改异常？
        ConcurrentModificationException
        当使用迭代器遍历时，使用了集合对象增删元素，就会产生并发修改异常。

    2.如何避免并发修改异常？
        统一操作数据的对象。（使用迭代器遍历，并且使用迭代器删除）
 */
public class Demo1 {
    public static void main(String[] args) {

        Collection<Integer> list = new ArrayList<>();
        list.add(11);
        list.add(12);
        list.add(13);
        list.add(14);
        list.add(15);

        //删除集合中的偶数元素

        //迭代器遍历
        //使用迭代器对象遍历元素
        Iterator<Integer> itr = list.iterator();
        while ((itr.hasNext())){
            Integer num = itr.next();
            if(num%2==0){
               // list.remove(num); //使用集合对象删除元素 并发修改异常
                itr.remove();
            }
        }

        System.out.println(list);
    }
}

增强for循环：

格式：
for(元素类型 变量名：数组或者集合){
}
底层原理：
增强for底层是迭代器，作用是简化迭代器的语法
使用注意：
使用增强for遍历集合过程中，不能增删集合元素，否则会有并发修改异常

源码参考1：

package _05增强for循环;

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

/*
    目标：掌握增强for循环的使用

    1.格式：
        for(元素类型  变量名 ： 数组或者集合){

        }

    2.原理：
        底层就是迭代器

    3.使用注意：
        在遍历过程无法增删元素，否则会有并发修改异常

 */
public class Demo1 {

    public static void main(String[] args) {
        Collection<String> coll = new ArrayList<>();
        coll.add("马云");
        coll.add("马化腾");
        coll.add("李彦宏");
        coll.add("刘强东");

        //使用增强for遍历
        //在遍历过程无法增删元素，否则会有并发修改异常
        for (String name : coll) {
            System.out.println(name);
            //coll.remove("马云"); //此处运行会报并发修改异常
        }

        //遍历数组
        int[] arr = {11, 22, 33};
        for(int a : arr){
            System.out.println(a);
        }

    }

}

源码参考2：

package _05增强for循环;

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

/*
    目标：掌握增强for循环的使用

    1.格式：
        for(元素类型  变量名 ： 数组或者集合){

        }

    2.原理：
        底层就是迭代器

    3.使用注意：
        在遍历过程无法增删元素，否则会有并发修改异常

 */
public class Demo2 {

    public static void main(String[] args) {
        Collection<String> coll = new ArrayList<>();
        coll.add("马云");
        coll.add("马化腾");
        coll.add("李彦宏");
        coll.add("刘强东");

        for (String name : coll) {
            System.out.println(name);
            //coll.remove("马云");
        }

    }

   /*
   反编译代码：
   public static void main(String args[]){
		Collection coll = new ArrayList();
		coll.add("马云");
		coll.add("马化腾");
		coll.add("李彦宏");
		coll.add("刘强东");

		String name;

		for (Iterator iterator = coll.iterator(); iterator.hasNext(); System.out.println(name)){
			name = (String)iterator.next();
		}

        执行步骤：
            Iterator iterator = coll.iterator();

            iterator.hasNext();
            name = (String)iterator.next();
            System.out.println(name)

	}
*/
}

泛型：

泛型类：
public class 类名<类型标记>{
}
创建对象时，确定泛型类的泛型类型
泛型接口：
public interface 接口名<泛型标记>{
}
实现接口时，确定接口的泛型类型
泛型方法：
修饰符 <“T”> 返回值类型 方法名(T t){
}
调用方法时，传入实参时确定泛型类型

泛型通配符?:
当使用泛型的时候，无法确定泛型的具体类型时，可以使用通配符？来表示某一种类型
泛型上限：
？ extends XX
？匹配的类型只能是XX或者XX的子类
泛型下限:
?super XX
?匹配的类型只能是XX或者XX的父类

源码参考1：

package _08泛型的概述;

import java.util.ArrayList;
import java.util.Map;

/*
    目标：了解泛型的概述和好处

    1.泛型的概述
        泛型是JDK5中引入的特性，它提供了编译时类型安全检测机制。

    2.泛型的好处
        把运行期间的问题提前到了编译期间。
        避免了强制类型转换。

 */
public class Demo1 {
    public static void main(String[] args) {

        //<String> 作用规范集合容器的元素的类型 ，约束集合类型
        ArrayList<String> array = new ArrayList<>();
        array.add("java");
        array.add("c++");
        //array.add(11);
        String s = array.get(0);


        /*ArrayList array = new ArrayList();
        array.add(11);
        array.add("java");
        array.add("c++");
        array.add(3.14);
        array.add(true);

        //获取数据时，需要进行类型转换
        String o = (String)array.get(0);
        System.out.println(o.length());*/

    }

}

源码参考2：

package _09泛型类的定义和使用;

/*
    目标：掌握泛型类的定义格式

        泛型类定义格式：
            public class 类名<类型标记>{

            }
            类型标记可以写成 T E  K  V  A M 等（一个大写字母）

        泛型类使用：
            创建对象时，确定泛型类的泛型类型

 */
public class Demo1 {
    public static void main(String[] args) {

        //创建泛型类的对象
        Generic<String> g = new Generic<>();
        g.setValue("java");
        String value = g.getValue();
        System.out.println("value = " + value);

        Generic<Integer> g2 = new Generic<>();
        g2.setValue(100);
        Integer a = g2.getValue();
        System.out.println(a);


    }
}
package _09泛型类的定义和使用;

//定义了泛型类
//T 表示某一个引用数据类型，在类中，可以使用数据类型的地方，就可以使用T代替
public class Generic<T> {

    private T value;

    public T getValue() {
        return value;
    }

    public void setValue(T value) {
        this.value = value;
    }
}

源码参考3：

package _10泛型接口的定义和使用;


/*
    目标：掌握泛型接口的定义格式

        泛型接口定义格式：
            public interface 接口名<泛型标记>{

            }

        泛型接口使用：
            实现接口时，在实现类中确定接口的泛型类型
 */
public class Demo1 {
    public static void main(String[] args) {

    }

}
package _10泛型接口的定义和使用;

public class My<T> implements MyList<T>{
    @Override
    public void add(T t) {

    }

    @Override
    public T get(int index) {
        return null;
    }
}
package _10泛型接口的定义和使用;


public class MyArrayList implements MyList<String>{

    @Override
    public void add(String s) {

    }

    @Override
    public String get(int index) {
        return null;
    }

}
package _10泛型接口的定义和使用;

public class MyLinkedList implements MyList<Integer> {
    @Override
    public void add(Integer integer) {

    }

    @Override
    public Integer get(int index) {
        return null;
    }
}
package _10泛型接口的定义和使用;

//定义泛型接口
public interface MyList<E> {

    void add(E e);

    E get(int index);


}

源码参考4：

package _11泛型方法的定义和使用;


/*
    目标：掌握泛型方法的定义格式

        泛型方法定义格式：
            修饰符  <T> 返回值类型 方法名(T t){

            }

        泛型方法使用：
            调用方法时，传入实参时确定泛型类型
 */
public class Demo1 {

    public static void main(String[] args) {
        //泛型方法的参数必须是引用类型
        Integer[] arr = {11, 22, 33};
        printArray(arr);

        Double[] arr2 = {1.1, 2.2, 3.3};
        printArray(arr2);
    }

    //定义泛型方法
    public static <T> void printArray(T[] arr) {
        System.out.print("[");

        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                System.out.print(arr[i]);
            } else {
                System.out.print(arr[i] + ", ");
            }
        }

        System.out.println("]");
    }


    /*//数组的格式化打印
    public static void printArray(double[] arr){
        System.out.print("[");

        for (int i = 0; i < arr.length; i++) {
            if(i==arr.length-1){
                System.out.print(arr[i]);
            }else {
                System.out.print(arr[i]+", ");
            }
        }

        System.out.println("]");
    }

    //数组的格式化打印
    public static void printArray(int[] arr){
        System.out.print("[");

        for (int i = 0; i < arr.length; i++) {
            if(i==arr.length-1){
                System.out.print(arr[i]);
            }else {
                System.out.print(arr[i]+", ");
            }
        }

        System.out.println("]");
    }*/

}

泛型通配符参考源码：

package _12泛型通配符和泛型上下限.应用举例;

//汽车父类
public class Car {

}
package _12泛型通配符和泛型上下限.应用举例;

//奥迪汽车
public class Audi extends Car{

}
package _12泛型通配符和泛型上下限.应用举例;

//吉普汽车
public class Jeep extends Car{

}
package _12泛型通配符和泛型上下限.应用举例;

import java.util.ArrayList;

//qq飞车游戏
public class QQPlay {
    public static void main(String[] args) {
        ArrayList<Audi> audis = new ArrayList<>();
        audis.add(new Audi());
        audis.add(new Audi());
        play(audis);

        ArrayList<Jeep> jeeps = new ArrayList<>();
        jeeps.add(new Jeep());
        jeeps.add(new Jeep());
        play(jeeps);

        ArrayList<Car> cars = new ArrayList<>();
        cars.add(new Car());
        cars.add(new Car());
        play(cars);

       /* ArrayList<Dog> dogs = new ArrayList<>();
        play(dogs);

        ArrayList<Object> objs = new ArrayList<>();
        play(objs);*/

    }


    //定义方法，可以接收任意汽车集合（泛型没有重载和多态）
    //ArrayList<?> 表示 ArrayList集合可以接收任意类型
   /* public static void play(ArrayList<?> list){

    }*/

    //为了限制通配符能匹配的范围，需要使用上下限
    //? extends Car :泛型的类型只能Car或者Car的子类（上限）
    public static void play(ArrayList<? extends Car> list){

    }

    //? super Car ：泛型的类型只能是Car或者Car的父类（下限）
    /*public static void play(ArrayList<? super Car> list){

    }*/

}

class Dog{

}

可变参数

使用场景：
当方法形参的类型确定，而个数不确定时，可以使用可变参数(…)表示。
格式：
修饰符 返回值类型 方法名（参数类型…变量名）{
}
原理：
可变参数的本质是数组。
使用注意：
一个方法中只能有一个可变参数。
当方法有多个参数时，可变参数必须时最后一个人参数

参考源码1：

package _13可变参数;

/*
	目标：掌握可变参数的使用
	
    可变参数格式：
        修饰符  返回值类型  方法名(参数类型 ... 变量名){

        }

    原理：
       可变参数底层就是数组
 */
public class Demo1 {
    public static void main(String[] args) {
        //如果参数是可变参，传参时参数个数可以变化
        System.out.println(getSum());
        System.out.println(getSum(1));
        System.out.println(getSum(1, 2));
        System.out.println(getSum(1, 2, 3));

        /*int[] arr = {1};
        System.out.println(getSum(arr));

        int[] arr2 = {1,2};
        System.out.println(getSum(arr2));

        int[] arr3 = {};
        System.out.println(getSum(arr3));*/
    }

    //可变参数底层就是数组
    public static int getSum(int... arr){
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum+=arr[i];
        }
        return sum;
    }


   /* public static int getSum(int[] arr){
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum+=arr[i];
        }
        return sum;
    }
    */

    /*public static int getSum(int a, int b){
        return a+b;
    }

    public static int getSum(int a, int b, int c){
        return a+b+c;
    }

    public static int getSum(int[] arr){
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum+=arr[i];
        }
        return sum;
    }*/


}

参考源码2：

package _13可变参数;

import java.util.Collections;

/*
	可变参数使用注意：
		1.一个方法只能定义一个可变参数。
		2.如果方法中有多个参数，可变参数要放到最后。

 */
public class Demo2 {

    public static void main(String[] args) {
        getSum(1,2,3);

    }

    /*public static void getSum(int... arr, double ... arr2){

    }*/

    public static void getSum( int a, int... arr) {

    }


}

正则表达式：

作用：
正则表达式是一个强大的字符串处理工具，是用于匹配字符串的模板，可以对字符串进行格式化校验，查找，提取，替换等操作。

语法：
范围匹配：
常用写法：
[abz]:匹配abc中任意一个字符。
[a-z]:匹配小写字母a-z中的一个。
[A-Z]:匹配大写字母A-Z中的一个。
[0-9]:匹配数字0-9中的一个。
组合匹配：
[a-zA-Z0-9]:匹配a-z或者A-Z或者0-9之间的任意一个字符。
[a-dm-p]:匹配a-d或者m-p之间的任意一个字符。
排除匹配：
[^abc]:匹配除a、b、c之外的任意一个字符
[^a-z]:匹配除小写字母外的任意一个字符。

预定义字符：
“.”:匹配一个任意字符
“\d”:匹配一个数字字符，相当于[0-9]
“\D”:匹配一个非数字，相当于[^0-9]
“\s”：匹配一个空白字符
“\S”:匹配一个非空白字符
“\w”:匹配一个单词字符，包括大小写字母，数字，下划线，相当于[a-zA-Z0-9_]
“\W”:匹配一个非单词字符

数量词匹配
？0或1次
‘*’ 0次或者多次（任意次）
‘+’ 1次或者多次
{n} 重复n次
{n，} 重复n次以上（至少n次）
{n,m} 重复n到m次（包括n和m）

逻辑匹配符：
&& 并且（交集）
| ：或者（并集）

分组：
()

参考源码1：

package _14正则表达式_演示;

/*
普通方式校验字符串：
    判断用户输入的身份证号码是否合法。
    规则为：号码为18位，不能以数字0开头，前17位只可以是数字，最后一位可以是数字或者大写字母X。
 */
public class RegexTest1 {

    public static boolean checkId(String id){

        if(id==null){
            return false;
        }

        //号码为18位.如果不是18位，返回false
        if(id.length()!=18){
            return false;
        }
        //不能以数字0开头，如果以数字0开头，返回false
        if(id.startsWith("0")){
            return false;
        }
        //前17位只可以是数字，如果前17位中有不是数字的，返回false
        for(int i=0; i<17; i++){
            char ch = id.charAt(i);
            if(ch>'9' || ch<'0'){
                return false;
            }
        }
        //最后一位可以是数字或者大写字母X
        char last = id.charAt(17);
        if(last=='X' || (last>='0' && last<='9')){
            return true;
        }else {
            return false;
        }

    }

    //测试
    public static void main(String[] args) {
        System.out.println( checkId("445221199909091234") );
        System.out.println( checkId("44522119990909123X") );
        System.out.println( checkId("44522119990909123") );
        System.out.println( checkId("4452211999090912345") );
        System.out.println( checkId("045221199909091234") );
        System.out.println( checkId("4452A1199909091234") );
        System.out.println( checkId("44522119990909123x") );
    }



}
package _14正则表达式_演示;

/*
正则表达式校验字符串：
    判断用户输入的身份证号码是否合法。
    规则为：号码为18位，不能以数字0开头，前17位只可以是数字，最后一位可以是数字或者大写字母X。
 */
public class RegexTest2 {

    public static boolean checkId(String id){

      if(id!=null){
          // 规则为：号码为18位，不能以数字0开头，前17位只可以是数字，最后一位可以是数字或者大写字母X。
          return id.matches("[1-9]\\d{16}[0-9X]");
      }else {
          return false;
      }

    }

    //测试
    public static void main(String[] args) {
        System.out.println( checkId("445221199909091234") );
        System.out.println( checkId("44522119990909123X") );
        System.out.println( checkId("44522119990909123") );
        System.out.println( checkId("4452211999090912345") );
        System.out.println( checkId("045221199909091234") );
        System.out.println( checkId("4452A1199909091234") );
        System.out.println( checkId("44522119990909123x") );
    }
}

源码2：

package _15正则表达式语法_了解;

/*
    1.范围匹配 []
        [abc]：匹配abc中任意一个字符。
        [a-z]：匹配小写字母a-z中的一个。
        [A-Z]：匹配大写字母A-Z中的一个。
        [0-9]：匹配数字0-9中的一个。

        组合：
        [a-zA-Z0-9]：匹配a-z或者A-Z或者0-9之间的任意一个字符。
        [a-dm-p]： 匹配a-d或m-p之间的任意一个字符。


        排除：
        [^abc]：匹配除a、b、c之外的任意一个字符。
        [^a-z]：匹配除小写字母外的任意一个字符。
 */
public class Demo1 {

    public static void main(String[] args) {
        //字符串对象.matches("正则表达式") ，符合正则表达式规则，返回true

        //[abc]：匹配abc中任意一个字符。
        System.out.println( "a".matches("[abc]") );
        System.out.println( "b".matches("[abc]") );
        System.out.println( "c".matches("[abc]") );


        System.out.println( "ab".matches("[abc]b") ); //字符串的第一个字符可以是a,b,c，第二个字符只能是b

        //匹配abc的任意组合  acb  bca aaa  bbb  abb ...
        System.out.println( "acb".matches("[abc][abc][abc]") );
        System.out.println( "bbb".matches("[abc][abc][abc]") );


        //[a-z]：匹配小写字母a-z中的一个。
        System.out.println( "e".matches("[a-z]") );

        //[^abc]：匹配除a、b、c之外的任意一个字符。
        System.out.println( "我".matches("[^abc]") );

    }

}

参考源码3：

package _15正则表达式语法_了解;

/*
    2.预定义字符
        "." ： 匹配一个任意字符
        "\d"： 匹配一个数字字符，相当于[0-9]
        "\D"： 匹配一个非数字，相当于[^0-9]

        "\s"： 匹配一个空白字符
        "\S"： 匹配一个非空白字符

        "\w"： 匹配一个单词字符，包括大小写字母，数字，下划线，相当于[a-zA-Z0-9_]
        "\W"： 匹配一个非单词字符
 */
public class Demo2 {
    public static void main(String[] args) {

        //匹配长度为4的数字验证码
        System.out.println("1234".matches("\\d\\d\\d\\d"));
        System.out.println("0495".matches("\\d\\d\\d\\d"));

        //匹配一个三位数 (100~999)
        System.out.println("100".matches("[1-9]\\d\\d"));
        System.out.println("999".matches("[1-9]\\d\\d"));

        // "\s"： 匹配一个空白字符，只能匹配一个空白
        System.out.println(" ".matches("\\s"));

        //"." ： 匹配一个任意字符
        System.out.println(" ".matches("."));
        System.out.println("中".matches("."));
        System.out.println("a".matches("."));
        System.out.println("9".matches("."));

        //只是单独匹配 . 这个符号
        System.out.println(".".matches("\\.")); //true
        System.out.println("!".matches("\\.")); //false
    }
}

参考源码4：

package _15正则表达式语法_了解;

/*
    3.数量词（限定符）
        ?   0次或1次
        *   0次或多次 (任意次)
        +   1次或多次

        {n}    重复n次
        {n,}   重复n次以上 (至少n次)
        {n,m}  重复n到m次（包括n和m）
 */
public class Demo3 {
    public static void main(String[] args) {
        //匹配长度为4的数字验证码
        System.out.println("1234".matches("\\d{4}"));

        //匹配密码 5-8位的密码 (密码只能是单词字符)
        System.out.println("34rrA_".matches("\\w{5,8}"));
        System.out.println("12345@".matches("\\w{5,8}"));

        //衣服尺码 比如：L XL  XXL  XXXL
        System.out.println("L".matches("X*L")); //X可以出现任意次，L只能固定
        System.out.println("XL".matches("X*L")); //X可以出现任意次，L只能固定
        System.out.println("XXXL".matches("X*L")); //X可以出现任意次，L只能固定

        //匹配任意一个英文单词，英文单词全部是小写字母就行
        //a  is  out  love  hello
        System.out.println("a".matches("[a-z]+"));
        System.out.println("love".matches("[a-z]+"));

    }

}

参考源码5：

package _15正则表达式语法_了解;

/*
    4.逻辑匹配
        && ：并且（交集）
        |  ：或者（并集）

    5.括号分组 ()
        正则表达式中用小括号()来做分组，也就是括号中的内容作为一个整体。
 */
public class Demo4 {
    public static void main(String[] args) {

        //逻辑匹配：
        //匹配除去tmd外任意一个小写字母
        System.out.println("m".matches("[[a-z]&&[^tmd]]"));
        System.out.println("h".matches("[[a-z]&&[^tmd]]"));
        System.out.println("A".matches("[[a-z]&&[^tmd]]"));

        //匹配邮箱后缀 com 或者 cn 或者 org
        System.out.println("cn".matches("com|cn|org"));
        System.out.println("org".matches("com|cn|org"));
        System.out.println("edu".matches("com|cn|org"));

        //( )分组
        //匹配 over! 字符串出现3次
        System.out.println("over!over!over!".matches("over!{3}")); //false，因为正则表达式匹配over!!!
        System.out.println("over!over!over!".matches("(over!){3}")); //true

    }
}

练习邮箱格式源码：

package _16练习_邮箱格式校验;

/*
    目标：使用正则表达式完成邮箱格式校验

    要求：
        邮箱地址必须是6~18个字符，可使用字母，数字，下划线，需要以字母开头。
        邮箱后缀支持 @163.com 或者 @126.com 或者 @yeah.net。
 */
public class Demo1 {
    public static void main(String[] args) {

        String email = "itheima@yeah.net";

        boolean result = email.matches("[a-zA-Z]\\w{5,17}@(163\\.com|126\\.com|yeah\\.net)");

        System.out.println(result);


    }
}

表达式拓展源码：

package _16练习_邮箱格式校验;

import java.util.Arrays;

/*
    String replaceAll(String regex, String replacement)
        将该字符串中所有匹配正则表达式的内容替换成新的字符串，并返回替换后的新的字符串。

    String[] split(String regex)
        根据匹配规则，把字符串分割成多个子串。

 */
public class Demo2 {
    public static void main(String[] args) {
        //replaceAll(正则表达式, 新的字符串)
        String date = "2021-8-4";

        //将日期换成2021/8/4
        String s = date.replaceAll("-", "/");
        System.out.println(s);

        /*String word =" 我   爱       java ";
        //把字符串的所有空格去掉
        String s1 = word.replaceAll(" ", "");
        System.out.println(s1);*/

        String word ="我   爱       java";
        //把字符串中间的空格换成一个空格 "我 爱 java"
        String s1 = word.replaceAll(" +", " ");
        System.out.println(s1);

        //split(String regex)
        String date1 = "2021-8-4";
        //将date1字符串切割出年，月，日
        String[] arr = date1.split("-");
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);

        String[] arr2 = word.split(" +");
        System.out.println(Arrays.toString(arr2));

    }
}

数据结构

栈：先进后厨
队列：先进先出
数组：查询快，增删慢
链表：增删快，查询慢

package _01常见数据结构_了解;

/*
    目标: 了解常见数据结构的特点

    小结：
        栈结构特点
            先进后出

        队列结构特点
            先进先出

        数组结构特点
            查询快，增删慢（有索引，长度固定）

        链表结构特点
            增删快，查询慢（有节点，节点能指向相邻元素）
 */
public class Demo1 {


}

今天就学到这里
小结：
在这里插入图片描述

Rope_peng
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
正确遍历删除集合元素
城溪羡鱼的博客
10-13 1313
正确遍历删除集合元素（1）for循环遍历（2）for-each遍历（3）Iterator遍历 （1）for循环遍历 假设想删除集合里面所有的“b”，用普通For循环会失败，这是因为size是变化的，当删除第一个b之后，元素会往前移且size从4变成了3，此时下一次遍历会看到的是c而不是第二个b。因此，没有删除干净。 package blog; import java.util.ArrayList; import java.util.List; public class HowIteReEm { publ
JAVA
Cola_6的博客
05-30 986
快捷键： alt+enter是自动修正代码 ctrl+y删除光标所在行 ctrl+d复制光标所在行 Ctrl+alt+L 格式化代码，即将代码对齐 Ctrl+/ 单行注释 Ctrl+shift+/ 选中代码进行多行注释 alt+shift+上下箭头，移动光标行 for(i=0;i<5;i++)可以打成 5.fori+回车 for(i=4;i>=1;i++)倒序，可...
【软件构造】集合遍历时删除元素的问题和迭代器
weixin_51540989的博客
06-10 591
集合遍历时删除元素的问题
springboot民办高校科研项目管理系统-计算机毕业设计源码54009
VX_DZbishe的博客
08-11 299
论文主要是对基于springboot的民办高校科研项目管理系统进行了介绍，包括研究的现状，还有涉及的开发背景，然后还对系统的设计目标进行了论述，还有系统的需求以及整个的设计方案，对系统的设计以及实现，也都论述的比较细致，最后对基于springboot的民办高校科研项目管理系统进行了一些具体测试。本次报告，首先分析了研究的背景、作用、意义，为研究工作的合理性打下了基础。
SpringBoot快速入门（手动创建）
m0_74124657的博客
08-11 275
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
集合（1）
supercool7的博客
08-12 438
表示不同的类型集合，Collection、Map、List、Set、Queue、Deque等，以及辅助性质的接口Iterator、LinkIterator、Comparator、Comparable这些接口是为迭代和比较元素而准备。对接口的具体实现，主要常用的有：ArrayList、LinkedList、HashMap、HashSet、TreeMap等等。理解Java集合体系可以从三个层次：最上层的接口、中间的抽象类、最后的实现类。是所有集合框架的根接口，包含了对集合进行基本操作的方法。
软件测试需要具备的基础知识【功能测试】---后端知识（三）
yang_xs的博客
08-12 767
为了更好的学习软件测试的相关技能，需要具备一定的基础知识。需要学习的基础知识包括：1、计算机基础2、前端知识3、后端知识4、软件测试理论后期分四篇文章进行编写，这是第三篇CS架构BS架构效率：c/s效率高，某些内容已经安装在系统中了，b/s每次都要加载最新的数据升级：b/s无缝升级；c/s删除老版本再安装新版本安全：c/s更安全，需要安装、注册、登录；b/s有浏览器即可使用，安全程度低开发成本：b/s成本低；c/s需要不同的系统要不同的开发人员，成本高。
Spring Boot 3.x Rest API最佳实践之API设计
felix_alone2012的博客
08-08 979
本系列教程将会以企业中API基础功能封装为目标，用最新的Spring Boot 3.x版本来逐步搭建和完善Rest API项目基础架构，并结合实际电商项目中API的实现需求来进行最佳实践。如果觉得对你有帮助，记得点赞收藏，关注小卷，后续更精彩！
反射和注解
supercool7的博客
08-08 270
反射的基本步骤包括获取Class对象、获取类的信息（构造函数、方法、字段等），然后通过Constructor、Method、Field等类的实例进行具体的操作。注解以@符号开头，通常紧跟着一个标识符，后面可以跟一些参数，用于给类、方法、字段等添加元数据信息，这些信息可以在编译时、运行时被读取和处理。通过Class类，可以获取类的构造函数、方法、字段等信息，而不需要在编译时确定这些信息。Spring、SpringBoot、Mybatis等框架中都大量使用了反射机制。此外，开发者还可以定义自己的注解，通过。
Mybatis XML 数据源为 Oracle 之批量插入或更新 Merge Into 的具体介绍与使用
最新发布
欢迎来到 ABin-阿斌的博客：写一生代码，创一世佳话，筑一览芳华。
08-12 391
由于近期在所开发的项目中，对于数据入库，有存在即更新，不存在则插入的需求，因此发现了 Oracle中的 MergeInto 命令。本文将对MergeInto的用法进行介绍并将 MergeInto 和批量插入进行结合，同时还会对在 MergeInto 开发中遇到的问题进行总结。MergeInto 命令是 Oracle9i 中新增的命令，有了 MergeInto 语句，我们对数据能够不仅仅只做单一的插入或单一的更新，而是可以将更新与插入一起操作。
安卓Android & JAVA校招/实习面试合集:多线程、强软弱虚引用、进程、内存管理、Activity、Fragment......
qq_41915623的博客
08-10 436
安卓Android、java面试资料合集：内存管理、多线程、进程、强软弱虚应用、Activity
Java：继承，this，super
m0_75257168的博客
08-10 351
可以同名，但参数列表不能相同（有参无参构造）
Spring一个强大便捷的代理工厂类
330553352的专栏
08-10 295
但如果你需要一种更加灵活和可配置性，那么Spring还提供了一个非常方便强大的ProxyFactoryBean类，该类特别适合那些需要更多自定义和控制的场景，例如当你需要为特定的Bean创建代理，或者需要在不修改原始代码的情况下为现有类添加额外的功能时。在Spring框架中，AOP（面向切面编程）是一种强大的编程范式，它允许开发者在不修改原有代码的情况下，为程序添加额外的功能，如日志记录、事务管理、安全控制等。在上面配置拦截器时，我们都是指定的具体拦截器，其实我们还可以使用通配符，指定拦截器。
【智能排班系统】SpringBoot整合邮件发送服务
记录一名在读研究生的学习笔记、感悟、开发产物
08-12 257
本文档指导如何配置Spring Boot应用以通过QQ邮箱发送邮件。首先，用户需登录QQ邮箱并开启SMTP服务以获取授权码。随后，在Spring Boot项目中，通过`application.yml`配置文件指定SMTP服务器的地址、端口及认证信息等参数。此外，还介绍了如何创建一个配置类`MailConfig`来读取这些配置，并使用Lombok简化getter和setter方法。为了封装邮件发送所需的属性，文档还提供了`EmailDto`类。
DSL domain specific language of Kola
AK15221736052的博客
08-08 745
Kola 从 SmartBear 的 PactFlow, Spring clout Contract, Spock, Karate 等前辈上得到很多参考和灵感；直接用 ApiHug 上下文的 api 可以有更丰富的上下文， 关于request, response 的定义， path, 参数， 校验规则。但是 BDD 的表达方式，真的是太好了，兼顾程序世界的结构化，和非程序世界的通俗易懂；更不用说， 测试界的基石: Junit5, TestNG, AssertJ 等基础框架；在 ApiHug 上下文，
基于vue框架的NBA球星管理系统1878g（程序+源码+数据库+调试部署+开发环境）系统界面在最后面。
h2345678的博客
08-12 828
随着互联网的普及和体育产业的蓬勃发展，篮球运动在全球范围内拥有庞大的粉丝群体，NBA（美国职业篮球联赛）作为其中的佼佼者，其球星更是备受关注。传统的球星信息管理方式往往依赖于纸质文档或简单的电子表格，这种方式不仅效率低下，难以实现数据的即时更新与共享，也无法满足球迷和媒体对球星信息深度挖掘的需求。因此，开发一套基于Vue框架的NBA球星管理系统，通过信息化手段整合球星信息，实现数据的快速录入、存储、查询与分析，对于提升管理效率、满足用户需求具有重要意义。，处理前端请求并提供业务逻辑。
Java面试题（一）----Java基础
weixin_73253843的博客
08-12 504
Java中==和equals有什么区别？ 一个是运算符，一个是方法。 == 如果比较的对象是基本数据类型，则比较数值是否相等； 如果比较的是引用数据类型，则比较的是对象的内存地址是否相等。 因为Java只有值传递，对于==来说，不管是比较基本数据类型，还是引用数据类型的变量，其比较的都是值，只是引用类型变量存的值是对象的地址。引用类型对象变量其实是一个引用，它们的值是指向对象所在的内存地址。
MTK Android12 关机界面全屏展示
十年饮冰，难凉热血
08-08 1002
实现点击关机【重启一样的逻辑】，弹出一个界面的需求，实现方式：1）去掉关机、重启的dialog的 dismiss方法，mDialog.dismiss();【也可以不去，全屏界面会盖住】2）在关闭实现全屏界面，这里用全屏dialog 实现。
购物系统小程序的设计
2401_83198589的博客
08-11 268
管理员账户功能包括：系统首页，个人中心，商品分类管理，商品信息管理，特价商品管理，用户管理，留言板管理，订单管理，系统管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，商品信息，特价商品，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
Java开发基础：第一周学习总结——DOS命令与JDK配置
"第一周总结(Java开发基础)" 在学习Java开发的过程中，第一周的总结主要涵盖了以下几个关键知识点： 1. **DOS命令**：在Windows操作系统中，DOS命令是进行基本操作的重要工具。例如，`盘符切换`允许你从一个驱动器...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值