【Java】day18--静态导入、增强for循环、可变参数、自动装箱与拆箱、枚举类、正则表达式部分知识点总结

（一）静态导入

jdk1.5新特性之------>静态导入
静态导入的作用：简化书写。
静态导入仅对于一个类的静态成员起作用。
静态导入的格式：
    import static 包名.类名.静态成员；
静态导入要注意的事项：
    1.如果静态导入的成员与本类的静态成员同名了，那么优先使用本类的静态成员。
    2.如果要使用静态导入方法，需要指定类名调用。

import java.util.ArrayList;
import java.util.Collections;
import static java.util.Collections.*;
import static java.lang.System.out;
public class staticc_demo1 {

	public static void main(String[] args) {
		ArrayList list=new ArrayList();
		list.add(10);
		list.add(15);
		list.add(8);
		list.add(11);
		Collections.sort(list);
		System.out.println("元素内容："+list);//out是System类的静态成员变量，表示标准输出流
		out.println("最大值："+max(list));//静态导入后可以简化书写
		System.out.println("最小值："+min(list));
	}
	public static void sort(ArrayList list) {
		System.out.println("排序成功。。。");
	}
}

（二）增强for循环

jdk1.5新特性之-------->增强for循环
增强for循环的主要作用是：简化迭代器的书写格式。
增强for循环的格式：
    for(元素的数据类型  变量名:遍历的目标){
    }
增强for循环的前提：
    只有实现了Iterable接口的对象或数组对象才能使用 。
增强for循环要注意的细节：
    1.增强for循环的底层还是通过获取迭代器的方式进行遍历的，只不过不需要手动获取迭代器由jvm自动获取，所以在使用增强for循环遍历元素
    的过程中不能使用集合对象改变集合对象的元素个数。
    2.增强for循环与迭代器的区别：增强for循环只能用于遍历集合的元素，不能增删；但用迭代器的方法既能遍历也能增删元素。
    3.增强for循环遍历时必须存在一个遍历的目标对象，而普通的for循环可以不存在。

public class jdk15_demo1 {

	public static void main(String[] args) {
		//Iterable根接口--Collection子接口--Set子接口--HashSet实现类，所以HashSet实现了Iterable接口
		HashSet set=new HashSet();//加泛型减少强制转换
		//以后的开发过程中一个集合对象只会存储同一种类型的数据，因为同一类型的数据才会有相同的处理方式。有必要使用泛型
		set.add("小米");
		set.add("大米");
		set.add("黑米");
		set.add("红米");
		/*Iterator it=set.iterator();
		System.out.println("迭代器的遍历方式：");
		while(it.hasNext()) {
			System.out.print(it.next()+",");
		}*/
		/*
		//增强for循环
		System.out.println("增强for循环遍历：");
		for(String item:set) {//遍历出来的每个元素都会交给item变量
			System.out.print(item+",");
			set.add("aaa");
		}*/
		/*
		int[] arr= {15,16,18,20};
		for(int item:arr) {
			System.out.println(item);
		}
		for(int i=0;i<5;i++) {
			System.out.println("hello world");
		}*/
		
		TreeMap tree=new TreeMap();
		tree.put(101,"小米");
		tree.put(113,"大米");
		tree.put(125,"黑米");
		tree.put(222,"红米");
		//使用增强for循环遍历map集合
		Set> entrys=tree.entrySet();
		for(Entry item:entrys) {
			System.out.println(item);
		}
	}
}

（三）可变参数

jdk1.5的新特性------可变参数。
可变参数的格式：
    数据类型... 变量名
可变参数要注意的实现：
    1.如果一个函数的形参使用了可变参数，那么调用该函数的时候可以传参也可不传参。
    2.可变参数实际就是一个数组。
    3.可变参数必须位于形参列表中的最后一个位置。
    4.一个方法中最多只能使用一个可变参数。

public class variable_demo1 {

