【java 基础三】- 正则表达式、枚举、equals等

小咪咪 2023-10-12 09:54 10阅读 0赞

## 一 枚举 ##

### 1.1 定义 ###

Java枚举是一种特殊的数据类型，用于表示有限个预设的值。它在Java语言中是一种类（class）类型，但又比普通的类类型多了些特殊的约束，这些约束使得枚举类型更加简洁、安全和便捷。枚举类型的名称必须以大写字母开头，可以包含字母、数字和下划线。

### 1.2 特点 ###

*  Java中枚举和类、接口的级别相同。
 *  枚举和类一样，都有自己的属性、方法、构造方法，但枚举的构造方法只能是private修饰，也就无法从外部构造对象。
 *  使用enum关键字声明一个枚举类型时，就默认继承自Java中的java.lang.Enum类，并实现了java.lang.Seriablizable和java.lang.Comparable两个接口。
 *  所有的枚举值都是public static final的，且非抽象的枚举类不能再派生子类。
 *  枚举类的所有实例（枚举值）必须在枚举类的第一行显式地列出，否则这个枚举类将永远不能产生实例

### 1.3 作用 ###

*  作为类型安全的常量。例如：

public enum Color {
         RED, GREEN, BLUE, YELLOW }  
    public static void main(String[] args) {
          
        System.out.println(Color.RED); // 输出 RED  
    }

*  避免使用魔法值，用于 switch 语句中：

以前：
    public static final String MONDAY = "0";
    
    现在
    public enum Day {
         MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY }  
    public static void main(String[] args) {
          
        Day today = Day.MONDAY;  
        switch (today) {
          
            case MONDAY:  
                System.out.println("今天是星期一");  
                break;  
            case TUESDAY:  
                System.out.println("今天是星期二");  
                break;  
            // ...  
            default:  
                System.out.println("今天是星期日");  
                break;  
        }  
    }

*  用于消除重复代码，提高程序的可维护性、可读性、安全性、可扩展性：

public enum Direction {
         UP, DOWN, LEFT, RIGHT }  
    public class Move {
          
        public Direction direction;  
        public int distance;  
        // ...  
    }  
    public class Robot {
          
        public void move() {
          
            Move move = new Move();  
            move.direction = Direction.UP;  
            move.distance = 10;  
            // ...  
        }  
    }

### 1.4 枚举构造方法 ###

枚举也可以有构造方法，其本质也是一个类，java.lang.Enum

public enum CoinP {
        
    	UNKONWN("-1"),
    	ONE("0");
    	
    	private final String pos;
    	CoinP(String pos) {
        
    		this.pos = pos;
    	}
    	public String getPos() {
        
    		return pos;
    	}
    }

### 1.5 常用方法 ###

![在这里插入图片描述][1df2c421669c4ca0868d6c6a118e8d2d.png]

## 二 正则表达式 ##

一看就懂，一用就废。

### 2.1 定义 ###

Java正则表达式是一种用来匹配和解析字符串的工具，它提供了一种强大的方式来查找、处理和操作文本数据。在Java中，正则表达式通常使用java.util.regex包下的类进行支持。

Java正则表达式的基本结构由一个模式（Pattern对象）和一组规则（Matcher对象）组成，其中模式描述了要匹配的文本模式，规则定义了匹配的模式如何被解析和应用。

### 2.2 用法 ###

/**
         * 判断是否为数字
         * true 是数字
         */
        public static boolean isNumer(String str) {
        
            if (TextUtil.isEmpty(str)) {
        
                return false;
            }
            Pattern pattern = Pattern.compile("^[0-9]*$");
            Matcher m = pattern.matcher(str)；
            return m.matches();
        }
    	
    	public static boolean isPhone(String num) {
        
    		String phone = "18810022666"; 
     		String regex = "1[34578][0-9]{9}"; 
    		boolean flag = phone.matches(regex);
    	}

这里 String 可以直接调用matches，因为在内部进行了封装

public boolean matches(String regex) {
        
            return Pattern.matches(regex, this);
        }
    
    Pattern.java
    	public static boolean matches(String regex, CharSequence input) {
        
            Pattern p = Pattern.compile(regex);
            Matcher m = p.matcher(input);
            return m.matches();
        }

### 2.3 方法 ###

#### Matcher.find() ####

翻译一下：

> 尝试查找与模式匹配的输入序列的下一个子序列。  
> 此方法从该匹配器区域的开头开始，或者，如果上次调用该方法成功，并且此后未重置匹配器，则从上次匹配未匹配的第一个字符开始。  
> 如果匹配成功，则可以通过开始、结束和分组方法获得更多信息。  
> 如果且仅当输入序列的子序列与该匹配器的模式匹配，则为true

find()方法在部分匹配时和完全匹配时返回true,匹配不上返回false;

