JDK1.8新特性笔记

最新推荐文章于 2024-06-11 21:32:56 发布
最新推荐文章于 2024-06-11 21:32:56 发布
阅读量270 收藏
点赞数 2
CC 4.0 BY-SA版权
分类专栏： 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tsuki824/article/details/115610625
本文介绍了JDK1.8的新特性，包括特殊的接口，其方法可带方法体；Lambda表达式，能简化匿名内部类；数据流编程，有Transformaction和action两类算子，且前者需碰到后者才执行；函数式接口可定义默认和静态方法等内容。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

jdk1.8新特性

jdk1.8新特性主要知识点：
1.特殊的接口
2.Lambda表达式
3.数据流编程
4.并行数据排序
5.optional中避免null检查
6.新的时间和日期APL
7.可重复注释

方法的调用：可以使用::调用方法

特殊的接口

1.类的两个要素：属性和方法
*属性的三要素:类型，名字，值
*属性的五要素：修饰符，返回值，方法名，形参，方法体
方法引用
三种表现形式：

  1. 对象：：实例方法名
  2. 类：：静态方法名
  3. 类：：实例方法名 （lambda参数列表中第一个参数是实例方法的调用 者，第二个参数是实例方法的参数时可用）
public void test() {
        /**
        *注意：
        *   1.lambda体中调用方法的参数列表与返回值类型，要与函数式接口中抽象方法的函数列表和返回值类型保持一致！
        *   2.若lambda参数列表中的第一个参数是实例方法的调用者，而第二个参数是实例方法的参数时，可以使用ClassName::method
        *
        */
        Consumer<Integer> con = (x) -> System.out.println(x);
        con.accept(100);

        // 方法引用-对象::实例方法
        Consumer<Integer> con2 = System.out::println;
        con2.accept(200);

        // 方法引用-类名::静态方法名
        BiFunction<Integer, Integer, Integer> biFun = (x, y) -> Integer.compare(x, y);
        BiFunction<Integer, Integer, Integer> biFun2 = Integer::compare;
        Integer result = biFun2.apply(100, 200);

        // 方法引用-类名::实例方法名
        BiFunction<String, String, Boolean> fun1 = (str1, str2) -> str1.equals(str2);
        BiFunction<String, String, Boolean> fun2 = String::equals;
        Boolean result2 = fun2.apply("hello", "world");
        System.out.println(result2);
    }

*在接口中的方法可以有方法体

Lambda表达式

lambda表达式本质上是一段匿名内部类，也可以是一段可以传递的代码
.是被python，scala逼出来的，语法简洁
2.匿名类：

 //匿名内部类
  Comparator<Integer> cpt = new Comparator<Integer>() {
      @Override
      public int compare(Integer o1, Integer o2) {
          return Integer.compare(o1,o2);
      }
  };

  TreeSet<Integer> set = new TreeSet<>(cpt);

  System.out.println("=========================");

  //使用lambda表达式
  Comparator<Integer> cpt2 = (x,y) -> Integer.compare(x,y);
  TreeSet<Integer> set2 = new TreeSet<>(cpt2);

*目标方法的参数得是一个接口
*方法的参数里面直接new后面跟上接口名
*必须马上写类体，重写方法体
3.Lambda就是一个匿名函数，我们只需将要执行的代码放到Lambda表达式中

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表达式,测试类

	/**
	 * 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);
		}
	}
}

Lambda的标准格式
（参数列表）->{
}
(参数列表)：参数列表
{}：方法体
->：没有实际含义，起到连接的作用
Lmabda表达式的语法总结：** () -> ();**

无参数无返回值 :

() -> System.out.println(“Hello WOrld”)

有一个参数无返回值

(x) -> System.out.println(x)

有且只有一个参数无返回值

x -> System.out.println(x)

有多个参数，有返回值，有多条lambda体语句

(x，y) -> {System.out.println(“xxx”);return xxxx;}；

有多个参数，有返回值，只有一条lambda体语句

(x，y) -> xxxx

数据流编程

1.Spark特性和方法相像
2.数据：容器；
*放的是什么（泛型）
*大小
*Crud
3.需求List里面存储的数据超级大；
*找10个及格的分数
*循环之中满足需求，break；
*容器的大小：无上限
4.重要的接口：Stream
/*Stream接口的方法可以归为两类（算子就是方法）
*Stream接口的方法可以归为两类（算子就是方法）
*方法的返回值还是Stream：（Transformaction算子)
方法的返回值不是Stream：(action算子)`
transformaction算子

/**
 * 数据流编程
 * @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算子

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算子

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 ; 
			}
		}
	}
}

action算子
5.数据流
*一根管子，一个数据会把所有的管子走完以后，再走第二个数据
*而不是所有的数据走完第一个管子以后，再一块走第二个管子
在这里插入图片描述
在这里插入图片描述
重点:
所有的transfofrmaction算子都是懒惰的，必须碰到action算子，才会一起执行

函数式接口

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() ; 
	}
	/* ====新特性结束 ==== */
}

