反射正则泛型总结（9）

来源：互联网发布：筑业家装报价软件编辑：程序博客网时间：2024/05/21 12:48

泛型：

jdk1.5出现的安全机制。

好处：

1，将运行时期的问题ClassCastException转到了编译时期。

2，避免了强制转换的麻烦。

<>:什么时候用？当操作的引用数据类型不确定的时候。就使用<>。将要操作的引用数据类型传入即可.

其实<>就是一个用于接收具体引用数据类型的参数范围。

在程序中，只要用到了带有<>的类或者接口，就要明确传入的具体引用数据类型。

泛型技术是给编译器使用的技术,用于编译时期。确保了类型的安全。

运行时，会将泛型去掉，生成的class文件中是不带泛型的,这个称为泛型的擦除。

为什么擦除呢？因为为了兼容运行的类加载器。

泛型的补偿：在运行时，通过获取元素的类型进行转换动作。不用使用者在强制转换了。

泛型的通配符：? 未知类型。

泛型的限定：

? extends E: 接收E类型或者E的子类型对象。上限

一般存储对象的时候用。比如添加元素 addAll.

? super E: 接收E类型或者E的父类型对象。下限。

一般取出对象的时候用。比如比较器。

反射机制：运行状态中对于任意一个类class文件，都能知道这个类的属性和方法。同时可以调用他的任意属性和方法。

基本的 Java 类型（boolean、byte、char、short、int、long、float 和 double）和关键字 void 也表示为 Class 对象。

应用举例说明：例如应用程序Tomcat程序提供一个接口servlet接口类，编写一个Myservlent类实现此接口。

将类名信息写到配置文件中，Tomcat读取配置文件，加载配置文件指向的类文件。通过反射机制使用创建运行Myservlent类。

获取class的三种方式：

1.Object的getclass（）方法 [需要常见对象，对象调用此方法]

2.任何数据类型都有一个静态的方法class来获取对应的class类文件。[需要用到类中静态成员]

3.只通过类的字符串名称就可以获取该类class文件。

Class clazz = Class.forName(name);//name是一个类名字符串，类名必须是全类名。

获取构造器：

空参构造器：

创建空参对象 Object obj = clazz.newInstance() 创建此 Class 对象所表示的类的一个新实例。

有参构造器：

有参构造器获取Constructor constructor = clazz.getConstructor(String.class , int.class) 返回一个 Constructor 对象,代参构造函数

Object obj = constructor..newInstance("小明",22); //调用有参方法创建实例

获取字段：

公有字段： Field filed = clazz.getField("age");//获取该字段的值

私有字段：暴力访问设置：filed.setAccessible(true);//忽略访问权限检查

filed.set(obj, "小");//设置字段值

获取方法：Method method = clazz.getMethod("show", null); //指定方法名和参数列表，null表示无参。

方法运行：method.invoke(obj, null); //指定方法名和参数列表，null表示无参。

Constructor 提供关于类的单个构造方法的信息以及对它的访问权限。

Field 提供有关类或接口的单个字段的信息，以及对它的动态访问权限。反射的字段可能是一个类（静态）字段或实例字段。

Method 提供关于类或接口上单独某个方法（以及如何访问该方法）的信息。所反映的方法可能是类方法或实例方法（包括抽象方法）。

AccessibleObject 类是 Field、Method 和 Constructor 对象的基类。它提供了将反射的对象标记为在使用时取消默认 Java 语言访问控制检查的能力。对于公共成员、默认（打包）访问成员、受保护成员和私有成员，在分别使用 Field、Method 或 Constructor 对象来设置或获取字段、调用方法，或者创建和初始化类的新实例的时候，会执行访问检查。

Constructor 对象实例演示：

public static void constructor_test1() throws Exception {

//通过文件名获取Class文件

Class clazz = Class.forName("ClassDemo.Person");

//通过Class对象创建无参对象

Object obj = clazz.newInstance();

//获取带参数的构造函数创建对象

Constructor constructor1 = clazz.getConstructor(String.class , int.class);

Object obj1 = constructor1.newInstance("小红",99);

//通过强制获取私有构造器

Constructor constructor2 = clazz.getDeclaredConstructor(String.class);

constructor2.setAccessible(true);

Object obj2 = constructor2.newInstance("小花花");

}

Field 字段实例演示

public static void field_test1() throws Exception {

// 获取字段演示

// 通过文件名获取Class文件

Class clazz = Class.forName("ClassDemo.Person");

// 通过Class对象创建无参对象

Object obj = clazz.newInstance();

//公有的字段获取和设置方法

Field filed = clazz.getField("age");

filed.set(obj, 22);

//私有的字段获取和设置方法

Field filed1 =clazz.getDeclaredField("name");

filed1.setAccessible(true);

filed1.set(obj, "小");

}

Method 方法实例演示

