Java从1.8以后引入了函数式编程，这是很大的一个改进。函数式编程的优点在提高编码的效率，增强代码的可读性。本文历时两个多月一点点写出来，即作为心得，亦作为交流。
 
1.Java函数式编程的语法：
 
使用Consumer作为示例，它是一个函数式接口，包含一个抽象方法accept，这个方法只有输入而无输出也就是说这个方法无返回值。 
 现在我们要定义一个Consumer接口的实例化对象，传统的方式是这样定义的：
 
public static void main(String[] args) {
         //JDK1.8版本之前的做法
         Consumer<Integer> con = new Consumer<Integer>() {
             @Override
             public void accept(Integer t) {
                 System.out.println(t);
             }
         };
         //调用方法
         con.accept(3);
     }
 
这里可以打印出3.
 
上面是JDK1.8以前的做法，在1.8以后引入函数式的编程可以这样写：
 
public static void main(String[] args) {
         //第一种写法:
         Consumer<Integer> con = (param) -> {System.out.println(param);}; 
         //第二种写法:
         Consumer<Integer> con1 = (param) -> System.out.println(param);
         //第三种写法:
         Consumer<Integer> con2 = System.out::println;
         
         con2.accept(3);
     }
 
上面的con、con1、con2这个Consumer对象的引用照样可以打印出3.
 
在上面的第二种写法是第一种写法的精简，但是只有在函数题中只有一条语句时才可以这么使用，做进一步的简化。
 
在上面的第三种写法是对第一、二种写法的进一步精简，由于第三种写法只是进行打印，调用了System.out中的println静态方法对输入参数直接进行打印。它表示的意思就是针对输入的参数将其调用System.out中的静态方法println进行打印。
 
上面已说明，函数式编程接口都只有一个抽象方法，因此在采用这种写法时，编译器会将这段函数编译后当作该抽象方法的实现。 
 如果接口有多个抽象方法，编译器就不知道这段函数应该是实现哪个方法的了。 
 因此，=  后面的函数体我们就可以看成是accept函数的实现。
 
输入：-> 前面的部分，即被()包围的部分。此处只有一个输入参数，实际上输入是可以有多个的，如两个参数时写法：(a, b);当然也可以没有输入，此时直接就可以是()。
 函数体：->后面的部分，即被{}包围的部分；可以是一段代码。
 输出：函数式编程可以没有返回值，也可以有返回值。如果有返回值时，需要代码段的最后一句通过return的方式返回对应的值。但是Consumer这个函数式接口不能有具体的返回值。
 
Java 8 中我们可以通过 `::` 关键字来访问类的构造方法，对象方法，静态方法。
 
好了，到这一步就可以感受到函数式编程的强大能力。 
 通过最后一段代码，我们可以简单的理解函数式编程，Consumer接口直接就可以当成一个函数了，这个函数接收一个输入参数，然后针对这个输入进行处理；当然其本质上仍旧是一个对象，但我们已经省去了诸如老方式中的对象定义过程，直接使用一段代码来给函数式接口对象赋值。 
 而且最为关键的是，这个函数式对象因为本质上仍旧是一个对象，因此可以做为其它方法的参数或者返回值，可以与原有的代码实现无缝集成！
 

 2.Java函数式接口
 
java.util.function.Consumer;
 java.util.function.Function;
 java.util.function.Predicate;
 
2.1 Consumer是一个函数式编程接口； 顾名思义，Consumer的意思就是消费，即针对某个东西我们来使用它，因此它包含有一个有输入而无输出（无返回值）的accept接口方法； 
 除accept方法，它还包含有andThen这个方法； 
 
JDK源码定义如下：
 
default Consumer<T> andThen(Consumer<? super T> after) {
         Objects.requireNonNull(after);
         return (T t) -> { accept(t); after.accept(t); };
 
 }
 
andThen这个方法是作用是：指定在调用当前Consumer后是否还要调用其它的Consumer； 
 
public static void main(String[] args) {
         //定义第一个Consumer
         Consumer<Integer> consumer1 = (param) -> {System.out.println(param);};
         
         //定义第二个Consumer
         Consumer<Integer> consumer2 = (param) -> {System.out.println(param * param);};
         
         //consumer1可以连续的调用自己
         //consumer1.andThen(consumer1).andThen(consumer1).accept(3);
         //打印出 3 3 3
         
         //consumer1可以调用自己后调用consumer2
         consumer1.andThen(consumer1).andThen(consumer2).accept(3);
         //打印出3 3 9
     }
 
注意：当一个Consumer接口调用另外一个Consumer对象时两个Counsumer对象的泛型必须一致。
 
2.2  Function也是一个函数式编程接口；它代表的含义是“函数”，它是个接受一个参数并生成结果的函数，而函数经常是有输入输出的，因此它含有一个apply方法，包含一个输入与一个输出； 
 除apply方法外，它还有compose与andThen及indentity三个方法，其使用见下述示例；
 
apply的用法：
 
public static void main(String[] args) {
         Function<Integer, Integer> fun = res -> res + 1；
         Integer  i = fun.apply(2)；
         System.out.println(i);
 }
 
上面打印出2。
 
Function编程接口有两个泛型Function<T, R> T表示：函数的输入类型，R表示：函数的输出类型。
 
compose的用法：
 
JDK源码定义：
 
default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
         Objects.requireNonNull(before);
         return (V v) -> apply(before.apply(v));
 
 }
 
public static void main(String[] args) {
         Function<Integer, Integer> fun = res -> res + 1;
         Function<Integer, Integer> fun1 = res -> res * 10;
         Integer i = (Integer) fun.compose(fun1).apply(2);
         System.out.println(i);
 }
 
上面打印出21；
 
上面表示了fun2接收到2以后先计算，然后将fun2计算的结果再交给fun再计算。
 
