Java基础---反射&&正则

1.获取Class对象的3中方法：

•  方法一： 通过Object类中的getClass方法 想用这种方式，必须明确具体的类 

	public static void getClassObjectMethod_1() {
		Person p = new Person();
		Class class1 = p.getClass();
		Person p2 = new Person();
		Class class2 = p2.getClass();

		System.out.println(class1 == class2);
	}

•   方法二：任何数据类型都具备一个静态属性.class来获取Class对象 相对简单，但是还是要明确到类中的静态成员，还是不够扩展

	public static void getClassObjectMethod_2() {
		Class class1 = Person.class;
		Class class2 = Person.class;
		System.out.println(class1 == class2);

	}

• 方法三：通过给定的类名的字符串名称就可以获取class对象，更为扩展

	public static void getClassObjectMethod_3() throws ClassNotFoundException {
		String classname = "cn.itcast.bean.demo.Person";
		Class class1 = Class.forName(classname);
		Class class2 = Class.forName(classname);

		System.out.println(class1 == class2);
	}

2. 获取对象的方法

• 获取无参构造函数

	public static void creatNewObject_1()throws Exception{
		// 早期：new的时候，先根据被new的类的名称寻找该类的字节码文件，并加载进内存
		// 并创建该字节码文件的对象，并接着创建该字节码文件的对应的Person对象。
		Person person = new Person();

		// 现在：
		String classname = "cn.itcast.bean.demo.Person";
		// 寻找该名称类文件，并加载进内存，并产生Class对象
		Class class1 = Class.forName(classname);
		// 产生该类的对象
		Object ob1 = class1.newInstance();
	}

• 获取有参构造函数

	public static void creatNewObject_2() throws Exception {
		// 早期：
		// Person person=new Person("三胖",5);

		// 如今:
		// 当获取指定名称对应类中的所体现的对象时，
		// 而该对象初始化不使用空参数构造函数怎么办？
		// 既然是通过指定的构造函数进行对象的初始化，
		// 所以应该先获取到该构造函数，通过字节码文件对象即可完成
		// 该方法是：getConstructor（paramterType);

		String classname = "cn.itcast.bean.demo.Person";
		// 寻找该名称类文件，并加载进内存，并产生Class对象
		Class class1 = Class.forName(classname);
		// 获取指定构造器的对象
		Constructor constructor = class1.getConstructor(String.class, int.class);
		// 通过该构造器对象的newInstance方法进行对象初始化
		Object object = constructor.newInstance("三胖", 5);

	}

3. 获取字段

	public static void getfieldDemo() throws ClassNotFoundException, NoSuchFieldException, SecurityException,
			InstantiationException, IllegalAccessException {

		String classname = "cn.itcast.bean.demo.Person";
		Class c = Class.forName(classname);

		Field field = c.getDeclaredField("age");// 能获取包含私有的字段
		field.setAccessible(true);// 对私有字段的访问取消权限检查，暴力访问
		Object obj = c.newInstance();

		field.set(obj, 50);
		Object o = field.get(obj);
		System.out.println(o);
	}

4. 获取函数

• 获取无参函数

	public static void getmetod_1() throws Exception {

		Class class1 = Class.forName("cn.itcast.bean.demo.Person");

		Method[] methods = class1.getMethods();
		methods = class1.getDeclaredMethods();

		for (Method method : methods) {
			System.out.println(method);
		}
	}

• 获取指定无参函数

	public static void getmetod_2() throws Exception {

		Class class1 = Class.forName("cn.itcast.bean.demo.Person");

		Method method = class1.getMethod("show1", null);

		// Object obj=class1.newInstance();

		Constructor constructor = class1.getConstructor(String.class, int.class);
		Object obj = constructor.newInstance("小强", 20);

		method.invoke(obj, null);

	}

• 获取指定有参函数

	public static void getmetod_3() throws Exception {

		Class class1 = Class.forName("cn.itcast.bean.demo.Person");
		Method method = class1.getMethod("show4", String.class);
		Constructor constructor = class1.getConstructor(String.class, int.class);
		Object obj = constructor.newInstance("小金", 50);
		method.invoke(obj, "三胖");
	}

---

 正则：

• 1. 正则表达式示例

public class Matches_Demo1 {

	public static void main(String[] args) {
		// method_1();
		// method_2();
		// method_3();
		method_4();

	}

