Lambda 表达式这个名字的由来可以追溯到 λ演算（Lambda Calculus），这是一个由数学家 阿隆佐·邱奇（Alonzo Church） 在 1930 年代提出的数学和逻辑系统。

• λ 是 "lambda" 的缩写，在数学中常用于表示函数

• 比如

  名字由来详解

  1. λ 符号的起源

• λ 是希腊字母表的第 11 个字母

• 在 λ 演算中，邱奇使用 λ 来表示函数抽象

• 例如：λx.x+1 表示一个接受参数 x 并返回 x+1 的函数

————————————————————————

言归正传

List<AtAuctionGoods> atAuctionGoods = atAuctionGoodsMapper.selectByExample(atAuctionGoodsExample);

各组成部分：

1. List<AtAuctionGoods> - 查询结果的类型，是一个包含 AtAuctionGoods 对象的列表

2. atAuctionGoods - 变量名，用于存储查询结果

3. atAuctionGoodsMapper - MyBatis 的 Mapper 接口实例

4. selectByExample - MyBatis 的查询方法，根据条件示例查询

5. atAuctionGoodsExample - 查询条件对象，包含了筛选条件

对应的 MyBatis 文件结构

Mapper 接口

public interface AtAuctionGoodsMapper {
    List<AtAuctionGoods> selectByExample(AtAuctionGoodsExample example);
    // 其他方法...
}

实体类

public class AtAuctionGoods {
    private Long id;
    private String goodsName;
    private BigDecimal price;
    private Long packageId;  // 可能关联包裹的字段
    // 其他字段、getter/setter...
}

查询条件示例

AtAuctionGoodsExample example = new AtAuctionGoodsExample();
example.createCriteria()
    .andPackageIdEqualTo(packageId);  // 设置包裹ID条件

如果查询有误，可能的

取出auctionGoodsCode字段集合

根据你的需求，要取出 auctionGoodsCode 字段的集合，有几种实现方式：

方法一：先查询再提取（推荐）

// 1. 查询本包裹下的商品
List<AtAuctionGoods> atAuctionGoods = atAuctionGoodsMapper.selectByExample(atAuctionGoodsExample);

// 2. 提取 auctionGoodsCode 字段集合
List<String> auctionGoodsCodes = atAuctionGoods.stream()
    .map(AtAuctionGoods::getAuctionGoodsCode)  // 假设是String类型
    .collect(Collectors.toList());

方法二：使用 Java 8 Stream API（简洁版）

List<String> auctionGoodsCodes = atAuctionGoodsMapper.selectByExample(atAuctionGoodsExample)
    .stream()
    .map(AtAuctionGoods::getAuctionGoodsCode)
    .collect(Collectors.toList());

方法三：使用自定义 Mapper 方法（效率更高）

如果需要只查询特定字段，可以添加自定义查询方法：

1. 在 Mapper 接口中添加方法：

public interface AtAuctionGoodsMapper {
    // 原有的方法
    List<AtAuctionGoods> selectByExample(AtAuctionGoodsExample example);
    
    // 新增：只查询 auctionGoodsCode 字段
    List<String> selectAuctionGoodsCodesByExample(AtAuctionGoodsExample example);
}

2. 在 XML 映射文件中添加：

运行

<select id="selectAuctionGoodsCodesByExample" resultType="java.lang.String">
    SELECT auction_goods_code 
    FROM at_auction_goods
    <if test="_parameter != null">
        <include refid="Example_Where_Clause" />
    </if>
</select>

3. 使用自定义方法：

// 直接获取 auctionGoodsCode 集合
List<String> auctionGoodsCodes = atAuctionGoodsMapper.selectAuctionGoodsCodesByExample(atAuctionGoodsExample);

方法四：手动遍历提取

List<String> auctionGoodsCodes = new ArrayList<>();
for (AtAuctionGoods goods : atAuctionGoods) {
    auctionGoodsCodes.add(goods.getAuctionGoodsCode());
}

根据你的具体需求选择：

• 如果只是偶尔需要：使用方法一或二，代码清晰简单

• 如果频繁使用且性能重要：使用方法三，减少数据传输量

• 如果使用老版本 Java：使用方法四

注意：

请确认 AtAuctionGoods 实体类中有 getAuctionGoodsCode() 方法，且字段类型正确。

::这是什么符号，什么作用

:: 是 Java 8 引入的 方法引用 运算符。它有几种常见用法：

1. 基本作用

• 用于简化 Lambda 表达式

• 引用已有的方法

• 语法：类名::方法名

2. 常见用法示例

情况1：静态方法引用

// Lambda 写法
Function<String, Integer> parser1 = s -> Integer.parseInt(s);

// 方法引用写法（更简洁）
Function<String, Integer> parser2 = Integer::parseInt;

情况2：实例方法引用（你代码中的用法）

List<AtAuctionGoods> goodsList = ...;

// Lambda 写法
List<String> codes1 = goodsList.stream()
    .map(goods -> goods.getAuctionGoodsCode())
    .collect(Collectors.toList());

// 方法引用写法（你代码中的用法）
List<String> codes2 = goodsList.stream()
    .map(AtAuctionGoods::getAuctionGoodsCode)  // 引用 getter 方法
    .collect(Collectors.toList());

情况3：任意对象的实例方法引用

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

// Lambda 写法
names.forEach(name -> System.out.println(name));

// 方法引用写法
names.forEach(System.out::println);

情况4：构造方法引用

// Lambda 写法
Supplier<List<String>> supplier1 = () -> new ArrayList<>();

// 方法引用写法
Supplier<List<String>> supplier2 = ArrayList::new;

3. 在你的代码中具体作用

.map(AtAuctionGoods::getAuctionGoodsCode)

等同于：

.map(goods -> goods.getAuctionGoodsCode())

4. 四种方法引用类型

类型	语法	对应的 Lambda 表达式
静态方法引用	类名::静态方法	(args) -> 类名.静态方法(args)
实例方法引用（特定对象）	对象::实例方法	(args) -> 对象.实例方法(args)
实例方法引用（任意对象）	类名::实例方法	(obj, args) -> obj.实例方法(args)
构造方法引用	类名::new	(args) -> new 类名(args)

5. 优点

1. 代码更简洁：减少冗余代码

2. 可读性更好：直接看到引用的方法

3. 易于维护：方法变更只需改一处

注意：

方法引用只能用于 函数式接口（只有一个抽象方法的接口），比如 Function<T,R>、Consumer<T>、Supplier<T> 等。