1229-方法引用(简化lambda)-stream流-单元测试-单例模式

方法引用
stream流
单元测试（junit）
单例模式

方法引用

概念：对特殊的lambda简化的一种语法

使用时机：（）-> {lambda体}

特殊的lambda：当lambda体只有1句代码，并且这句代码是在调用一个方法

java中的方法：

构造方法：new 构造方法()

实例方法:对象名.方法名（）

类方法（静态方法）：类名.方法名（）

构造方法的方法引用的语法：类名 :: new（简化lambda调用构造方法）

java 复制代码

/**
 * Dog类
 */
public class Dog {  
    private String name;
    private Integer age;

    public Dog() {
    }

    public Dog(String name, Integer age) {
        this.name = name;
        this.age = age;
    }
}
/**
 * 创建Dog对象的接口
 */
public interface IFacotryDog {
    Dog create(String name,Integer age);
}

// 创建IFacotryDog对象的方法
		IFacotryDog ifd = (name,age) -> new Dog(name,age); // 创建函数接口对象
		Dog d = ifd.create("小可爱", 3);
        System.out.println(d);

		// 上面代码中lambda,可以使用构造方法的引用来简化
        // 创建IFacotryDog对象
        IFacotryDog ifd2 = Dog::new; // 类名：调用构造方法的类名::new
        Dog d2 = ifd2.create("老可爱", 3);
        System.out.println(d2);

类方法的方法引用的语法：类名（调用方法存放的类) :: 方法名（要调用的方法名）

java 复制代码

/**
 * 设计一个函数式接口
 */
public interface IChangeStringNumber {
    int change(String number);
}

// 创建函数式接口IChangeStringNumber对象
        IChangeStringNumber  icsn = n -> Integer.parseInt(n);
        int num = icsn.change("123");
        System.out.println(num);
        
// 上面代码中lambda是在调用一个类方法，使用类方法引用来简化：类名::方法       
        IChangeStringNumber icsn2 = Integer::parseInt;
        icsn2.change("123");

实例方法的方法引用的语法: 对象 :: 方法名 实例方法Get Set方法可以直接用类名调用，这是特殊情况

java 复制代码

/**
 * 设计一个函数式接口
 */
public interface IIsAvi {
    boolean isAvi(String filename);

}

// 创建IIsAvi对象
        IIsAvi avi = fn -> fn.endsWith(".avi"); // 创建函数式接口的对象
        boolean temp = avi.isAvi("蘋蘋在某酒店学习外语.png");
        System.out.println(temp);

        // lambda在调用一个实例方法，用实例方法引用来简化：对象::方法名

        String f = "xxxx.txt";
        IIsAvi avi2 = f::endsWith; // 实例方法的引用
        boolean avi1 = avi2.isAvi(f);
        System.out.println(avi1);

        // 遍历集合
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
//        PrintStream ps = System.out;
//        list.forEach(a -> ps.println(a));
        list.forEach(System.out::println);

小结：

方法引用：简化特殊lambda

构造方法引用：类名 :: new

实例的方法的引用：对象名 :: 方法名

类方法的方法引用：类名 :: 方法名

Stream流

概念：Stream是操作数组或者集合的流（相比IO流，IO流是操作文件流）

注意：Stream只操作数据，不保存数据

创建Steam流的三种方式：

java 复制代码

// 1、创建Stream
        // 1）、通过Arrays 
        int[] arrs = {1,3,5,7,9};
        IntStream sm = Arrays.stream(arrs);// 通过arrs数组创建Stream
        // sm是Stream流对象，sm操作的数据源是arrs

        // 2)、通过集合对象
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 56);
        Stream<Integer> sm2 = list.stream(); // 创建Stream对象
        
        // 3)、Stream里面的of方法
        Stream<Integer> sm3 = Stream.of(1, 2, 3, 4, 5, 6);

操作流的方法

Stream流的操作步骤：

1）、创建流对象（指定流操作数据源）

2）、操作流：过滤，截取，跳过，去重，排序，切片

3）、结束流：遍历、收集、统计

