javaSE（1）

一、.ArrayList（）和 LinkedList（）的差别。

1. 实现方式：
- ArrayList是基于数组实现的动态数组，它可以自动扩容以容纳更多的元素。
- LinkedList是基于双向链表实现的，每个元素都包含一个指向前一个和后一个元素的引用。

2. 插入和删除操作：
- 在ArrayList中，插入和删除元素可能需要移动其他元素以保持数组的连续性，这可能会导致性能下降。
- 在LinkedList中，插入和删除元素只需要改变相邻元素的引用，因此性能更好。

3. 随机访问：
- ArrayList支持随机访问，可以通过索引直接访问元素。
- LinkedList不支持随机访问，需要从头部或尾部开始遍历链表才能访问特定位置的元素。

4. 内存占用：
- ArrayList在添加或删除元素时可能会浪费一些内存空间，因为它需要预留一定的额外空间以供扩容。
- LinkedList的每个元素都包含额外的指针，因此可能会占用更多的内存空间。

5. 性能比较：
- 在大多数情况下，ArrayList的性能优于LinkedList，特别是在需要频繁访问元素的情况下。
- 在需要频繁插入和删除元素的情况下，LinkedList的性能可能更好。

  ArrayList适合需要频繁访问元素的情况，而LinkedList适合需要频繁插入和删除元素的情况。在选择使用哪种数据结构时，需要根据具体的需求和场景做出合适的选择。

二、MySQL中如何创建索引，索引的作用，索引的底层

在MySQL中，可以通过以下方式创建索引：

1. 在创建表时指定索引：

CREATE TABLE table_name (
    column1 data_type,
    column2 data_type，
    INDEX index_name (column_name)
);
 

2. 在已创建的表上添加索引：

CREATE INDEX index_name ON table_name (column_name);
 

3. 在已创建的表上添加唯一索引：
CREATE UNIQUE INDEX index_name ON table_name (column_name);

索引的作用：
- 提高查询效率：通过索引，数据库引擎可以快速定位到需要查询的数据，减少了全表扫描的时间，提高了查询效率。
- 加速排序：当使用索引进行排序时，可以避免对整个数据集进行排序，从而提高排序的速度。
- 加速数据的唯一性约束：通过在唯一字段上创建唯一索引，可以确保数据的唯一性。

索引的底层实现：
在MySQL中，主要有两种类型的索引实现方式：
1. B-Tree索引：B-Tree是一种平衡树结构，可以快速定位到需要查询的数据。在MySQL中，大多数索引都是基于B-Tree实现的。
2. Hash索引：Hash索引是通过哈希算法将索引列的值映射到一个哈希表中，可以快速查找到对应的数据。但是，Hash索引只支持等值查询，不支持范围查询和排序。

在实际应用中，根据具体的查询需求和数据特点选择合适的索引类型和创建方式，可以有效提高查询效率和性能。

三、spring注入

在Spring框架中，可以使用多种方式进行依赖注入（DI）：

1. 构造函数注入（Constructor Injection）：

@Component
public class MyClass {
    private MyDependency myDependency;

    @Autowired
    public MyClass(MyDependency myDependency) {
        this.myDependency = myDependency;
    }
}
```

2. 属性注入（Setter Injection）：

@Component
public class MyClass {
    private MyDependency myDependency;

    @Autowired
    public void setMyDependency(MyDependency myDependency) {
        this.myDependency = myDependency;
    }
}
```

3. 字段注入（Field Injection）：

@Component
public class MyClass {
    @Autowired
    private MyDependency myDependency;
}
```

4. 方法注入（Method Injection）：

@Component
public class MyClass {
    private MyDependency myDependency;

    @Autowired
    public void injectDependency(MyDependency myDependency) {
        this.myDependency = myDependency;
    }
}
```

5. 接口注入（Interface Injection）：

public interface MyInterface {
    void setMyDependency(MyDependency myDependency);
}

@Component
public class MyClass implements MyInterface {
    private MyDependency myDependency;

