JAVA SE 6.版本特性及常用类

原创 已于 2025-03-26 14:31:06 修改 · 961 阅读 · 10
标签
#java #开发语言
于 2025-03-13 00:14:19 首次发布

1.Java各版本特性

在这里插入图片描述

1.Java8

  • 1.Lambda表达式
  • 2.函数式接口
  • 3.方法引用
  • 4.默认方法
  • 5.Stream API
  • 6.Optional类
  • 7.Date Time API
  • 8.Nashorn、JavaScript引擎

1.Lambda表达式

  • 1.定义：Lambda表达式是对匿名函数的简写形式，Lambda允许把函数作为一个方法的参数，可以写出更简洁的代码
  • 2.实质：语法糖，实质底层还是一个方法
    package domains;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.Getter;
import lombok.NoArgsConstructor;

/**
 * 员工
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
@Getter
public class Employee {
      
      
    private String name;
    private int age;
    private double salary;
}

    package dao;

public interface TestPredicate<T> {
      
      
    boolean test(T e);
}

    package dao.daoImpl;

import dao.TestPredicate;
import domains.Employee;

public class FilterEmployeeByAge implements TestPredicate<Employee> {
      
      
    @Override
    public boolean test(Employee employee) {
      
      
        return employee.getAge() > 24;
    }
}

    package dao.daoImpl;

import dao.TestPredicate;
import domains.Employee;

public class FilterEmployeeBySalary implements TestPredicate<Employee> {
      
      
    @Override
    public boolean test(Employee employee) {
      
      
        return employee.getSalary() > 8000;
    }
}

    import dao.TestPredicate;
import dao.daoImpl.FilterEmployeeByAge;
import dao.daoImpl.FilterEmployeeBySalary;
import domains.Employee;
import org.junit.Test;
import java.util.*;

public class TestLambda {
      
      

    List<Employee> employees = Arrays.asList(
            new Employee("张三",8,100),
            new Employee("李四",12,500),
            new Employee("王五",18,3000),
            new Employee("赵六",24,8000),
            new Employee("田七",35,15000),
            new Employee("吴八",40,25000)
    );

    /**
     * 原始
     */
    @Test
    public void test1(){
      
      
        //比较器 - 匿名内部类
        Comparator<Integer> comparator = new Comparator<Integer>(){
      
      
            @Override
            public int compare(Integer o1, Integer o2) {
      
      
                return Integer.compare(o1,o2);
            }
        };
        //注意：比较器的类型需要和TreeSet类型一致
        TreeSet<Integer> treeSet = new TreeSet<>(comparator);
    }

    /**
     * Lambda表达式化简
     */
    @Test
    public void test2(){
      
      
        //化简1
        Comparator<Integer> comparator = (x,y) -> Integer.compare(x,y);
        TreeSet<Integer> treeSet = new TreeSet<>(comparator);
        //化简2
        TreeSet<Integer> integerTreeSet = new TreeSet<>((x,y) -> Integer.compare(x,y));
    }

    /**
     * 需求1：获取员工年龄大于24岁的员工信息
     */
    @Test
    public void test3(){
      
      
        List<Employee> filterEmployees = filterAgeEmployees(employees);
        for (Employee filterEmployee : filterEmployees) {
      
      
            System.out.println(filterEmployee);
            /*  结果：
             Employee(name=田七, age=35, salary=15000.0)
             Employee(name=吴八, age=40, salary=25000.0)
            */
        }
    }

    /**
     * 需求1：获取员工年龄大于24岁的员工信息 优化1
     */
    @Test
    public void test4(){
      
      
        List<Employee> filterEmployees = filterEmployee(employees, new FilterEmployeeByAge());
        for (Employee filterEmployee : filterEmployees) {
      
      
            System.out.println(filterEmployee);
            /*  结果：
                Employee(name=田七, age=35, salary=15000.0)
                Employee(name=吴八, age=40, salary=25000.0)
            */
        }
    }

    /**
     * 需求2：获取员工工资大于8000的员工信息
     */
    @Test
    public void test5(){
      
      
        List<Employee> filterEmployees = filterSalaryEmployees(employees);
        for (Employee filterEmployee : filterEmployees) {
      
      
            System.out.println(filterEmployee);
            /*  结果：
                Employee(name=田七, age=35, salary=15000.0)
                Employee(name=吴八, age=40, salary=25000.0)
            */
        }
    }

    /**
     * 需求2：获取员工工资大于8000的员工信息 优化1
     */
    @Test
    public void test6(){
      
      
        List<Employee> filterEmployees = filterEmployee(employees,new FilterEmployeeBySalary());
        for (Employee filterEmployee : filterEmployees) {
      
      
            System.out.println(filterEmployee);
            /*  结果：
                Employee(name=田七, age=35, salary=15000.0)
                Employee(name=吴八, age=40, salary=25000.0)
            */
        }
    }

    /**
     * 根据年龄条件过滤员工信息
     * @param employees
     * @return
     */
    public List<Employee> filterAgeEmployees(List<Employee> employees){
      
      
        ArrayList<Employee> employeeArrayList = new ArrayList<>();
        for (Employee employee : employees) {
      
      
            if(employee.getAge() > 24){
      
      
                employeeArrayList.add(employee);
            }
        }
        return employeeArrayList;
    }

    /**
     * 根据薪水条件过滤员工信息
     * @param employees
     * @return
     */
    public List<Employee> filterSalaryEmployees(List<Employee> employees){
      
      
        ArrayList<Employee> employeeArrayList = new ArrayList<>();
        for (Employee employee : employees) {
      
      
            if(employee.getSalary() > 8000){
      
      
                employeeArrayList.add(employee);
            }
        }
        return employeeArrayList;
    }

    //优化方式一：策略设计模式. 优点：可以根据传入的策略执行不同的策略
    //注意：泛型类型需要填写，否则lambda会发生类型不匹配异常
    public List<Employee> filterEmployee(List<Employee> list, TestPredicate<Employee> predicate){
      
      
     ArrayList<Employee> employeeArrayList = new ArrayList<>();
        for (Employee employee : employees) {
      
      
            if(predicate.test(employee)){
      
      
                employeeArrayList.add(employee);
            }
        }
        return employeeArrayList;
    }

    //优化方式二：匿名内部类
    @Test
    public void test7(){
      
      
        List<Employee> filterEmployees = filterEmployee(employees,new TestPredicate<Employee>(){
      
      
            @Override
            public boolean test(Employee employee) {
      
      
                return employee.getSalary() < 5000;
            }
        });
        for (Employee filterEmployee : filterEmployees) {
      
      
            System.out.println(filterEmployee);
            /*  结果：
                Employee(name=张三, age=8, salary=100.0)
                Employee(name=李四, age=12, salary=500.0)
                Employee(name=王五, age=18, salary=3000.0)
            */
        }
    }
    //优化方式三：Lambda表达式
    @Test
    public void test8(){
      
      
        List<Employee> filterEmployees = filterEmployee(employees,(e) -> e.getSalary() < 5000);
        filterEmployees.forEach(System.out::println);
    }

    //优化方式四：Stream API
    @Test
 public void test9(){
      
      
        employees.stream().filter((e) -> e.getSalary() < 5000).forEach(System.out::println);
    }

}
1.Lambda基础语法
import org.junit.Test;

