java基础-进阶lambda表达式&内建函数接口&正则表达式

Stirng\StringBuffer\StringBuilderd的区别

String字符串对象中的字符串发生改变，重新在内存中分配一个内存存储，
StringBuffer和StringBuilder我们可以对同一个对象进行字符串序列操作。

String和StringBuilder都是线程不安全的，StringBuffer是线程安全的。
如果字符串字符序列短，并且不考虑线程安全问题使用String，
如果字符串字符序列长而且需要操作同一个字符串对象以及不考虑线程安全问题使用StringBuilder。

集合
在集合类用户存放引用类型对象，可以存放多个
图片来之冰山一角，如侵，联系必删

Collection接口

字接口:List<E> element Object <String> 表示泛型
Set<E>

List集合:是一个接口
实现类：ArrayList(类似数组类型集合),LinkedList(链表式集合),Vector(线性安全的集合)
特点：元素有序可重复
  List可以存放简单类型，（实际存放到集合中的是引用类型）使用包装类实现
  List可以存放null而且是多个

Lambda表达式

简介：
从JDK1.8开始为了简化使用者进行代码的开发，专门提供有Lambda表达式的支持，
利用此操作形式可以实现函数式的编程。
对于函数式的编程比较著名的语言：haskell、Scala,
利用函数式编程可以避免掉面向对象编程中一些繁琐的处理问题。
面向对象在其长期的发展中，一直有部分的反对者，
这些反对者认为面向对象的设计过于复杂了，并且过于繁琐。

范例：使用Lambda表达式实现一个接口匿名内部类的功能。

interface IMessage{
	public void send(String str);
}
public class JavaDemo{
	public static void main(String[] args){
		IMessage msg=()->{
	System.out.println(“发送消息：”+str);
};
	ssg.send(“www.mldn.cn”);
	}
}
//利用这种形式就避免了复杂的面向对象结构化要求。

Lambda表达式如果想要使用，那么必须有一个重要的实现要求：SAM（Single Abstract Method）
只有一个抽象方法。只有一个抽象方法的接口被称做函数式接口。
而只有函数式的接口可以被Lambda表达式所使用。

为了使接口是函数式接口，我们往往在接口定义的上一行追加一句话
@FunctionalInterface//函数式接口
函数式接口里面的方法永远有且只有一个。
接口中的static方法和default方法都是为函数式编程作准备的。
对于Lambda表达式而言，提供有如下几种格式：

方法没有参数：()->{};
方法有参数:(参数，参数)->{};
如果现在只有一行语句返回：(参数,参数)->返回语句;
    例如：（t1,t2）->t1+t2;
解释，返回t1+r2的值，但是因为只有一行语句，所以我们不用return。
利用Lambda表达式，我们的确可以摆脱传统面向对象啊之中关于结构的限制，使得代码更加的简便。

方法引用

引用数据类型最大的特点是可以进行内存的指向处理，
但是在传统的开发之中一直所使用的只是对象引用操作，而从JDK1.8之后也提供了方法的引用。
即不同的方法名称可以描述同一个方法。
如果要进行方法的引用，java中有提供如下四种形式。

引用静态方法：类名称::static 方法名称
引用某个实例对象的方法：实例化对象：：普通方法
引用特定类型的方法：特定类：：普通方法；
引用构造方法：类名称::new。
利用方法引用这一概念可以为一个方法定义多个名字，但是要求必须是函数式接口。
提供方法引用的概念更多的情况下也只是弥补了对于引用的支持功能。方法引用只是提供了更多灵活型的选择。

内建函数式接口

在jdk1.8之中提供有Lambda表达式也提供有方法引用，但是如果现在由开发者自己定义函数式接口，往往都需要使用“@FunctionalInterface”注解来进行大量的声明。于是很多情况下，为了方法直接使用系统提供的函数式接口。
在系统之中专门提供有一个java.util.function的开发包，里面可以直接使用函数式接口。
在这个包下有如下几个核心接口供我们使用。

1.功能型函数式接口:
//接口定义:
@FunctionalInterface
public interface Function<T,R>{
	public R apply(T t);
}
 
//接口使用:
import java.util.function.*;
Public class JavaDemo{
	public static void main(String[] args){
	Function<String,Boolean>fun=”**Hello”::startWith;
	System.out.println(fun.apply(“**”));
	}
}

2.消费型函数式接口:
//只能够进行数据的处理操作，而没有任何的返回。
//接口定义：
@FunctionalInterface
public interface Consumer<T>{
	public void accept(T t);
}
//接口使用：
import java.util.function.*;
public class JavaDemo{
	public static void main(String[] args){
	Consumer<String> con=”System.out.println;
	con.accept(“hello,world”);
	}
}

