java学习笔记-EW帮帮网

java泛型

泛型就像是一个"万能模板"，它允许我们在编写代码时不指定具体的数据类型，等到实际使用时再确定类型。这样一份代码就可以处理多种数据类型。

一，泛型的基本语法

泛型类

class 类名<T> {
    // T可以是任何非基本类型
    // 在类内部可以把T当作真实类型使用
}

泛型方法
泛型接口

二，泛型通配符

有时候我们不知道或者不关心具体类型，可以使用通配符?：

无界通配符
上界通配符
下界通配符

三，泛型在实际中的应用

集合框架
自定义泛型类
泛型方法

四，泛型的限制

不能使用基本类型：如List<int>是非法的，必须用List<Integer>
不能实例化泛型类型：如new T()是不允许的
不能创建泛型数组：如new T[10]是非法的
类型擦除：运行时泛型信息会被擦除，List<String>和List<Integer>在运行时都是List

五，最佳实践

尽量使用泛型，使代码更安全
使用有意义的类型参数名称，如<K,V>表示键值对
当不确定类型时使用通配符?
优先使用Java集合框架中的泛型集合

泛型是Java中提高代码质量和安全性的重要工具，虽然初学可能觉得复杂，但掌握后会让你的代码更加健壮和灵活。

Java中的List

List是Java中最常用的集合类型之一，你可以把它想象成一个"可以自动变长变短的数组"。

一，基本概念

List是什么？
• 就像你去超市的购物清单，可以一项一项往下写

• 可以随时添加、删除、修改里面的内容

• 里面的内容是有顺序的（先放进去的在前面）
和数组的区别
• 数组：长度固定，比如String[5]就只能放5个

• List：长度可变，想放多少放多少

二，常用List类型

Java中最常用的两种List：

ArrayList
• 像一排连续座位，查找快但中间插入/删除慢

• 适合：经常按位置查找，不常插入删除的情况
LinkedList
• 像珍珠项链，每颗珍珠都连着下一颗

• 适合：经常在中间插入/删除的情况

三，基本使用

1，创建List

// 创建ArrayList
List<String> shoppingList = new ArrayList<>();

// 创建LinkedList
List<Integer> numbers = new LinkedList<>();

2，添加元素

shoppingList.add("苹果");  // ["苹果"]
shoppingList.add("香蕉");  // ["苹果", "香蕉"]
shoppingList.add(1, "牛奶"); // ["苹果", "牛奶", "香蕉"]

3，获取元素

String firstItem = shoppingList.get(0); // "苹果"

4，删除元素

shoppingList.remove(0); // 删除第1个
shoppingList.remove("香蕉"); // 删除"香蕉"

5，遍历List

// 方法1：for循环
for(int i=0; i<shoppingList.size(); i++) {
    System.out.println(shoppingList.get(i));
}

// 方法2：增强for循环
for(String item : shoppingList) {
    System.out.println(item);
}

// 方法3：Java8的forEach
shoppingList.forEach(item -> System.out.println(item));

四，实际例子

假设我们要管理一个班级的学生名单：

List<String> students = new ArrayList<>();

// 添加学生
students.add("张三");
students.add("李四");
students.add("王五");

// 转学来一个新同学
students.add(1, "赵六"); // 插到第二位

// 李四退学了
students.remove("李四");

// 查看班级人数
System.out.println("班级人数：" + students.size());

// 打印所有学生
System.out.println("班级名单：");
for(String name : students) {
    System.out.println(name);
}

五，注意事项

泛型：List<String>表示这个List只能放String类型
索引：和数组一样从0开始计数
常用方法：
• size() - 获取元素个数

• isEmpty() - 判断是否为空

• contains() - 是否包含某元素

• clear() - 清空列表

List是Java编程中最基础也最重要的集合类型，掌握了它，你就迈出了Java集合框架的第一步！

增强for循环