import java.util.Comparator;
import java.util.function.Consumer;

/**
 * Lambda表达式的基础语法:Java8中引入了一个新的操作符->，该操作符为箭>	头操作符或Lambda操作符
 * 箭头操作符将Lambda表达式拆分成两部分:
 * 左侧：Lambda表达式的参数列表
 * 右侧：Lambda表达式中所需执行的功能，即Lambda体
 *
 * 语法格式一:无参数，无返回值(小括号不可省略)
 *      () -> System.out.println("Hello Lambda");
 *
 * 语法格式二:一个参数，无返回值(小括号可省略，建议加上)
 *      x -> System.out.println(X);
 *
 * 语法格式三:两个及两个以上参数，并且Lambda体中有多条语句，小括号和大括号和return都不能省略
 *
 * 语法格式四:如果Lambda体中只有一条语句，return和大括号皆可省略
 *
 * 语法格式五:Lambda表达式的参数列表的数据类型可以省略不写，因为JVM编辑器通过上下文可以推断出数据类型，即类型推断
 *
 * 总结：
 *      1.可选类型声明：不需要声明参数类型，编译器可以通过上下文可以推断出数据类型
 *      2.可选参数圆括号：一个参数无需定义圆括号，但多个参数或无参需要定义圆括号
 *      3.可选的大括号：如果主题体只包含了一个语句，就不需要使用大括号，否则需要大括号
 *      4.可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，否则需要加return
 *
 * Lambda需要函数式接口的支持
 *      * 函数式接口：接口中只有一个抽象方法的接口
 *      * 通过注解@FuncationalInterface修饰可以检查是否为函数式接口
 *
 * 注意事项:
 *      1.lambda表达式只能引用标记了final的外层局部变量，即不能在Lambda内部修改定义在域外的局部变量，否则会编译错误(jdk7)
 *      2.lambda表达式的引用的外层局部变量可以不用声明为 final，但是必须不可被后面的代码修改（即隐性的具有 final 的语义，jdk8）
 *      3.lambda达式当中不允许声明一个与局部变量同名的参数或者局部变量
 */
