day14_0710课堂笔记

day0710课堂笔记

1、回顾

• 容器中最常使用ArrayLList和HashMap

• 如何控制HashMap的线程安全问题

  使用HashTable（通过synchronized关键字控制线程安全）

  使用Collections工具类的方法

  ​ static <K,V> Map<K,V> synchronizedMap(Map<K,V> m)

  juc包下的ConcurretHashMap（推荐使用）

2、Properties

• key和value都是String类型

• Properties是线程安全的

• 现常用作配置文件

• 方法：setPropertry（String s）存

  ​ getPropertry（String s）取

  package com.wse.properties01;
  
  import java.io.IOException;
  import java.util.Properties;
  
  public class PropertiesDemo01 {
      public static void main(String[] args) throws IOException {
          Properties pr = new Properties();
          pr.load(Thread.currentThread().getContextClassLoader().getResourceAsStream("bd/bd.properties"));
          System.out.println(pr.getProperty("username"));
          System.out.println(pr.getProperty("password"));
      }
  }
  
  

3、Collections工具类

package com.wse.collections02;

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 CollectionsDemo02 {
    public static void main(String[] args) {

        //创建容器
        List<String> l = new ArrayList<>();
        //添加数据
        l.add("a");
        l.add("b");
        l.add("d");
        l.add("c");
        //打印容器
        System.out.println(l);//[a, b, d, c]
        //static <T extends Comparable<? super T>> void sort(List<T> list) 进行排序
        Collections.sort(l);
        //打印容器
        System.out.println(l);//[a, b, c, d]

        //void fill(List, Object) //用一个特定的对象重写整个 List 容器
        //Collections.fill(l,"aaa");
        //System.out.println(l);//[aaa, aaa, aaa, aaa]


        //void reverse(List) //对 List 容器内的元素进行逆续排列
        Collections.reverse(l);
        System.out.println(l);//[d, c, b, a]


        //void shuffle(List) //对 List 容器内的元素进行随机排列
        Collections.shuffle(l);
        System.out.println(l);//[c, a, b, d]

        Collections.sort(l);//[a, b, c, d
        //int binarySearch(List, Object)//采用折半查找的方法查找特定对象
        //  	要求使用前先升序排序
        int c = Collections.binarySearch(l, "c");
        System.out.println(c);




    }
}

4、Java8提供的函数式接口

package com.wse.function04;

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) {

        //测试消费型接口
        happy(11111, (integer) -> {
            System.out.println("打赏" + integer + "圆");
        });//打赏11111圆

        //测试函数式接口
        System.out.println(string("aaa", (s) -> s.toUpperCase()));//AAA

        //测试供给型接口，产生10个, 1~10之间的随机数返回
        List<Integer> list = sup(10, () -> (int) (Math.random() * (10 - 1 + 1) + 1));
        System.out.println(list);

        //测试断言式接口
        List<String> list1 = new ArrayList<>();
        list1.add("qaaa");
        list1.add("qa");
        list1.add("qaafa");
        list1.add("qaafy");
        List<String> list2 = pd(list1, (s) -> s.length() > 3);
        System.out.println(list2);
    }

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

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

    //供给型接口
    //指定规则,指定个数,产生满足条件个数的数字返回
    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> pd(List<String> list, Predicate<String> predicate) {
        //创建新的接收数组
        List<String> newList = new ArrayList<>();
        //遍历原数组
        for (String s : list) {
            //将元素传入断言式接口，判断结果，结果为true，字符个数大于3，则将数据添加到新数组中
            if (predicate.test(s)) {
                newList.add(s);
            }
        }
        //返回新数组
        return newList;
    }


}

5、方法引用

package com.wse.function04;

import java.util.ArrayList;
import java.util.List;
import java.util.function.BiFunction;
import java.util.function.BiPredicate;

/**
 *  方法引用: 简化Lambda-->Lambda表达式特殊的一种表现形式
 *        当lambda体中的实现是通过调用另外一个方法实现的时候,这个方法的参数列表和返回值类型与抽象方法的参数列表与返回值一致的时候,
 *        就可以使用方法引用进行代替
 *
 *     方法引用
 *        引用::成员方法名
 *        类名::静态方法名
 *        类名::成员方法名
 *
 *     构造器引用
 *        类名::new
 */
public class FunctionDemo02 {
    public static void main(String[] args) {
        List<String> list = new ArrayList();
        list.add("123");
        list.add("12");
        list.add("1");

        //forEach遍历集合
        list.forEach((o)->{
            System.out.println(o);
        });//

        //引用::成员方法名
        //Lambda体实现的功能就是打印参数-->可以通过方法引用来代替
        //通过PrintStream这个类型  的对象调用println实现的,Lambda的抽象方法的参数做为println方法的参数,都没有返回值
        list.forEach(System.out::println);

        //类名::静态方法名
        //比较2个double参数,返回最大的
        //2个参数 1个返回值  BiFunction
        //lambda的实现求2个参数的最大值是通过调用另外一个方法实现的,并且抽象方法的参数作为内部引用的方法的参数,引用方法的返回值作为抽象方法的返回值-->方法引用
        BiFunction<Double, Double,Double> biFunction = Math::max;

        System.out.println(biFunction.apply(111.2,222.2));

        //类名::成员方法名
        //比较2个字符串是否相等  2个字符串参数  布尔类型
        //1)lambda是否是通过引用另外一个方法实现的->是  2)返回值匹配  3)抽象方法第一个参数s1作为内部引用另一个方法的对象存在,如果抽象方法存在多个参数,第二个参数开始匹配内部引用的方法的参数列表-->方法引用
        BiPredicate<String,String> biPredicate = String::equals;
        System.out.println(biPredicate.test("a","ba"));//false
    }
}