JDK1.8新特性总结

迷南。 2023-06-21 12:28 1阅读 0赞

### 文章目录 ###

*  介绍
 *   *   *  1. 特殊的接口
         *  2.lambda表达式
         *  3.数据流编程
 *  实战
 *   *   *  1. 特殊的接口
         *  2.lambda
         *  3. 数据流编程

**总结jdk1.8新特性知识点如下：**

**1·特殊的接口:接口里面的方法可以有方法体。**

**2·方法的调用:可以使用::调用方法。**

**3·lambda表达式:语法超级简单，被python,scala逼出来的语法。**

**4·数据流编程:Spark特性和方法特别像。**

····································下面内容分为介绍和实战··································

# 介绍 #

### 1. 特殊的接口 ###

类的二个要素是什么?属性和方法
    属性三要素:(修饰符)类型,名字,值
    方法五要素:修饰符,返回值,方法名,形参,方法体
    构造方法:是一个特殊的方法
    抽象方法:是一个特殊的方法
    抽象类是一个特殊的类
    接口是一个特殊的抽象类
    接口中的方法全部是抽象的
    接口中的属性全部是public static final
    Jdk1.8新特性:在接口中的方法可以有方法体

### 2.lambda表达式 ###

是被python,scala逼出来的;语法超级简洁
    匿名类:
    目标方法的参数得是一个接口;
    方法的参数里面直接new后面跟上接口名
    必须马上写类体,重写方法体
    lambda表达式的先决条件
    目标方法的参数是一个接口
    接口中只有一个抽象方法,这个抽象方法不是Object里面的方法
    接口最好顶一个注解:@FunctionalInterface
    lambda如何写开发:
    把接口中抽象的方法复制一份到代码中(一定要加注释)
    常见的lambda表达式接口
    所有的lambda表达式常见的工具类都在java.util.function

<table> 
 <thead> 
  <tr> 
   <th>接口名</th> 
   <th>抽象方法</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Consumer &lt; T &gt;</td> 
   <td>void accept(T t);</td> 
  </tr> 
  <tr> 
   <td>Supplier&lt; T &gt;</td> 
   <td>T get();</td> 
  </tr> 
  <tr> 
   <td>Function&lt; T,R &gt;</td> 
   <td>R apply(T t);</td> 
  </tr> 
  <tr> 
   <td>Predicate&lt; T &gt;</td> 
   <td>boolean test( T t ) ;</td> 
  </tr> 
 </tbody> 
</table>

### 3.数据流编程 ###

数据：容器；
    1）放的是什么（泛型）
    2）大小
    3）Crud

需求：List里面存储的数据超级大；
    1）找10个及格的分数；
    2）循环之中满足需求，break；
    3）容器的大小,无上限；

重要的接口： Stream
    Stream接口的方法可以归为两类(算子就是方法)
    1）方法的返回值还是Stream:(Transformaction算子)
    2）方法的返回值不是Stream:(action算子)

数据流:
    1）一根管子,一个数据会把所有的管子走完以后,再走第二个数据，而不是所有的数据走完第一个管子以后,再一块走第二个管子
    重点：所有的transformaction算子都是懒惰的,必须碰到action算子,才会一块执行。

# 实战 #

### 1. 特殊的接口 ###

接口:(com.jinghangzz.jdk\_new.inter.IAnimal)

