Loading [MathJax]/jax/output/CommonHTML/config.js
前往小程序,Get更优阅读体验!
立即前往
首页
学习
活动
专区
圈层
工具
发布
首页
学习
活动
专区
圈层
工具
MCP广场
社区首页 >专栏 >【Spring】Spring IOC&DI:架构旋律中的“依赖交响”与“控制华章”

【Spring】Spring IOC&DI:架构旋律中的“依赖交响”与“控制华章”

作者头像
用户11288949
发布于 2025-01-17 05:57:21
发布于 2025-01-17 05:57:21
8200
代码可运行
举报
文章被收录于专栏:学习学习
运行总次数:0
代码可运行

📚️1.IOC&DI入门

1.1什么是Spring

通过前⾯的学习, 我们知道了Spring是⼀个开源框架, 他让我们的开发更加简单. 他⽀持⼴泛的应⽤场景, 有着活跃⽽庞⼤的社区, 这也是Spring能够⻓久不衰的原因.但是这个概念相对来说, 还是⽐较抽象.

我们⽤⼀句更具体的话来概括Spring, 那就是: Spring 是包含了众多⼯具⽅法的 IoC 容器

1.2什么是IOC

在前⾯讲到, 在类上⾯添加 @RestController 和@Controller 注解, 就是把这个对象交给Spring管理, Spring 框架启动时就会加载该类. 把对象交给Spring管理, 就是IoC思想

IOC:: Inversion of Control (控制反转), 也就是说 Spring 是⼀个"控制反转"的容器

控制反转:

当需要某个对象时, 传统开发模式中需要⾃⼰通过 new 创建对象, 现在不需要再进⾏创建, 把创建对象的任务交给容器, 程序中只需要依赖注⼊ (Dependency Injection,DI)就可以了

总结:

IOC就是一个创建任务对象的容器;

DI就是我们后面需要注入的依赖

1.3IOC的介绍
1.3.1传统的开发过程

假如我们在实现创建一个车子的时候,我们知道他是依赖于车身,轮胎,底盘...那么就有如下的依赖的情况:

那么我们在程序实现的时候就是如下所示的:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
public class Car {
    //车依赖于车身
    private Framwork framwork;
    public Car(int size) {
        framwork = new Framwork(size);
        System.out.println("Car init....");
    }
    public void run(){
        System.out.println("car run....");
    }
}

解释:

这就是车在制造的时候,依赖车身,所以就会创建一个车身的对象,那但是此时车身依赖由于底盘,就会在车身类进行对象的构造;

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
public class Framwork {
    private Bottem bottem;
    public Framwork(int size){
        bottem=new Bottem(size);
        System.out.println("framwork init....");
    }
}

解释:

此时我们就会发现,车身的制造依赖于底盘,那么就要创建底盘的对象,那么此时一直到最后一环指定就是轮胎;

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
public class Tire {
    private int size;
    public Tire(int size){
        this.size=size;
        System.out.println("tire init...");
    }
}

解释:

如果这里我们这里,最后一环的情况下,假如我们要规定颜色和轮胎的尺寸大小,此时就会发现一个问题;

以上程序的问题是:当最底层代码改动之后,整个调⽤链上的所有代码都需要修改.程序的耦合度⾮常⾼(修改⼀处代码, 影响其他处的代码修改)

1.3.2IOC程序开发

此时我们就可以使用IOC程序开发的思想进行改进,将整个对象进行统一管理,然后就可以大大降低耦合性;

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
public static void main(String[] args) {
        Tire tire = new Tire(20);
        Bottom bottom = new Bottom(tire);
        Framework framework = new Framework(bottom);
        Car car = new Car(framework);
        car.run();
    }
static class Car {
    private Framework framework;
    public Car(Framework framework) {
        this.framework = framework;
        System.out.println("Car init....");
    }
    public void run() {
        System.out.println("Car run...");
    }
}

解释:

这里小编只展示了一小部分,其余的写法基本是一致的;代码经过以上调整,⽆论底层类如何变化,整个调⽤链是不⽤做任何改变的,这样就完成了代码之间的解耦,从⽽实现了更加灵活、通⽤的程序设计了

