枚举，Collections工具类，正则表达式

枚举

enumeration简写为enum，是一种特殊的类，里面只包含一组有限的特定的对象。

实现方式

自定义实现

1.将构造器私有化，防止直接new一个对象

2.去掉setXxx方法，防止属性被修改

3.在类内部，直接创建固定的对象

4.可以加入final修饰符

class Season{
    private String name;
    private String desc;//描述
    
    // 定义四个对象
    public static final Season SPRING = new Season("春天","温暖");
    public static final Season SUMMER = new Season("夏天","炎热");
    public static final Season AUTUMN = new Season("秋天","凉爽");
    public static final Season SPRING = new Season("冬天","寒冷");
    //私有化构造器
    private Season(String name,String desc){
        this.name=name;
        this.desc=desc;
    }
    //GetXxx方法省略
    //重写equals,hashCode方法省略
}

使用enum关键字实现

1.使用关键字enum代替class

2.public static final Season SPRING = new Season("春天","温暖");使用SPRING("春天","温暖");来代替

3.如果多个常量（对象），使用,间隔

4.把定义常量对象写在最前面

enum Season{
    // 定义四个对象
    SPRING("春天","温暖"),SUMMER("夏天","炎热"),AUTUMN("秋天","凉爽"),SPRING("冬天","寒冷");
    private String name;
    private String desc;//描述
   
    //私有化构造器
    private Season(String name,String desc){
        this.name=name;
        this.desc=desc;
    }
    //GetXxx方法省略
    //重写equals,hashCode方法省略
}

注意事项

1.当我们使用enum关键字开发个枚学类时，默认会继承Enum类

2.传统的public static final Season SPRING = new Season(“春天”，“温暖":简化成SPRING(“春天"温暖”)，这里必须知道，它调用的是哪个构造器

3.如果使用无参构造器创建枚举对象，则实参列表和小括号都可以省略

4.当有多个枚举对象时，使用,间隔，最后有一个分号结尾

5.枚举对象必须放在枚举类的行首.

代码输出

enum Gender{
    BOY，GIRL;
}
Gender boy1=Gender.BOY;
Gender boy2=Gender.BOY;
System.out.println(boy);//输出BOY——本质是调用Gender的父类Enum的toString()方法
//public String toString(){
//	return name;
//}
System.out.println(boy1==boy2)//返回true

Calendar

1. Calendar的构造器是私有的，想创建对象需要通过getInstance进行创建。

2. Calendar是一个抽象类。

3. 得到月份：c.get(Calendar.MONTH)+1，因为Calendar返回月的时候是从0开始编号的。

Collections工具类

1. 是一个操作Set，List，Map等集合的工具类

2. 提供了一系列静态的方法对集合元素进行排序

排序操作

1. reverse(List): 反转List中元素的顺序

   Collections.reverse(list);
   

2. shuffle(List): 对List集合元素进行随机排序

   Collections.shuffle(list);
   

3. sort(List):根据元素的自然顺序对指定List集合元素按升序排序

   Collections.sort(list);
   

4. sort(List, Comparator): 根据指定的Comparator产生的顺序对List集合元素进行排序

   //需要传入一个比较器
   //这会按字符串长度排序
   Collections.sort(list,new Comparator(){
   	@Override
   	public int compare(Object o1,Object o2){
           return ((String)o1).length()-((String)o2).length();
       }
   });
   

5. swap(List, int, int): 将指定list集合中i处元素和j处元素进行交换

   Collections.swap(list,0,1);
   

查找替换

1. Object max(ollection):根据元素的自然顺序，返回给定集合中的最大元素

   Collections.max(list);
   

2. Object max(Collection, Comparator): 根据Comparator指定的顺序，返回给定集合中的最大元素

   //需要传入一个比较器
   //返回字符串长度最大的
   Collections.max(list,new Comparator(){
   	@Override
   	public int compare(Object o1,Object o2){
           return ((String)o1).length()-((String)o2).length();
       }
   });
   

3. Object min(Collection):和1相似

4. Object min(Collection, Comparator):和2相似

5. int frequency(Collection, Object): 返回指定集合中指定元素的出现次数

   Collection.frequenct(list,"tom");
   