package com.jinghangzz.jdk_new.inter;
    
    import java.util.function.Supplier;
    
    /**
     * 接口:
     * 	为什么接口中的方法要有方法体:
     * 		接口就是为了定标准,这个标准要求所有的实现类,实现抽象方法;
     * 		其实有些方法,所有的实现类代码都是一样的;干脆就把这些代码挪到接口中;
     * 
     * @author TeaBig
     */
    public interface IAnimal
    {
    	/* 属性 */
    	int HEAD_NUM = 1 ; 
    	/* 下面的写法等同于上面的
    	 * 被static修饰的,名字都是大写,
    	 * 但是驼峰标识:单词之前使用_隔开
    	 *  */
    	//public static int HEADNUM = 1 ; 
    	
    	/* 抽象的方法 */
    	/**
    	 * 抽象的方法,跑
    	 */
    	void run();
    	/* 丢人的写法 */
    	//public abstract void run1();
    	
    	/* ====新特性开始 ==== */
    	/**
    	 * 有方法体的方法(普通的方法)
    	 * 吃
    	 * 要求:
    	 * 		必须被default修饰
    	 * 		此default和修饰符里面的default不一样
    	 * 		它是被public修饰
    	 */
    	default void eat()
    	{
    		System.out.println("==IAnimal==eat");
    	}
    	
    	/**
    	 * 睡的方法
    	 */
    	default String sleep()
    	{
    		System.out.println("==IAnimal==sleep");
    		return "===" ; 
    	}
    	
    	/* 静态的方法 */
    	static void staticMethod()
    	{
    		System.out.println("==IAnimal==staticMethod");
    	}
    	
    	/**
    	 * 参数是一个接口;
    	 * Supplier<IAnimal> supplier(供应商)
    	 * @return
    	 */
    	static IAnimal createObj(Supplier<IAnimal> supplier)
    	{
    		/* 让供应商去提供供货 */
    		return supplier.get() ; 
    	}
    	/* ====新特性结束 ==== */
    }
    
    Person类
    package com.jinghangzz.jdk_new.inter;
    
    /**
     * 人,是一个实现类
     * 		如果一个类实现一个接口,就要把接口中所有的抽象方法实现一遍
     * 		也可以实现接口中有方法体的方法(不能是静态方法)
     * @author TeaBig
     */
    public class Person implements IAnimal
    {
    	@Override
    	public void run()
    	{
    		System.out.println("==Person==run");
    	}
    
    	@Override
    	public void eat()
    	{
    		/* 调用父类的方法 */
    		//IAnimal.super.eat();
    		System.out.println("Person==eat");
    	}
    }
    
    Dog
    package com.jinghangzz.jdk_new.inter;
    
    /**
     * 狗
     * @author TeaBig
     */
    public class Dog implements IAnimal
    {
    
    	@Override
    	public void run()
    	{
    		System.out.println("==Dog==run");
    	}
    
    }
    
    测试类
    package com.jinghangzz.jdk_new.inter;
    
    /**
     * 所有的程序的入口函数
     * @author TeaBig
     */
    public class ClientMain
    {
    	public static void main(String[] args)
    	{
    		System.out.println("=南宋中兴四将=");
    		/* 测试第一个
    		 * 父类引用指向子类对象
    		 *  */
    		IAnimal person = new Person();
    		/* 调用属性 */
    		int headNum = person.HEAD_NUM ; 
    		System.out.println("=person.HEAD_NUM=" + headNum);
    		/* 接口名.属性 */
    		System.out.println("=IAnimal.HEAD_NUM=" + IAnimal.HEAD_NUM);
    		/* 调用方法 */
    		/* 调用抽象方法 */
    		person.run();
    		/*=====新知识======*/
    		/* 调用的是接口中有方法体的方法 */
    		person.eat(); 
    		person.sleep();
    		/* 调用的是接口中的静态方法 */
    		IAnimal.staticMethod();
    		
    		/*==new对象==*/
    //		IAnimal dog = new Dog();
    		/* Dog::new	调用的是Dog中的new方法
    		 * ::调用方法的简写,左边是类名或者接口名,右边是方法名
    		 * 返回值必须是functional Interface;
    		 * 必须有返回值
    		 *  */
    		IAnimal dog = IAnimal.createObj(Dog::new);
    		System.out.println("=createObj==" + dog);
    		IAnimal dog1 = Dog::new;
    		/* 调用方法 */
    		//String res = dog::sleep;
    	}
    }

### 2.lambda ###

lambda示例代码

