JDK1.8

标签：JDK1.8 String list System new public out

1. Lamdba表达式

Lambda表达式是什么？

Lambda是一个匿名函数，我们可以将Lambda表达式理解为一段可以传递的代码（将代码像数据一样传递）。使用它可以写出简洁、灵活的代码。作为一种更紧凑的代码风格，使java语言表达能力得到提升。

public static void main(String[] args) {
 		//使用匿名函数
        new Thread(new Runnable(){
            @Override
            public void run(){
                System.out.println("我是没有使用Lambda表达式：不简洁");
            }
        }).start();
	      
        
        
        //使用Lambda表达式
        new Thread(
        		()->System.out.println("我是使用Lambda表达式：简洁、灵活")
        ).start();
        
}

Lambda表达式在java语言中引入了一种新的语法元素和操作。这种操作符号为“->”,Lambda操作符或箭头操作符，它将Lambda表达式分割为两部分。左边：指Lambda表达式的所有参数右边：指Lambda体，即表示Lambda表达式需要执行的功能

六种语法格式：

语法格式一：无参数、无返回值，只需要一个Lambda体

public interface Lock {
	public abstract void lockUp();  //上锁
}



public static void main(String[] args) {
    Lock lock = ()-> System.out.println("Lambda表达式：简洁、灵活，优雅永不过时");
    lock.lockUp();
}

语法格式二：lambda有一个参数、无返回值

public interface Lock {
	public abstract void lockUp(String str);  //上锁
}



public static void main(String[] args) {
    Lock lock = (s) -> System.out.println(s+"上锁");
    lock.lockUp("张三");
}

Lambda只有一个参数时，可以省略（）

public interface Lock {
	public abstract void lockUp(String str);  //上锁
}



public static void main(String[] args) {
    Lock lock = s -> System.out.println(s+"上锁");
    lock.lockUp("张三");
}

语法格式四：Lambda有两个参数时，并且有返回值

public interface Lock {
	public abstract String lockUp(String str,String str2);  //上锁
}

Lock lock = (s1,s2) -> {
    System.out.println("门被上锁。。。。。。");
    return "上锁";
};
lock.lockUp("张三","李四");

语法格式五：当Lambda体只有一条语句的时候，return和{}可以省略掉

public interface Lock {
	public abstract String lockUp(String str,String str2);  //上锁
}

Lock lock = (s1,s2) ->  "上锁";
lock.lockUp("张三","李四");

类型推断：数据类型可以省略，因为编译器可以推断得出，称为“类型推断”

public interface Lock {
	public abstract void lockUp(String str);  //上锁
}



public static void main(String[] args) {
    //可以写类型
    Lock lock = (String s) -> System.out.println(s+"上锁");
    lock.lockUp("张三");
    
    //可以不写类型
    Lock lock = (s) -> System.out.println(s+"上锁");
    lock.lockUp("张三");
}

2. forEach+Lambda

使用forEach和Lambda循环list集合

List<String> list = new ArrayList<String>();
list.add("A");
list.add("B");
list.add("C");
//使用forEach和Lambda循环list集合
list.forEach(s->System.out.println(s));



public class UserVo {
	private String userName;

	public String getUserName() {
		return userName;
	}

	public void setUserName(String userName) {
		this.userName = userName;
	}
}
List<UserVo> list = new ArrayList<UserVo>();
list.add(new UserVo());
list.add(new UserVo());
list.add(new UserVo());

//使用forEach和Lambda循环list集合并输出对象信息
list.forEach(s->System.out.println(s.getUserName()));

使用forEach和Lambda循环Map集合

Map<String, UserVo> map = new HashMap<String, UserVo>();
map.put("A", new UserVo());
map.put("B", new UserVo());
map.put("C", new UserVo());

map.forEach((k,v)->System.out.println(k+"==="+v.getUserName()));

3. 函数式接口

什么是函数式接口？

函数式接口：只包含一个抽象方法的接口，称为函数式接口，并且可以使用lambda表达式来创建该接口的对象，可以在任意函数式接口上使用@FunctionalInterface注解，来检测它是否是符合函数式接口。同时javac也会包含一条声明，说明这个接口是否符合函数式接口

函数式接口： 有且仅有一个抽象方法的接口。
Java中的函数式编程体现就是Lambda表达式。
所以函数式接口即可以适用于Lambda使用的接口。

