java -- Collections和四大内置函数型接口

Properties

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

public class PropertiesDemo01 {
	public static void main(String[] args) throws IOException {
		Properties pro = new Properties();
		
		//void load(InputStream inStream)     从输入流中读取属性列表（键和元素对）。 
		pro.load(Thread.currentThread().getContextClassLoader().getResourceAsStream("db.properties"));
		
		//根据key获取value  String getProperty(String key) 用指定的键在此属性列表中搜索属性。 
		System.out.println(pro.getProperty("username"));
		System.out.println(pro.getProperty("userpwd"));
	}
}

Collections

常用方法

package day14;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/*Collections
 * void sort(List) //对 List 容器内的元素排序,按照升序进行排序。
 * 	容器中存放的是自定义引用数据类型的数据,需要自己通过内部外部比较器指定比较规则
 * void shuffle(List) //对 List 容器内的元素进行随机排列
 * void reverse(List) //对 List 容器内的元素进行逆续排列
 * void fill(List, Object) //用一个特定的对象重写整个 List 容器
 * int binarySearch(List, Object)//采用折半查找的方法查找特定对象
 * 	要求使用前先升序排序
 */
public class CollectionsDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList();
        list.add("abc");
        list.add("bc");
        list.add("ab");
        list.add("a");
        list.add("ac");

        System.out.println(list);
        //fill()
        //Collections.fill(list, "haha");

        //reverse()
        //Collections.reverse(list);

        //shuffle()
        //Collections.shuffle(list);

        //sort()
        Collections.sort(list);
        System.out.println(list);

        List<User> list2 = new ArrayList();
        list2.add(new User("zhang",123));
        list2.add(new User("li",3));
        list2.add(new User("wang",2));

        System.out.println(list2);
        Collections.sort(list2);
        System.out.println(list2);

        //指定使用外部比较器 static <T> void sort(List<T> list, Comparator<? super T> c)
        Collections.sort(list2,(o1,o2)-> o1.getPwd() - o2.getPwd());
        System.out.println(list2);


        //binarySearch()
        System.out.println(list);
        System.out.println(Collections.binarySearch(list, "ab"));
    }
}

class User implements Comparable<User>{
    private String name;
    private int pwd;

    public User() {
       
    }

    public User(String name, int pwd) {
        super();
        this.name = name;
        this.pwd = pwd;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getPwd() {
        return pwd;
    }

    public void setPwd(int pwd) {
        this.pwd = pwd;
    }

    @Override
    public String toString() {
        return "User [name=" + name + ", pwd=" + pwd + "]";
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        result = prime * result + pwd;
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        User other = (User) obj;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        if (pwd != other.pwd)
            return false;
        return true;
    }
    @Override
    public int compareTo(User o) {
        return this.name.compareTo(o.name);
    }
}

java8 四大内置函数型接口

Consumer< T > 消费性接口（有来无回）

	//测试消费性接口
	public static void happy(int money,Consumer<Integer> com) {
		com.accept(money);
	}

public static void main(String[] args) {
    //今天给主播打赏1万块  托马斯
	happy(10000,(i)->System.out.println("今天给主播打赏"+i+"块  托马斯"));
}

Predicate < T > 段言型

//对一个字符串容器中的数据进行判断过滤,过滤条件:如果字符个数>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 void main(String[] args) {
    //如果字符个数>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);
}

Function<T,R> 函数型接口

//函数型接口
	//可以对某个字符串,进行某种操作,结果返回
	public static String strHandler(String str,Function<String,String> my) {
		return my.apply(str);
	}

public static void main(String[] args) {
    //去前后空格
	System.out.println(strHandler("	hahah  ", (s)->s.trim()));;
}

Supplier 供给型接口

//供给型接口使用 
	//指定规则,指定个数,产生满足条件个数的数字返回
	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;
	}

public static void main(String[] args) {
    //产生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);
		}
}

方法引用

简化Lambda–>Lambda表达式特殊的一种表现形式

当lambda体中的实现是通过调用另外一个方法实现的时候,这个方法的参数列表和返回值类型与抽象方法的参数列表与返回值一致的时候,就可以使用方法引用进行代替

方法引用

• 引用::成员方法名
• 类名::静态方法名
• 类名::成员方法名

构造器引用

• 类名::new

package com.xxxx.function04;

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));
		 
	}	
}