前言
文章主要介绍了JDK5.0,7.0与8.0新增加常用的新特性
JDK5.0
1、枚举
枚举是JDK5中引入的一个新类型,它允许开发者定义一组常量。枚举可以用来表示事物的状态或类型。
枚举的定义如下:
public enum Color {
RED,
GREEN,
BLUE
}
2、foreach
foreach 循环是JDK5中引入的新循环语句,它可以用于遍历集合或数组。foreach 循环的语法如下:
for (元素类型 元素变量 : 集合或数组) {
// 对元素变量进行操作
}
foreach 循环的示例代码如下:
public class ForeachTest {
public static void main(String[] args) {
List<String> list = Arrays.asList("a", "b", "c");
for (String str : list) {
System.out.println(str); // a b c
}
}
}
3、自动装箱和拆箱
自动装箱是指将基本类型自动转换为包装类的过程,自动拆箱是指将包装类自动转换为基本类型的过程。
自动装箱和拆箱的示例代码如下:
public class AutoBoxingAndUnboxingTest {
public static void main(String[] args) {
int i = 10;
// 自动装箱
Integer j = i;
// 自动拆箱
i = j;
}
}
4、StringBuilder
StringBuilder 是JDK5中引入的一个字符串缓冲区类,它允许开发者在字符串末尾追加字符或字符串。
StringBuilder 的示例代码如下:
public class StringBuilderTest {
public static void main(String[] args) {
StringBuilder builder = new StringBuilder();
builder.append("Hello, ");
builder.append("World!");
System.out.println(builder); // Hello, World!
}
}
5、Callable
Callable接口允许您创建可以返回结果并抛出异常的线程任务。与Runnable不同,Callable允许线程池返回结果,使错误处理更容易。
import java.util.concurrent.Callable;
public class MyCallable implements Callable<Integer> {
@Override
public Integer call() throws Exception {
// 执行一些计算,并返回结果
return 42;
}
}
6、线程池
使用线程池来执行任务,提高了应用程序的性能和资源管理。
ExecutorService executor = Executors.newFixedThreadPool(5);
executor.submit(new MyRunnable());
Future<Integer> result = executor.submit(new MyCallable());
7、泛型
允许在编写类型安全的代码时使用参数化类型。这提高了代码的可读性和可维护性。
List<String> list = Arrays.asList("wo", "ai", "ni");//规定使用String
list.forEach(s-> System.out.println(s));//遍历打印
JDK7.0
1、switch...case支持String
在 JDK7 之前,switch...case 语句只能用于整数类型。JDK7 开始,switch...case 语句可以用于 String 类型。
public class SwitchTest {
public static void main(String[] args) {
String color = "red";
switch (color) {
case "red":
System.out.println("红色");
break;
case "green":
System.out.println("绿色");
break;
case "blue":
System.out.println("蓝色");
break;
default:
System.out.println("未知颜色");
break;
}
}
}
2、类型推断(泛型)
在 JDK7 之前,泛型类型必须显式指定。JDK7 开始,可以使用类型推断来自动推断泛型类型。
public class TypeInferenceTest {
public static void main(String[] args) {
List<String> list = Arrays.asList("a", "b", "c");
// JDK7 之前的写法
List<String> list2 = new ArrayList<>();
for (String str : list) {
list2.add(str);
}
// JDK7 之后的写法
List<String> list3 = list;
}
}
3、Objects(工具类)
JDK7 继续完善了 Objects 工具类,增加了一些新方法。
列举了一些比较常用的Objects 工具类
Objects.nonNull():判断对象是否为 null。
Objects.requireNonNull():判断对象是否为 null,如果为 null 则抛出异常。
Objects.equals():比较两个对象是否相等。
Objects.hashCode():计算对象的哈希码。
Objects.toString():将对象转换为字符串。
JDK8.0
1、Lambda表达式。
语法:->操作符,
左侧:指定了表达式需要的参数列表。(要执行的方法的参数列表。)
右侧:指定了Lambda体,要执行的功能。(重写的方法的方法体。)
Runnable runnable1 = () -> {
for (int i = 0; i < 100; i++) {
if(i % 2 == 0) {
System.out.println(i);
}
}
};
Runnable r1=()->System.out.println("你好中国!");
r1.run();
Runnable r2= new Runnable() {
@Override
public void run() {
System.out.println("美国");
}
};
r2.run();
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
names.forEach(name -> System.out.println(name));
注意:
1:如果用在接口上,这个接口必须是函数式接口(一个接口中只有一个抽象方法)。
2:如果重写的方法只有一条语句,大括号可以省略。
3:如果有参数,参数的数据类型必须省略。
4:如果只有一个参数,参数的小括号可以省略。
5:如果有多个参数,小括号就不可以省略
7:如果有返回值,并且重写的方法只有一条语句,return必须省略
8:如果有返回值,重写的方法有多条语句,return正常写。
2、函数式接口
只包含一个抽象方法的接口。接口中可以有其他的方法。(默认方法,静态方法)
JDK内置的函数式接口:
四大核心函数式接口:
1、Consumer<T>(消费):对类型为T的对象应用操作,包含一个方法accept(T t)
import java.util.function.Consumer;
public class ConsumerExample {
public static void main(String[] args) {
Consumer<String> printer = (str) -> System.out.println(str);
printer.accept("Hello, World!");
}
}
2、Supplier<T>(供给):返回类型为T的对象,T get()
import java.util.function.Supplier;
public class SupplierExample {
public static void main(String[] args) {
Supplier<Integer> randomInteger = () -> (int) (Math.random() * 100);
System.out.println(randomInteger.get());
}
}
3、Function<T>(函数式):对类型为T的对象进行操作,会返回一个结果。R apply(T t)
import java.util.function.Function;
public class FunctionExample {
public static void main(String[] args) {
Function<Integer, String> intToString = (num) -> "Number: " + num;
System.out.println(intToString.apply(42));
}
}
4、Predicate<T>(判断性):确定T的对象是否满足要求,并返回boolean。boolean test(T t)
import java.util.function.Predicate;
public class PredicateExample {
public static void main(String[] args) {
Predicate<Integer> isEven = (num) -> num % 2 == 0;
System.out.println(isEven.test(4)); // 输出 true
}
}
3、 Stream API
使用Stream的三个步骤:
1、创建Stream一个数据源,获取一个流对象
2、中间操作。
Stream.of(11,2,20,39,58,67,100,100)
.distinct()
.sorted((t1,t2) -> -t1.compareTo(t2))
.limit(3)
.forEach(System.out::println);
1)筛选与切片
(1)filter(Predicate):从流中排除一些元素
(2)distinct():筛选,通过流所生成的元素的hashCode和equals去除重复的元素。
(3)limit(long maxSize):截断流,元素不超过给定数量
(4)skip(long):跳过元素,忽略元素。
2)映射
(1)map(Function):接收一个函数作为参数,会被应用到每个元素上,并将其映射为一个新的元素。
(2)mapToDouble(ToDoubleFunction):接收一个函数作为参数,会被应用到每个元素上,并将其映射为一个新的DoubleFunction流。
(3)mapxxxx
3)排序
sorted():产生一个新流,按照自然排序。
sorted(Comparator):产生一个新流,按照定制排序。
3、终止操作。
1)匹配与查找
import java.util.Arrays;
import java.util.List;
public class StreamTest {
public static void main(String[] args) {
// 创建一个列表
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
// 遍历列表
numbers.forEach((number) -> System.out.println(number));
// 检查是否所有元素都为偶数
boolean allEven = numbers.stream().allMatch((number) -> number % 2 == 0);
System.out.println("所有元素都为偶数:" + allEven);
// 检查是否至少有一个元素为偶数
boolean anyEven = numbers.stream().anyMatch((number) -> number % 2 == 0);
System.out.println("至少有一个元素为偶数:" + anyEven);
// 检查是否没有元素为偶数
boolean noneEven = numbers.stream().noneMatch((number) -> number % 2 == 0);
System.out.println("没有元素为偶数:" + noneEven);
// 返回第一个元素
Integer first = numbers.stream().findFirst().get();
System.out.println("第一个元素:" + first);
// 返回任意一个元素
Integer any = numbers.stream().findAny().get();
System.out.println("任意一个元素:" + any);
// 返回最大值
Integer max = numbers.stream().max(Integer::compareTo).get();
System.out.println("最大值:" + max);
// 返回最小值
Integer min = numbers.stream().min(Integer::compareTo).get();
System.out.println("最小值:" + min);
// 统计元素个数
long count = numbers.stream().count();
System.out.println("元素个数:" + count);
}
}
(1)forEach():遍历
(2)allMatch():检查是否匹配所有元素
(3)anyMatch():是否至少匹配一个元素
(4)noneMatch():没有匹配的元素
(5)findFirst():返回第一个元素
(6)findAny():返回任意一个元素
(7)max、min:返回最大、最小值
(8)count():统计
2)规约
(1)reduce(T,BinaryOperator):可以将流中的元素反复结合起来,得到一个值,返回T
(2)reduce(BinaryOperator):可以将流中的元素反复结合起来,得到一个值,返回BinaryOperator
3)收集
(1)collect(Collectors) 将流转换位其他形式。