    @Autowired
    public void setMyDependency(MyDependency myDependency) {
        this.myDependency = myDependency;
    }
}
```

6. 自动装配（Autowired）：
使用@Autowired注解可以告诉Spring容器自动装配bean，可以用在构造函数、方法、字段上。

四、final finally finalize 区别

1. final：
- final是一个关键字，可以用来修饰类、方法和变量。
- 修饰类：表示该类是不可继承的，即为最终类，不能被其他类继承。
- 修饰方法：表示该方法是不可重写的，子类不能重写final修饰的方法。
- 修饰变量：表示该变量是一个常量，只能被赋值一次，不能再修改。

2. finally：
- finally是一个关键字，用于定义在try-catch语句块中的一个代码块，无论是否发生异常，finally中的代码都会被执行。
- 通常用于释放资源、关闭连接等操作，确保资源得到正确释放。

3. finalize：
- finalize是一个方法，是Object类中的一个方法，用于在对象被垃圾回收前执行一些清理操作。
- finalize方法是Java中的垃圾回收机制中的一个保底机制，用于在对象被回收前执行一些清理操作，但不建议在代码中显式调用finalize方法，因为finalize方法的执行时机是不确定的。

  final是修饰符，用于表示不可改变的类、方法或变量；finally是一个关键字，用于定义在try-catch语句块中的一个代码块；finalize是一个方法，用于在对象被垃圾回收前执行一些清理操作。三者在Java中有不同的作用和用法。

五、接口和抽象类的区别

在Java中，接口（interface）和抽象类（abstract class）是两种用于实现多态性和封装的重要机制，它们之间有以下区别：

1. 定义方式：
- 接口：接口中只包含抽象方法和常量的定义，不包含成员变量和方法的实现。接口中的方法默认是public abstract类型。
- 抽象类：抽象类可以包含抽象方法和非抽象方法，也可以包含成员变量。抽象类中的抽象方法必须在子类中被实现或者子类也声明为抽象类。

2. 多继承：
- 接口：Java中支持多继承，一个类可以实现多个接口。
- 抽象类：Java中不支持多继承，一个类只能继承一个抽象类。

3. 实现：
- 接口：类通过implements关键字实现接口，实现接口的类必须实现接口中定义的所有方法。
- 抽象类：类通过extends关键字继承抽象类，可以选择性地实现抽象类中的方法。

4. 构造函数：
- 接口：接口中不能包含构造函数。
- 抽象类：抽象类中可以包含构造函数。

5. 变量类型：
- 接口：接口中的变量默认是public static final类型，即为常量，可以直接访问。
- 抽象类：抽象类中的变量可以是各种类型，可以有各种访问修饰符。

总的来说，接口用于定义规范和行为，实现类可以实现多个接口；抽象类用于封装共性的行为和属性，子类只能继承一个抽象类。根据具体的需求和设计模式，选择合适的接口或抽象类来实现多态性和封装。

六、mybatis分页

在MyBatis中实现分页查询可以通过使用`RowBounds`或者`PageHelper`两种方式来实现。以下是两种方式的简要介绍：

1. 使用 RowBounds 实现分页：

int offset = (pageNum - 1) * pageSize;
RowBounds rowBounds = new RowBounds(offset, pageSize);
List<User> userList = sqlSession.selectList("getUserList", null, rowBounds);
```

2. 使用 PageHelper 插件实现分页：
首先需要在pom.xml中添加PageHelper的依赖：

<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper</artifactId>
    <version>5.3.0</version>
</dependency>
```

然后在MyBatis的配置文件中配置PageHelper插件：

<plugins>
    <plugin interceptor="com.github.pagehelper.PageInterceptor">
        <property name="helperDialect" value="mysql"/>
    </plugin>
</plugins>
```

在代码中使用PageHelper进行分页查询：

import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;

PageHelper.startPage(pageNum, pageSize);
List<User> userList = userDao.getUserList();
PageInfo<User> pageInfo = new PageInfo<>(userList);
```

通过以上两种方式，可以在MyBatis中实现分页查询功能。RowBounds是MyBatis自带的分页功能，而PageHelper是一个独立的插件，可以更方便地实现分页查询。根据具体的需求和习惯选择合适的方式来实现分页功能。

七、Java垃圾回收

Java的垃圾回收机制是一种自动内存管理机制，用于在运行时自动释放不再被程序使用的内存，防止内存泄漏和提高程序性能。Java的垃圾回收机制主要包括以下几个方面：

1. 对象的创建和内存分配：
在Java中，使用`new`关键字创建对象时，内存会在堆内存中分配给该对象。当对象不再被引用时，垃圾回收机制会自动识别并回收这些无用的对象。

2. 引用计数法：
Java不使用引用计数法来进行垃圾回收。引用计数法是一种简单的垃圾回收算法，它通过对对象的引用计数进行计算来判断对象是否可以被回收。但是引用计数法存在循环引用的问题，无法解决循环引用的对象无法被回收的情况。

3. 可达性分析算法：
Java使用可达性分析算法来进行垃圾回收。可达性分析算法从一组称为"GC Roots"的对象作为起始点，通过对象之间的引用关系，判断哪些对象是可以被程序访问到的，即可达的对象。不可达的对象会被标记为垃圾对象，并在适当的时机被回收。

4. 垃圾回收器：
Java的垃圾回收机制由垃圾回收器（Garbage Collector）负责实现。垃圾回收器会周期性地扫描堆内存中的对象，标记和清除不再被引用的对象，释放内存空间。Java的垃圾回收器有多种类型，如Serial GC、Parallel GC、CMS GC、G1 GC等，每种垃圾回收器都有不同的特点和适用场景。

5. 垃圾回收的时机：
Java的垃圾回收机制是自动触发的，程序员无需手动调用垃圾回收方法。垃圾回收器会根据一些条件（如内存占用情况、GC策略等）来判断何时进行垃圾回收操作，以保证程序的性能和内存的有效利用。

总的来说，Java的垃圾回收机制是一种自动化的内存管理机制，通过可达性分析算法和垃圾回收器来实现对象的自动回收，从而避免内存泄漏和提高程序性能。