properties Collections工具类，四大内置函数型接口方法引用

Properties

Properties为Hashtable的子类，要求键与值只能为字符串 ，不能为null，长与 配置文件(与外界交互 的信息)
即内存与存储介质(文件、数据库、网络、服务器内存等)交互。

** 在资源文件中建立 .properties文件**
在properties文件中以键值对的方式存储
例如：

username = zhansan
pwd = 123456

//加载properties文件
Properties properties = new Properties();
properties.load(Thread.currentThread().getContextClassLoader().getResourceAsStream("db.properties"));

//通过以下方式获取 key-value
properties.getProperty("username")

Collections工具类

类 java.util.Collections 提供了对容器操作的工具方法，与 Arrays 使用差不多。

常用方法

void sort(List) //对 List 容器内的元素排序,按照升序进行排序。 
void shuffle(List) //对 List 容器内的元素进行随机排列 
void reverse(List) //对 List 容器内的元素进行逆续排列 
void fill(List, Object) //用一个特定的对象重写整个 List 容器 
int binarySearch(List, Object)//采用折半查找的方法查找特定对象

例如：

List aList = new ArrayList(); 
for (int i = 0; i < 5; i++) 
	aList.add("a" + i);
 	System.out.println(aList); 	
 	Collections.shuffle(aList); // 随机排列   
 	System.out.println(aList);
 	Collections.reverse(aList); // 逆续
 	System.out.println(aList); 
 	Collections.sort(aList); // 排序 
 	System.out.println(aList); 
 	System.out.println(Collections.binarySearch(aList, "a2")); 
 	Collections.fill(aList, "hello"); 
 	System.out.println(aList);

四大内置函数型接口

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

/**
 *  四大内置函数型接口
 *  Consumer<T> 消费性接口 (有来无回)
 * 			void accept(T t)  
 *  Predicate<T>  段言型
 *  		boolean test(T t)  
 *	Function<T,R> 函数型接口
 *			R apply(T t)  
 *  Supplier 供给型接口
 *  		T get()  
 *
 */
public class FunctionDemo01 {
	public static void main(String[] args) {
		//今天给主播打赏1万块  托马斯
		happy(10000,(i)->System.out.println("今天给主播打赏"+i+"块  托马斯"));
		//去前后空格
		System.out.println(strHandler("	hahah  ", (s)->s.trim()));;
		
		//如果字符个数>3,就放入新容器中返回
		List<String> list = new ArrayList();
		list.add("123");
		list.add("12");
		list.add("1");
		list.add("1234");
		list.add("12345");
		List<String> list2 = predicateString(list,(s)->s.length()>3);
		System.out.println(list2);
		
		//产生10个, 1~10之间的随机数返回
		List<Integer> list3 = sup(10,()->(int)(Math.random()*(10-1+1)+1));
		System.out.println(list3);
		
		list3.forEach((i)->{System.out.println(i);});
		
		for(Integer  i:list3) {
			System.out.println(i);
		}
	}
	
	//供给型接口使用 
	//指定规则,指定个数,产生满足条件个数的数字返回
	public static List<Integer> sup(int num,Supplier<Integer> supplier){
		List<Integer> newList = new ArrayList();
		for(int i=1;i<=num;i++) {
			newList.add(supplier.get());
		}
		
		return newList;
	}
	
	//对一个字符串容器中的数据进行判断过滤,过滤条件:如果字符个数>3,就放入新容器中返回
	public static List<String> predicateString(List<String> list,Predicate<String> pre){
		//存放满足条件的字符串
		List<String> newList = new ArrayList();
		//遍历容器 拿出每一个字符串进行判断
		for(String str:list) {
			if(pre.test(str)) {
				newList.add(str);
			}
		}
		//满足条件的放入集合
		return newList;
	}
	
	
	//函数型接口
	//可以对某个字符串,进行某种操作,结果返回
	public static String strHandler(String str,Function<String,String> my) {
		return my.apply(str);
	}
	
	
	
	//测试消费性接口
	public static void happy(int money,Consumer<Integer> com) {
		com.accept(money);
	}
}

方法引用符 ::

双冒号::为引用运算符，而它所在的表达式被称为方法引用。如果Lambda要表达的函数方案已经存在于某个方法的实现中，那么则可以通过双冒号来引用该方法作为Lambda的替代者。

import java.io.PrintStream;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.function.BiFunction;
import java.util.function.BiPredicate;
import java.util.function.Function;
import java.util.function.Supplier;

import com.xxxx.bean.Employee;

/*
 *	 方法引用: 简化Lambda-->Lambda表达式特殊的一种表现形式
 * 		当lambda体中的实现是通过调用另外一个方法实现的时候,这个方法的参数列表和返回值类型与抽象方法的参数列表与返回值一致的时候,就可以使用方法引用进行代替
 * 
 *  	方法引用
 *  		引用::成员方法名  		
 *  		类名::静态方法名
 *  		类名::成员方法名
 *  
 *  	构造器引用
 *  		类名::new
 */
public class FunctionQ02 {
	public static void main(String[] args) {
		List<String> list = new ArrayList();
		list.add("123");
		list.add("12");
		list.add("1");
		
		//引用::成员方法名
		//遍历容器,打印里面的每一个数据
		list.forEach((o)->{System.out.println(o);});
		//Lambda体实现的功能就是打印参数-->可以通过方法引用来代替
		//通过PrintStream这个类型  的对象调用println实现的,Lambda的抽象方法的参数做为println方法的参数,都没有返回值
		PrintStream ps = System.out;
		list.forEach(ps::println);
		list.forEach(System.out::println);
		
		
		//类名::静态方法名
		//比较2个double参数,返回最大的
		//2个参数 1个返回值  BiFunction
		BiFunction<Double,Double,Double> bi = (b1,b2)->Math.max(b1,b2);
		//lambda的实现求2个参数的最大值是通过调用另外一个方法实现的,并且抽象方法的参数作为内部引用的方法的参数,引用方法的返回值作为抽象方法的返回值-->方法引用
		bi = Math::max;
		System.out.println(bi.apply(100.0, 200.0));
		
		//比较2个int类型的参数
		Comparator<Integer> com = (i1,i2)->Integer.compare(i1, i2);
		com = Integer::compare;
		
		//类名::成员方法名
		//比较2个字符串是否相等  2个字符串参数  布尔类型
		BiPredicate<String,String> pre = (s1,s2)->s1.equals(s2);
		//1)lambda是否是通过引用另外一个方法实现的->是  2)返回值匹配  3)抽象方法第一个参数s1作为内部引用另一个方法的对象存在,如果抽象方法存在多个参数,第二个参数开始匹配内部引用的方法的参数列表-->方法引用
		pre =String::equals;
		System.out.println(pre.test("zhangsan", "zhangsan1"));
		
		//供给型 
		Employee e = new Employee("熊大",5);
		Supplier<String> sup = ()->e.getName();
		sup = e::getName;  //对象固定  
		System.out.println("名字为="+sup.get());;
		
		Function<Employee,String> func =Employee::getName;
		System.out.println(func.apply(e));
		 
	}
	
}