package com.jinghangzz.jdk_new.lambda;
    
    import java.util.Date;
    
    /**
     * lambda的测试类
     * 		最终要实现的效果和匿名类很像
     * @author TeaBig
     */
    public class LambdaMain
    {
    	public static void main(String[] args)
    	{
    		System.out.println("====");
    		//lambdaAll();
    		
    
    		System.out.println("==main开始==");
    		/* 创建线程并启动 
    		 * 接口中唯一的抽象方法
    		 * public abstract void run();
    		 * 最全的写法:它是唯一的抽象方法的简写
    		 * 	(方法的形参) -> {方法体,如果有返回值,一定要写返回值}
    		 * 最全的省略:
    		 * 		如果目标方法只有一个参数,可以省略小括号
    		 * 		小括号里面的形参:类型可以省略
    		 * 		如果方法体只有一行,大括号可以省略
    		 * */
    		Thread t = new Thread( () -> System.out.println(Thread.currentThread() + "==计数=="+ "==" + new Date().toLocaleString()) );
    		t.start();
    		System.out.println("=main结束==");
    	
    	}
    
    	/**
    	 * 最全的写法(lambda)
    	 */
    	private static void lambdaAll()
    	{
    		System.out.println("=main开始==");
    		/* 创建线程并启动 
    		 * 接口中唯一的抽象方法
    		 * public abstract void run();
    		 * 最全的写法:它是唯一的抽象方法的简写
    		 * 	(方法的形参) -> {方法体,如果有返回值,一定要写返回值}
    		 * 最全的省略:
    		 * 		如果目标方法只有一个参数,可以省略小括号
    		 * 		小括号里面的形参:类型可以省略
    		 * 		如果方法体只有一行,大括号可以省略
    		 * */
    		Thread t = new Thread( () -> 
    		{
    			for (int i = 0; i < 10; i++)
    			{
    				System.out.println(Thread.currentThread() + "==计数="+ i +"=" + new Date().toLocaleString());
    				try
    				{
    					Thread.sleep(500);
    				} catch (InterruptedException e)
    				{
    					e.printStackTrace();
    				}
    			}
    		} );
    		t.start();
    		System.out.println("·==main结束=");
    	}
    }

Lambda表达式的示例代码

package com.jinghangzz.jdk_new.lambda;
    
    import java.util.Arrays;
    import java.util.List;
    import java.util.function.Consumer;
    
    /**
     * lambda的测试类 最终要实现的效果和匿名类很像
     * 	如果看到一个方法的参数类型后面跟了一个...
     * 		在方法定义的时候,把这三个点的参数,当成数组使用(String ... str)和(String[] str)效果一样
     * 		在方法使用的时候,这三个点要传入实参,实参的个数随便填写
     * 		...必须是方法形参的最后一个
     * ~示例:方法调用时(String[] str)
     * String[] str = {"1","2","3"} ;
     * 	目标方法(str) 
     * ~方法调用时String ... str
     * 	目标方法("1","2","3","3","3","3","3","3")
     * @author TeaBig
     */
    public class LambdaTest
    {
    	public static void main(String[] args)
    	{
    		System.out.println("====");
    		/* 调用方法 */
    		String[] str = {"1","a","b","c","d"};
    		//method1Arr(str,"2");
    		/* 调用方法 */
    		//method2Point(str);
    		method2Point(1,"1","a","b","c","d","e");
    		/* 集合抽取lambda */
    		lambdaList();
    	}
    
    	/**
    	 * lambda表达式,测试类
    	 */
    	private static void lambdaList()
    	{
    		/* 准备一个List */
    		List< String > list = Arrays.asList("1","a","b","c","d");
    		/* 如何循环
    		 * void accept(T t);
    		 * (类型忽略,直接写名字,形参名,名字随便写)
    		 *  */
    //		list.forEach( (t) -> 
    //		{
    //			System.out.println("==lambda循环==" + t);
    //		} );
    		/* 超级简单的写法 */
    		list.forEach( t -> System.out.println("==lambda循环==" + t));
    		/* 匿名类
    		 * 泛型是和容器的泛型一致
    		 *  */
    		list.forEach(new Consumer< String >()
    		{
    			@Override
    			public void accept(String t)
    			{
    				System.out.println("==Consumer循环==" + t) ; 
    			}
    		});
    	}
    	
    	/**
    	 * 方法的形参是数组
    	 * @param str
    	 */
    	public static void method1Arr(String[] str)
    	{
    		/* 查看数组里面的内容 */
    		for (int i = 0; i < str.length; i++)
    		{
    			String temp = str[i];
    			System.out.println(i + "==method1Arr==" + temp);
    		}
    	}
    	
    	/**
    	 * 方法的形参是三个点
    	 * @param str
    	 */
    	public static void method2Point(int j , String... str)
    	{
    		/* 查看数组里面的内容 */
    		for (int i = 0; i < str.length; i++)
    		{
    			String temp = str[i];
    			System.out.println(i + "==method2Point==" + temp);
    		}
    	}
    }