*当一个类继承父类又实现接口时，若后两者方法名相同，则优先继承父类中的同名方法，即“类优先”，如果实现两个同名方法的接口，则要求实现类必须手动声明默认实现哪个接口中的方法。

/**
 * 人,是一个实现类
 * 		如果一个类实现一个接口,就要把接口中所有的抽象方法实现一遍
 * 		也可以实现接口中有方法体的方法(不能是静态方法)
 * @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");
	}
}


/**
 * 狗
 * @author TeaBig
 */
public class Dog implements IAnimal
{

	@Override
	public void run()
	{
		System.out.println("==Dog==run");
	}

}

测试类

/**
 * 所有的程序的入口函数
 * @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;(等讲到lambda表达式的时候再说)
         * 必须有返回值
		 */
		IAnimal dog = IAnimal.createObj(Dog::new);
		System.out.println("==createObj==" + dog);
		IAnimal dog1 = Dog::new;
		/* 调用方法 */
		//String res = dog::sleep;
	}
}

action算子
数据流只能碰到一个action算子
例如：

public void other()
	{
		/* 准备一个List */
		List<Integer> intList = Arrays.asList(1,2,3,4,5);
		/* 准备一个Stream */
		Stream<Integer> stream = intList.stream() ; 
		try
		{
			/* 把流里面的数据变成数组 */
//			Object[] arrays = stream.toArray();
//			System.out.println("==toString==>" + Arrays.toString(arrays));
			/* 数据的数量 */
//			long count = stream.count() ; 
//			System.out.println("==count==>" + count);
			/* 查询每一个元素 */
//			Optional<Integer> findFirst = stream.findFirst();
//			System.out.println("==findFirst==>" + findFirst.get());
			/* 获取到迭代器 */
//			for (Iterator<Integer> iterator = stream.iterator(); iterator.hasNext();)
//			{
//				Integer intValue = (Integer) iterator.next();
//				System.out.println("==循环==" + intValue);
//			}
			
			/* 获取最大值
			 * 先排序:(不管是升序还是降序,他始终认的是第一个)
			 *  */
//			Optional<Integer> maxOption = stream.max( (t1,t2) -> t1 - t2);
//			System.out.println("==max=>" + maxOption.get());
			/* 获取最小值 */
//			Optional<Integer> minOption = stream.min( (t1,t2) -> t2 - t1);
//			System.out.println("==min=>" + minOption.get());
			
			/* 缩减
			 * 参数是:java.util.function.BinaryOperator<T>;得找有抽象方法的接口:
			 * java.util.function.BiFunction<T, U, R> 
			 * 抽象方法是:R apply(T t, U u);
			 * 泛型T,U是输入参数,R是输出参数
			 *  */
			Optional<Integer> reduce = stream.reduce( (t1,t2) -> t1 + t2);
			System.out.println("==reduce=>" + reduce.get());
		}catch(Exception e)
		{
			if(stream != null)
			{
				/* 关闭 */
				stream.close();
				stream = null ; 
			}
		}
	}
}

action算子