	public static void main(String[] args) {
		System.out.println(new int[] {});//匿名数组对象 [I@1f32e575
		int res=sum("小米",1,2,5,10);//当一个函数使用可变参数，传递数据时，JVM会自动把实参数据保存到一个数组中，然后再传递给可变参数。
		System.out.println(res);
	}
	public static int sum(String name,int... arr) {//arr这里实际是一个数组
		int sum=0;
		//增强for循环
		for(int item:arr) {
			sum+=item;
		}
		System.out.println(arr);
		System.out.println(arr.length);
		return sum;
	}
}

  （四）自动装箱与自动拆箱

jdk1.5新特性之---自动装箱与自动拆箱

java是面向对象的语言，任何事物都使用了一个类进行描述。 基本数据类型也是一类事物，所以
java对于基本类型的数据也使用了对应的类进行描述，把描述基本类型变量的类称为--包装类。

基本数据类型         包装类型
  byte        Byte
  short       Short
  int         Integer
  long        Long
  float          Float
  double      Double
  boolean      Boolean
  char        Character
基本数据类型设计出对应的包装类型的好处：可以让基本数据类型也使用方法，让功能变得强大。

集合：存储任意对象类型数据的集合容器，不存储基本类型数据。

自动装箱---自动把基本数据类型转成引用类型数据。

public class jdk15_demo3 {

	public static void main(String[] args) {
		/*
		String str="12";	
		//功能一：把字符串转成数字
		int num=Integer.parseInt(str);
		System.out.println(num);
		//功能二：可以把数字转成指定进制格式的字符串。
		int num2=10;
		System.out.println("二进制："+Integer.toBinaryString(num2));
		System.out.println("八进制："+Integer.toOctalString(num2));
		System.out.println("十六进制："+Integer.toHexString(num2));
	*/
		//自动装箱---自动把基本数据类型转成引用类型数据。
		ArrayList list=new ArrayList();
		list.add(new Integer(1));
		list.add(2);//jvm自动new Integer(数据) 将基本类型数据转成引用类型
	
		//自动拆箱  ：自动把引用数据类型数据转成基本数据类型。引用（对象）类型不允许参与运算。
		Integer i=new Integer(10);//引用数据类型数据
		System.out.println(2+i);//intValue()获取基本数据类型数据
    }
}

（五）Integer考点

public class jdk15_demo3 {

	public static void main(String[] args) {
        
            Integer i1=12;
		Integer i2=12;
		System.out.println("是同一个对象么？"+(i1==i2));//true
		
		i1=127;
		i2=127;
		System.out.println("是同一个对象么？"+(i1==i2));//true
		
		i1=128;
		i2=128;
		System.out.println("是同一个对象么？"+(i1==i2));//false
		/*
			Integer类内部维护了一个静态数组，该数组内部存储了-128~127，当创建一个Integer对象
			时，若数据在-128~127范围内，那么会直接从数组中获取，而不会创建新的Integer对象。
		 	把一些常用的数据事先创建好，然后贡献给大家一起使用：享元模式。
		 	好处：减少创建对象的次数，节省内存空间。
		 * 
		 * */
	}
}

（六）枚举类

枚举类：
    枚举的应用场景：一些方法在运行时，需要的数据不能是任意的，而必须是在一定范围内的值。
    如：一年四季、方向
定义枚举类的格式：
    enum 类名{
    
    }
枚举类要注意的事项：
    1.枚举类是一个特殊的类。
    2.枚举值磨人的修饰符是：public static final.
    3.枚举值其实就是一个当前枚举类的对象。
    4.枚举值必须位于枚举类中的第一个语句。
    5.枚举类的构造方法默认的修饰符是private,修饰符也必须是private。
    6.枚举类允许出现抽象的方法，但是一旦出现了抽象的方法，那么枚举值就必须实现抽象方法。

switch语句适用的数据类型：byte\short\int\char\ String\枚举类型。
注意事项：
    1.在switch语句中使用枚举类的时候，case语句后面不需要枚举类，只需写枚举值即可。