增强for循环（也称为for-each循环）是Java中一种简化版的循环语法，专门用于遍历数组或集合中的元素。它比传统for循环更简洁易读。

一，基本语法格式

// 用户表(user)的Mapper
@Mapper
public interface UserMapper {
    User selectById(Long id);
    int insert(User user);
    // 其他基础CRUD操作...
}

示例1：遍历数组

// 定义一个字符串数组
String[] fruits = {"苹果", "香蕉", "橙子", "西瓜"};

// 使用增强for循环遍历
for(String fruit : fruits) {
    System.out.println(fruit);
}

输出结果：

苹果
香蕉
橙子
西瓜

示例2：遍历集合

// 定义一个ArrayList集合
List<Integer> numbers = new ArrayList<>();
numbers.add(10);
numbers.add(20);
numbers.add(30);

// 使用增强for循环遍历
for(int num : numbers) {
    System.out.println(num * 2); // 每个数字乘以2后输出
}

输出结果：

20
40
60

二，与传统for循环对比

传统for循环写法：

for(int i = 0; i < fruits.length; i++) {
    System.out.println(fruits[i]);
}

增强for循环优势：

代码更简洁
不需要手动控制索引
不容易出现数组越界错误

三，注意事项

不能修改集合：在增强for循环中不能直接增删集合元素，否则会抛出ConcurrentModificationException异常
没有索引信息：如果需要索引，还是要用传统for循环
适用于所有Iterable对象：不仅可以遍历数组和List，还可以遍历Set、Map的keySet等

四，实际应用场景

遍历显示所有商品
计算学生成绩总和
查找集合中符合条件的元素
批量处理数据

记住口诀："对于集合中的每一个元素，做某事"，这样写代码时就自然想到增强for循环了！

Java Lambda表达式

Lambda表达式是Java 8引入的一种简洁的匿名函数写法，可以大幅简化代码。下面我用通俗易懂的方式讲解它的写法和用法。

一、Lambda表达式基本语法

(参数列表) -> { 方法体 }

1，最简单的形式

// 无参数无返回值
() -> System.out.println("Hello Lambda")

2，带参数的形式

// 一个参数
x -> x * x

// 多个参数
(x, y) -> x + y

3，带参数类型声明

(int a, int b) -> a + b

二、常见使用场景

替代匿名内部类

// 旧写法
new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("传统写法");
    }
}).start();

// Lambda写法
new Thread(() -> System.out.println("Lambda写法")).start();

集合遍历

List<String> list = Arrays.asList("Java", "Python", "C++");

// 传统for循环
for(String s : list) {
    System.out.println(s);
}

// Lambda写法
list.forEach(s -> System.out.println(s));

集合操作

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

// 过滤偶数
numbers.stream()
       .filter(n -> n % 2 == 0)
       .forEach(System.out::println);

三、方法引用

Lambda表达式的进一步简化写法：

// 等同于 s -> System.out.println(s)
list.forEach(System.out::println);

四、实际应用示例

排序

List<String> names = Arrays.asList("Tom", "Jerry", "Alice");

// 传统写法
Collections.sort(names, new Comparator<String>() {
    @Override
    public int compare(String a, String b) {
        return a.compareTo(b);
    }
});

// Lambda写法
Collections.sort(names, (a, b) -> a.compareTo(b));

// 方法引用写法
Collections.sort(names, String::compareTo);

条件过滤

List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5, 6);

// 过滤出大于3的数
List<Integer> result = nums.stream()
                          .filter(x -> x > 3)
                          .collect(Collectors.toList());

五、注意事项

Lambda表达式只能用于函数式接口（只有一个抽象方法的接口）
参数类型可以省略，编译器会自动推断
方法体只有一行代码时，可以省略大括号和return
方法体有多行代码时，需要使用大括号

记住：Lambda表达式让代码更简洁，但不要过度使用，适当保持可读性更重要。

java学习笔记

java泛型

一，泛型的基本语法

泛型类

泛型方法

泛型接口