学习Java8新特性（一）

雨点打透心脏的1/2处 2023-10-06 14:27 73阅读 0赞

### 1.Java8的新特性带给了我们哪些好处？ ###

1.  **Lambda表达式**
2.  函数式接口
3.  方法引用和构造器引用
4.  **Stream API**
5.  接口的默认方法和静态方法
6.  新时间日期API
7.  其他新特性

这篇文章我们主要来**康康**Lambda表达式带给我们好处：

1.  我们先创建一个Person人员信息的实体类:

public class Person {
        
     private String name;
     private Integer id;
    public Person() {
        
    	
    }
    public Person(String name, Integer id) {
        
    	
    	this.name = name;
    	this.id = id;
    }
    public String getName() {
        
    	return name;
    }
    public void setName(String name) {
        
    	this.name = name;
    }
    
    public Integer getId() {
        
    	return id;
    }
    public void setId(Integer id) {
        
    	this.id = id;
    }
    @Override
    public String toString() {
        
    	return "Person [name=" + name + ", id=" + id + "]";
    }
     
    }

2.然后在把一些人员信息的对象存放在List集合中，这时候如果说我们有一个需求:**需要查询出id大于20的人员信息**

//创建一个Person类，并创建几个Person对象放在List集合中
    		List<Person> list=Arrays.asList(//asList:把数组中的元素传换成List元素
    			new Person("UZI",55),
    			new Person("小猪",44),
    			new Person("小狗",33),
    			new Person("The shy",22)
    				);
    		
    		//需求:需要查询出id大于20的人员信息
    		public static List<Person> personlist(List<Person> lists){
        
    			//创建一个存放id大于20的人员信息
    			List<Person> arrayList = new ArrayList<Person>();
    			for (Person person : lists) {
        
    				if(person.getId() >=20){
        
    				arrayList.add(person);	
    				}
    			}
    			return arrayList;
    			
    		}
    		@Test
    		public void test1(){
        
    		List<Person> lists=	TestLambda1.personlist(list);
    		for (Person person : lists) {
        
    			System.out.println(person);
    		}
    		}

3.如果这时候傻比老板又给你提了一个需求:**查询小于40的人员信息**

public static List<Person> personlist1(List<Person> lists){
        
    			//创建一个存放id大于20的人员信息
    			List<Person> arrayList = new ArrayList<Person>();
    			for (Person person : lists) {
        
    				if(person.getId() <=40){
        
    				arrayList.add(person);	
    				}
    			}
    			return arrayList;
    		}
    		
    		@Test
    		public void test2(){
        
    		List<Person> lists=	TestLambda1.personlist1(list);
    		for (Person person : lists) {
        
    			System.out.println(person);
    		}
    		}

虽然，需求确实完成了，但是这样不仅显得代码过于冗余繁琐，还让自己累个半死，就得不偿失了。关键的代码就那么几行：  
if(person.getId() …xxx)\{  
arrayList.add(person);  
\}  
**所以，为了节省我们的时间，我们可以提出优化方案**

### 方案1:**采用策略设计模式** ###

1.先创建一个接口

public interface LambdaMethod <T>{
        
    
    	//创建一个接口，这个接口有一个方法
    	public Boolean test(T t);
    }

2.如果这时候傻B老板给你提出需求(比如查询出ID大于40的人员信息)， 就可以直接去创建一个接口实现类，去完成需求方法:

public class ImpMethod implements LambdaMethod<Person>{
        
    
    	@Override
    	public Boolean test(Person t) {
        
    		if(t.getId()>40){
        
    			return true;
    		}else{
        
    			return false;
    		}
    		
    	}
    
    
    }

3.直接在添加方法中传入一个我们写的需求实现类:

public static List<Person> personlist2(List<Person> lists,LambdaMethod<Person> method){
        
    					//创建一个存放id大于40的人员信息
    					List<Person> arrayList = new ArrayList<Person>();
    					for (Person person : lists) {
        
    						if(method.test(person)){
        
    						arrayList.add(person);	
    						}
    					}
    					return arrayList;
    				}
    				@Test
    				public void test3(){
        
    				List<Person> lists=	TestLambda1.personlist2(list,new ImpMethod());
    				for (Person person : lists) {
        
    					System.out.println(person);
    				}
    				}

当然除了策略设计模式，我们还可以使用匿名内部类的方式：

### 方案2:**匿名内部类** ###

还是上面的添加方法，只不过我们传进去的不是已经实现需要的一个实现类了，而是直接使用匿名内部类的方式，添加一个匿名的实现类来实现方法：

@Test
    				public void test4(){
        
    					List<Person> lists=	TestLambda1.personlist2(list,new LambdaMethod<Person>() {
        
    
    						@Override
    						public Boolean test(Person t) {
        
    							if(t.getId()<=40){
        
    								return true;
    							}
    							return false;
    						}
    					});
    					for (Person person : lists) {
        
    						System.out.println(person);
    					}
    				}

### 上面两个方案其实都是可以优化的，但是还是感觉太冗余，那么我们可以试试JDK1.8的Stream和Lambda表达式，看看它们是如何优化的。 ###

### 方案3（java8）：Lambda表达式（只需要一句代码就可以优化） ###

@Test
    		//查询出id小于50的人员信息
    		public void test5(){
        
    	  List<Person> personlist2 = personlist2(list, (e) ->e.getId()<=50);
    	  personlist2.forEach(System.out::println);
    		}

### 方案4：stream ###

@Test
    			//查询出id大于30的人员信息
    			public void test6(){
        
    				list.stream()
    				    .filter((e) ->e.getId()>=30)
    				    .limit(2)//从查询的结果集中取两条数据，按照最高的取：44 55
    				    .forEach(System.out::println);
    				System.out.println("====================");

***而且我们还可以直接一句代码查询出所有的人员信息***:

list.stream()
    				    .map(Person::getName)
    				    .forEach(System.out::println);
    			}

## 是不是瞬间感觉Lambda表达式和Stream巨方便呢~ ##