andThen方法的用法：
 
JDK源码定义：
 
default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
         Objects.requireNonNull(after);
         return (T t) -> after.apply(apply(t));
 
 }
 
public static void main(String[] args) {
         Function<Integer, Integer> fun = res -> res + 1;
         Function<Integer, Integer> fun1 = res -> res * 10;
         Integer i = (Integer) fun.andThen(fun1).apply(3);
         System.out.println(i);
  }
 
上面打印出40
 
上面表示了fun先计算得到4，然后将计算结果4再给fun1计算得到40；
 
indentity方法的用法：
 
JDK源码定义：
 
static <T> Function<T, T> identity() {
         return t -> t;
  }
 
public static void main(String[] args) {
         System.out.println(Function.identity().apply("总分"));
 
 }
 
上面打印出“总分“；就是说传入什么参数输出什么参数。
 
2.3 Predicate为函数式接口，predicate的中文意思是“断定”，即判断的意思，判断某个东西是否满足某种条件； 因此它包含test方法，根据输入值来做逻辑判断，其结果为True或者False。 
 
test方法的用法：
 
JDK源码定义： boolean test(T t);
 
public static void main(String[] args) {
         Predicate<String> pre = res -> res.equals("1234");
         boolean rest = pre.test("1234");
         System.out.println(rest);
  }
 
上面打印出true。
 
and方法的用法：
 
JDK源码定义：
 
default Predicate<T> and(Predicate<? super T> other) {
         Objects.requireNonNull(other);
         return (t) -> test(t) && other.test(t);
  }
 
public static void main(String[] args) {
         Predicate<String> pre = res -> res.equals("1234");
         Predicate<String> pre1 = res -> res.equals("1234");
         Predicate<String> pre3 = res -> res.equals("1234");
         boolean rest = pre.and(pre1).test("1234");
         boolean rest1 = pre.and(pre1).test("12341");
         System.out.println(rest);
         System.out.println(rest1); 
 
}
 上面先打印出true，后打印出false
 
根据源码，"1234"先和pre比较，如果为true，再和pre1比较。不为true直接返回false，不再和pre1比较。当“1234”和pre比较后为true，再和pre1比较结果为true，所以最终返回true。
 
negate()的用法：
 
JDK源码定义：
 
default Predicate<T> negate() {
         return (t) -> !test(t);
  }
 
public static void main(String[] args) {
         Predicate<String> pre = res -> res.equals("1234");
         boolean rest = pre.negate().test("1234");
         System.out.println(rest);
 }
 
上面打印出false，上面的意思是如果比较的结果是true，那么返回false，如果为false，就返回true。
 
or的方法的用法：
 
JDK源码定义：
 
default Predicate<T> or(Predicate<? super T> other) {
         Objects.requireNonNull(other);
         return (t) -> test(t) || other.test(t);
 }
 
public static void main(String[] args) {
         Predicate<String> pre = res -> res.equals("1234");
         Predicate<String> pre1 = res -> res.equals("12341");
         boolean rest = pre.or(pre1).test("12341");
         System.out.println(rest);
  }
 
上面打印出true；
 
or方法的意思是：只要一个为true就返回true。
 
isEqual方法用法：
 
JDK源码定义：
 
static <T> Predicate<T> isEqual(Object targetRef) {
         return (null == targetRef)
                 ? Objects::isNull
                 : object -> targetRef.equals(object);
  }
 
public static void main(String[] args) {
         System.out.println(Predicate.isEqual("12345").test("12345"));
 
}
 
上面打印出true；isEqual里的参数是要比较的目标对象。
 
3.函数式编程接口的使用
 
通过Stream以及Optional两个类，可以进一步利用函数式接口来简化代码。
 
3.1 Stream
 
Stream可以对多个元素进行一系列的操作，也可以支持对某些操作进行并发处理。
 
3.1.1 Stream对象的创建
 
Stream对象的创建途径有以下几种：
 
a. 创建空的Stream对象
 
Stream str = Stream.empty();
 
b. 通过集合类中的stream或者parallelStream方法创建；
 
List<String> list = Arrays.asList("a", "b", "c", "d");
 Stream listStream = list.stream(); //获取串行的Stream对象
 Stream parallelListStream = list.parallelStream(); //获取并行的Stream对象  
 
c. 通过Stream中的of方法创建：
 
Stream s = Stream.of("test");
 
Stream s1 = Stream.of("a", "b", "c", "d");
 
d. 通过Stream中的iterate方法创建： 
     iterate方法有两个不同参数的方法：
 
public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f);  
 public static<T> Stream<T> iterate(T seed, Predicate<? super T> hasNext, UnaryOperator<T> next)
 其中第一个方法将会返回一个无限有序值的Stream对象：它的第一个元素是seed，第二个元素是f.apply(seed); 第N个元素是f.apply(n-1个元素的值)；生成无限值的方法实际上与Stream的中间方法类似，在遇到中止方法前一般是不真正的执行的。因此无限值的这个方法一般与limit等方法一起使用，来获取前多少个元素。 
 当然获取前多少个元素也可以使用第二个方法。 
 第二个方法与第一个方法生成元素的方式类似，不同的是它返回的是一个有限值的Stream；中止条件是由hasNext来断定的。
 第二种方法的使用示例如下：
 
/**
  * 本示例表示从1开始组装一个序列，第一个是1，第二个是1+1即2，第三个是2+1即3..，直接10时中止；
  * 也可简化成以下形式：
  *        Stream.iterate(1,
  *        n -> n <= 10,
  *        n -> n+1).forEach(System.out::println);
  * 写成以下方式是为简化理解
  */
 Stream.iterate(1,
         new Predicate<Integer>() {
             @Override
             public boolean test(Integer integer) {
                 return integer <= 10;
             }
         },
     new UnaryOperator<Integer>() {
         @Override
         public Integer apply(Integer integer) {
             return integer+1;
         }
 }).forEach(System.out::println);
 