public class DataStreamAction
{
	/**
	 * 数据流测试的基本代码
	 */
	@Test
	public void base()
	{
		/* 准备一个List */
		List<Integer> intList = Arrays.asList(100,2,38,12,50,87);
		/* 准备一个Stream */
		Stream<Integer> stream = intList.stream() ; 
		try
		{
			/* 循环 */
			stream.forEach( t -> System.out.println("==循环==" + t));
		}catch(Exception e)
		{
			if(stream != null)
			{
				/* 关闭 */
				stream.close();
				stream = null ; 
			}
		}
	}
	
	/**
	 * 数据流测试的基本代码
	 * 数据流,只能碰到一个action算子
	 */
	@Test
	public void other()
	{
		/* 准备一个List */
		List<Integer> intList = Arrays.asList(1,2,3,4,5);
		/* 准备一个Stream */
		Stream<Integer> stream = intList.stream() ; 
		try
		{
			/* 把流里面的数据变成数组 */
//			Object[] arrays = stream.toArray();
//			System.out.println("==toString==>" + Arrays.toString(arrays));
			/* 数据的数量 */
//			long count = stream.count() ; 
//			System.out.println("==count==>" + count);
			/* 查询每一个元素 */
//			Optional<Integer> findFirst = stream.findFirst();
//			System.out.println("==findFirst==>" + findFirst.get());
			/* 获取到迭代器 */
//			for (Iterator<Integer> iterator = stream.iterator(); iterator.hasNext();)
//			{
//				Integer intValue = (Integer) iterator.next();
//				System.out.println("==循环==" + intValue);
//			}
			
			/* 获取最大值
			 * 先排序:(不管是升序还是降序,他始终认的是第一个)
			 *  */
//			Optional<Integer> maxOption = stream.max( (t1,t2) -> t1 - t2);
//			System.out.println("==max=>" + maxOption.get());
			/* 获取最小值 */
//			Optional<Integer> minOption = stream.min( (t1,t2) -> t2 - t1);
//			System.out.println("==min=>" + minOption.get());
			
			/* 缩减
			 * 参数是:java.util.function.BinaryOperator<T>;得找有抽象方法的接口:
			 * java.util.function.BiFunction<T, U, R> 
			 * 抽象方法是:R apply(T t, U u);
			 * 泛型T,U是输入参数,R是输出参数
			 *  */
			Optional<Integer> reduce = stream.reduce( (t1,t2) -> t1 + t2);
			System.out.println("==reduce=>" + reduce.get());
		}catch(Exception e)
		{
			if(stream != null)
			{
				/* 关闭 */
				stream.close();
				stream = null ; 
			}
		}
	}
}

关联源码

在这里插入图片描述

