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

本文讲述了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)收集

        (1)collect(Collectors) 将流转换位其他形式。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

橙橙橙留香

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值