import java.util.regex.*;  
      
    public class RegexExample {
          
        public static void main(String[] args) {
          
            String input = "Hello, world!";  
            Pattern pattern = Pattern.compile("\\w+");  
            Matcher matcher = pattern.matcher(input);  
            while (matcher.find()) {
          
                System.out.println(matcher.group());  
            }  
        }  
    }

在上面的代码中，我们首先定义了一个输入字符串input，然后使用Pattern类的compile()方法创建了一个正则表达式模式pattern。接下来，我们使用Matcher类的matcher()方法将输入字符串与正则表达式模式进行匹配，并将匹配器对象matcher赋给变量。最后，我们使用while循环调用find()方法，找到所有与正则表达式模式匹配的子串，并使用group()方法输出每个匹配的子串。  
运行上面的代码，输出结果如下：

Hello  
    world

#### matcher.groups(int group) ####

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

> 表达式 ((A)(B(C）))  
> 里面有三个组：  
> ((A)(B(C）))  
> (A)  
> (B(C）)  
> (C）  
> 形式为 matcher.group( )

即直接用小括号来分组，捕获组是指在正则表达式中使用圆括号括起来的部分，用于匹配和提取子字符串， groupCount 方法来查看表达式有多少个分组。  
举个简单的例子

import java.util.regex.*;  
      
    public class RegexExample {
          
        public static void main(String[] args) {
          
            String input = "Hello, world!";  
            Pattern pattern = Pattern.compile("(\\w+) (\\w+)");  
            Matcher matcher = pattern.matcher(input);  
            if (matcher.find()) {
          
                String[] groups = matcher.groups().split(" ");  
                for (String group : groups) {
          
                    System.out.println(group);  
                }  
            }  
        }  
    }

在上面的代码中，我们首先定义了一个输入字符串input，然后使用Pattern类的compile()方法创建了一个正则表达式模式pattern。该模式包含两个捕获组，分别匹配一个单词和一个空格。接下来，我们使用Matcher类的matcher()方法将输入字符串与正则表达式模式进行匹配，并将匹配器对象matcher赋给变量。然后，我们使用find()方法查找第一个匹配项，并使用groups()方法获取所有捕获组的匹配结果。最后，我们使用split()方法将结果按空格分割成一个字符串数组，并使用for循环输出每个捕获组的匹配结果。

#### matcher.matches() ####

即常用的全部匹配

### 2.4 正则表达式支持字符 ###

<table> 
 <thead> 
  <tr> 
   <th align="left">字符</th> 
   <th align="left">解释</th> 
   <th align="left">示例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">.</td> 
   <td align="left">匹配除换行符\n之外的任何单字符。</td> 
   <td align="left">jav. 可匹配java、javb、javc</td> 
  </tr> 
  <tr> 
   <td align="left">[]</td> 
   <td align="left">用于确定中括号表达式的开始和结束位置。</td> 
   <td align="left">java匹配j[abc]va</td> 
  </tr> 
  <tr> 
   <td align="left">-</td> 
   <td align="left">[] 内表示字符范围</td> 
   <td align="left">java匹配[a-z]av[a-g]</td> 
  </tr> 
  <tr> 
   <td align="left">^</td> 
   <td align="left">匹配一行的开头。</td> 
   <td align="left">java匹配j[^b-f]va</td> 
  </tr> 
  <tr> 
   <td align="left">\</td> 
   <td align="left">用于转义下一个字符，或指定八进制、十六进制字符。</td> 
   <td align="left">(匹配(</td> 
  </tr> 
  <tr> 
   <td align="left">$</td> 
   <td align="left">匹配一行的结尾。如果设置了 RegExp 对象的 Multiline 属性，$ 还会与"\n"或"\r"之前的位置匹配。</td> 
   <td align="left">;$匹配位于一行及外围的;号</td> 
  </tr> 
  <tr> 
   <td align="left">*</td> 
   <td align="left">指定前面子表达式可以出现零次或多次</td> 
   <td align="left">zo* 匹配zoo或z</td> 
  </tr> 
  <tr> 
   <td align="left">+</td> 
   <td align="left">指定前面子表达式可以出现一次或多次</td> 
   <td align="left">zo+ 匹配zo或zoo</td> 
  </tr> 
  <tr> 
   <td align="left">?</td> 
   <td align="left">指定前面子表达式可以出现零次或一次</td> 
   <td align="left">zo? 匹配z或zo</td> 
  </tr> 
  <tr> 
   <td align="left">{}</td> 
   <td align="left">用于标记前面子表达式的出现频度</td> 
   <td align="left">o{2} 匹配food中的两个o</td> 
  </tr> 
  <tr> 
   <td align="left">()</td> 
   <td align="left">标记子表达式的开始和结束位置</td> 
   <td align="left">o{2} 匹配food中的两个o</td> 
  </tr> 
  <tr> 
   <td align="left">\b</td> 
   <td align="left">匹配一个字边界 va\b匹配java中的va，但不匹配javar中的va</td> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left">\B</td> 
   <td align="left">非字边界匹配 va\B匹配javar中的va，但不匹配java中的va</td> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left">\d</td> 
   <td align="left">匹配 0~9 的所有数字</td> 
   <td align="left">1[\d] 可匹配13 、15</td> 
  </tr> 
  <tr> 
   <td align="left">\D</td> 
   <td align="left">匹配非数字</td> 
   <td align="left">[\D]java匹配Jjava</td> 
  </tr> 
  <tr> 
   <td align="left">\w</td> 
   <td align="left">匹配所有的单词字符，包括 0~9 所有数字、26 个英文字母和下画线_</td> 
   <td align="left">java匹配[\w]ava</td> 
  </tr> 
  <tr> 
   <td align="left">\W</td> 
   <td align="left">匹配所有的非单词字符</td> 
   <td align="left">$java匹配[\W]java</td> 
  </tr> 
  <tr> 
   <td align="left">\s</td> 
   <td align="left">匹配所有的空白字符，包括空格、制表符、回车符、换页符、换行符等</td> 
   <td align="left">Java 2匹配Java\s2</td> 
  </tr> 
  <tr> 
   <td align="left">\S</td> 
   <td align="left">匹配所有的非空白字符 java匹配 j[\S]va</td> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left">\f</td> 
   <td align="left">匹配换页符</td> 
   <td align="left">等效于\x0c和\cL</td> 
  </tr> 
  <tr> 
   <td align="left">\n</td> 
   <td align="left">匹配换行符</td> 
   <td align="left">等效于\x0a和\cJ</td> 
  </tr> 
 </tbody> 
</table>

Object

## 三 equals 方法 ##

在 Java 中，equals() 方法用于比较两个对象是否相等。默认情况下，equals() 方法比较的是对象的引用，即两个对象只有在引用相同的情况下才被认为是相等的。  
如果你想比较两个对象的值是否相等，你需要重写 equals() 方法。重写 equals() 方法的一般步骤如下：

*  检查传入的对象是否为 null，如果是，返回 false。
 *  检查传入的对象是否与该对象相同，如果是，返回 true。
 *  检查传入的对象是否属于同一类，如果不是，返回 false。
 *  将传入的对象转换为该类的类型。
 *  比较该类中的所有字段是否相等，如果都相等，返回 true，否则返回 false。

举个例子：

public class Person {
          
        private String name;  
        private int age;  
      
        // 构造函数和其他方法省略  
      
        @Override  
        public boolean equals(Object obj) {
          
            if (obj == null) {
          
                return false;  
            }  
            if (this == obj) {
          
                return true;  
            }  
            if (getClass() != obj.getClass()) {
          
                return false;  
            }  
            Person other = (Person) obj;  
            if (!Objects.equals(name, other.name)) {
          
                return false;  
            }  
            if (age != other.age) {
          
                return false;  
            }  
            return true;  
        }  
    }

在这个示例中，我们重写了 equals() 方法来比较两个 Person 对象是否相等。我们首先检查传入的对象是否为 null，然后检查传入的对象是否与该对象相同。接下来，我们将传入的对象转换为 Person 类型，并比较 name 和 age 字段是否相等。如果都相等，则返回 true，否则返回 false。

### equals 和 == ###

在Java中，equals()和==都是用于比较两个对象是否相等的方法，但它们之间有一些区别。  
equals()方法是Object类的一个方法，它用于比较两个对象的值是否相等。默认情况下，equals()方法比较的是对象的引用，即两个对象只有在引用相同的情况下才被认为是相等的。因此，如果你想比较两个对象的值是否相等，你需要重写equals()方法。

举例：

在这个示例中，我们重写了equals()方法来比较两个Person对象是否相等。我们首先检查传入的对象是否为null，然后检查传入的对象是否与该对象相同。接下来，我们将传入的对象转换为Person类型，并比较name和age字段是否相等。如果都相等，则返回true，否则返回false。  
另一方面，运算符用于比较两个对象的引用是否相等。如果两个对象的引用相同，则它们被认为是相等的。否则，它们被认为是不同的。因此，如果你想比较两个对象的引用是否相等，你应该使用运算符。  
例如：

Person p1 = new Person("Tom", 20);  
    Person p2 = new Person("Tom", 20);  
    Person p3 = p1;  
    System.out.println(p1 == p2); // false，p1和p2是不同的对象  
    System.out.println(p1 == p3); // true，p1和p3引用同一个对象

[1df2c421669c4ca0868d6c6a118e8d2d.png]: https://img-blog.csdnimg.cn/1df2c421669c4ca0868d6c6a118e8d2d.png