1.3.3IOC的优势

在传统的代码中对象创建顺序是:Car -> Framework -> Bottom -> Tire 改进之后解耦的代码的对象创建顺序是:Tire -> Bottom -> Framework -> Car

改进之后的控制权发⽣的反转,不再是使⽤⽅对象创建并控制依赖对象了,⽽是把依赖对象注⼊将当前对象中,依赖对象的控制权不再由当前类控制了

那么此时就可以看做是如下所示的情况:

此时优点就是如下:

1. 资源集中管理: IoC容器会帮我们管理⼀些资源(对象等), 我们需要使⽤时, 只需要从IoC容器中去取就可以了 2. 我们在创建实例的时候不需要了解其中的细节, 降低了使⽤资源双⽅的依赖程度, 也就是耦合度.

1.4DI的介绍

DI: Dependency Injection(依赖注⼊)

容器在运⾏期间, 动态的为应⽤程序提供运⾏时所依赖的资源,称之为依赖注⼊。程序运⾏时需要某个资源,此时容器就为其提供这个资源.

就是一个依赖的注入;

IoC 是⼀种思想,也是"⽬标", ⽽思想只是⼀种指导原则,最终还是要有可⾏的落地⽅案,⽽ DI 就属于具体的实现。所以也可以说, DI 是IoC的⼀种实现

📚️2.IOC&DI的使用

既然 Spring 是⼀个 IoC(控制反转)容器,作为容器, 那么它就具备两个最基础的功能: • 存 • 取 Spring 容器 管理的主要是对象, 这些对象, 我们称之为"Bean". 我们把这些对象交由Spring管理, 由 Spring来负责对象的创建和销毁. 我们程序只需要告诉Spring, 哪些需要存, 以及如何从Spring中取出对象

此时我们就会使用@component来进行管理Bean,使用@Autowired来进行依赖的注入,那么代码如下:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
@Component
public class BookDao {
    public List<BookInfo> mockData(){
        List<BookInfo> books=new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            BookInfo book = new BookInfo();
            book.setId(i);
            book.setBookName("书籍" + i);
            book.setAuthor("作者" + i);
            book.setCount(i * 5 + 3);
            book.setPrice(new BigDecimal(new Random().nextInt(100)));
            book.setPublish("出版社" + i);
            book.setStatus(1);
            books.add(book);
        }
        return books;
    }
}

我们将这个数据对象交给spring管理,就是加上注解@Component;

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
@Component //交给spring进行管理
public class BookService {
    @Autowired
    private BookDao bookDao;
    public List<BookInfo> getBookList(){

        List<BookInfo> books=bookDao.mockData();
        for (BookInfo book : books) {
            if (book.getStatus() == 1) {
                book.setStatusCN("可借阅");
            } else {
                book.setStatusCN("不可借阅");
            }
        }
        return books;
    }
}

这里就是将逻辑处理的对象交给spring管理,由于这里要使用数据,所以要引入依赖,这个依赖就可以将数据的对象传过来;

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
@RequestMapping("/book")
@RestController
public class BookController {
    @Autowired
    private BookService bookService;
    @RequestMapping("/getList")
    public List<BookInfo> getList() {
        //获取数据
        //交给spring注入依赖

        List<BookInfo> books = bookService.getBookList();
        //处理⻚⾯展⽰
        return books;
    }
}

最后在controller表现层操作时,将引入逻辑处理层的对象,此时就可以spring管理的对象拿出来,就是依赖的引入;

📚️3.IOC详解

通过上⾯的案例, 我们已经知道了Spring IoC 和DI的基本操作, 接下来我们来系统的学习Spring IoC和DI的操作.前⾯我们提到IoC控制反转,就是将对象的控制权交给Spring的IOC容器,由IOC容器创建及管理对象。也就是bean的存储

3.1Bean的存储

在之前的⼊⻔案例中,要把某个对象交给IOC容器管理,需要在类上添加⼀个注解:@Component⽽Spring框架为了更好的服务web应⽤程序, 提供了更丰富的注解