filter(过滤的条件：函数式接口)：将不满足条件的数据过滤掉 filter(Predicate<? super T> predicate)`

java 复制代码

stream.filter(a -> a % 2 == 0)  // Predicate：断言型的接口

limit(long 数字)：截取流里面多个数据，限制流里面显示的条数

java 复制代码

stream.limit(2L) // 截取前面2个元素，限制流里面显示的条数
stream.limit(6L) // 截取前面6个元素

skip(long n)：跳过几条

java 复制代码

stream.skip(2L) // 跳过前两条

distinct( ) 去重

java 复制代码

stream.distinct() // 去除重复数据

sorted(Comparator<? super T> comparator)：排序进行排序数据必须实现Comparator

java 复制代码

stream.sorted((o1, o2) -> o2 - o1)    // 默认是升序

map():切片（给你一种类型，变为另一种类型） map(Function<? super T,? extends R> mapper) 函数型接口

java 复制代码

// 将字符串变成int
String str = "12,34,67,5,90,23,4,67,8,9";
String[] split = str.split(",");
Stream<String> stream = Arrays.stream(split); // 创建流
    // 将字符串变成int
long count = stream
 			.map(Integer::parseInt) // Function,将a由String转换int  由.map(a -> integer.parseInt(a))

concat(Stream<? extends T> a, Stream<? extends T> b) 将两个流连在一起

java 复制代码

Stream.concat(manlist.stream(), womanList.stream())

结束流

collect():收集
collect(Collectors.toList()); // 将结果收集为一个集和

java 复制代码

Stream.collect(Collectors.tolist())  // 将收集的内容变成一个集合

count():统计个数

java 复制代码

Stream.count  // 统计流中的个数

Stream流的分类

1、串行流：单线程使用（使用最多）

2、并行流：多线程使用

java 复制代码

// 创建一个串行流
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
  Stream<Integer> stream = list.stream();// 创建的串行流
  stream.forEach(System.out::println);

// 并行流
Stream<Integer> integerStream = list.parallelStream();   方法parallelStream
integerStream.forEach(System.out::println);

小结stream流

小结Stream流

Stream流的分类

1、串行流：单线程使用（使用最多）

2、并行流：多线程使用

1、创建流

Arrays.stream（数组）

集合对象.stream()

Stream.of(可变参数)

2、流操作的方法：

filter（）

limit()

skip()

sorted()

distinct()

map()

3、流结束的方法

forEach()

collect()

count()

单元测试

测试：检查代码有没有bug

黑盒测试：不看代码结构，只看结果

白盒测试：必须要看代码

灰盒测试：能看一部分代码

上面的测试是专业人员弄的
单元测试：测试自己写方法，程序员自己测

使用main方法来做，每一个方法只有一个main,测试很不方便

使用单元测试来代替main

java 复制代码

/**
 * 使用单元测试
 *  需要使用一个@Test的注解
 *  第一次使用需要导包
 */
public class TestCase {
    @Test // 单元测试的注解
    // 单元测试的方法，不能有返回值，可以抛出Exception
    public void testDemo1() throws Exception {
        System.out.println("这个单元测试1");
    }
    @Test
    public void testDemo2() throws Exception {

        System.out.println("这个单元测试2");
    }
    @Test
    public void testDemo3() throws Exception {

        System.out.println("这个单元测试3");
    }
    // 在测试方法代码冗余（重复的代码）
    @Before // 在每个测试方法执行之前要执行方法
    public void before() throws Exception {
        System.out.println("hello");
    }

    @After
    public void after() throws  Exception {
        System.out.println("用来释放锁，关闭流");
    }


}

单例模式

概念：一个类就是只有一个对象，那么就是单例，将一个类设计成单例的方式就是单例模式

怎样将一个类设计为单例

1、私有构造方法

2、在当前类创建对象

3、在该类设计一个类方法，返回这个对象

饿汉模式：

java 复制代码

/**
 * 将Dog设计为单例:也叫(饿汉模式)
 */
public class Dog {
     // 省略属性
    // 2、创建对象
    private static Dog d = new Dog(); // 不管这个对象用不用，在内存中存在
  
    // 1、私有化构造方法
    private Dog() {}

    // 3、设计一个类方法，返回创建的对象
    public static Dog getInstance() {
        return d;
    }
}

public class SingletonDemo {
    public static void main(String[] args) {
        Dog d1 = Dog.getInstance();
        System.out.println(d1);
        Dog d2 = Dog.getInstance();
        System.out.println(d2);
        Dog d3 = Dog.getInstance();
        System.out.println(d3);
        // 以上指向的都是同一个地址
    }
}

懒汉模式：**

枚举模式：**