正则表达式和反射的学习

最新推荐文章于 2023-12-06 13:10:35 发布

原创最新推荐文章于 2023-12-06 13:10:35 发布 · 546 阅读

本内容遵循CC 4.0 BY-SA版权协议

1.正则表达式
(1)正则表达式就是符合一定规则的字符串。
(2)掌握的规则:通过这些常见的规则，看懂别人写的正则表达式。
  A:字符
   x 字符x
   \\ 反斜线字符
   \r 回车符
   \n 换行符

  B:字符类
   [abc] a、b 或 c
   [^abc] 任何字符，除了 a、b 或 c
   [a-zA-Z] a 到 z 或 A 到 Z，两头的字母包括在内
   [0-9] 包含0-9的字符

  C:预定义字符类
   . 任何字符
   \d 数字：[0-9]
   \w 单词字符：[a-zA-Z_0-9]

  D:边界适配器
   ^ 行的开头
   $ 行的结尾
   \b 单词边界
    这里不是单词
    haha hehe xixi hello world
    \b[a-z]{4}\b

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

  F:组和捕获
   组是以(开始编号的。
   ((A)(B(C))) 那么，在这个组里面有几个组呢？
   第一个组：(A)(B(C))
   第二个组：A
   第三个组：B(C)
   第四个组：C
(3)正则表达式的功能：
  A:匹配功能
   String -- matches
  B:切割功能
   String -- split
  C:替换功能
   String -- replaceAll
  D:获取功能
   Pattern
   Matcher
    find()
    group()

import java.util.Arrays;

/*
 * "192.168.3.23 202.10.34.2 3.3.3.3 127.0.0.1 80.12.23.34"。
 * 能将这些ip地址排序。按照地址段数值从小到大排序。最后以一个字符串输出。
 * 思路：
 * 		1：把每一位的前面都添加两个0。
 * 		2：把每一位保留3位。
 * 		3：切割得到一个字符串数组，对其进行排序即可。
 * 		4：把排序后的字符串数组转成一个字符串
 */
public class IPDemo {
	public static void main(String[] args) {
		//把每一位的前面都添加两个0。
		String str = "192.168.3.23 202.10.34.2 3.3.3.3 127.0.0.1 80.12.23.34";
		
		String s1 = str.replaceAll("(\\d+)", "00$1");
		//00192
		//003
		// System.out.println("s1:"+s1);
		
		//00192.00168.003.023 00202.0010.0034.002 003.003.003.003 00127.000.000.001 0080.0012.0023.0034
		//把每一位保留3位。
		String s2 = s1.replaceAll("0*(\\d{3})", "$1");
//		System.out.println("s2:"+s2);
		
		//切割得到一个字符串数组，对其进行排序即可。
		String[] strArray = s2.split(" ");
		Arrays.sort(strArray);//自然排序
		
		//把排序后的字符串数组转成一个字符串
		StringBuilder sb = new StringBuilder();
		for(String s : strArray){
			//再次去0
			String ss = s.replaceAll("0*(\\d+)", "$1");
			sb.append(ss).append(" ");
		}
		
		String result = sb.toString().trim();
		System.out.println("result:"+result);
	}
}

2:反射(掌握)
(1)在程序的运行时期，通过字节码文件对象去使用构造方法，成员方法，成员变量。
(2)三种方式获取字节码文件对象(
  A:Object类的getClass()方法
  B:静态属性class
  C:Class类的静态方法forName(String className)
(3)反射的使用

在不同包下的类之间的相互调用是有限制的，特别是私有字段和方法，但是通过反射，我们可以获取。

首先在不同包下建立了Person类

/*
 * 要通过反射来使用Person类中的构造方法，成员方法，成员变量。
 */
public class Person {
	private String name;
	int age;
	public String address;

	public Person() {
	}
	
	Person(String name){
		this.name = name;
	}

	public Person(String name, int age) {
		this.name = name;
		this.age = age;
	}

	public void show() {
		System.out.println("show");
	}

	public void haha(String str) {
		System.out.println("haha:" + str);
	}

	public String hehe() {
		return "hehe";
	}

	public String method(String name, int age) {
		return "method:" + name + ":" + age;
	}

	private void function() {
		System.out.println("function");
	}

	@Override
	public String toString() {
		return "name:" + name + ",age:" + age;
	}
}

A:获取构造方法并使用

import java.lang.reflect.Constructor;

import cn.itcast_02.Person;

/*
 * 通过反射获取构造方法并使用
 */
public class ReflectDemo2 {
	public static void main(String[] args) throws Exception {
		// 获取字节码文件对象
		Class c = Class.forName("cn.itcast_02.Person");

		// 获取带二个参数的构造方法
		
		Constructor con = c.getConstructor(String.class, int.class);

		// 创建对象
		
		Object obj = con.newInstance("林青霞", 25);
		System.out.println(obj);
	}
}

B:获取成员变量并使用

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;

/*
 * 通过反射获取成员变量并使用
 */
public class ReflectDemo {
	public static void main(String[] args) throws Exception {
		// 获取Class文件对象
		Class c = Class.forName("cn.itcast_02.Person");

		// 获取所有的字段
		// public Field[] getFields() 所有公共字段
		// public Field[] getDeclaredFields() 所有字段
		// Field[] fields = c.getFields();
		Field[] fields = c.getDeclaredFields();
		for (Field field : fields) {
			System.out.println(field);
		}

		System.out.println("***************************");
		// 使用无参构造方法创建了对象
		Constructor con = c.getConstructor();
		Object obj = con.newInstance();
		System.out.println(obj);// name:null,age:0

		// 修改name的值
		// 获取name字段所对应的对象
		// public Field getField(String name)
		// public Field getDeclaredField(String name)
		// Exception in thread "main" java.lang.NoSuchFieldException: name
		Field field = c.getDeclaredField("name");

		
		//暴力访问
		field.setAccessible(true);
		field.set(obj, "林青霞"); // 给obj都系的field字段的值设置为林青霞

		System.out.println(obj);// name:林青霞,age:0
	}
}

C:获取成员方法并使用

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

/*
 * 通过反射获取成员方法并使用。
 * 
 * 
 */
public class ReflectDemo {
	public static void main(String[] args) throws Exception {
		// 获取Class字节码文件对象
		Class c = Class.forName("cn.itcast_02.Person");

		// 获取方法
		// public Method[] getMethods() 包括父类的公共的方法
		// public Method[] getDeclaredMethods() 本类的所有方法
		// Method[] methods = c.getMethods();
		Method[] methods = c.getDeclaredMethods();
		for (Method m : methods) {
			System.out.println(m);
		}

		System.out.println("********************************");
		// 通过无参构造获取一个对象
		Constructor con = c.getConstructor();
		Object obj = con.newInstance();

		// 获取单个方法并使用
		// public Method getMethod(String name,Class... parameterTypes)
		// 第一个参数name表示获取到的方法名
		// 第二个参数parameterTypes表示获取的方法的参数的Class类型参数

		// 获取无参方法的对象
		Method m = c.getMethod("show");
		/*
		 * Person p = new Person(); p.show();
		 */
		// obj.m();

		// public Object invoke(Object obj,Object... args)
		// 方法的返回值Object表示将来调用后的方法返回值
		// 第一个参数obj表示调用该方法的对象
		// 第二个参数args表示调用该方法的实际参数
		m.invoke(obj);
		System.out.println("********************************");
		// 调用带参数没有返回值的方法
		Method m2 = c.getMethod("haha", String.class);
		m2.invoke(obj, "林青霞");
		System.out.println("********************************");
		// 调用无参数有返回值的方法
		Method m3 = c.getMethod("hehe");
		Object objString = m3.invoke(obj);
		// String ss = (String)objString;
		System.out.println(objString);
		System.out.println("********************************");
		// 调用有参数有返回值的方法
		Method m4 = c.getMethod("method", String.class, int.class);
		Object objString2 = m4.invoke(obj, "王祖贤", 16);
		System.out.println(objString2);
		System.out.println("********************************");
		// 调用私有方法
		Method m5 = c.getDeclaredMethod("function");
		m5.setAccessible(true);
		m5.invoke(obj);
	}
}

反射可以避免编译期间的审查

/*
 * 如果要在ArrayList<Integer>集合中添加一个字符串数据，如何实现呢？
 * 
 * 通过反射可以避免泛型的编译期间检查。擦出泛型
 */
public class ArrayListTest {
	public static void main(String[] args) throws Exception {
		ArrayList<Integer> array = new ArrayList<Integer>();

		// array.add("hello");
		// 使用反射解决
		Class c = array.getClass();
		Method m = c.getMethod("add", Object.class);

		m.invoke(array, "hello");
		m.invoke(array, "world");
		m.invoke(array, "itcast");

		System.out.println(array);

		for (Integer i : array) {
			System.out.println(i);
		}
	}
}

学习感悟："."在正则表达式中可以表示任意字符，如果用它作为正则来切割或者替换，必须加入转义字符，这里会犯错。反射可以逃过JAVA虚拟机的编译，这是因为泛型在编译之后将泛型擦掉了，所以字节码文件中是没有泛型信息的。