3.供给型函数是接口：
//没有接收参数，但是有返回值
//接口定义：
@FunctionalInterface
public interface Supplier<T>{
	public T get();
}
//接口使用：
import java.util.function.*;
public class JavaDemo{
public static void main(String[] args){
	Supper<String> sup=”HELLO,world”::toLowerCase;
	System.out.println(sup.get());
	}
}

4.断言型函数式接口：进行数据的判断
//接口定义：
@FunctionalInterface
public interface Predicate<T>{
public boolean test(T t);
}
//接口使用：
import java.util.function.*;
public class JavaDemo{
	public static void main(String[] args){
		predicate<boolean> pre=”HELLO,”::equalsIgnoreCase;
		System.out.println(pre.test(“hello”));
	}
}

在实际上的项目开发之中，如果jdk本身提供的函数式接口可以被我们所使用，那么就没有必要重新定义了。

正则表达式

String是一个万能的类型，因为String不仅支持各种字符串的处理操作，也支持有向各个数据类型的转换功能，所以在项目的开发之中，只要是用户输入的信息基本上都用String表示。然后由String转向各种其它类型。于是在向其它数据类型转换的时候，为了保证转换的正确性，往往需要对其进行一些复杂的验证处理，那么这种情况下如果只是单纯的依靠String类中的方法，那是非常复杂的。使用正则表达式是很方便的。
认识正则表达式
现在假设有一个字符串要求你判断字符串是否由数字所组成，如果有数组所组成则将数字进行乘法计算。

public class Number1 {
    public static void main(String[] args) {
        String str="123";
        if(str.matches("\\d+")){
            int num=Integer.parseInt(str);
            System.out.println(num*2);
        }
    }
}

正则表达式最早是从Perl语言里面发展而来的，在JDK1.4以前如果使用正则表达式需要引入其它的*.jar文件，但是从JDK1.4之后，正则已经被默认JDK所支持。并且提供有java.util.regex开发包，同时针对String类进行了一些修改，使其可以有方法直接支持对正则对处理。
使用正则对最大特点在于方便进行验证处理，以及方便进行复杂字符串对修改处理。代码生成器就是使用正则来实现对。

正则标记

如果要想进行正则对处理操作，那么就首先需要对长使用对正则标记有所掌握。从JDK1.4开始提供有java.util.regex开发包，这个包里面提供有一个Pattren程序类，在这个程序类里面定义有所有支持对正则标记。

1.数量：单个 字符匹配
	x,例如
	String str=”a”;
	String regex=”a”;
	str.matches(regex);
	任意字符：表示任意字符组成：
	\\:匹配 \
	\t:匹配制表符
	\n:匹配换行
	2.数量：单个 字符集匹配（可以从里面任选一个字符）
	[abc]:可以是abc中的任意一个 
	[^abc]:^表示不是的意思，在这里就表示不是abc才能匹配	.
	[a-zA-Z]:表示由一个任意字母所组成，不区分大小写。
	[0-9]:表示由一位数字组成。
	3.数量：单个 简化的字符集
	
. ：表示任意的一个字符
	\d:  等价于[0-9]范围
	范例：
	String str=”1”;
	String regex=”\\d”; //两个\\表示一个\。前一个为转义字符
	\D:  等价于[^0-9].
	\s: 匹配任意的一位空格，可能是空格、换行、制表符
	\S: 匹配任意的一位非空格数据、
	\w: 匹配字母、数字、下划线，等价于[a-zA-Z_0-9]
	\W: 匹配非字母、数字、下划线，等价于[^a-zA-Z_0-9]
	4.边界匹配；
	^：匹配边界开始
	$:  	匹配边界结束
	5、数量变大，默认情况下只有添加上了数量单位才可以匹配多位字符：
	表达式?: 该正则可以出现0次或1次
	表达式*: 	该正则可以出现0次、1次或多次
	表达式+：该正则可以出现1次或多次
	表达式{n}:表达式的长度正好为n次
	表达式{n,}: 表达式的长度为n次或以上；
	表达式{n,m}：表达式的长度在n~m次；
	6、逻辑表达式：可以连接多个正则
	表达式X表达式Y:  X表达式后紧跟上Y表达式；
	表达式X｜表达式Y: 有一个表达式满足即可； 
	（表达式）： 为表达式设置一个整体描述，可以为整体描述设置数量单位。

