方法引用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; // 类名：调用构造方法的类名::new
Dog 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
// 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
Stream
// 3)、Stream里面的of方法
Stream
操作流的方法
Stream流的操作步骤： 1）、创建流对象（指定流操作数据源） 2）、操作流：过滤，截取，跳过，去重，排序，切片 3）、结束流：遍历、收集、统计
filter(过滤的条件：函数式接口)：将不满足条件的数据过滤掉 filter(Predicate 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 comparator)：排序 进行排序数据必须实现Comparator
stream.sorted((o1, o2) -> o2 - o1) // 默认是升序
map():切片（给你一种类型，变为另一种类型） map(Function mapper) 函数型接口
// 将字符串变成int
String str = "12,34,67,5,90,23,4,67,8,9";
String[] split = str.split(",");
Stream
// 将字符串变成int
long count = stream
.map(Integer::parseInt) // Function,将a由String转换int 由.map(a -> integer.parseInt(a))
concat(Stream a, Stream b) 将两个流连在一起
Stream.concat(manlist.stream(), womanList.stream())
结束流
collect():收集 collect(Collectors.toList()); // 将结果收集为一个集和
Stream.collect(Collectors.tolist()) // 将收集的内容变成一个集合
count():统计个数
Stream.count // 统计流中的个数
Stream流的分类
1、串行流：单线程使用（使用最多）
2、并行流：多线程使用
// 创建一个串行流
List
Stream
stream.forEach(System.out::println);
// 并行流
Stream
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 // 单元测试的注解
// 单元测试的方法，不能有返回值，可以抛出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、在该类设计一个类方法，返回这个对象
饿汉模式：
/**
* 将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);
// 以上指向的都是同一个地址
}
}
懒汉模式：**
枚举模式：**
好文阅读
您阅读本篇文章共花了：
发表评论