注意：自定义函数式接口时，@FunctionalInterface是可选的，就算不写这个注解，只要保证满足函数式接口定义的条件，也照样是函数式接口。

//正确  函数式接口
@FunctionalInterface
public interface Lock {
	
	public abstract String lockUp(String str1,String str2);  //上锁
	//public abstract void openLock();  //开锁

}

//报错
@FunctionalInterface
public interface Lock {
	
	public abstract String lockUp(String str1,String str2);  //上锁
	public abstract void openLock();  //开锁

}

4. 方法引用和构造器引用

1. 方法引用

当要传递给Lambda体的操作已经有实现方法，可以直接使用方法引用(实现抽象方法的列表，必须要和方法引用的方法参数列表一致)

方法引用：使用操作符“：：”将方法名和（类或者对象）分割开来。

有下列三种情况：

对象：：实例方法

类：：实例方法

类：：静态方法

@FunctionalInterface
public interface Lock {
	public abstract void lockUp(String str);  //上锁
}

Lock lock = System.out::println;
lock.lockUp("测试。。。");

2. 构造器引用

本质上：构造器引用和方法引用相识，只是使用了一个new方法

使用说明：函数式接口参数列表和构造器参数列表要一致，该接口返回值类型也是构造器返回值类型

格式：ClassName :: new

@FunctionalInterface
public interface Lock {
	public abstract String lockUp(String str);  //上锁
}

//非构造器引用
Lock lock1 = (s) -> new String(s);
//构造器引用
Lock lock2 = String::new;

5. Stream API

1. 什么是Stream？

Java8中两个最为重要特性：第一个的是Lambda表达式，另一个是Stream API。

StreamAPI它位于java.util.stream包中，StreamAPI帮助我们更好地对数据进行集合操作，它本质就是对数据的操作进行流水线式处理，也可以理解为一个更加高级的迭代器,主要作用是遍历其中每一个元素。简而言之,StreamAP提供了一种高效且易于使用的处理数据方式。

2. Stream特点：

1、Stream自己不会存储数据。

2、Stream不会改变源对象。相反，它们会返回一个持有结果的新Stream对象

3、Stream操作时延迟执行的。这就意味着它们等到有结果时候才会执行。

3. Stream操作的三个步骤？

1、创建Stream：一个数据源（例如：set 、list），获取一个流
2、中间操作：一个中间操作连接，对数据源的数据进行处理
3、终止操作:一个终止操作，执行中间操作连，产生结果。

4. Stream创建可以通过三种方式创建。

通过java.util.Collection.stream() 方法用集合创建流
使用java.util.Arrays.stream(T[] array)方法用数组创建流
使用Stream的静态方法：of()、iterate()、generate()

    //1.通过 `java.util.Collection.stream()` 方法用集合创建流
    List<String> list = Arrays.asList("d","a", "b", "c");
    Stream<String> streamList = list.stream();
    System.out.println("###############顺序流##############");

    streamList.forEach(System.out::print);
    System.out.println();
    System.out.println("###############并行流##############");
    // 创建一个并行流
    Stream<String> parallelStream = list.parallelStream();
    parallelStream.forEach(System.out::print);
    System.out.println();
    //2.使用`java.util.Arrays.stream(T[] array)`方法用数组创建流
    int[] array={1,3,5,6,8};
    IntStream streamint = Arrays.stream(array);
    streamint.forEach(System.out::print);
    System.out.println();
    //3.使用`Stream`的静态方法：`of()、iterate()、generate()
    Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);
    stream.forEach(System.out::print);
    System.out.println();
    Stream<Integer> stream2 = Stream.iterate(0, (x) -> x + 3).limit(4);
    stream2.forEach(System.out::print);
    System.out.println();
    Stream<Double> stream3 = Stream.generate(Math::random).limit(3);
    stream3.forEach(System.out::print);
    System.out.println();

5. 中间操作

用下面这个集合来举例：


public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list, "张无忌", "周芷若", "赵敏", "张强", "张三丰","张无忌");
}

（1）.limit(n) 从list中取出n个元素

list.stream().limit(2).forEach(System.out::println);

（2）.skip(n) 从list第n个元素开始，取出所有元素

list.stream().skip(3).forEach(System.out::println);

（3）.distinct() 去除重复

list.stream().distinct().forEach(System.out::println);

（4）.filter(Predicate<? super T> predicate) 筛选条件

括号中的内容为一个断言型函数式接口，其中的T为当前集合中元素的类型。