e. 通过Stream中的generate方法创建 
 与iterate中创建无限元素的Stream类似，不过它的每个元素与前一元素无关，且生成的是一个无序的队列。也就是说每一个元素都可以随机生成。因此一般用来创建常量的Stream以及随机的Stream等。 
 示例如下：
 
/**
  * 随机生成10个Double元素的Stream并将其打印
  */
 Stream.generate(new Supplier<Double>() {
     @Override
     public Double get() {
         return Math.random();
     }
 }).limit(10).forEach(System.out::println);
 
//上述写法可以简化成以下写法：
 Stream.generate(() -> Math.random()).limit(10).forEach(System.out::println);
 

 f. 通过Stream中的concat方法连接两个Stream对象生成新的Stream对象 
 这个比较好理解不再赘述。
 
3.1.2 Stream对象的使用
 Stream对象提供多个非常有用的方法，这些方法可以分成两类： 
 中间操作：将原始的Stream转换成另外一个Stream；如filter返回的是过滤后的Stream。 
 终端操作：产生的是一个结果或者其它的复合操作；如count或者forEach操作。
 
其清单如下所示，方法的具体说明及使用示例见后文。 
 所有中间操作：
 
 
所有的终端操作：
 
下面就几个比较常用的方法举例说明其用法：
 
3.1.2.1 filter
 用于对Stream中的元素进行过滤，返回一个过滤后的Stream 
 其方法定义如下：
 
Stream<T> filter(Predicate<? super T> predicate);

 使用示例：
 
Stream<String> s = Stream.of("test", "t1", "t2", "teeeee", "aaaa");
 //查找所有包含t的元素并进行打印
 s.filter(n -> n.contains("t")).forEach(System.out::println);

 3.1.2.2 map
 元素一对一转换。 
 它接收一个Funcation参数，用其对Stream中的所有元素进行处理，返回的Stream对象中的元素为Function对原元素处理后的结果 
 其方法定义如下：
 
<R> Stream<R> map(Function<? super T, ? extends R> mapper);

 示例，假设我们要将一个String类型的Stream对象中的每个元素添加相同的后缀.txt，如a变成a.txt，其写法如下：
 
Stream<String> s = Stream.of("test", "t1", "t2", "teeeee", "aaaa");
 s.map(n -> n.concat(".txt")).forEach(System.out::println);

 3.1.2.3 flatMap
 元素一对多转换：对原Stream中的所有元素使用传入的Function进行处理，每个元素经过处理后生成一个多个元素的Stream对象，然后将返回的所有Stream对象中的所有元素组合成一个统一的Stream并返回； 
 方法定义如下：
 
<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);

 示例，假设要对一个String类型的Stream进行处理，将每一个元素的拆分成单个字母，并打印：
 
Stream<String> s = Stream.of("test", "t1", "t2", "teeeee", "aaaa");
 s.flatMap(n -> Stream.of(n.split(""))).forEach(System.out::println);

 3.1.2.4 takeWhile
 方法定义如下：
 
default Stream<T> takeWhile(Predicate<? super T> predicate)

 如果Stream是有序的（Ordered），那么返回最长命中序列（符合传入的Predicate的最长命中序列）组成的Stream；如果是无序的，那么返回的是所有符合传入的Predicate的元素序列组成的Stream。 
 与Filter有点类似，不同的地方就在当Stream是有序时，返回的只是最长命中序列。 
 如以下示例，通过takeWhile查找”test”, “t1”, “t2”, “teeeee”, “aaaa”, “taaa”这几个元素中包含t的最长命中序列：
 
Stream<String> s = Stream.of("test", "t1", "t2", "teeeee", "aaaa", "taaa");
 //以下结果将打印： "test", "t1", "t2", "teeeee"，最后的那个taaa不会进行打印 
 s.takeWhile(n -> n.contains("t")).forEach(System.out::println);

 3.1.2.5 dropWhile
 与takeWhile相反，如果是有序的，返回除最长命中序列外的所有元素组成的Stream；如果是无序的，返回所有未命中的元素组成的Stream;其定义如下：
 
default Stream<T> dropWhile(Predicate<? super T> predicate)

 如以下示例，通过dropWhile删除”test”, “t1”, “t2”, “teeeee”, “aaaa”, “taaa”这几个元素中包含t的最长命中序列：
 
Stream<String> s = Stream.of("test", "t1", "t2", "teeeee", "aaaa", "taaa");
 //以下结果将打印："aaaa", "taaa" 　
 s.dropWhile(n -> n.contains("t")).forEach(System.out::println);

 3.1.2.6 reduce与collect
 关于reduce与collect由于功能较为复杂，在后续将进行单独分析与学习，此处暂不涉及。
 
3.2 Optional用于简化Java中对空值的判断处理，以防止出现各种空指针异常。 
 Optional实际上是对一个变量进行封装，它包含有一个属性value，实际上就是这个变量的值。
 
3.2.1 Optional对象创建
 它的构造函数都是private类型的，因此要初始化一个Optional的对象无法通过其构造函数进行创建。它提供了一系列的静态方法用于构建Optional对象:
 
3.2.1.1 empty
 用于创建一个空的Optional对象；其value属性为Null。 
 如：
 
Optional o = Optional.empty();

 3.2.1.2 of
 根据传入的值构建一个Optional对象; 
 传入的值必须是非空值，否则如果传入的值为空值，则会抛出空指针异常。 
 使用：
 
