Java中的匿名内部类及函数式编程以及正则表达式

 

首先谈谈

package cn.it.cast.dao;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Lambda {
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("The old runable now is using!");
            }
        }
        ).start();

        //1.替代匿名内部类
        new Thread(() -> System.out.println("It's a lambda function!")).start();


        //2.使用lambda表达式对集合进行迭代
        String[] s = {"aa","bb","cc"};
        List<String> languages = Arrays.asList(s);
        //before java8
        for(String each:languages) {
            System.out.println(each);
        }
        //after java8
        languages.forEach(x -> System.out.println(x));
        languages.forEach(System.out::println);

        //3.用lambda表达式实现map
        List<Double> cost = Arrays.asList(10.0, 20.0,30.0);
        //map()函数的功能是function依次作用于序列中的每一个元素，然后返回一个全新的序列
        cost.stream().map(x -> x + x*0.05).forEach(x -> System.out.println(x));
        //用lambda表达式实现map与reduce

        //reduce实现的则是将所有值合并为一个
        double allCost = cost.stream().reduce((sum,x) -> sum + x).get();
        System.out.println(allCost);
        System.out.println("=======================");

        cost.stream().filter(x -> x > 25.0).forEach(x -> System.out.println(x));
    }
}

字符的取值范围
1.[abc] : 表示可能是a，可能是b，也可能是c。
2.[^abc]: 表示不是a,b,c中的任意一个
3.[a-zA-Z]: 表示是英文字母
4.[0-9]:表示是数字

简洁的字符表示
.：匹配任意的字符
\d：表示数字
\D：表示非数字
\s：表示由空字符组成，[ \t\n\r\x\f]
\S：表示由非空字符组成，[^\s]
\w：表示字母、数字、下划线，[a-zA-Z0-9_]
\W：表示不是由字母、数字、下划线组成

数量表达式
1.?: 表示出现0次或1次
2.+: 表示出现1次或多次
3.*: 表示出现0次、1次或多次
4.{n}：表示出现n次
5.{n,m}：表示出现n~m次
6.{n,}：表示出现n次或n次以上

逻辑表达式
1.XY: 表示X后面跟着Y，这里X和Y分别是正则表达式的一部分
2.X|Y：表示X或Y，比如"food|f"匹配的是foo（d或f），而"(food)|f"匹配的是food或f
3.(X):子表达式，将X看做是一个整体

java中提供了两个类来支持正则表达式的操作
分别是java.util.regex下的Pattern类和Matcher类
使用Pattern类进行字符串的拆分，使用的方法是String[] split(CharSequence input)
使用Matcher类进行字符串的验证和替换，
匹配使用的方法是boolean matches()
替换使用的方法是 String replaceAll(String replacement)

Pattern类的构造方法是私有的
所以我们使用Pattern p = Pattern.compile("a*b");进行实例化
Matcher类的实例化依赖Pattern类的对象Matcher m = p.matcher("aaaaab");

在实际的开发中，为了方便我们很少直接使用Pattern类或Matcher类，而是使用String类下的方法
验证：boolean matches(String regex)
拆分: String[] split(String regex)
替换： String replaceAll(String regex, String replacement)

package cn.it.cast.dao;

public class zhengze {
    public static void main(String[] args) {
        String str = "1234567";
//        char[] c = str.toCharArray();
//        boolean b = true;
//        for(char c1:c){
//            if(!(c1>='0'&&c1<='9')){
//                b = false;
//                break;
//            }
//        }
//        System.out.println(b);

        String regex = "\\d+";
        System.out.println(str.matches(regex));


        String str2 = "1234567affffffffff_";
        String regex2 = "\\w{15,}";
//        Pattern pat = Pattern.compile(regex);
//        Matcher mat = pat.matcher(str);
//        System.out.println(mat.matches());
        System.out.println(str2.matches(regex2));

        String str3 = "12Y34h56dAd7";
        String regex3 = "[a-zA-Z]+";
//        Pattern pat = Pattern.compile(regex);
//        Matcher mat = pat.matcher(str);
//        System.out.println(mat.replaceAll(":"));
        System.out.println(str3.replaceAll(regex3, "-"));


        String str4 = "Tom:30|Jerry:20|Bob:25";
        String regex4 = "\\|";
//        Pattern pat = Pattern.compile(regex);
//        String[] arr = pat.split(str);
        String[] arr = str4.split(regex4);
        for (String s : arr) {
            System.out.println(s);
        }

        //这里默认邮箱的后缀是.com或.net.cn
        String str5 = "aa@aa.net.cnfff";
        String regex5 = "[ant]";
        System.out.println(str5.matches(regex5));


    }

}