enum Direction{
	//public static final Direction UP=new Direction();//本质是这样，由jvm实现
	//UP,DOWN,LEFT,RIGHT;		//枚举值是该类的对象，由无参的构造方法创建，不存在无参的，应该传一个参数的
	//对象中不允许有抽象方法存在
	UP("上"){
		@Override
		public void test() {
			System.out.println("向上");
		}
	},DOWN("下"){
		@Override
		public void test() {
			System.out.println("向下");
		}
	},LEFT("左"){
		@Override
		public void test() {
			System.out.println("向左");
		}
	},RIGHT("右"){
		@Override
		public void test() {
			System.out.println("向右");
		}
	};
	String value;
	public void print() {
		System.out.println("value:"+value);
	}
	private Direction(String value) {
		this.value = value;
	}
	public abstract void test();
}
public class jdk15_demo5 {

	public static void main(String[] args) {
		Direction.UP.print();
		Direction.DOWN.print();
		Direction.LEFT.test();
	}
}

enum Gender{
	MAN("男"),WOMAN("女");
	String value;
	private Gender(String value) {
		this.value = value;
	}
}
/*
//保证性别输入只有男女
class Gender{
	String value;
	//对外提供本类的对象
	public static final Gender MAN=new Gender("男");
	public static final Gender WOMAN=new Gender("女");
	//私有化构造函数
	private Gender(String value) {
		this.value=value;
	}
} */
class Person{
	String name;
	private Gender sex;
	@Override
	public String toString() {
		return "{姓名："+this.name+" 性别："+this.sex.value+"}";
	}
	public Gender getSex() {
		return sex;
	}
	public void setSex(Gender sex) {
			this.sex = sex;
	}	
}
public class jdk15_demo4 {

	public static void main(String[] args) {
		Person p=new Person();
		p.name="小米";
		p.setSex(Gender.WOMAN);//不能自创建Gender对象，只能用类提供的对象，否则编译即报错
		System.out.println(p);
	}
}

（七）正则表达式

正则表达式：用于操作字符串的一些规则。

预定义字符类：
    .任何字符(与行结束符可能匹配也可能不匹配)
    \d 数字：[0-9]
    \D 非数字：[^0-9]
    \s 空白字符：[\t\n\x0B\f\r](\n回车 \r换行)
    \S 非空白字符：[^\s]
    \w 单词字符：[a-z A-Z _ 0-9] 
    \W 非单词字符：[^\w]
注意：一个预定义字符只能匹配一个字符，除非预定义字符配合了数量词使用。    
 
数量词:
    X? X, ？表示一次或零次
    X* X,零次或多次
    X+ X,一次或多次
    X{n} X,恰好出现n次
    X{n,} X,至少n次
    X{n,m} X,至少n次，最多m次
    
范围词：
    [abc]  a b 或c(简单类)
    [^abc] 任意字符除了a b c(否定)
    [a-zA-Z ] (范围)
注意：一个范围词没有配合数量词使用也只能匹配一个字符而已。

public class regular_demo2 {

	public static void main(String[] args) {
		/*
		System.out.println(".任何字符："+("%".matches(".")));
		System.out.println("\\d代表数字："+("12".matches("\\d\\d")));
		System.out.println("\\D代表数字："+("&".matches("\\D")));
		System.out.println("\\s代表数字："+("\r".matches("\\s")));
		System.out.println("\\w代表单词字符："+("a".matches("\\w")));
		System.out.println("\\W代表数字："+("*".matches("\\W")));
		 */
		/*
		System.out.println("?一次或零次："+"".matches("\\d?"));
		System.out.println("*零次或多次："+"12".matches("\\d*"));
		System.out.println("+一次或多次："+"1".matches("\\d+"));
		System.out.println("{n}恰好n次："+"12".matches("\\d{2}"));
		System.out.println("{n,}至少n次："+"123".matches("\\d{2,}"));
		System.out.println("{n,m}至少n次，最多m次："+"124567".matches("\\d{2,5}"));
		*/
		System.out.println("d".matches("[abc]+"));
		System.out.println("d".matches("[^abc]+"));
		System.out.println("123456".matches("[a-zA-Z0-9_]+"));
		
	}
}

正则对字符串的常见操作：

    匹配：matches
    切割: split()
    替换: replaceAll(String reg,String replace)
    查找 

public class regular_demo3 {