6. void copy(List dest,List src):将src中的内容复制到dest中

   //为了完成一个完整的拷贝，必须要求dest的大小比src大，否则会报错——数组越界
   //所以在使用此方法之前，先扩大dest的大小
   for(int i=0;i<src.size();i++){
       dest.add("");//往里面放什么都行，此处放的为空
   }
   //然后再调用方法
   Collections.copy(dest,src);
   

7. boolean replaceAll(List list, object oldVal, object newVal):使用新值替换List 对象的所有旧值

   Collections.replaceAll(list,"tom", "汤姆");
   

Map排序

List<Map.Entry<C, Double>> res = new ArrayList<>();
        for(Map.Entry<C, Double> entry : statistics.entrySet()) {
            res.add(entry);
        }
        Collections.sort(res, new Comparator<Map.Entry<C, Double>>(){
            public int compare(Map.Entry<C, Double> e1, Map.Entry<C, Double> e2) {
            	return (int)(e1.getValue() - e2.getValue());
            }
        });

正则表达式

正则表达式语法

**转义符：\\ **

**注意：在java中，\\ 代表\ **

需要用到转义符的字符如下：.*+()$\/?[]^{}

字符匹配符

实例

String content = "a11c8";
String regStr ="[a-z]";
Pattern pattern = Pattern.compile(regStr);
Matcher matcher = pattern.matcher(content);

while(matcher.find()){
    System.out.println("找到 "+matcher.group(0));
}

将会输出

找到 a
找到 c

区分大小写

(?!)abc;//表示abc均不区分大小写
a(?!)bc;//表示bc不区分大小写
a((?!)b)c;//表示只有b不区分大小写
pattern pat = Pattern.compile(regEx,Pattern.CASE_INSENSITIVE);//加一个参数也代表不区分大小写

选择匹配符

|可以匹配之前的，也可以匹配之后的（即“或”）

限定符

定位符（规定要匹配的字符出现的位置）

实例

String content = "123abc12";//这个将无法匹配，因为是以数字结尾的
String content = "123abc";//这个将完全匹配，因为前半部分是数字，后半部分是字母
String regStr ="^[0-9]+[a-z]+$";
Pattern pattern = Pattern.compile(regStr);
Matcher matcher = pattern.matcher(content);

while(matcher.find()){
    System.out.println("找到 "+matcher.group(0));
}

捕获分组

实例

String content = "s7789 nn1189han";
String regStr ="(?<g1>\\d\\d)(\\d\\d)";
Pattern pattern = Pattern.compile(regStr);
Matcher matcher = pattern.matcher(content);

while(matcher.find()){
    System.out.println("找到 "+matcher.group(0));
    System.out.println("第一个分组内容 "+matcher.group(1));
    System.out.println("第一个分组内容 "+matcher.group("g1"));
    System.out.println("第二个分组内容 "+matcher.group(2));
}

将会输出

找到 7789
第一个分组内容 77
第一个分组内容 77   
第二个分组内容 89
找到 1189
第一个分组内容 11
第一个分组内容 11
第二个分组内容 89   

非捕获分组

实例

String regStr = "哈尔滨大学|哈尔滨红场|哈尔滨刀哥";
//等价于
String regStr = "哈尔滨(?:大学|红场|刀哥)";//注：这不会分组

贪婪匹配、非贪婪匹配

Java默认是贪婪匹配，即匹配尽可能长的，而非贪婪匹配：

Pattern类

没有公共构造方法，想要创建对象，需要使用其公共静态方法

Pattern r =Pattern.compile(pattern);

方法

matches()：判断是否整体匹配成功，会返回一个boolean值

matcher()：部分匹配，如果匹配成功，返回true。其匹配的内容放到matcher.group(n)(n=0,1,2…)

Matter类

是对输入字符串进行解释和匹配的引擎，也没有公共构造方法，想要创建对象，需要调用Pattern对象的方法

Pattern r =Pattern.compile(pattern);

索引方法

查找方法

替换方法

一些小知识

1.Map中不能放基本数据类型，我们都知道Integer代表int，其他的基本数据类型首字母大写即可

2.小细节：

//如果字符串
String str=null;
//那么
str.length();//会报错
//应该使用
str.isEmpty();//或者
str==null;

//如果字符串
String str="";
//则可以使用
str.length()==0;

3.(double)2/3会输出0

因为会先算int的2/3，得0

OK，全文结束，感谢阅读

😄