package cn.it.cast.dao;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Zifuchuan {
    public static void main(String[] args) {
       String str = "sdfjgseuisgusdfjfiwefuiweuisdf";
//        int count = 0;
//        int index = 0;
//
//        while ((index=str.indexOf("sdf",index))!=-1){
//            count++;
//            index=index+3;
//        }
//        System.out.println(count);

/*
类 Pattern ：正则表达式的编译表示形式。
       指定为字符串的正则表达式必须首先被编译为此类的实例。然后，可将得到的模式用于创建 Matcher 对象，依照正则表达式，该对象可以与任意字符序列匹配。执行匹配所涉及的所有状态都驻留在匹配器中，所以多个匹配器可以共享同一模式。
       因此，典型的调用顺序是
       Pattern p = Pattern.compile(“a*b”);
       Matcher m = p.matcher(“aaaaab”);
       boolean b = m.matches();
类 Matcher：通过调用模式的 matcher 方法从模式创建匹配器。创建匹配器后，可以使用它执行三种不同的匹配操作：
       matches 方法尝试将整个输入序列与该模式匹配。
       lookingAt 尝试将输入序列从头开始与该模式匹配。
       find 方法扫描输入序列以查找与该模式匹配的下一个子序列

 */
/*
Matcher的常用方法有：



find()：尝试查找与该模式匹配的输入序列的的下一个子序列。

find(int start)：重置此匹配器，然后尝试查找匹配该模式、从指定索引开始的输入序列的下一个子序列。

group()：匹配成功返回的组

start()：返回先前匹配的起始位置的索引。

end()：返回最后匹配字符的索引加一。

matches()：尝试将整个区域与模式匹配。匹配成功返回true

lookingAt()：尝试将从区域开头开始的输入序列与该模式匹配。

replaceFirst()：替换掉匹配的第一个子序列

replaceAll()：替换掉匹配的全部子序列

appendReplacement：重要，下面重点说

appendTail(StringBuffer buf)：重要，下面重点说


 */
        int count = 0;
        Pattern p = Pattern.compile("sdf");
        Matcher m = p.matcher(str);
        while( m.find() )
        {
            count++;
            System.out.println( "匹配项" + count+"：" + m.group() +"起始位置："+m.start()+"最后匹配："+m.end()); //group方法返回由以前匹配操作所匹配的输入子序列。
        }
        System.out.println( "匹配个数为"+count );

        System.out.println(m.replaceAll("sss"));
        System.out.println(m.replaceFirst("sss"));


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

        System.out.println(m.lookingAt()+"  "+m.group()+"起始位置："+m.start()+"最后匹配："+m.end());
        System.out.println(str);

        Pattern pattern = Pattern.compile("dog");
        Matcher matcher = pattern.matcher("z1zzzzzdogzzzzz2zzdogzzzz3zzz");
        StringBuffer buffer = new StringBuffer();
        while(matcher.find()){
            matcher.appendReplacement(buffer, "cat");
        }

        System.out.println(buffer.toString());
        matcher.appendTail(buffer);
        System.out.println(buffer.toString());



    }
}

类 Pattern ：正则表达式的编译表示形式。
       指定为字符串的正则表达式必须首先被编译为此类的实例。然后，可将得到的模式用于创建 Matcher 对象，依照正则表达式，该对象可以与任意字符序列匹配。执行匹配所涉及的所有状态都驻留在匹配器中，所以多个匹配器可以共享同一模式。
       因此，典型的调用顺序是
       Pattern p = Pattern.compile(“a*b”);
       Matcher m = p.matcher(“aaaaab”);
       boolean b = m.matches();
类 Matcher：通过调用模式的 matcher 方法从模式创建匹配器。创建匹配器后，可以使用它执行三种不同的匹配操作：
       matches 方法尝试将整个输入序列与该模式匹配。
       lookingAt 尝试将输入序列从头开始与该模式匹配。
       find 方法扫描输入序列以查找与该模式匹配的下一个子序列

 */
/*
Matcher的常用方法有：

find()：尝试查找与该模式匹配的输入序列的的下一个子序列。

find(int start)：重置此匹配器，然后尝试查找匹配该模式、从指定索引开始的输入序列的下一个子序列。

group()：匹配成功返回的组

start()：返回先前匹配的起始位置的索引。

end()：返回最后匹配字符的索引加一。

matches()：尝试将整个区域与模式匹配。匹配成功返回true

lookingAt()：尝试将从区域开头开始的输入序列与该模式匹配。

replaceFirst()：替换掉匹配的第一个子序列

replaceAll()：替换掉匹配的全部子序列

appendReplacement：重要，下面重点说

appendTail(StringBuffer buf)：重要，下面重点说