枚举和file类的知识点

来源：互联网发布：淘宝店铺过户近亲属编辑：程序博客网时间：2024/04/25 17:14

枚举

枚举：是一些值得获取不是随便来的，它是由一个范围的。在运用枚举的时候，建立一个枚举类，enum 类名{ 要限制的内容}

例如：public static void main(String[] args) {
Week w = Week.Friday;
}

// 枚举类型
enum Week{

// 用枚举来限制星期几，让其不能随意的更改
Monday("周一"), Tuesday, Wensday, Thurday, Friday, Saturday, Sunday;

String value;
private Week(){

}
private Week(String value){
this.value = value;

}
}

final class Weeks{

public static final Weeks Monday = new Weeks("周一");
public static final Weeks Tuesday = new Weeks();
public static final Weeks Wensday = new Weeks();
public static final Weeks Thurday = new Weeks();
public static final Weeks Friday = new Weeks();
public static final Weeks Saturday = new Weeks();
public static final Weeks Sunday = new Weeks();
String value;
private Weeks(){
}

private Weeks(String value){
this.value = value;
}
}

2.switch 和枚举的结合使用

注意：（1）在switch中case语句的后面，直接写枚举值，不用再声明这个枚举值是那个枚举类型，即枚举case 枚举值；

（2）枚举值放在枚举类的第一个语句

静态导入：import static

作用：在同一个静态方法要被多次使用的时候，达到简化书写的作用。

格式：import static 包名.类名.静态方法名或者是静态成员的名字。

在导入之后使用这个类的这个静态方法，就可以直接写方法名，而不用写类名.方法名。

注意：（1）如果静态导入的成员（成员变量，方法）和本类中的方法或者是成员同名的情况下那么默认使用本类中的方法。

（2）如果你还是要使用静态导入的这个方法，加上类名就可以了。

可变参数类型

1.实际上是一个数组。

2.可变参数既然是一个数组，那么代表它的类型是固定的。

3.一个方法中可以有可变参数以及其他参数，但是可变参数要放在最后一个参数位置上, 其他参数放在前面

4.一个方法中最多只能有一个可变参数, 因为可变参数一定要放在形参的最后一个位置

5.如果方法的形参使用的是可变参数，那么可变参数可以不传参数。

例如： int a = 10;
int b = 20;
int c = 30;
String str = a + "hello" + b + "hi" + c;
System.out.println(str);

// 输出的是10hello20hi30

例如：int t =compute（10，20，30）；

System.out.println(t);// 结果输出60

int t =compute（10，20，30，50，60，40）；

System.out.println(t);// 结果输出210

// 前面调用下面的compute方法的时候传递的参数个数，来确定这个数组b中的元素个数

public static int compute（String a，int...b）{

int res=0；

for（int data：b）{

res+=data；

}

return res；

}

正则表达式：（ regular expression）是一种规则，针对于字符串进行操作的规则

正则表达式有特定的语法结构和规范，要按照规定来定义这个表达式
1.预定义字符类单个字符匹配
. 任何字符（与行结束符可能匹配也可能不匹配）
\d 数字：[0-9]
\D 非数字： [^0-9]
\s 空白字符：[ \t\n\x0B\f\r]
\S 非空白字符：[^\s]
\w 单词字符：[a-zA-Z_0-9]
\W 非单词字符：[^\w]

例如：System.out.println(".预定义字符的匹配：==========" + "a".matches(".")); // 表示可以输出任意字符

System.out.println("\\d预定义字符的匹配：==========" + "a".matches("\\d")); // 输出的是0到9的数字

System.out.println("\\d预定义字符的匹配：==========" + "1".matches("\\d"));
System.out.println("\\D预定义字符的匹配：==========" + "@".matches("\\D"));//输出的是除了0到9的数字意外的
System.out.println("\\s预定义字符的匹配：==========" + "\n".matches("\\s")); //输出的是换行等命令符
System.out.println("\\S预定义字符的匹配：==========" + "@".matches("\\S"));
System.out.println("\\w预定义字符的匹配：==========" + "*".matches("\\w"));
System.out.println("\\W预定义字符的匹配：==========" + "1".matches("\\W"));
System.out.println("\\W预定义字符的匹配：==========" + "123".matches("\\d{2,8}"));

2.Greedy 数量词
X? X，一次或一次也没有
X* X，零次或多次
X+ X，一次或多次
X{n} X，恰好 n 次
X{n,} X，至少 n 次
X{n,m} X，至少 n 次，但是不超过 m 次

例如：System.out.println("X？数量词的匹配：==========" + "".matches("a?")); // a 匹配 a？是true ""去匹配也是true
System.out.println("X* 数量词的匹配：==========" + "aaa".matches("a*")); // "" true , "aaa"true
System.out.println("X+ 数量词的匹配：==========" + "a".matches("a+")); //"" false. 只要字符串是a, 或者全是多个a，就是true
System.out.println("X{n} 数量词的匹配：==========" + "aa".matches("a{2}")); //正好 2次
System.out.println("X{n,} 数量词的匹配：==========" + "aaaaa".matches("a{6,}")); //至少要6次
System.out.println("X{n,m} 数量词的匹配：==========" + "aaaaa".matches("a{1,4}"));// 输出的是1至4之间

3. 字符类
[abc] a、b 或 c（简单类）
[^abc] 任何字符，除了 a、b 或 c（否定）
[a-zA-Z] a 到 z 或 A 到 Z，两头的字母包括在内（范围）
[a-d[m-p]] a 到 d 或 m 到 p：[a-dm-p]（并集）
[a-z&&[def]] d、e 或 f（交集）
[a-z&&[^bc]] a 到 z，除了 b 和 c：[ad-z]（减去）
[a-z&&[^m-p]] a 到 z，而非 m 到 p：[a-lq-z]（减去）

例如：System.out.println("[] 范围表示的匹配：==========" + "a".matches("[a]"));
System.out.println("[] 范围表示的匹配：==========" + "c".matches("[abc]")); //寻找在abc范围内的字符
System.out.println("[]+ 范围表示的匹配：==========" + "abcabcacbbcaa".matches("[abc]+")); // true
System.out.println("[]{3} 范围表示的匹配：==========" + "aaa".matches("[abc]{3}"));
System.out.println("[]{3,} 范围表示的匹配：==========" + "aaaaabbbbacccdddsss".matches("[abcds]{3,}"));
System.out.println("[]{3,5} 范围表示的匹配：==========" + "aass".matches("[abcds]{3,5}"));
System.out.println("[^]+ 范围表示的匹配：==========" + "gggfjjf".matches("[^abcds]+"));
System.out.println("[a-h]{3,} 范围表示的匹配：==========" + "aaabc".matches("[a-h]{3,}")); //[abcdefgh]
System.out.println("[]{3,} 范围表示的匹配：==========" + "aaaaabbbbacccdddsss".matches("[abcds]{3,}"));
System.out.println("[a-g[m-q]]{3,} 范围表示的匹配：==========" + "abcqpo".matches("[a-g[m-q]]{3,}")); // a-g || m-q
System.out.println("[a-z&&[def]]{3,} 范围表示的匹配：==========" + "dfeff".matches("[a-z&&[def]]{3,}")); //交集

0 0