目录
在Java8中，接口中的抽象方法默认被 public，abstract修饰符修饰，在Java8之前不允许普通方法存在接口中，在java8之后接口中可以存在普通方法，但是必须被static或者default修饰。
Lamda
好处：简化匿名内部类的调用
规范：使用lamda表达式需要依赖函数式接口
- 一个接口只有一个抽象方法
- 可以使用被static或者default修饰的方法
- 接口被@FunctionalInterface修饰
例子
如果lamda表达式只有一个返回值可以不写大括号和return语句
List<Integer> list = Arrays.asList(1, 3, 2, 9, 7);
list.forEach(item-> System.out.println("我是"+item));
Collections.sort(list,(o1,o2)->{return o2-o1;});
System.out.println(list);Stream
+--------------------+ +------+ +------+ +---+ +-------+
| stream of elements +-----> |filter+-> |sorted+-> |map+-> |collect|
+--------------------+ +------+ +------+ +---+ +-------+ //获取集合中大于2、并且经过排序、平方去重的有序集合
List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
List<Integer> collect = numbers.stream()
.filter(item -> item > 2)
.sorted((o1, o2) ->{return o2.compareTo(o1);})
.map(i -> i * i)
.distinct()
.collect(Collectors.toList());
System.out.println(collect);import java.util.ArrayList;
import java.util.Arrays;
import java.util.IntSummaryStatistics;
import java.util.List;
import java.util.Random;
import java.util.stream.Collectors;
import java.util.Map;
public class Java8Tester {
public static void main(String args[]){
System.out.println("使用 Java 8: ");
System.out.println("列表: " +strings);
count = strings.stream().filter(string->string.isEmpty()).count();
System.out.println("空字符串数量为: " + count);
count = strings.stream().filter(string -> string.length() == 3).count();
System.out.println("字符串长度为 3 的数量为: " + count);
filtered = strings.stream().filter(string ->!string.isEmpty()).collect(Collectors.toList());
System.out.println("筛选后的列表: " + filtered);
mergedString = strings.stream().filter(string ->!string.isEmpty()).collect(Collectors.joining(", "));
System.out.println("合并字符串: " + mergedString);
squaresList = numbers.stream().map( i ->i*i).distinct().collect(Collectors.toList());
System.out.println("Squares List: " + squaresList);
System.out.println("列表: " +integers);
IntSummaryStatistics stats = integers.stream().mapToInt((x) ->x).summaryStatistics();
System.out.println("列表中最大的数 : " + stats.getMax());
System.out.println("列表中最小的数 : " + stats.getMin());
System.out.println("所有数之和 : " + stats.getSum());
System.out.println("平均数 : " + stats.getAverage());
System.out.println("随机数: ");
random.ints().limit(10).sorted().forEach(System.out::println);
// 并行处理
count = strings.parallelStream().filter(string -> string.isEmpty()).count();
System.out.println("空字符串的数量为: " + count);
}
}使用 Java 8:
列表: [abc, , bc, efg, abcd, , jkl]
空字符串数量为: 2
字符串长度为 3 的数量为: 3
筛选后的列表: [abc, bc, efg, abcd, jkl]
合并字符串: abc, bc, efg, abcd, jkl
Squares List: [9, 4, 49, 25]
列表: [1, 2, 13, 4, 15, 6, 17, 8, 19]
列表中最大的数 : 19
列表中最小的数 : 1
所有数之和 : 85
平均数 : 9.444444444444445
随机数:
-1743813696
-1301974944
-1299484995
-779981186
136544902
555792023
1243315896
1264920849
1472077135
1706423674
空字符串的数量为: 2
Optional
import java.util.Optional;
public class Java8Tester {
public static void main(String args[]){
Java8Tester java8Tester = new Java8Tester();
Integer value1 = null;
Integer value2 = new Integer(10);
// Optional.ofNullable - 允许传递为 null 参数
Optional<Integer> a = Optional.ofNullable(value1);
// Optional.of - 如果传递的参数是 null，抛出异常 NullPointerException
Optional<Integer> b = Optional.of(value2);
System.out.println(java8Tester.sum(a,b));
}
public Integer sum(Optional<Integer> a, Optional<Integer> b){
// Optional.isPresent - 判断值是否存在
System.out.println("第一个参数值存在: " + a.isPresent());
System.out.println("第二个参数值存在: " + b.isPresent());
// Optional.orElse - 如果值存在，返回它，否则返回默认值
Integer value1 = a.orElse(new Integer(0));
//Optional.get - 获取值，值需要存在
Integer value2 = b.get();
return value1 + value2;
}
}运行结果：
$ javac Java8Tester.java
$ java Java8Tester
第一个参数值存在: false
第二个参数值存在: true
10
案例一：将一段字符串中的一部分进行排序
public static void main(String[] args) {
String str = "2-5-4-3-8-9";
Integer[] integers = Arrays.stream(str.split("-"))
.map(Integer::parseInt)
.sorted()
.toArray(Integer[]::new);
String s = Arrays.toString(integers).replaceAll("，", "-");
String substring = s.substring(1, s.length() - 1);
System.out.println(substring);
}案例二：查询list集合中性别时女的数据，如果为空要输出默认值
public static void main(String[] args) {
List<UserEntity> userEntityList = new ArrayList<>();
UserEntity userEntityDefault = new UserEntity();
userEntityList.add(new UserEntity("1", "111", "male"));
userEntityList.add(new UserEntity("2", "222", "female"));
userEntityList.add(new UserEntity("3", "333", "male"));
userEntityList.add(new UserEntity("4", "444", "female"));
UserEntity userEntity1 = userEntityList.stream().filter(s-> Objects.equals(s.getO3(), "male")).findFirst().orElse(userEntityDefault);
System.out.println(userEntity1);
}案例三
public class Trader{
private String name;
private String city;
public Trader(String n, String c){
this.name = n;
this.city = c;
}
public String getName(){
return this.name;
}
public String getCity(){
return this.city;
}
public void setCity(String newCity){
this.city = newCity;
}
public String toString(){
return "pojo1.Trader:"+this.name + " in " + this.city;
}
}public class Transaction{
private Trader trader;
private int year;
private int value;
public Transaction(Trader trader, int year, int value)
{
this.trader = trader;
this.year = year;
this.value = value;
}
public Trader getTrader(){
return this.trader;
}
public int getYear(){
return this.year;
}
public int getValue(){
return this.value;
}
public String toString(){
return "{" + this.trader + ", " +
"year: "+this.year+", " +
"value:" + this.value +"}";
}
}
public class Test {
public static void main(String[] args) {
Trader raoul = new Trader("Raoul", "Cambridge");
Trader mario = new Trader("Mario","Milan");
Trader alan = new Trader("Alan","Cambridge");
Trader brian = new Trader("Brian","Cambridge");
Transaction transaction2 = new Transaction(brian, 2011, 300);
List<Transaction> transactions = Arrays.asList(
new Transaction(brian, 2011, 300),
new Transaction(raoul, 2012, 1000),
new Transaction(raoul, 2011, 400),
new Transaction(mario, 2012, 710),
new Transaction(mario, 2012, 700),
new Transaction(alan, 2012, 950)
);
//找出2011年发生的所有交易，并按交易额排序
List<Transaction> collect = transactions.stream().filter(transaction -> transaction.getYear() == 2011).sorted((o1,o2)->o1.getYear()-o2.getYear()).collect(Collectors.toList());
System.out.println(collect);
//交易员在哪些不同的城市工作过
List<String> collect1 = transactions.stream().map(transaction -> transaction.getTrader().getCity()).distinct().collect(Collectors.toList());
System.out.println(collect1);
//查找所有来自剑桥的交易员，并按姓名进行排序并且通过字符串连接返回
String cambridge = transactions.stream().filter(transaction -> transaction.getTrader().getCity().equals("Cambridge")).map(o1 -> o1.getTrader().getName()).distinct().sorted((o1, o2) -> o1.compareTo(o2)).collect(Collectors.joining(", "));
System.out.println(cambridge);
//有没有交易员在米兰工作
/**
* anyMatch表示，判断的条件里，任意一个元素成功，返回true
*
* allMatch表示，判断条件里的元素，所有的都是，返回true
*
* noneMatch跟allMatch相反，判断条件里的元素，所有的都不是，返回true
*/
Boolean milanTrader = transactions.stream().anyMatch(transaction ->transaction.getTrader().getCity().equals("milan"));
System.out.println(milanTrader);
//打印生活在剑桥的交易员的所有交易额
transactions.stream().filter(transaction -> transaction.getTrader().getCity().equals("Cambridge")).forEach(o1-> System.out.println(o1.getValue()));
//所有交易中，最高的交易额是多少
Optional<Integer> maxValue = transactions.stream()
.map(Transaction::getValue)
.distinct()
.reduce(Integer::max);
System.out.println(maxValue);
//最小交易额
Integer integer = transactions.stream()
.map(o1 -> o1.getValue())
.distinct()
.reduce(Integer::min).get();
// Optional<Integer> minValue = (Optional<Integer>) integer
System.out.println(integer);
//将一段字符串中的一部分进行排序
String str = "2-5-4-3-8-9";
String collect2 = Arrays.stream(str.split("-")).sorted((o1, o2) -> o1.compareTo(o2)).collect(Collectors.joining(","));
//
Transaction transaction3 = transactions.stream().filter(transaction -> transaction.getYear() == 2000).findFirst().orElse(transaction2);
System.out.println(transaction3);
}
}[{pojo1.Trader:Brian in Cambridge, year: 2011, value:300}, {pojo1.Trader:Raoul in Cambridge, year: 2011, value:400}]
[Cambridge, Milan]
Alan, Brian, Raoul
false
300
1000
400
950
Optional[1000]
300
{pojo1.Trader:Brian in Cambridge, year: 2011, value:300}
510
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
