Java基础编程500题——匿名内部类与lambda表达式

💥 该系列属于【Java基础编程500题】专栏，如您需查看Java基础的其他相关题目，请您点击左边的连接

目录

1. 定义一个函数式接口，实现一个方法，接受一个字符串并返回其长度。使用匿名内部类在Main方法中创建该接口的实例，并输出字符串“Hello World”的长度。

2. 使用lambda表达式实现一个函数式接口，该接口有一个方法，接受一个整数数组并返回数组中的最大值。在Main方法中调用该方法，并输出结果。

3. 定义一个函数式接口，该接口有一个方法，接受一个字符串并返回其首字母大写形式。使用匿名内部类和lambda表达式在Main方法中创建该接口的实例，并输出字符串“java”首字母大写后的形式。

4. 定义一个函数式接口，实现一个方法，使用lambda表达式将字符串转换为整数。

5. 使用匿名内部类实现一个比较器，对整数数组进行升序排序。

6. 使用lambda表达式实现一个比较器，对整数数组进行降序排序。

7. 使用方法引用创建一个函数式接口，该接口用于计算两个整数的和。

8*. 使用匿名内部类实现一个线程，输出“匿名内部类创建的线程正在运行”。

9*.使用lambda表达式实现一个线程，输出“lambda表达式创建的线程正在运行”。

10*. 使用方法引用实现一个线程，输出“方法引用创建的线程正在运行”。

---

    ✨✨  返回题目目录 ✨ ✨ 

Java基础编程500题

---

“匿名内部类不是类，而是一个实现了某个接口的对象。”

1. 定义一个函数式接口StringUtil，实现一个方法，接受一个字符串并返回其长度。使用匿名内部类在Main方法中创建该接口的实例，并输出字符串“Hello World”的长度。

@FunctionalInterface
interface StringUtil {
    int length(String str);
}

public class Main {
    public static void main(String[] args) {
        StringUtil stringUtil = new StringUtil() {
            @Override
            public int length(String str) {
                return str.length();
            }
        };
        System.out.println("字符串长度：" + stringUtil.length("Hello World"));
    }
}

2. 使用lambda表达式实现一个函数式接口NumberUtil，该接口有一个方法，接受一个整数数组并返回数组中的最大值。在Main方法中调用该方法，并输出结果。

@FunctionalInterface
interface NumberUtil {
    Integer Max(int a, int b);
}

public class Main {
    public static void main(String[] args) {
        NumberUtil numberUtil = (a, b) -> Math.max(a, b);
        System.out.println(numberUtil.Max(2, 4));
    }
}

3. 定义一个函数式接口，该接口有一个方法，接受一个字符串并返回其首字母大写形式。使用匿名内部类和lambda表达式在Main方法中创建该接口的实例，并输出字符串“java”首字母大写后的形式。

@FunctionalInterface
interface Capitalize {
    String capitalize(String str);
}

public class Main {
    public static void main(String[] args) {
        Capitalize capitalize1 = new Capitalize() {
            @Override
            public String capitalize(String str) {
                if (str == null || str.isEmpty()) {
                    return str;
                }
                return Character.toUpperCase(str.charAt(0)) + str.substring(1);
            }
        };

        Capitalize capitalize2 = str -> {
            if (str == null || str.isEmpty()) {
                return str;
            }
            return Character.toUpperCase(str.charAt(0)) + str.substring(1);
        };


        System.out.println("首字母大写：" + capitalize1.capitalize("java"));
        System.out.println("首字母大写：" + capitalize2.capitalize("java"));
    }
}

4. 定义一个函数式接口，实现一个方法，使用lambda表达式将字符串转换为整数。

@FunctionalInterface
interface StringToIntConverter {
    int convert(String str);
}

public class Main {
    public static void main(String[] args) {
        StringToIntConverter converter = str -> Integer.parseInt(str);
        System.out.println("字符串转换为整数：" + converter.convert("123"));
    }
}

5. 使用匿名内部类实现一个比较器，对整数数组进行升序排序。

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        Integer[] numbers = {3, 1, 4, 1, 5, 9};
        Arrays.sort(numbers, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1.compareTo(o2);
            }
        });
        System.out.println("匿名内部类实现的排序结果：" + Arrays.toString(numbers));
    }
}

6. 使用lambda表达式实现一个比较器，对整数数组进行降序排序。

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        Integer[] numbers = {3, 1, 4, 1, 5, 9};
        Arrays.sort(numbers, (o1, o2) -> o2.compareTo(o1));
        System.out.println("lambda表达式实现的降序排序结果：" + Arrays.toString(numbers));
    }
}

7. 使用方法引用创建一个函数式接口，该接口用于计算两个整数的和。

// 方法一：

// 定义函数式接口
@FunctionalInterface
interface Calculator {
    int calculate(int a, int b);
}

public class Main {
    public static void main(String[] args) {
        // 使用方法引用
        Calculator add = Integer::sum;
        System.out.println("两数之和：" + add.calculate(10, 20));
    }
}

//方法二：

// 定义函数式接口
@FunctionalInterface
interface Calculator {
    int calculate(int a, int b);
}

public class Main {
    public static void main(String[] args) {
        // 使用方法引用
        Calculator add = Main::sum;
        System.out.println("两数之和：" + add.calculate(10, 20));
    }

    public static int sum(int a, int b) {
        return a + b;
    }
}

8*. 使用匿名内部类实现一个线程，输出“匿名内部类创建的线程正在运行”。

public class Main {
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("匿名内部类创建的线程正在运行");
            }
        }).start();
    }
}

9*.使用lambda表达式实现一个线程，输出“lambda表达式创建的线程正在运行”。

public class Main {
    public static void main(String[] args) {
        new Thread(() -> System.out.println("lambda表达式创建的线程正在运行")).start();
    }
}

10*. 使用方法引用实现一个线程，输出“方法引用创建的线程正在运行”。

public class Main {
    public static void runTask() {
        System.out.println("方法引用创建的线程正在运行");
    }

    public static void main(String[] args) {
        new Thread(Main::runTask).start();
    }
}