	public static void method_4() {
		/*
		 * 4、获取
		 * 
		 * 1、将正则规则封装成对象 
		 * Pattern p = Pattern.compile("a*b");
		 * 2、通过正则对象的matcher方法与字符串相关联，获取要对字符串操作的匹配器对象
		 * 	Matcher Matcher m =p.matcher("aaaaab"); 
		 * 3、通过Matcher匹配器对象的方法对字符串进行操作
		 *  boolean b = m.matches();
		 * 
		 */
		String str = "djwi e ed,dena ejj eder .wej";
		String regex = "\\b[a-z]{3}\\b";
		Pattern p = Pattern.compile(regex);// 将正则封装成对象
		Matcher m = p.matcher(str);// 获取匹配器对象

		System.out.println(str);
		while (m.find()) {
			System.out.println(m.group());
			System.out.println(m.start() + ":" + m.end());
		}

	}

	public static void method_3() {

		// 3、替换，其实就是用string类中的replaceAll方法

		String str = "zhangsaniiilisihhhwangwuoozhaoliu";
		String rps1 = str.replaceAll("(.)\\1+", "$1");
		System.out.println(str);
		System.out.println(rps1);

		String tel = "15000000000";
		String rps2 = tel.replaceAll("(\\d{3})\\d{4}(\\d{4})", "$1****$2");
		System.out.println(tel);
		System.out.println(rps2);

	}

	private static void method_2() {

		// 2、切割，其实就是string类中的splitst

		String str = "zhangsaniiilisihhhwangwuoozhaoliu";
		String regex = "(.)\\1+";
		String[] strs = str.split(regex);
		for (String name : strs) {
			System.out.println(name);
		}
	}

	public static void method_1() {

		// 1、匹配，其实就是用string类中的matches方法

		String tel = "15000000000";
		String regex = "1[358]\\d{9}";
		boolean b = tel.matches(regex);
		System.out.println(tel + ":" + b);
	}

}

• 示例2：

public class TestDemo {

	public static void main(String[] args) {
		// test1();
		 test2();
//		test3();
	}

	public static void test3() {
		/**
		 * 邮箱地址校验
		 */
		String mail = "abc@sina.com";
		boolean b = mail.matches("[a-zA-Z_]+\\@[a-zA-Z_]+\\.([a-zA-Z]{1,3})+");
		System.out.println(mail + ":" + b);
	}
	
	public static void test2() {
		/**
		 * ip地址切割：ip=192.168.1.0 3.5.6.4 168.16.7.64
		 */

		// 1、对ip进行补0；
		String ip = "192.168.1.0   3.5.6.4    168.16.7.64";
		ip = ip.replaceAll("(\\d+)", "00$1");

		// 3、保留后三位
		ip = ip.replaceAll("0*(\\d{3})", "$1");

		// 3、把每个ip切割出来；
		String[] ips = ip.split(" +");
		TreeSet<String>treeSet=new TreeSet<String>();
		for (String ipp : ips) {
			treeSet.add(ipp);
		}
		for (String jpp : treeSet) {
			// 4、去掉多余的零
			jpp = jpp.replaceAll("0*(\\d+)", "$1");
			System.out.println(jpp);
		}
	}

	public static void test1() {
		String str = "我我....我我..我我...我要..要要..要.要要.要回回...回回..回回....回回..回回..回回家...家家...家家...家家.家";
		str = str.replaceAll("\\.+", "");
		str = str.replaceAll("(.)\\1+", "$1");

		System.out.println(str);
	}
}

• 示例3：爬虫

public class PachongDemo {

	public static void main(String[] args) throws IOException {
		
	List<String>list=demo_2();
	
	
	for(String i:list) {
		System.out.println(i);
		}	
	}
	
	public static List<String> demo_2() throws IOException {
		
		//URL统一资源定位符
		URL url=new URL("https://news.163.com/18/0929/09/DSS2A0NO0001875N.html");
		BufferedReader bur=new BufferedReader(new InputStreamReader(url.openStream()));
		
		List<String>list=new ArrayList<String>();
		
		String regex="南昌";
		Pattern pa=Pattern.compile(regex);
		
		String line=null;
		while((line=bur.readLine())!=null) {
			Matcher m=pa.matcher(line);
			if(m.find()) {
				list.add(m.group());
			}
		}
		bur.close();
		
		return list;
	
	}
	
	//从本地磁盘文件爬取
	public static List<String> demo_1() throws IOException {
		
		BufferedReader bur=new BufferedReader(new FileReader("demo.txt"));
		
		List<String>list=new ArrayList<String>();
		
		String regex="\\w+@(\\w+\\.\\w+)+";//正则表达式
		Pattern pa=Pattern.compile(regex);//正则对象
		
		String line=null;
		while((line=bur.readLine())!=null) {
			Matcher m=pa.matcher(line);
			if(m.find()) {
				list.add(m.group());
			}
		}
		bur.close();
		return list;
	}
}