o = Optional.of("test"); 
 1
 3.2.1.3 ofNullable
 根据传入值构建一个Optional对象 
 传入的值可以是空值，如果传入的值是空值，则与empty返回的结果是一样的。
 
3.2.2 方法
 Optional包含以下方法：
 
3.2.3 使用场景
 常用的使用场景如下：
 
3.2.3.1 判断结果不为空后使用
 如某个函数可能会返回空值，以往的做法：
 
String s = test();
 if (null != s) {
     System.out.println(s);
 }

 现在的写法就可以是：
 
Optional<String> s = Optional.ofNullable(test());
 s.ifPresent(System.out::println);

 乍一看代码复杂度上差不多甚至是略有提升；那为什么要这么做呢？ 
 一般情况下，我们在使用某一个函数返回值时，要做的第一步就是去分析这个函数是否会返回空值；如果没有进行分析或者分析的结果出现偏差，导致函数会抛出空值而没有做检测，那么就会相应的抛出空指针异常！ 
 而有了Optional后，在我们不确定时就可以不用去做这个检测了，所有的检测Optional对象都帮忙我们完成，我们要做的就是按上述方式去处理。
 
3.2.3.2 变量为空时提供默认值
 如要判断某个变量为空时使用提供的值，然后再针对这个变量做某种运算； 
 以往做法：
 
if (null == s) {
     s = "test";
 }
 System.out.println(s);

 现在的做法：
 
Optional<String> o = Optional.ofNullable(s);
 System.out.println(o.orElse("test"));

 3.2.3.3 变量为空时抛出异常，否则使用
 以往写法：
 
if (null == s) {
     throw new Exception("test");
 }
 System.out.println(s);
 

 现在写法：
 
Optional<String> o = Optional.ofNullable(s);
 System.out.println(o.orElseThrow(()->new Exception("test")));
  

 
今天和大家分享一组常用函数公式的使用方法，用心掌握这些函数，工作效率会大大提升。欢迎转发给更多有需要的人。
 
一、相关概念
 
(一)函数语法
 
由函数名+括号+参数组成
 
例： 求和函数：SUM(A1,B2,…) 。参数与参数之 间用逗号“,”隔开
 
(二)运算符
 
1. 公式运算符：加(+)、减(-)、乘(*)、除(/)、百分号(%)、乘幂(＾) 
 
2. 比较运算符：大与(>)、小于(=) 、不等于(<>)
 
3. 引用运算符：区域运算符(：)、联合运算符(,)
 
(三)单元格的相对引用与绝对引用
 
例： A1
 
 $A1 锁定第A列
 
 A$1 锁定第1行
 
 $A$1 锁定第A列与第1行
 
二、常用函数
 
(一)数学函数
 
1. 求和 =SUM(数值1,数值2,……)
 
2. 条件求和 =SUMIF(查找的范围,条件(即对象),要求和的范围)
 
例：(1)=SUMIF(A1:A4,”>=200”,B1:B4)
 
 函数意思：对第A1栏至A4栏中，大于等于200的数值对应的第B1列至B4列中数值求和
 
(2)=SUMIF(A1:A4,”<300”,C1:C4)
 
函数意思：对第A1栏至A4栏中，小于300的数值对应的第C1栏至C4栏中数值求和
 
3. 求个数 =COUNT(数值1,数值2,……)
 
例：(1) =COUNT(A1:A4) 函数意思：第A1栏至A4栏求个数
 
 (2) =COUNT(A1:C4) 函数意思：第A1栏至C4栏求个数
 
4. 条件求个数 =COUNTIF(范围,条件)
 
例：(1) =COUNTIF(A1:A4，”<>200”)
 
 函数意思：第A1栏至A4栏中不等于200的栏求个数
 
 (2) =COUNTIF(A1:C4,”>=1000”)
 
 函数意思：第A1栏至C4栏中大于等1000的栏求个数
 
5. 求算术平均数 =AVERAGE(数值1,数值2,……)
 
例：(1) =AVERAGE(A1,B2)
 
(2) =AVERAGE(A1:A4)
 
6. 四舍五入函数 =ROUND(数值,保留的小数位数)
 
7. 排位函数 =RANK(数值,范围,序别) 1-升序 0-降序
 
例：(1) =RANK(A1,A1:A4,1)
 
 函数意思：第A1栏在A1栏至A4栏中按升序排序，返回排名值。
 
 (2) =RANK(A1,A1:A4,0)
 
 函数意思：第A1栏在A1栏至A4栏中按降序排序，返回排名值。
 
8. 乘积函数 =PRODUCT(数值1,数值2,……)
 
9. 取绝对值 =ABS(数字)
 
10. 取整 =INT(数字)
 
(二)逻辑函数
 
条件函数：=IF(条件,执行条件,执行条件假)—可执行七层嵌套
 
例： A1=5 A2=3 A3=6 A4=7
 
=IF(A1>A2,1,0)=1(真)
 
=IF(A1
 
=IF(A1>A2,IF(A3>A4,8,9),1)=9
 
(三)文本函数
 
1. 截取函数： =LEFT(文本,截取长度)—从左边截取
 
=RIGHT(文本,截取长度)—从右边截取
 
=MID(文本,开始位,截取长度)—从中间截取
 
2. 计算字符长度：LEN(文本)—文本的长度
 
3. 合并字符函数：CONCATENATE(文本1,文本2,…)
 
4. 在字符串中查找特定字符：FIND(文本,范围,数值)—数值表示查找第几个
 
=FIND(“a”,“abcadeafga”,2)=4
 
=FIND(“a”,“abcadeafga”,3)=7
 
=FIND(“a”,“abcadeafga”,4)=10
 
5. 比较两个字符是否完全相符：EXACT(文本1,文本2)
 
=EXACT(“a”,“a”)=TRUE
 
=EXACT(“a”,“ab”)=FALSE
 
=EXACT(“a”,“A”)=FALSE
 
6. 将数值转化为文本：TEXT(数值,参数) )—参数一般为0
 