String类对正则对支持
在进行正则表达式大部分处理对情况下都会基于String类来完成，并且在String类里面提供有如下于正则有关的方法；
no 方法名称 类型 描述
01 Public boolean matches(String regex) 普通 将指定字符串进行正则判断
02 Public String replaceAll(String regex,String replacement) 普通 替换全部
03 Public String replaceFirst(String regex,String replacement) 普通 替换首个
04 Public String[] split(String regex) 普通 正则拆分
05 Public String[] split(String regex,int limit) 普通 正则拆分，拆分为指定个数
案例：判断一个数据是否为小数，如果是小数则将其变为都double 类型；

public void regex(){
    String str="105.09";
    String regex="\\d+(\\.\\d+)?";
    double d=-1.d;
    if(str.matches(regex)) d = Double.parseDouble(str);
    System.out.println(d);
}

范例：判断一个字符串是否由日期所组成，如果是由日期所组成，则将其转换成Date类型。

public void regex() throws ParseException {
    String str="2021-08-28";
    String regex="\\d{4}-\\d{2}-\\d{2}";
    if(str.matches(regex)) {
        System.out.println(new SimpleDateFormat("yyyy-MM-dd").parse(str));
    }
}

正则不能进行具体的含义判断处理只能进行格式的判断，如上如果将月份该为20月，也是能匹配上的。
范例：判断给定的电话号码是否正确；
电话号码：51283346
电话号码：01051283346
电话号码：(010)-51283346

public void regex() throws ParseException {
    String str="01051283346";
    String regex="((\\d{3,4})|(\\(\\d{3,4})\\)-)?\\d{7,8}";
    System.out.println(str.matches(regex));
}

范例：使用正则进行email地址验证：
1.email的用户名可以有字母、数字、所组成、下划线不能开头
2.emial的域名可以由字母、数字、、-所组成
3.域名的后缀必须是:.cn、.com、.net、.com.cn、.gov

public void regex() throws ParseException {
    //String str="(010)-51283346";
    String str="anhuiwuyanzhu001@heh.com";
    String regex="[a-zA-Z0-9]\\w+@\\w+\\.(cn|com|com.cn|net|gov)";
    System.out.println(str.matches(regex));
}

这几中正则表达式是比较常用的，这种基础得会写。
J

java.util.regex开发包

虽然在大部分的情况下都可以利用String类实现正则的操作，但是也有一些特殊的情况下，需要用到java.util.regex开发包提供的正则处理类。在这个包中一共定义有来两个类：Pattern(正则表达式编译)、Matcher（匹配）
1.Pattern类提供有正则表达式的编译处理:public static Pattern compile(String regex);
同时也提供有字符串的拆分操作:public String[] split(CharSequence input);
案例:按非字母拆分字符串

public void pattern(){
    String str="esa789g6a6h79913j21kl*(^&*gea&()*&^6";
    String regex="[^a-zA-Z]+";
    Pattern pat=Pattern.compile(regex);
    String[] arr= pat.split(str);
    for(String ele:arr){
        System.out.println(ele);
    }
}

2.Matcher类，实现了正则匹配的处理类，这个类的对象实例化依靠Pattern类来完成。
Pattern类提供的方法：public Matcher matcher (CharSequence input)
而当获取了Matcher类的对象之后就可以利用该类中的方法进行如下操作：
正则匹配：public boolean matchers();
字符串替换：public String replaceAll(String replacement);
范例：实现字符串匹配

public void matcher(){
    String str="101";
    String regex="\\d+";
    Pattern pat=Pattern.compile(regex);
    Matcher mat=pat.matcher(str);
    System.out.println(mat.matches());
}

如果纯粹的是以拆分，替换，匹配三种操作为例根本用不到java.util.regex开发包，只依靠String类就可以完成，但是regex开发包里面提供有一种分组的功能，而这种分组的功能是String不具备的。
范例：

public void matcher1(){
    //要求取出"#{内容}"标记中的所有内容
    String str="INSERT INTO dept(deptno,dname,ioc) VALUES (#{deptno},#{dname},#{ioc})";
    String regex="#\\{\\w+\\}";
    Pattern pat=Pattern.compile(regex);
    Matcher mat=pat.matcher(str);
    while(mat.find()){//是否有匹配成功的内容
        System.out.println(mat.group(0).replaceAll("(#|\\{|\\})",""));
    }
}

Java.util.regex开发包，如果不是进行一些更为复杂的正则处理是很难使用到的，而String类所提供的功能只提供正则的基本操作。

UUID类

UUID类是一种生成无重复字符串的一种程序类，这种程序类的主要功能是根据时间戳实现一个自动的无重复的字符串定义。无重复指的是概率很低，可能是千亿分之一.
UUID.randomUUID();//生成一个UUID对象，UUID类型重写了toString方法。