1. 类注解:@Controller、@Service、@Repository、@Component、@Configuration. 2. ⽅法注解:@Bean.

那么下面小编来示范一下;

3.2类注解实现

这里小编就只使用controller进行操作,通过controller注解来进行存储Bean;

代码如下所示:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
@Controller
public class UserController {
   public void userController(){
        System.out.println("userController start...");
    }
}

此时我们就将这里的对象给spring进行管理了;

如何从Spring容器中获取对象:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
@SpringBootApplication
public class SpringIocDemoApplication {
     public static void main(String[] args) {
     //获取Spring上下⽂对象
     ApplicationContext context = 
     SpringApplication.run(SpringIocDemoApplication.class, args);
     //从Spring上下⽂中获取对象
     UserController userController = context.getBean(UserController.class);
     //使⽤对象
     userController.sayHi();
     }
}

解释:

ApplicationContext 翻译过来就是: Spring 上下⽂因为对象都交给 Spring 管理了,所以获取对象要从 Spring 中获取,那么就得先得到 Spring 的上下⽂

这个上下⽂, 就是指当前的运⾏环境, 也可以看作是⼀个容器, 容器⾥存了很多内容, 这些内容是当前运⾏的环境

可以看到此时的对象就是拿到了的,即输出了usercontroller start这句话~~~

然后我们将这个controller进行删除试试:

此时就是出现异常了:就是这不到这个类型对象的存在,所以就抛出了异常;

3.3获取Bean的其他方式

上述就是通过类型来进行获取Bean的;

上述代码是根据类型来查找对象, 如果Spring容器中, 同⼀个类型存在多个bean的话, 怎么来获取呢?

ApplicationContext 也提供了其他获取bean的⽅式, ApplicationContext 获取bean对象的功能, 是⽗类BeanFactory提供的功能.

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
public interface BeanFactory {
    String FACTORY_BEAN_PREFIX = "&";

    Object getBean(String name) throws BeansException;

    <T> T getBean(String name, Class<T> requiredType) throws BeansException;

    Object getBean(String name, Object... args) throws BeansException;

    <T> T getBean(Class<T> requiredType) throws BeansException;

