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

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

方法引用

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

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

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

java中的方法：

构造方法：new 构造方法()
实例方法:对象名.方法名（）
类方法（静态方法）：类名.方法名（）

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

/*** 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; // 类名：调用构造方法的类名::newDog d2 = ifd2.create("老可爱", 3);System.out.println(d2);

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

/*** 设计一个函数式接口*/
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方法可以直接用类名调用，这是特殊情况

/*** 设计一个函数式接口*/
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流的三种方式：

// 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)`

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

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

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

skip(long n)：跳过几条

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

distinct( ) 去重

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

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

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

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

// 将字符串变成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) 将两个流连在一起

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

结束流

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

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

count():统计个数

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

Stream流的分类

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

2、并行流：多线程使用

// 创建一个串行流
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

/*** 使用单元测试*  需要使用一个@Test的注解*  第一次使用需要导包*/
public class TestCase {@Test // 单元测试的注解// 单元测试的方法，不能有返回值，可以抛出Exceptionpublic void testDemo1() throws Exception {System.out.println("这个单元测试1");}@Testpublic void testDemo2() throws Exception {System.out.println("这个单元测试2");}@Testpublic void testDemo3() throws Exception {System.out.println("这个单元测试3");}// 在测试方法代码冗余（重复的代码）@Before // 在每个测试方法执行之前要执行方法public void before() throws Exception {System.out.println("hello");}@Afterpublic void after() throws  Exception {System.out.println("用来释放锁，关闭流");}}

单例模式

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

怎样将一个类设计为单例

1、私有构造方法
2、在当前类创建对象
3、在该类设计一个类方法，返回这个对象

饿汉模式：

/*** 将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);// 以上指向的都是同一个地址}
}