7. 将数值型字符转换为数值：VALUE(数值文本)
 
(四)判断公式
 
1. 把公式产生的错误显示为空
 
公式：C2=IFERROR(A2/B2,””)
 
说明：如果是错误值则显示为空，否则正常显示。
 

  
 
 
2. IF多条件判断返回值
 
公式：C2=IF(AND(A2<500,B2=”未到期”),”补款”,””)
 
说明：两个条件同时成立用AND，任一个成立用OR函数。
 

  
 
 
(五)统计公式
 
1. 统计两个表格重复的内容
 
公式：B2=COUNTIF(Sheet15!A:A,A2)
 
说明：如果返回值大于0说明在另一个表中存在，0则不存在。
 

  
 
 
2. 统计不重复的总人数
 
公式：C2=SUMPRODUCT(1/COUNTIF(A2:A8,A2:A8))
 
说明：用COUNTIF统计出每人的出现次数，用1除的方式把出现次数变成分母，然后相加。
 

  
 
 
(六)求和公式
 
1. 隔列求和
 
公式：H3=SUMIF($A$2: $G$2,H$2,A3:G3)
 
或者： =SUMPRODUCT((MOD(COLUMN(B3:G3),2)=0)*B3:G3)
 
说明：如果标题行没有规则用第2个公式
 

  
 
 
2. 单条件求和
 
3. 单条件模糊求和
 
4. 多条件模糊求和
 
5. 多表相同位置求和
 
公式：B2=SUM(Sheet1:Sheet19!B2)
 
说明：在表中间删除或添加表后，公式结果会自动更新。
 

  
 
 
6. 按日期和产品求和
 
(七)查找与引用公式
 
1. 单条件查找公式
 
公式1： C11=VLOOKUP(B11,B3:F7,4,FALSE)
 
说明：查找是VLOOKUP最擅长的，基本用法
 

  
 
 
2. 双向查找公式
 
公式=INDEX(C3:H7,MATCH(B10,B3:B7,0),MATCH(C10,C2:H2,0))
 
说明：利用MATCH函数查找位置，用INDEX函数取值
 

  
 
 
3. 查找最后一条符合条件的记录。
 
公式：详见下图
 
说明：0/(条件)可以把不符合条件的变成错误值，而lookup可以忽略错误值
 

  
 
 
4. 多条件查找
 
公式：详见下图
 
说明：公式原理同上一个公式
 

  
 
 
5. 指定区域最后一个非空值查找
 
6. 按数字区域间取对应的值

 一. string的构造函数的形式： 
 
 
string str：生成空字符串

string s(str)：生成字符串为str的复制品

string s(str, strbegin,strlen)：将字符串str中从下标strbegin开始、长度为strlen的部分作为字符串初值

string s(cstr, char_len)：以C_string类型cstr的前char_len个字符串作为字符串s的初值

string s(num ,c)：生成num个c字符的字符串

string s(str, stridx)：将字符串str中从下标stridx开始到字符串结束的位置作为字符串初值

eg:


    string str1;               //生成空字符串
    string str2("123456789");  //生成"1234456789"的复制品
    string str3("12345", 0, 3);//结果为"123"
    string str4("012345", 5);  //结果为"01234"
    string str5(5, '1');       //结果为"11111"
    string str6(str2, 2);      //结果为"3456789"
 
#include <iostream>
#include <string>
using namespace std;

void test1()
{
    string str1;               //生成空字符串
    string str2("123456789");  //生成"1234456789"的复制品
    string str3("12345", 0, 3);//结果为"123"
    string str4("0123456", 5);  //结果为"01234"
    string str5(5, '1');       //结果为"11111"
    string str6(str2, 2);      //结果为"3456789"

    cout<<"str2:"<<str2<<endl;
    cout<<"str3:"<<str3<<endl;
    cout<<"str4:"<<str4<<endl;
    cout<<"str5:"<<str5<<endl;
    cout<<"str6:"<<str6<<endl;
}

int main()
{
    test1();
    return 0;
}
 
 
 二. string的大小和容量：： 
 

1. size()和length()：返回string对象的字符个数，他们执行效果相同。

2. max_size()：返回string对象最多包含的字符数，超出会抛出length_error异常

3. capacity()：重新分配内存之前，string对象能包含的最大字符数

 
void test2()
{
    string s("1234567");
    cout << "size=" << s.size() << endl;
    cout << "length=" << s.length() << endl;
    cout << "max_size=" << s.max_size() << endl;
    cout << "capacity=" << s.capacity() << endl;

}
 
 
 三. string的字符串比较：： 
 
1. C ++字符串支持常见的比较操作符（>,>=,<,<=,==,!=），甚至支持string与C-string的比较(如 str<”hello”)。  
在使用>,>=,<,<=这些操作符的时候是根据“当前字符特性”将字符按字典顺序进行逐一得 比较。字典排序靠前的字符小，  
比较的顺序是从前向后比较，遇到不相等的字符就按这个位置上的两个字符的比较结果确定两个字符串的大小(前面减后面)
同时，string (“aaaa”) <string(aaaaa)。    

2. 另一个功能强大的比较函数是成员函数compare()。他支持多参数处理，支持用索引值和长度定位子串来进行比较。 
  他返回一个整数来表示比较结果，返回值意义如下：0：相等 1：大于 -1：小于 (A的ASCII码是65，a的ASCII码是97)
 