public class TestLambda2 {
    
    
    
    @Test
    public void test1(){
    
    
        //传统匿名内部类
        Runnable runnable = new Runnable(){
    
    
            @Override
            public void run() {
    
    
                System.out.println("Hello World");
            }
        };
        runnable.run();
        //lambda表达式
        Runnable lambda = () -> System.out.println("Hello Lambda");
        lambda.run();
    }

    @Test
    public void test2(){
    
    
        Consumer<String> consumer = x -> System.out.println(x);
        consumer.accept("测试成功!");
    }

    @Test
    public void test3(){
    
    
        Comparator<Integer> comparator = (x, y) -> {
    
    
            System.out.println("测试成功!");
            return Integer.compare(x, y);
        };
    }

    @Test
    public void test4(){
    
    
        Comparator<Integer> comparator = (x, y) -> Integer.compare(x, y);
    }
}
2.Lambda上下文推断
//不能拆分开写，否则无法根据上下文推断出aaa,bbb,ccc的类型
String[]<
最低0.47元/天 解锁文章
（Java SE 6 Downloads）.zip
03-03
Java SE 6 Downloads Java 6 最后一个版本，超稳定。
JavaSE6_API
11-22
JavaSE6_API 帮助文档
Java历史版本官方下载地址（Java 6、Java 7、Java 8）
热门推荐
大道至简
05-24 14万+
Java历史版本官方下载地址： 1、Java 7官方下载地址；2、Java 8官方下载地址；
JDK / JAVA / JAVA SE 5,6,7,8,9,10,11官方下载地址大全
qq_24918471的博客
07-15 3万+
JAVA5 https://www.oracle.com/technetwork/java/javasebusiness/downloads/java-archive-downloads-javase5-419410.html JAVA6 https://www.oracle.com/technetwork/java/javase/downloads/java-archive-downloa...
全面Java SE 6.0编程技能指南
weixin_36277197的博客
12-01 934
本文还有配套的精品资源，点击获取 简介：本书详细介绍了Java SE 6.0（Java 6）的核心技术，包括Java基础、面向对象编程、异常处理、集合框架、I/O、多线程编程、网络编程、数据库编程、Swing GUI编程、国际化和本地化以及Java Applet和Web Start。本书旨在通过实例和练习，帮助开发者充分掌握Java 6的各个方面，以适应桌面应用、Web应用...
Java SE 6.0核心技术与应用案例
weixin_42509513的博客
05-01 681
Java SE 6.0作为Java平台的标准版的一个重要更新，引入了许多改进和新特性。本章将对Java SE 6.0的基础知识点进行回顾和概述，为深入学习后续章节的高级特性打下坚实的基础。在某些场景中，我们可能需要根据对象的特定属性来排序或比较。在这种情况下，可以实现Comparable接口或定义一个Comparator。// 构造器、equals和hashCode方法省略@Overrideif (this.x!// 使用Comparator进行排序@Override})
野马的性格 Java SE 6.0新特性体验（转自天极网）
十分钟年华老去
11-27 1810
没找到原始地址，只看到个 作者:朱先忠编译 出处:天极开发 【导读】Mustang（也称作Java SE 6），如今刚进入其第二个测试阶段。本文作者将同你进一步探讨这个新的发行版本中所提供的许多新的特征(从控制台I/O和存取权限控制方法到系统托盘API和表格排序和过滤等)。 一、引言
Java SE 6 新特性: Web 服务
csndwyl58379010的博客
06-09 3841
Java SE 6 新特性: Web 服务 2008-03-17 11:00 Web 服务 基 于 XML 的数据通常被作为 Web 服务之间互相调用的标准的数据传输文件格式。Java SE 6 SDK 中基于 XML 的解析技术，也提供了 Web 服务的 API 支持。和较早的 JDK 5 相比，新版本的 JDK Web 服务功能更改了名称...
java 版本区别，java SE是什么，下载JDK时各个名称的含义
yinghuo110的博客
06-11 4万+
问题一：常用的Java的三个版本以及JAVA SE是什么一、Java的版本区别     常用的 java 程序分为  Java SE、java EE、Java ME三个版本，介绍如下：1. Java SE（Java Platform，Standard Edition）java se 以前称为J2SE。它允许开发和部署在桌面、服务器、嵌入式环境和实时环境中使用的 Java 应用程序。Java SE是...
Java SE 1.6特性详解与实战指南.zip
weixin_42613017的博客
04-24 1164
Java SE 1.6，代号为 Mustang，于2006年发布，标志着Java语言的一个重要发展阶段。作为Java平台的一个长期支持版本，它为开发者们带来了众多新特性和改进。在这一章节中，我们将浅入深地探索Java SE 1.6的主要功能和亮点，理解它对当时开发社区的影响及其持续至今的价值。NIO.2中的核心API主要包括包下的类和接口。以下是几个关键类和它们的作用：Path: 它是一个抽象的路径表示，用于表示文件系统中的一个位置。Paths: 一个工具类，提供用于获取Path。
Java SE 24 新增特性
Practitioner
03-19 926
在这两种情况下，即通过 long、float、double 和布尔类型进行 switch 以及使用基元变量进行模式匹配时，与所有新的 switch 功能一样，switch 必须要涵盖所有可能的情况。这个功能在 JDK 23 上是第二次预览，现在是第三次预览，下述代码中，Child1的构造函数，只能先通过super构造父类，然后才能初始化子类的 b 这个变量。这个功能在JDK 23 上是第一次预览，主要功能是通过简洁地导入模块导出的所有包的功能来增简化了模块库的重复使用，但不要求导入代码本身必须在模块中。
Java SE(6)——类和对象（一）
最新发布
2401_89167985的博客
05-01 1522
面向对象编程关注的是对象，对象就相当于是生活中的实物，比如：洗衣机。但是计算机不知道什么是洗衣机，这需要我们开发人员来告诉计算机什么是洗衣机上图左边的信息就是对洗衣机的描述，我们可以用这种描述信息来表示一个具体的实物，这个过程称为抽象。所谓抽象，指的是从具体事物中抽取共同的、本质的特征，忽略次要的、非本质的特征。但是这些简化的抽象结果（图片左侧的描述信息）也不能被计算机识别，开发人员就需要使用某种面向对象的编程语言来进行描述，比如：Javafield;//属性或者成员变量method;
JavaSe6 编程指南
04-02
JavaSe6 编程指南
java se 6 api
05-19
java se 6 api
Java Archive Downloads - Java SE 6
11-17
JDK6　Java Archive Downloads - Java SE 6
Java SE 6 新特性5: Java DB 和 JDBC 4.0
elimago的专栏
09-18 1149
2006 年底，Sun 公司发布了 Java Standard Edition 6（Java SE 6）的最终正式版，代号 Mustang（野马）。跟 Tiger（Java SE 5）相比，Mustang 在性能方面有了不错的提升。与 Tiger 在 API 库方面的大幅度加强相比，虽然 Mustang 在 API 库方面的新特性显得不太多，但是也提供了许多实用和方便的功能：在脚本，WebSe
Java 1.6开发工具包中文版API参考
weixin_42592399的博客
09-26 1022
本文还有配套的精品资源，点击获取 简介：Java Development Kit (JDK) 1.6，也称为Java SE 6，是一个为Java开发者提供全面开发环境的工具集。JDK 1.6带来了包括Swing组件增强、内存管理改进、动态代理类支持、NIO.2扩展、Scripting支持、国际化改进、JDBC 4.0升级、XML处理API优化、并发工具增强和安全管理加强在内...
Java第二阶段JavaSE6(集合)
CabbageTomato的博客
02-16 771
一、Java集合框架 1.集合和数组一样，可以保存一组元素，但是集合将元素的操作都封装成了方法，操作简便，并且集合提供了多种不同的实现供我们使用。 2.java,util.Collection是所有集合的顶级接口，里面定义了所有集合都必须具备的功能方法 3.集合有两类常用子类： 1）java.util.List:可重复的集合，且有序。通常我们称它为“线性表” 2）java.util.Set:不可重复的集合 上述两个都是接口，而元素是否重复取决于元素自身的equals方法，即：Set集合中不会存
JVM(五)：JAVA SE 6 参数大全
qq_39947090的博客
12-15 494
HotSpot JVM SE 6 参数
Mac 10.11 java se6 不兼容问题
iamfreedom2011的专栏
10-12 2335
本帖最后由 赵艾安 于 2015-7-3 18:50 编辑  不少朋友问下题何解，终于，撸主找到了解题方法~此文来自国外大神，点击传送门可前去瞻仰。 This application requires the legacy Java SE 6 runtime which is unavailable for this version of OS X 解决办法
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值