    <T> T getBean(Class<T> requiredType, Object... args) throws BeansException;

可以看到这里可以根据类型和名字进行对象的获取,那么Bean的名字是啥?

Spring bean是Spring框架在运⾏时管理的对象, Spring会给管理的对象起⼀个名字,给每个对象起⼀个名字, 根据Bean的名称(BeanId)就可以获取到对应的对象.

Bean的命名

官方的文档就是如下所示:

具体的内容就是:

命名约定使⽤Java标准约定作为实例字段名. 也就是说,bean名称以⼩写字⺟开头,然后使⽤驼峰式⼤⼩写 ;

类名: UserController, Bean的名称为: userController 类名: AccountManager, Bean的名称为: accountManager

当然也有特殊的情况,前面两个单词都是大写:

类名: UController, Bean的名称为: UController 类名: AManager, Bean的名称为: AManager

还有就是三个大写字母,的Bean的命名就是:

类名:UserControllerDI,Bean的名称;usercontrollerDI

此时我们使用三种获取Bean的方式进行获取Bean对象:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
  public static void main(String[] args) {
        ApplicationContext context= SpringApplication.run(SpringIocApplication.class, args);
        UserController bean = context.getBean(UserController.class);
        bean.userController();

        UserController bean1 = (UserController) context.getBean("userController");
        bean1.userController();

        UserController bean2 = context.getBean("userController",UserController.class);
        bean2.userController();
}

解释:

此时我们这里第一种获取Bean的方式就是通过类型进行获取,然后第二种就是通过bean的名称进行获取,第三种就是前面两种的合并的方式;

此时我们进入运行状态:

ApplicationContext与BeanFactory

继承关系和功能⽅⾯来说:Spring 容器有两个顶级的接⼝:BeanFactory 和ApplicationContext。其中 BeanFactory 提供了基础的访问容器的能⼒,⽽ApplicationContext 属于 BeanFactory 的⼦类,它除了继承了 BeanFactory 的所有功能之外,它还拥有独特的特性,还添加了对国际化⽀持、资源访问⽀持、以及事件传播等⽅⾯的⽀持 从性能⽅⾯来说:ApplicationContext 是⼀次性加载并初始化所有的 Bean 对象,⽽ BeanFactory 是需要那个才去加载那个,因此更加轻量. (空间换时间

这里小编就不再演示其他几个了,基本代码和思想都是一样的~~~

3.4多种注解含义

• @Controller:控制层, 接收请求, 对请求进⾏处理, 并进⾏响应. • @Servie:业务逻辑层, 处理具体的业务逻辑. • @Repository:数据访问层,也称为持久层. 负责数据访问操作 • @Configuration:配置层. 处理项⽬中的⼀些配置信息

类注解之间的关系查看 @Controller / @Service / @Repository / @Configuration 等注解的源码发 现:

这些注解⾥⾯都有⼀个注解 @Component ,说明它们本⾝就是属于 @Component 的"⼦类". @Component 是⼀个元注解,这些其他的注解就是@Component的衍生类;

3.5方法注解Bean

1.使⽤外部包⾥的类, 没办法添加类注解 2. ⼀个类, 需要多个对象, ⽐如多个数据源

3.5.1方法注解要配合注解类

代码如下所示:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
@Configuration
public class BeanConfig {
    @Bean
    public UserInfo userInfo(){
        return new UserInfo("zhangsan");
    }
}

那么此时就将这个对象进行了管理了;

那么我们就可以拿到这个对象:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
UserInfo bean = context.getBean("UserInfo.class");
        System.out.println(bean);
3.5.2存在多个对象

代码如下:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
@Configuration
public class BeanConfig {
    @Bean
    public UserInfo user1(){
        return new UserInfo("zhangsan");
    }
    //@Primary
    @Bean
    public UserInfo user2(){
        return new UserInfo("lisi");
    }
}

那么此时我们使用类型进行获取时候;

那么此时我们就要通过bean的名称来进行获取了;

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
User user1 = (User) context.getBean("user1");
 User user2 = (User) context.getBean("user2")

📚️4.DI详解

依赖注⼊是⼀个过程,是指IoC容器在创建Bean时, 去提供运⾏时所依赖的资源,⽽资源指的就是对象.在上⾯程序案例中,我们使⽤了 @Autowired 这个注解,完成了依赖注⼊的操作

1. 属性注⼊(Field Injection) 2. 构造⽅法注⼊(Constructor Injection) 3. Setter 注⼊(Setter Injection)

4.1属性的注入

代码如下:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
@Controller
public class UsercontrollerDI {
    @Autowired
    private  UserServiceDI userServicedi;
    //private final UserServiceDI userServiceDI=new UserServiceDI();
    public void start(){
        userServicedi.start();
    }

}

这里就是通过属性的注入的方式进行依赖的注入;

此时我们进行对象的获取和打印:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
   UsercontrollerDI bean3 = context.getBean(UsercontrollerDI.class);
        bean3.start();

去掉@Autowired , 再运⾏⼀下程序看看结果:

就是说明了这里由于没有注入依赖,那么就直接为空了(这个对象)

4.2构造方法注入

代码如下所示:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
@Controller
public class UserControllerDI2 {
    private UserServiceDI userServiceDI;
    public UserControllerDI2(){

    }
    @Autowired
    public UserControllerDI2(UserServiceDI userServiceDI){
        this.userServiceDI=userServiceDI;
    }

    public void start(){
        userServiceDI.start();
    }
}

解释:

这就是通过构造方法来进行操作的,当然这里有点问题就是当存在两个构造方法的时候,默认就是无参的构造方法;

只有一个构造方法的时候,默认是使用这一个 若存在两个构造方法,此时就要指定使用那个构造方法

4.3setter方式注入

这里就和get与set方式基本一致了:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
@Controller
public class UserSet {
    private UserServiceDI userServiceDI;

    @Autowired
    public void setUserServiceDI(UserServiceDI userServiceDI) {
        this.userServiceDI = userServiceDI;
    }
    public void start(){
        userServiceDI.start();
    }
}

这里小编就不在过多的解释了;

4.4几种方式的优缺

属性注入

◦ 优点: 简洁,使⽤⽅便; ◦ 缺点: ▪ 只能⽤于 IoC 容器,如果是⾮ IoC 容器不可⽤,并且只有在使⽤的时候才会出现 NPE(空指 针异常) ▪ 不能注⼊⼀个Final修饰的属性

构造函数注入

优点: ▪ 可以注⼊final修饰的属性 ▪ 注⼊的对象不会被修改 ▪ 依赖对象在使⽤前⼀定会被完全初始化,因为依赖是在类的构造⽅法中执⾏的,⽽构造⽅法 是在类加载阶段就会执⾏的⽅法. ▪ 通⽤性好, 构造⽅法是JDK⽀持的, 所以更换任何框架,他都是适⽤的 ◦ 缺点: ▪ 注⼊多个对象时, 代码会⽐较繁琐

setter方式注入

优点: ⽅便在类实例之后, 重新对该对象进⾏配置或者注⼊ ◦ 缺点: ▪ 不能注⼊⼀个Final修饰的属性 ▪ 注⼊对象可能会被改变, 因为setter⽅法可能会被多次调⽤, 就有被修改的⻛险

4.5@Autowired的缺点

当出现多个同种类型的对象的时候:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
public class BeanConfig {
    @Bean
    public UserInfo userInfo(){
        return new UserInfo("zhangsan");
    }
    //@Primary
    @Bean
    public UserInfo userInfo1(){
        return new UserInfo("lisi");
    }
}

此时我们进行注入,就会出现如下的情况:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
@Autowired
    private UserInfo user;
    public void start(){
        System.out.println(user);
    }

直接出错;

很明显就是分不清楚,那个是要注入的Bean;

那么就有下面几种方法;

4.5.1使用@Primary

代码如下:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
@Bean
    public UserInfo userInfo(){
        return new UserInfo("zhangsan");
    }
    @Primary
    @Bean
    public UserInfo userInfo1(){
        return new UserInfo("lisi");
    }

此时我们默认这个对象;

4.5.2使用@Qualifier

注意这里要和autowired进行搭配使用

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
    @Qualifier("userInfo1")
    @Autowired
    private UserInfo user;

这里就要指定那个;

4.5.3使用@Resource

这里和上面一样,只不过不用搭配@Autowired了;

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
  @Sesource("userInfo1")
    private UserInfo user;

•@Autowird 与 @Resource的区别 • @Autowired 是spring框架提供的注解,⽽@Resource是JDK提供的注解 • @Autowired 默认是按照类型注⼊,⽽@Resource是按照名称注⼊. 相⽐于 @Autowired 来说,@Resource ⽀持更多的参数设置,例如 name 设置,根据名称获取 Bean.

📚️5.总结

本期小编主要讲解了关于Spring IOC和DI的详细介绍,从入门讲解概念到实际的应用,都有涉及,当然其中还涉及比较重要的面试题哦~~~

🌅🌅🌅~~~~最后希望与诸君共勉,共同进步!!!

本文参与 腾讯云自媒体同步曝光计划,分享自作者个人站点/博客。
原始发表:2025-01-17,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 作者个人站点/博客 前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体同步曝光计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
暂无评论
推荐阅读
编辑精选文章
换一批
Java集合框架知识整理
Java集合框架主要由Collection和Map两个根接口及其子接口、实现类组成。
Abalone
2022/07/14
6380
Java集合框架知识整理
Java集合详解【面试+工作】
在说集合前我们不得不说一下数组 数组的作用: 存放一组相同的数据类型(基本或对象)的数据,从而实现对数据的管理 优势:可以快速的通过下标对数组元素进行访问,效率高 劣势:容量实现定义好了,不能随着需求变化而扩容 因此出现了更好的集合框架 一、数组和集合的比较 数组不是面向对象的,存在明显的缺陷,集合弥补了数组的缺点,比数组更灵活更实用,而且不同的集合框架类可适用不同场合。如下: 1:数组能存放基本数据类型和对象,而集合类存放的都是对象的引用,而非对象本身! 2:数组容易固定无法动态改变,集合类容量动态改变。
Java帮帮
2018/03/15
2K0
Java集合详解【面试+工作】
java集合详解和集合面试题目
数组(可以存储基本数据类型)是用来存现对象的一种容器,但是数组的长度固定,不适合在对象数量未知的情况下使用。
全栈程序员站长
2022/09/05
6810
Java集合面试题&知识点总结(上篇)
解答:Java 集合类呢主要是指 java.Util包 下的集合容器。主要包含三种:List、Set、Map,其中 List、Set 主要继承自 Collection 接口,然后它们三个又都依赖了 Iterator 迭代器;
栗筝i
2023/10/29
2790
死磕 java集合之TreeSet源码分析
TreeSet底层是采用TreeMap实现的一种Set,所以它是有序的,同样也是非线程安全的。
彤哥
2019/07/08
4640
死磕 java集合之TreeSet源码分析
Java集合框架详解(全)
集合可以看作是一种容器,用来存储对象信息。所有集合类都位于java.util包下,但支持多线程的集合类位于java.util.concurrent包下。
硕人其颀
2020/06/02
1.1K0
Java集合面试题[通俗易懂]
大家好,又见面了,我是你们的朋友全栈君。 Java集合面试题 Java 集合框架的基础接口有哪些? Collection ,为集合层级的根接口。一个集合代表一组对象,这些对象即为它的元素。Java 平台不提供这个接口任何直接的实现。 Set ,是一个不能包含重复元素的集合。这个接口对数学集合抽象进行建模,被用来代表集合,就如一副牌。 List ,是一个有序集合,可以包含重复元素。你可以通过它的索引来访问任何元素。List 更像长度动态变换的数组。 Map ,是一个将 key 映射到 value 的对
全栈程序员站长
2022/07/23
5730
老哥,您看我这篇Java集合,还有机会评优吗?
集合在我们日常开发使用的次数数不胜数,ArrayList/LinkedList/HashMap/HashSet······信手拈来,抬手就拿来用,在 IDE 上龙飞凤舞,但是作为一名合格的优雅的程序猿,仅仅了解怎么使用API是远远不够的,如果在调用API时,知道它内部发生了什么事情,就像开了透视外挂一样,洞穿一切,这种感觉才真的爽,而且这样就不是集合提供什么功能给我们使用,而是我们选择使用它的什么功能了。
cxuan
2020/08/07
5900
老哥,您看我这篇Java集合,还有机会评优吗?
杰哥教你面试之一百问系列:java集合
集合是我们在java中经常会用到的东西,熟悉了集合我们就熟悉了java。当面试官在Java面试中涉及到Java集合的问题时,通常会涉及到集合的概念、类型、常见操作、性能等方面的内容。
程序那些事
2023/09/12
2730
深入浅出的分析 Set集合
原文链接:https://blog.csdn.net/javageektech/article/details/103077788
chenchenchen
2019/11/26
5300
Java 集合常见知识点&面试题总结(上),2022 最新版!
Java 集合, 也叫作容器,主要是由两大接口派生而来:一个是 Collection接口,主要用于存放单一元素;另一个是 Map 接口,主要用于存放键值对。对于Collection 接口,下面又有三个主要的子接口:List、Set 和 Queue。
Guide哥
2022/11/07
3390
Java 集合常见知识点&面试题总结(上),2022 最新版!
Java集合解惑
本文取自工匠若水的qq群里的Java基础题目,把里面有关Java集合放在一起。 全文github地址
1025645
2018/08/23
6910
Java集合分类以及各自特点
常用的就是ArrayList,LinkedList,HashSet,LinkedHashSet,TreeSet,HashMap,LinkedHashMap,TreeMap; 数组和集合的区别 区别1: 数组可以存储基本数据类型/引用数据类型 基本数据类型存的是值 引用数据类型存的是地址 数组在创建的时候 就会定义存储的数据类型 也就是只能存储一种数据类型 集合只能存储引用数据类型(对象) 集合中也可以存储基本数据类型(装箱)最终存储的还是 Object 如果没有泛型限定 默认存储的都是 Object类型的数据 也就是任意类型 区别2 数组长度是固定的,不能自动增长 集合是长度可变的,根据元素的多少来决定长度
全栈程序员站长
2022/09/01
5400
40个Java集合面试问题和答案
每种编程语言中都有集合,最初的Java版本包含几种集合类:Vector、Stack、HashTable和Array。随着集合的广泛使用,Java1.2提出了囊括所有集合接口、实现和算法的集合框架。在保证线程安全的情况下使用泛型和并发集合类,Java已经经历了很久。它还包括在Java并发包中,阻塞接口以及它们的实现。集合框架的部分优点如下:
田维常
2019/07/16
8220
大厂必问的Java集合面试题
本文已经收录到github仓库,此仓库用于分享互联网大厂高频面试题、Java核心知识总结,包括Java基础、并发、MySQL、Springboot、MyBatis、Redis、RabbitMQ等等,面试必备!欢迎大家star!
程序员大彬
2022/01/06
1.5K0
大厂必问的Java集合面试题
Java学习笔记——集合
存储对象可以使用数组 (基本数据类型 & 引用数据类型) 和集合 (引用数据类型),用数组存储对象的弊端有:一旦创建,其长度不可变;数组中真正存储的对象个数不可知,除非自定义类。使用集合可以解决这些问题。
梦飞
2022/06/23
2740
Java学习笔记——集合
深入探索Java集合框架
Java集合框架位于java.util包中,是Java编程语言的核心部分。它定义了几种类型的集合,包括列表(List)、集合(Set)、队列(Queue)、双端队列(Deque)以及映射(Map)。这些集合类型通过统一的接口和抽象类来实现,从而提供了对数据的一致视图。
公众号:码到三十五
2024/03/19
2350
Java 集合框架(7)---- Set 相关类解析
在上篇文章中,我们将剩下的常见的 Map 接口下的相关具体类做了一个解析,还有一些相关的类将会在下一篇文章中做一个总结,这篇我们来看看 Set 接口的相关类。老规矩,还是继续看一下 Set 接口下继承关系图:
指点
2019/01/18
5180
Java 集合框架(7)---- Set 相关类解析
Java--集合类之Collection与Map
上一篇:Java--集合类之Vector、BitSet、Stack、Hashtable 集合(Collection):一组单独的元素,通常应用了某种规则。在这里,一个 List(列表)必须按特定的顺序容纳元素,而一个Set(集)不可包含任何重复的元素。相反,“包”(Bag)的概念未在新的集合库中实现,因为“列表”已提供了类似的功能。 映射(Map):一系列“键-值”对(这已在散列表身上得到了充分的体现)。从表面看,这似乎应该成为一个“键-值”对的“集合”,但假若试图按那种方式实现它,就会发现实现过程相当笨拙
SuperHeroes
2018/05/22
9450
JavaSE(八)集合之Set
今天这一篇把之前没有搞懂的TreeSet中的比较搞得非常的清楚,也懂得了它的底层实现。希望博友提意见! 一、Set接口 1.1、Set集合概述   Set集合:它类似于一个罐子,程序可以依次把多个对象 “丢进” Set 集合,而 Set 集合通常不能记住元素的添加的顺序,也就是说Set 集合是无序的。         Set 集合与 Colleaction 基本相同,没有提供额外的方法,实际上 Set 就是 Collection,只是行为略有不同(Set 不允许包含重复元素)。 1.2、Set类型集合特点
用户1195962
2018/01/18
1K0
JavaSE(八)集合之Set
相关推荐
Java集合框架知识整理
更多 >
领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档
本文部分代码块支持一键运行,欢迎体验
本文部分代码块支持一键运行,欢迎体验