void test3()
{
    // (A的ASCII码是65，a的ASCII码是97)
    // 前面减去后面的ASCII码，>0返回1，<0返回-1，相同返回0
    string A("aBcd");
    string B("Abcd");
    string C("123456");
    string D("123dfg");

    // "aBcd" 和 "Abcd"比较------ a > A
    cout << "A.compare(B)：" << A.compare(B)<< endl;                          // 结果：1

    // "cd" 和 "Abcd"比较------- c > A
    cout << "A.compare(2, 3, B):" <<A.compare(2, 3, B)<< endl;                // 结果：1

    // "cd" 和 "cd"比较 
    cout << "A.compare(2, 3, B, 2, 3):" << A.compare(2, 3, B, 2, 3) << endl;  // 结果：0


    // 由结果看出来：0表示下标，3表示长度
    // "123" 和 "123"比较 
    cout << "C.compare(0, 3, D, 0, 3)" <<C.compare(0, 3, D, 0, 3) << endl;    // 结果：0

}
 
 
四. string的插入：push_back() 和 insert() 
 
 
void  test4()
{
    string s1;

    // 尾插一个字符
    s1.push_back('a');
    s1.push_back('b');
    s1.push_back('c');
    cout<<"s1:"<<s1<<endl; // s1:abc

    // insert(pos,char):在制定的位置pos前插入字符char
    s1.insert(s1.begin(),'1');
    cout<<"s1:"<<s1<<endl; // s1:1abc
}
 
 
 五、string拼接字符串：append() & + 操作符 
 
 
void test5()
{
    // 方法一：append()
    string s1("abc");
    s1.append("def");
    cout<<"s1:"<<s1<<endl; // s1:abcdef

    // 方法二：+ 操作符
    string s2 = "abc";
    /*s2 += "def";*/
    string s3 = "def";
    s2 += s3.c_str();
    cout<<"s2:"<<s2<<endl; // s2:abcdef
}
 
 
六、 string的遍历：借助迭代器 或者 下标法
 
 
void test6()
{
    string s1("abcdef"); // 调用一次构造函数

    // 方法一： 下标法

    for( int i = 0; i < s1.size() ; i++ )
    {
        cout<<s1[i];
    }
    cout<<endl;

    // 方法二：正向迭代器

    string::iterator iter = s1.begin();
    for( ; iter < s1.end() ; iter++)
    {
        cout<<*iter;
    }
    cout<<endl;

    // 方法三：反向迭代器
    string::reverse_iterator riter = s1.rbegin();
    for( ; riter < s1.rend() ; riter++)
    {
        cout<<*riter;
    }
    cout<<endl;
}
 
 
七、 string的删除：erase()
 
1. iterator erase(iterator p);//删除字符串中p所指的字符

2. iterator erase(iterator first, iterator last);//删除字符串中迭代器

区间[first,last)上所有字符

3. string& erase(size_t pos = 0, size_t len = npos);//删除字符串中从索引

位置pos开始的len个字符

4. void clear();//删除字符串中所有字符
 
void test6()
{
    string s1 = "123456789";


    // s1.erase(s1.begin()+1);              // 结果：13456789
    // s1.erase(s1.begin()+1,s1.end()-2);   // 结果：189
    s1.erase(1,6);                       // 结果：189
    string::iterator iter = s1.begin();
    while( iter != s1.end() )
    {
        cout<<*iter;
        *iter++;
    }
    cout<<endl;

}
 
八、 string的字符替换：
 
 
1. string& replace(size_t pos, size_t n, const char *s);//将当前字符串

从pos索引开始的n个字符，替换成字符串s

2. string& replace(size_t pos, size_t n, size_t n1, char c); //将当前字符串从pos索引开始的n个字符，替换成n1个字符c

3. string& replace(iterator i1, iterator i2, const char* s);//将当前字符串[i1,i2)区间中的字符串替换为字符串s
 
void test7()
{
    string s1("hello,world!");

    cout<<s1.size()<<endl;                     // 结果：12
    s1.replace(s1.size()-1,1,1,'.');           // 结果：hello,world.

    // 这里的6表示下标  5表示长度
    s1.replace(6,5,"girl");                    // 结果：hello,girl.
    // s1.begin(),s1.begin()+5 是左闭右开区间
    s1.replace(s1.begin(),s1.begin()+5,"boy"); // 结果：boy,girl.
    cout<<s1<<endl;
}
 
九、 string的大小写转换：tolower()和toupper()函数 或者 STL中的transform算法
 
 
方法一：使用C语言之前的方法，使用函数，进行转换
 
#include <iostream>
#include <string>
using namespace std;

int main()
{
    string s = "ABCDEFG";

    for( int i = 0; i < s.size(); i++ )
    {
        s[i] = tolower(s[i]);
    }

    cout<<s<<endl;
    return 0;
}
 
方法二：通过STL的transform算法配合的toupper和tolower来实现该功能
 
#include <iostream>
#include <algorithm>
#include <string>

using namespace std;

int main()
{
    string s = "ABCDEFG";
    string result;

    transform(s.begin(),s.end(),s.begin(),::tolower);
    cout<<s<<endl;
    return 0;
}
 
相关的我的另外一篇博客： 
 C++对string进行大小写转换 
 https://blog.csdn.net/qq_37941471/article/details/81988702
 
十、 string的查找：find
 
 
1. size_t find (constchar* s, size_t pos = 0) const;

  //在当前字符串的pos索引位置开始，查找子串s，返回找到的位置索引，

    -1表示查找不到子串

2. size_t find (charc, size_t pos = 0) const;

  //在当前字符串的pos索引位置开始，查找字符c，返回找到的位置索引，

    -1表示查找不到字符

3. size_t rfind (constchar* s, size_t pos = npos) const;

  //在当前字符串的pos索引位置开始，反向查找子串s，返回找到的位置索引，

    -1表示查找不到子串