### 3. 数据流编程 ###

transformaction算子

package com.jinghangzz.jdk_new.stream;
    
    import java.util.Arrays;
    import java.util.List;
    import java.util.function.Consumer;
    import java.util.function.Predicate;
    import java.util.stream.Stream;
    
    import org.junit.Test;
    
    /**
     * 数据流编程
     * @author TeaBig
     */
    public class DataStream
    {
    	/**
    	 * 测试一个方法(框架)
    	 */
    	@Test
    	public void base()
    	{
    		/* 准备一个容器 */
    		List< Integer > intList = Arrays.asList(100,2,38,12,50,87);
    		/* 准备一个Stream */
    		Stream< Integer > souStream = null;
    		try
    		{
    			souStream = intList.stream(); 
    			/* 并行:多线程 */
    			//souStream = intList.parallelStream();
    			System.out.println("=isParallel==>" + souStream.isParallel());
    			/* 循环数据
    			 * java.util.function.Consumer
    			 * void accept(T t);
    			 * 
    			 * forEach:action算子
    			 *  */
    			souStream.forEach( t -> System.out.println("==Stream循环==" + t));
    		} catch (Exception e)
    		{
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} finally
    		{
    			if(souStream != null)
    			{
    				souStream.close();
    				souStream = null ; 
    			}
    		}
    	}
    	
    	/**
    	 * 过滤
    	 * 按照指定的条件,对数据流里面的数据进行过滤
    	 */
    	@Test
    	public void transformaction_Filter()
    	{
    		/* 准备一个容器 */
    		List< Integer > intList = Arrays.asList(100,2,38,12,50,87);
    		/* 准备一个Stream */
    		Stream< Integer > souStream = intList.stream() ; 
    		/* 过滤 
    		 * java.util.function.Predicate< T > 
    		 * boolean test(T t);
    		 * 
    		 * 只有一行代码,return可以省略
    		 * */
    		Stream< Integer > filterStream = souStream.filter( (t) -> t > 50);
    		/* 循环数据
    		 * java.util.function.Consumer
    		 * void accept(T t);
    		 * 
    		 * forEach:action算子
    		 *  */
    		filterStream.forEach( t -> System.out.println("==Stream循环==" + t));
    		/* 关闭 */
    		souStream.close();
    	}
    	
    	/**
    	 * 过滤
    	 */
    	@Test
    	public void transformaction_Filter_Base()
    	{
    		/* 准备一个容器 */
    		List< Integer > intList = Arrays.asList(100,2,38,12,50,87);
    		/* 准备一个Stream */
    		Stream< Integer > souStream = intList.stream() ;
    		/* 过滤算子 */
    		Stream< Integer > filterStream = souStream.filter( new Predicate< Integer >()
    		{
    			@Override
    			public boolean test(Integer t)
    			{
    				System.out.println("=filter==test=" + t);
    				return t > 50;
    			}
    		} );
    		filterStream.forEach( new Consumer< Integer >()
    		{
    			@Override
    			public void accept(Integer t)
    			{
    				System.out.println("==循环==" + t);
    			}
    		} );
    		/* 关闭 */
    		souStream.close();
    	}
    	
    	/**
    	 * map算子
    	 * 按照指定的条件,对数据流里面的数据进行处理(加工)
    	 */
    	@Test
    	public void transformaction_Map()
    	{
    		/* 准备一个容器 */
    		List< Integer > intList = Arrays.asList(100,2,38,12,50,87);
    		/* 准备一个Stream */
    		Stream< Integer > souStream = null;
    		try
    		{
    			souStream = intList.stream(); 
    			
    			/* map算子;要把输入参数,经过一个方法变成另外一个参数;(处理参数)
    			 * java.util.function.Function<T, R>
    			 * R apply(T t);
    			 * 
    			 * 需求:要把这里面的整数,都加一个字符串
    			 *  */
    			Stream< String > mapStream = souStream.map( (t) -> t + "==我变化了");
    			
    			/* 循环数据
    			 * java.util.function.Consumer
    			 * void accept(T t);
    			 * 
    			 * forEach:action算子
    			 *  */
    			mapStream.forEach( t -> System.out.println("==Stream循环==" + t));
    		} catch (Exception e)
    		{
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} finally
    		{
    			if(souStream != null)
    			{
    				souStream.close();
    				souStream = null ; 
    			}
    		}
    	}
    	
    	/**
    	 * FlatMap算子
    	 * 它会对数据流里面的数据大小有要求
    	 */
    	@Test
    	public void transformaction_FlatMap()
    	{
    		/* 准备一个容器 */
    		List< String > strList = Arrays.asList("ab","cd","ef","test-hello-hadoop");
    		/* 准备一个Stream */
    		Stream< String > souStream = null;
    		try
    		{
    			souStream = strList.stream(); 
    			
    			/* map算子;要把输入参数,经过一个方法变成另外一个参数;(处理参数)
    			 * java.util.function.Function<T, R>
    			 * R apply(T t);
    			 * 
    			 * 需求:要把这里面的整数,都加一个字符串
    			 * 
    			 * map的参数:    Function<? super T, ? extends R> mapper;R木有要求
    			 * flatMap的参数:Function<? super T, ? extends Stream<? extends R>> mapper;R要求必须是Stream;
    			 *  */
    			Stream< String > flatMapStream = souStream.flatMap( t -> 
    			{
    				/* 把字符串根据-拆分开 */
    				String[] splitList = t.split("-");
    				/* 返回值还是Stream这里面放的是字符串 */
    				List< String > tempList = Arrays.asList(splitList);
    				return tempList.stream() ; 
    			});
    			
    			/* 循环数据
    			 * java.util.function.Consumer
    			 * void accept(T t);
    			 * 
    			 * forEach:action算子
    			 *  */
    			flatMapStream.forEach( t -> System.out.println("==Stream循环==" + t));
    		} catch (Exception e)
    		{
    			e.printStackTrace();
    		} finally
    		{
    			if(souStream != null)
    			{
    				souStream.close();
    				souStream = null ; 
    			}
    		}
    	}
    	
    	/**
    	 * FlatMap算子
    	 * 它会对数据流里面的数据大小有要求
    	 */
    	@Test
    	public void transformaction_other()
    	{
    		/* 准备一个容器 */
    		List< Integer > intList = Arrays.asList(100,2,50,50,50,87);
    		/* 准备一个Stream */
    		Stream< Integer > souStream = null;
    		try
    		{
    			souStream = intList.stream(); 
    			/*
    			 * distinct:去重
    			 * */
    			//Stream< Integer > stream = souStream.distinct();
    			/* 取前几条记录 */
    			//Stream< Integer > stream = souStream.limit(2);
    			/* 跳过前n条数据 */
    			//Stream< Integer > stream = souStream.skip(2);
    			/* 排序:默认升序 */
    			//Stream< Integer > stream = souStream.sorted();
    			/* java.util.Comparator< T >:
    			 * int compare(T o1, T o2);
    			 *  */
    			//Stream< Integer  > stream = souStream.sorted( (t1,t2) -> -(t1 - t2) );
    			Stream< Integer> stream = souStream.unordered();
    			
    			/* 循环数据
    			 * java.util.function.Consumer
    			 * void accept(T t);
    			 * 
    			 * forEach:action算子
    			 *  */
    			stream.forEach( t -> System.out.println("====Stream循环----" + t));
    		} catch (Exception e)
    		{
    			e.printStackTrace();
    		} finally
    		{
    			if(souStream != null)
    			{
    				souStream.close();
    				souStream = null ; 
    			}
    		}
    	}
    }