	public static void main(String[] args) {
		matchPhone("0133918670");
		matchTel("0372-7759404");
		splitTest1();
		splitTest2();
		replacePhone();
		replace2();
	}
	/*
	 匹配一个手机号：
	手机号码的规则：
		首位必须是1   第二位：3 4 5 7 8      长度必须是11位
	 */
	public static void matchPhone(String phone) {
		String reg="1[34578]\\d{9}";
		System.out.println(phone.matches(reg)?"合法手机号":"非合法手机号");
	}
	/*
	 匹配固定电话：
	 	规则：
	 		区号：1.长度3-4位    2. 0开头
	 		主机号：  首位不能是0     长度是7-8位
	 * */
	public static void matchTel(String tel) {
		String reg="0\\d{2,3}-[1-9]\\d{6,7}";
		System.out.println(tel.matches(reg)?"合法电话号":"非合法电话号");
	}
	//根据空格进行切割
	public static void splitTest1() {
		String str="明    天        学  i            o";
		String reg=" +";
		String[] strs=str.split(reg);//字符串数组
		System.out.println("数组的元素："+Arrays.toString(strs));
	} 
	//根据重叠词进行切割
	public static void splitTest2() {
		String str= "小小小小米米米米米米米真美美美美美美美美美丽丽丽呢";
		String reg="(.)\\1+";//分组：(.)只有1组   \\1表示引用第1组的内容。
		String[] strs=str.split(reg);
		System.out.println("数组的元素："+Arrays.toString(strs));

		/*
		 后面的一个正则字符要使用到前面正则匹配的内容。
		 前面正则的内容需要被复用起来。
		 如果正则的内容需要被复用，那么就需要对正则进行分组。
		 每个组都有一个编号，编号从1开始。 
		*/
	}
	//把手机号替换成***
	public static void replacePhone() {
		String str="有需要请联系13598121970有需要请联系13598121970有需要请联系13598121970有需要请联系13598121970";
		String reg="1[34578]\\d{9}";
		str=str.replaceAll(reg, "****");
		System.out.println(str);			
	}
	//去除重叠词
	public static void replace2() {
		String str="小小小小小小米米米米米米米米米真美美美美美美美美美美";
		String reg="(.)\\1+";//正则表达式
		str=str.replaceAll(reg, "$1");//注意如果引用正则的内容，如果不是在一个正则表达式内部，那么需要使用"$组号"进行引用。
		System.out.println(str);
	}
}

正则的查找：

如果正则表达式需要查找内容需要使用以下两个对象：
    Pattern(正则对象)
    Matcher(匹配器对象)
指定为字符串的正则表达式必须首先被编译为此类Pattern的实例。然后，Pattern对象可与任意字符序列匹配，匹配字符串之后可以得到一个Matcher对象，
所涉及与字符串匹配的状态都驻留在匹配器中。

典型的调用顺序：
    Pattern p=Pattern.compile("正则");
    Matcher m=p.matcher("aaaacccc");
    boolean b=m.matches();
匹配器常用的方法：
    find()  通知匹配器查找符合该正则的字符串。如果存在符合规则的字符串返回true,否则返回false.
    group() 获取符合规则的字符串。
    
注意：使用匹配器的方法时，要先调用find方法才能调用group方法。否则匹配器没有去查找合适的内容，报错。

单词边界匹配器：不匹配任何字符，只是代表了一个单词的开始或结束部分。
    \b   单词边界

public class regular_demo4 {
	//找出三个字符构成的单词
	
	public static void main(String[] args) {
		String str="jin tian hen kai xin ,tai yang he feng dou hen da";
		String reg="\\b[a-z]{3}\\b";//表示只能由三个小写字母组成,\\b表示了单词的开始和结束
		//第一步：要把字符串的正则编译成Pattern对象
		Pattern p=Pattern.compile(reg);
		//第二步:使用正则对象匹配字符串，得到一个matcher对象
		Matcher m=p.matcher(str);
		//
		//System.out.println("找到合适么？"+m.find());
		//System.out.println("内容："+m.group());//只能获取到一个
		while(m.find()) {
			System.out.println("内容："+m.group());
		}
	}
}

public class regular_demo5 {
	public static void main(String[] args) {
		System.out.println("hello world".matches("hello\\b world"));//true
	}
}