4. size_t rfind (charc, size_t pos = npos) const;

  //在当前字符串的pos索引位置开始，反向查找字符c，返回找到的位置索引，-1表示查找不到字符

5. size_tfind_first_of (const char* s, size_t pos = 0) const;

  //在当前字符串的pos索引位置开始，查找子串s的字符，返回找到的位置索引，-1表示查找不到字符

6. size_tfind_first_not_of (const char* s, size_t pos = 0) const;

  //在当前字符串的pos索引位置开始，查找第一个不位于子串s的字符，返回找到的位置索引，-1表示查找不到字符

7. size_t find_last_of(const char* s, size_t pos = npos) const;

  //在当前字符串的pos索引位置开始，查找最后一个位于子串s的字符，返回找到的位置索引，-1表示查找不到字符

8. size_tfind_last_not_of (const char* s, size_t pos = npos) const;

 //在当前字符串的pos索引位置开始，查找最后一个不位于子串s的字符，返回找到的位置索引，-1表示查找不到子串
 
void test8()
{
    string s("dog bird chicken bird cat");

    //字符串查找-----找到后返回首字母在字符串中的下标

    // 1. 查找一个字符串
    cout << s.find("chicken") << endl;        // 结果是：9

    // 2. 从下标为6开始找字符'i'，返回找到的第一个i的下标
    cout << s.find('i',6) << endl;            // 结果是：11

    // 3. 从字符串的末尾开始查找字符串，返回的还是首字母在字符串中的下标
    cout << s.rfind("chicken") << endl;       // 结果是：9

    // 4. 从字符串的末尾开始查找字符
    cout << s.rfind('i') << endl;             // 结果是：18-------因为是从末尾开始查找，所以返回第一次找到的字符

    // 5. 在该字符串中查找第一个属于字符串s的字符
    cout << s.find_first_of("13br98") << endl;  // 结果是：4---b

    // 6. 在该字符串中查找第一个不属于字符串s的字符------先匹配dog，然后bird匹配不到，所以打印4
    cout << s.find_first_not_of("hello dog 2006") << endl; // 结果是：4
    cout << s.find_first_not_of("dog bird 2006") << endl;  // 结果是：9

    // 7. 在该字符串最后中查找第一个属于字符串s的字符
    cout << s.find_last_of("13r98") << endl;               // 结果是：19

    // 8. 在该字符串最后中查找第一个不属于字符串s的字符------先匹配t--a---c，然后空格匹配不到，所以打印21
    cout << s.find_last_not_of("teac") << endl;            // 结果是：21

}
 
十一、 string的排序：sort(s.begin(),s.end())
 
 
#include <iostream>
#include <algorithm>
#include <string>
using namespace std;

void test9()
{
    string s = "cdefba";
    sort(s.begin(),s.end());
    cout<<"s:"<<s<<endl;     // 结果：abcdef
}
 
十二、 string的分割/截取字符串：strtok() & substr()
 
 
strtok():分割字符串
 
void test10()
{
    char str[] = "I,am,a,student; hello world!";

    const char *split = ",; !";
    char *p2 = strtok(str,split);
    while( p2 != NULL )
    {
        cout<<p2<<endl;
        p2 = strtok(NULL,split);
    }
}
 
 
void test11()
{
    string s1("0123456789");
    string s2 = s1.substr(2,5); // 结果：23456-----参数5表示：截取的字符串的长度
    cout<<s2<<endl;
}

  

   
字符串函数
   
strlen：获取字符串长度，字节长度
   
substr_count 某字符串出现的次数
   
substr：字符串截取，获取字符串（按照字节进行截取）
   
mb_strlenmb_substr
   
strchr：与substr相似，从指定位置截取一直到最后
   
strrchr（获取文件后缀名）：与strchr一样，只是从右边开始查找字符
   
strtolower：所有的字符都小写（针对英文字母）
   
strtoupper：所有的字符都大写
   
strrev：字符串反转（只能反转英文：英文存储只有一个字节），按照字节进行反转
   
strpos：从字符串中找对应字符出现的位置（数字下标），从最左边开始找
   
strrpos：与strpos一样，只是从字符串的右边开始找
   
trim：去掉函数两边的字符，默认是空格
   
str_split 函数把字符串分割到数组中。
   
chunk_split() 函数把字符串分割为一连串更小的部分
   
str_repeat("Shanghai",5);把字符串 "Shanghai " 重复 5 次 
   
str_replace('\\', '/', dirname(__DIR__))); 替换
   
ucfirst 首字母大写
  

  

   2
  
  

   
时间日期函数
   
time：得到当前时间的时间戳（整型：从格林威治时间1970年1月1日0时0分0秒开始）秒数
   
date：时间序列化函数，将指定的时间戳转换成规定时间日期的显示格式（随意的字符串：有专业的格式符规定），如果没有指定时间戳，系统默认使用当前时间的时间戳
   
strtotime：时间日期格式的字符串转换成对应的时间戳（只要是正确的英语时间表达方式，都可以进行转换）
   
microtime：微秒时间戳，根据不同的要求返回不同的结果 混合 microtime (布尔类型 )，可以返回一个浮点数的时间，也可以返回一个数组（时间戳和微秒数）
  

  

  

   
数学相关函数
   
abs：绝对值
   
floor：向下取整 floor(3.2) 结果等于3
   
ceil：向上取整
   
round：四舍五入
   
rand：取得一个指定范围内的随机整数
   
mt_rand：取得一个指定范围内的随机整数（效率更高）
   
min:PHP 会将非数值的 string 当成 0，但如果这个正是最小的数值则仍然会返回一个字符串。如果多个参数都求值为 0 且是最小值，min() 会返回按字母表顺序最小的字符串，如果其中没有字符串的话，则返回数值的 0;
   
