JDK5.0，7.0与8.0常用新特性

橙橙橙留香

已于 2024-01-13 14:39:56 修改

阅读量114

点赞数

文章标签： java

于 2023-10-24 21:24:09 首次发布

本文链接：https://blog.csdn.net/dS1_mple/article/details/134019577

版权

本文讲述了Java开发工具包JDK5、7、8版本新增的特性，如枚举、foreach、自动装拆箱、StringBuilder、Callable、线程池优化、泛型增强、switch对String的支持、类型推断、Objects工具和Lambda表达式、函数式接口及StreamAPI的应用。

摘要由CSDN通过智能技术生成

前言

文章主要介绍了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）收集