public static void method_test1() throws Exception {

// 获取方法演示

// 通过文件名获取Class文件

Class clazz = Class.forName("ClassDemo.Person");

// 通过Class对象创建无参对象

Object obj = clazz.newInstance();

// 公有无参的方法获取和执行方法

Method method1 = clazz.getMethod("show", null);

method1.invoke(obj, null);

//公有无参的方法获取和执行方法

Method method2 = clazz.getMethod("pramshow", String.class,int.class);

method2.invoke(obj, "xiao",50);

//私有的方法获取和执行方法

Method method3 = clazz.getDeclaredMethod("privateshow", null);

method3.setAccessible(true);

method3.invoke(obj, null);

}

正则表达式：

类 Pattern正则表达式的编译表示形式。指定为字符串的正则表达式必须首先被编译为此类的实例。然后，可将得到的模式用于创建 Matcher 对象，依照正则表达式，该对象可以与任意字符序列匹配。执行匹配所涉及的所有状态都驻留在匹配器中，所以多个匹配器可以共享同一模式。

字符类

[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]（减去）

预定义字符类

. 任何字符（与行结束符可能匹配也可能不匹配）

\d 数字：[0-9]

\D 非数字： [^0-9]

\s 空白字符：[ \t\n\x0B\f\r]

\S 非空白字符：[^\s]

\w 单词字符：[a-zA-Z_0-9]

\W 非单词字符：[^\w]

边界匹配器

^ 行的开头

$ 行的结尾

\b 单词边界

\B 非单词边界

\A 输入的开头

\G 上一个匹配的结尾

\Z 输入的结尾，仅用于最后的结束符（如果有的话）

\z 输入的结尾

Greedy 数量词

X? X，一次或一次也没有

X* X，零次或多次

X+ X，一次或多次

X{n} X，恰好 n 次

X{n,} X，至少 n 次

X{n,m} X，至少 n 次，但是不超过 m 次

正则对字符串常用功能：

匹配：

String str = "aaaaaassssss";

boolean b = str.matches("a+s+");//通过matches来匹配，返回boolean

切割：split（regex）

组（）：用小括号（）封装，自动编号，从1开始。没有括号整个表达式是第0组。使用组"\\1"这种转义形式就可以。

（（A）（B（C）））编号左边半个小括号确定编号顺序

第一组（（A）（B（C）））；第二组（A）；第三组（B（C））；第四组（C）

替换：replaceAll（regex1,regex2）

第二个参数需要引用第一个参数的组，使用$表示// replaceAll("(.)\\1+ ","$1");

获取：

1）将正则规则进行封装 Pattern p = Pattern.compile("[a-zA-Z][0-9a-zA-Z_]{6,15}@[0-9a-zA-Z]+(\\.[0-9a-zA-Z]+){1,3}");

2）通过正则对象的matcher方法与字符串关联，获取要对字符串操作的匹配其对象matcher Matcher m = p.matcher(str);

3）使用matcher对象的find方法获取结果。while (m.find())

实例演示：1，口吃 2.ip排序 3.邮箱校验 4.网络爬虫

public static void test4() throws IOException {

// 网络爬虫自动从一个文件匹配邮箱并存储起来文件位置：D:\\regexDemo.txt

File file = new File("D:\\regexDemo.txt");

BufferedReader br = new BufferedReader(new FileReader(file));

String str;

while ((str = br.readLine()) != null) {

Pattern p = Pattern.compile("[a-zA-Z][0-9a-zA-Z_]{6,15}@[0-9a-zA-Z]+(\\.[0-9a-zA-Z]+){1,3}");

Matcher m = p.matcher(str);

while (m.find())

System.out.println(m.group());

}

public static void test3() {

// 对邮箱校验

String str = "sdksldsk3@163.com";

boolean b = str.matches("[a-zA-Z][0-9a-zA-Z_]{6,15}@[0-9a-zA-Z]+(\\.[0-9a-zA-Z]+){1,3}");

System.out.println(b);

}

public static void test2() {

// 对IP排序 str="192.168.1.3 212.3.0.4 4.3.32.222 25.34.232.3"

// 先补位，在删除多的，在排序

String str = "192.168.1.3 212.3.0.4 4.3.32.202 25.34.232.3";

str = str.replaceAll("(\\d+)", "00$1");

str = str.replaceAll("0*(\\d{3})", "$1");

TreeSet<String> ts = new TreeSet<String>();

String[] str_ip = str.split(" +");

for (String ip : str_ip)

ts.add(ip);

for (String ip : ts)

System.out.println(ip.replaceAll("0*(\\d+)", "$1"));

}

public static void test1() {

// 治理口吃

// “我我我。。。我我我。。我我要要。。要。要要。。要。。要要要学。。。。。编。编编编编。。编编编编程。程程。程。。。。。。。程程程”

// 1.将点替换掉

String str = "我我我...我我我..我我要要.....要.要要..要....要要要学........编.编编编编...编编编..编程...程程.程........程程程";

str = str.replaceAll("\\.+", "");

// 将叠词去掉

str = str.replaceAll("(.)\\1+", "$1");

}

0 0