public static void main(String[] args) {
        List<Person> personList = new ArrayList<>();
        personList.add(new Person("欧阳雪",18,"中国",'F'));
        personList.add(new Person("Tom",24,"美国",'M'));
        personList.add(new Person("Harley",22,"英国",'F'));
        personList.add(new Person("向天笑",20,"中国",'M'));
        personList.add(new Person("李康",22,"中国",'M'));
        personList.add(new Person("小梅",20,"中国",'F'));
        personList.add(new Person("何雪",21,"中国",'F'));
        personList.add(new Person("李康",22,"中国",'M'));
}

找出年龄大于20的人并打印输出：

  personList.stream()
  .filter((person)->person.getAge()>20)
  .forEach(System.out::println);

（5）.map(Function<? super T,?> mapper ) 将元素转换成其他形式或提取信息。

打印出集合中所有人的年龄：

personList.stream()
.map((person -> person.getAge()))
.forEach(System.out::println);

（6）.sorted() 对元素进行排序

6. 终端操作

forEach() 遍历流中每一个元素，会关闭流

forEach 不能修改自己包含的本地变量值，也不能用 break/return 之类的关键字提前结束循环。
findFirst(),findAny()

查找操作，查找第一个、任何一个，返回的类型为Optional。常用于查询集中符合条件的元素，如果流是空的，则返回空大多数情况下，数据量不大的情况下，findAny()也会返回第一个元素，此时效果与findFirst()一致

allMatch，anyMatch，noneMatch

allMatch 要求Stream中所有元素都满足条件才返回true

anyMatch，只要有1个元素满足就返回true

noneMatch 要求所有的元素都不满足条件才返回true


//每个学生年纪都为18才返回true
boolean flag = list.stream().allMatch(e -> e.getAge() == 18);
//任意一个学生是18，则返回true
boolean flag = list.stream().anyMatch(e -> e.getAge() == 18);
//学生年纪没有一个是18 ，则返回true
boolean flag = list.stream().noneMatch(e -> e.getAge() == 18);

reduce:将整个数据流的值规约为一个值，其中count、min、max底层就是使用reduce,也可用于字符串连接

// 字符串连接，concat = "ABCD"
String concat = Stream.of("A", "B", "C", "D").reduce("", String::concat);
// 集合累加求和，另一写法reduce(0,Integer::sum)
int sum2=Stream.of(1,2,3,4,5).reduce((t,u)->t+u).get();
//输出最大值，另一写法reduce(Integer::max)
int max=Stream.of(1,2,3,4,5).reduce((t,u)-> t>=u? t:u).get();
 
2> 有2个参数 T reduce(T identity, BinaryOperator<T> accumulator)
多一个泛型T，实际上相对于在计算值的时候多一个初始化的值
int sum3=Stream.of(1,2,3,4,5).reduce(0,(t,u)->t+u);

min、max`最值操作：需要自定义比较器，返回数据流中最大、最小的值

//查年纪最大的
Optional<Student> max = list.stream().max(Comparator.comparing(Student::getAge));
if (max.isPresent()) {
    Student student = max.get();
}

count : 返回Stream中元素的个数

toArray数组操作：将数据流的元素转换成数组。

List<String> list=Arrays.asList("a","b","c","a");     
//返回数组 
String[] newArr=list.stream().toArray(String[]::new);

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

a
//查年纪最大的
Optional max = list.stream().max(Comparator.comparing(Student::getAge));
if (max.isPresent()) {
Student student = max.get();
}


6. count : 返回Stream中元素的个数

7. `toArray`数组操作：将数据流的元素转换成数组。

```java
List<String> list=Arrays.asList("a","b","c","a");     
//返回数组 
String[] newArr=list.stream().toArray(String[]::new);

[外链图片转存中…(img-gkjGbjTk-1733555964258)]

标签：JDK1.8,String,list,System,new,public,out
From： https://blog.csdn.net/QAZ412803/article/details/144311010

JDK1.8

JDK1.8

1. Lamdba表达式

Lambda表达式是什么？

2. forEach+Lambda

3. 函数式接口

什么是函数式接口？

4. 方法引用和构造器引用

1. 方法引用

2. 构造器引用

5. Stream API

1. 什么是Stream？

2. Stream特点：

3. Stream操作的三个步骤？

4. Stream创建可以通过三种方式创建。

5. 中间操作

6. 终端操作

相关文章

赞助商

阅读排行