max:PHP 会将非数值的字符串当成 0，但如果这个正是最大的数值则仍然会返回一个字符串。如果多个参数都求值为 0 且是最大值，max() 会返回其中数值的 0，如果参数中没有数值的 0，则返回按字母表顺序最大的字符串。对于多个数组,max从左到右比较;如果同时出现数组和非数组参数总把数组作为最大值返回;
  

  

  

   
数组相关函数
   
count() // 非数组返回1
   
key：获取当前数组当前指针所指向的元素的下标
   
current：获取的当前指针指向元素的数值
   
next：获取下一个元素的值，并且将指针下移
   
prev：获取上一个元素的值，并且将指针上移
   
end ：将指针移到数组的最后一个元素，并返回最终指针位置的值
   
reset：将指针移到数组的第一个元素，返回最终指针位置的值
   
array_keys：获取一个数组的所有键名，返回一个索引数组
   
array_values：获取一个数组的所有值，返回一个索引数组
   
explode：爆炸，将一个字符串按照某个指定的规则（通常是特殊字符），将数组分成多个段，每一段都当做一个数组的元素，返回一个索引数组
   
split 类似 explode  explode('.', 'abc.txt')等于split('\.','abc.txt')
   
implode：粘合，将一个数组内部的所有元素按照某个指定的规则（特殊字符），将所有的元素拼接成一个字符串
   
join()  把数组元素组合为一个字符串
   
array_merge：合并，指的是将两个数组中的元素进行累计。如果后面的数组与前面的数组有下标（键名：关联）相同的，那么后面的元素的值会覆盖前面的；如果是索引的相同下标，会自动的修改下标叠加到前面的数组里。
   
array_reverse — 返回反转后的数组
   
array_flip — 交换数组中的键和值
  

  

  

   
数据结构模拟函数
   
array_shift：从数组的前面弹出元素，得到元素的值
   
array_pop：从数组的后面弹出元素，获得元素的值
   
array_unshift：从数组的前面压入元素，得到当前数组元素的个数
   
array_push：从数组的后面压入元素，得到当前数组元素的个数
  

  

  

   
判断变量
   
is_bool：判断是否是布尔类型
   
is_float：判断浮点型
   
is_integer：判断整型
   
is_object：判断对象
   
is_array：判断数组
   
is_string：判断字符串
   
is_resource：判断资源
   
is_scalar：scalar是标量的，判断是基本数据类型：整型，浮点型，布尔型和字符串型
   
is_null 检测变量是否为NULL 是返回TRUE 否则返回false。1.被赋值为NULL;2.变量没被赋值;3.被unset()
   
 
   
is_numeric：判断数字或者纯数字组成的字符串
   
gettype：获得数据类型
   
settype：改变数据类型
   

   
isset
   
unset() 如果在函数中 unset() 一个全局变量，则只是局部变量被销毁，而在调用环境中的变量将保持调用 unset() 之前一样的值,如果在函数中 unset() 一个通过引用传递的变量，则只是局部变量被销毁，而在调用环境中的变量将保持调用 unset() 之前一样的值。empty//array(),"",0,"0",NULL,FALSE 都返回true
  

  

  

   
文件操作函数
   
opendir(路径)：打开一个路径资源（将路径内部的所有数据读入到内存）
   
readdir(路径资源)：从文件夹资源中读取当前资源指针所指向的文件的名字，指针会向下移动一位
   
closedir(资源)：释放对应的文件资源
   
scandir(路径)：读取一个路径内部的所有文件名，返回一个数组，数组的每一个元素都是文件名。
   
file_exists：判断一个文件是否存在（文件是广义：路径和文件）
   
is_dir：判断一个指定路径是否存在（文件夹）
   
is_file：判断一个指定路径是否是文件（文件）
   
mkdir：创建一个路径，如果路径存在就会报错
   
rmdir：移除文件夹
   
file_get_contents：从一个指定的文件内读取数据内容。
   
file_put_contents：将指定的字符串写入到对应的文件
   
fopen：打开一个文件资源
   
fgetc：c代表character，一次读取一个字符
   
fgets：s代表string，代表可以读取多个字符，取决于指定的读取长度或者是否碰到换行（最多只能读取一行数据）
   
两个函数都是对当前资源指针进行操作，读取之后都会将指针下移
   
fread：获取指定长度的数据直到文件结束
   
fwrite：向文件资源指针所在的位置写入数据，写东西不会将当前位置已有的东西往后移，而是会覆盖
   
fseek：将指针指定到对应的位置
   
fclose：使用对应的文件资源
   
copy：复制
   
unlink：删除文件
   
rename：重命名文件
   
filemtime：m代表modify，文件最后被修改的时间
   
filesize：文件大小（字节）
   
fileperms：文件权限（Linux下的八进制）
  

  

  

   
排序
   
rsort() 函数用于对数组单元从高到低进行排序。asort() 函数用于对数组单元从低到高进行排序并保持索引关系。arsort() 函数用于对数组单元从高到低进行排序并保持索引关系。ksort() 函数用于对数组单元按照键名从低到高进行排序。krsort() 函数用于对数组单元按照键名从高到低进行排序。
  

  

  

   
报错
   
error_reporting(E_ALL)
   
ini_set('display_errors', 1)
  

  

  

   
常量
   
define() 定义常量defined() 检测常量是否定义
  

  

  

   
序列化
   
serialize
   
unserialize
   
json_encode 对变量进行 JSON 编码 
   
json_decode  对JSON 格式的字符串进行编码
  

  

  

   
编码
   
base64_encode 本函数将字符串以 MIME BASE64 编码。在 BASE64 编码后的字符串只包含英文字母大小写、阿拉伯数字、加号与反斜线，共 64 个基本字符，不包含其它特殊的字符，因而才取名 BASE64。
   
base64_decode 解码