JDK1.8 Java新特性总结
m0_70808444的博客
08-25 1128
一个接口中只有一个抽象方法,这种接口称为函数式接口;
Java虚拟机(jdk1.8)学习笔记(经典垃圾收集器)
此物最相思
08-08 411
更具体的处理思路是让G1收集器去跟踪各个Region里面的垃圾堆积的“价值”大小，价值即回收所获得的空间大小以及回收所需时间的经验值，然后在后台维护一个优先级列表，每次根据用户设定允许的收集停顿时间（使用参数-XX：MaxGCPauseMillis指定，默认值是200毫秒），优先处理回收价值收益最大的那些Region，这也就是“Garbage First”名字的由来。-XX：GCTimeRatio参数：该参数的值则应当是一个大于0小于100的整数，也就是垃圾收集时间占总时间的比率，相当于吞吐量的倒数。
jdk1.8新特性
03-13
JDK1.8新特性简介剖析，仅做参考，希望大家相互学习 作为Comparator 和Runnable早期的证明，在JDK中已经定义的接口恰巧作为函数接口而与lambdas表达式兼容。同样方式可以在你自己的代码中定义任何函数接口或第三方库。 但有特定形式的函数接口，且广泛的，通用的，在之前的JD卡中并不存在。大量的接口被添加到新的java.util.function 包中。
jdk1.8 的新特性
Alfred_tfk的博客
05-12 7291
文章目录jdk1.8 的新特性一、 Lambda 表达式二、 方法引用三、函数式接口四、 接口允许定义默认方法和静态方法五、Stream API六、日期/时间类改进七、Optional 类八、 Java8 Base64 实现 jdk1.8 的新特性 一、 Lambda 表达式 Lambda 允许把函数作为一个方法的参数。 new Thread (()-> System.out.println ("abc" ) ) .start() ; 二、 方法引用 方法引用允许直接引用已有 Java 类或对
JDK 1.8 的新特性
weixin_47255175的博客
05-05 524
目录 一、接口的默认方法 二、Lambda 表达式 三、函数式接口 四、方法与构造函数引用 五、Lambda 作用域 六、访问局部变量 七、访问对象字段与静态变量 八、访问接口的默认方法 九、Date API 十、Annotation 注解 一、接口的默认方法 Java 8允许我们给接口添加一个非抽象的方法实现，只需要使用 default关键字即可，这个特征又叫做扩展方法， 示例代码如下: interface Formula { ​ double calcula..
jdk1.8的新特性
最新发布
qq_64847107的博客
06-11 976
Java.time包中引入了新的日期和时间API，包括LocalDate、LocalTime、LocalDateTime、ZonedDateTime、Instant等类，取代了旧的java.util.Date和Calendar类，提供了更好的设计和线程安全。为了配合Lambda表达式，Java 8增加了@FunctionalInterface注解来标记只有一个抽象方法的接口，如java.util.function包下的各种函数接口（如Predicate、Function、Consumer等）。
tomcat6.0.48+jdk1.7或jdk1.8或jdk1.6
06-28
标题中的"tomcat6.0.48+jdk1.7或jdk1.8或jdk1.6"指的是一个配置环境，其中Tomcat是Apache软件基金会的一个开源Java Servlet容器，版本为6.0.48，它主要用于部署和运行Java Web应用程序。而JDK（Java Development Kit...
一键tomcat7+jdk1.7和8+jdk1.8-详细笔记文档总结
07-09
export JAVA_HOME=/path/to/jdk1.7 或 /path/to/jdk1.8 export PATH=$PATH:$JAVA_HOME/bin:$CATALINA_HOME/bin ``` - 在Windows中，编辑`系统环境变量`，在`Path`变量中添加`%JAVA_HOME%\bin;%CATALINA_HOME%\...
tomcat6.0.44+jdk1.7或jdk1.8或jdk1.6
06-28
标题中的"tomcat6.0.44+jdk1.7或jdk1.8或jdk1.6"指的是一个配置环境，其中包含了Tomcat 6.0.44版本的应用服务器，以及Java Development Kit（JDK）的1.7、1.8或1.6版本。这个环境适用于那些需要在这些特定版本上运行...
JDK 1.8新特性
ggboy88的博客
09-09 456
一、lambda表达式 介绍 1). 使代码更加简洁； 2）可以配合很多新特性使用，编程更加优雅 例如：Runable 以前的写法 public class LambdaTest1 { public static void main(String[] args) { Runnable runnable = new Runnable() { public void run() { System.out.println("老方式实现
jDk 1.8新特性
zou2ouzou的博客
12-12 309
https://www.cnblogs.com/jacksontao/p/8608291.html
JDK 1.8 新特性
fanxiaobin
08-29 2132
总结JDK1.8中的新特性
面试总结之[JDK1.8新特性]
热门推荐
有糖哥
08-16 2万+
这几天面试中,问到JDK的基本都会问到有关JDK1.8的新特性,基于这点,自己简单总结了下; 看到网上有个人总结了这样一句话,感觉比较通俗易懂; 速度更快 – 红黑树 代码更少 – Lambda 强大的Stream API – Stream 便于并行 – Parallel 最大化减少空指针异常 – Optional 1:HashMap 有人会在问你HashMap的时候会问你...
JDK1.8新特性学习资料：入门到上手指南
在【描述】中提到的“性能对比等给同事学习分享笔记”，可能是指开发者在使用JDK8的新特性之前，应当对新旧版本的性能进行对比，从而理解在不同场景下使用新特性可能带来的性能变化。例如，使用Stream API与传统循环...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值