diff --git "a/java_member/2023/all_member/\350\213\227\347\220\252\350\266\205" "b/java_member/2023/all_member/\350\213\227\347\220\252\350\266\205"
new file mode 100644
index 0000000000000000000000000000000000000000..1d08995aaef34edd5b3807c853cc632010d3ab9e
--- /dev/null
+++ "b/java_member/2023/all_member/\350\213\227\347\220\252\350\266\205"
@@ -0,0 +1,577 @@
+集合类的作用：集合类是用来存储对象的集合。常见的集合类包括单列集合和双列集合，它们分别表示存储一个元素和存储键值对的集合。
+
+集合与数组的区别
+长度区别：数组的长度是固定的，而集合的长度是可变的
+内容区别：数组可以是基本类型也可以是引用类型，而集合只能是引用类型。
+元素内容：数组只能存储同一种类型，而集合可以存储不同的类型（其实集合一般存储的也是同一种类型的值）
+
+常用集合的分类
+Collection接口的接口 对象的集合（单列集合）
+├——-List 接口：元素按进入先后有序保存，可重复
+│—————-├ LinkedList 接口实现类， 链表， 插入删除， 没有同步， 线程不安全
+│—————-├ ArrayList 接口实现类， 数组， 随机访问， 没有同步， 线程不安全
+│—————-└ Vector 接口实现类 数组， 同步， 线程安全
+│ ———————-└ Stack 是Vector类的实现类
+└——-Set 接口： 仅接收一次，不可重复，并做内部排序
+├—————-└HashSet 使用hash表（数组）存储元素
+│————————└ LinkedHashSet 链表维护元素的插入次序
+└ —————-TreeSet 底层实现为二叉树，元素排好序
+————————————————
+
+Map 接口 键值对的集合 （双列集合）
+├———Hashtable 接口实现类， 同步， 线程安全
+├———HashMap 接口实现类 ，没有同步， 线程不安全-
+│—————–├ LinkedHashMap 双向链表和哈希表实现
+│—————–└ WeakHashMap
+├ ——–TreeMap 红黑树对所有的key进行排序
+└———IdentifyHashMap
+————————————————
+
+List和set的区别：
+Collection：1.有序性（list保证按插入顺序排序，set存储和取出的顺序是不一致的）
+          2.唯一性（list可以重复，而set是不可重复的）
+          3.获取元素（list可以通过索引直接操作元素，而set不能根据索引获取元素）
+
+
+
+                            
+单列集合：
+1.list（列表）
+允许重复元素，元素有序排列。
+常用实现类：ArrayList、LinkedList。
+常用方法：
+add(E e)：将元素添加到列表的末尾。
+get(int index)：获取指定位置的元素。
+size()：返回列表中的元素个数。
+remove(int index)：移除指定位置的元素
+
+2.set（集合）
+不允许重复元素，元素无序排列。
+常用实现类：HashSet、LinkedHashSet、TreeSet。
+常用方法：
+add(E e)：向集合中添加元素。
+contains(Object o)：检查集合是否包含指定的元素。
+size()：返回集合中的元素个数。
+remove(Object o)：从集合中移除指定的元素。
+
+3.queue（队列）
+先进先出（FIFO）的数据结构。
+常用实现类：LinkedList、PriorityQueue。
+常用方法：
+offer(E e)：将指定元素插入队列。
+poll()：移除并返回队列头部的元素。
+peek()：返回队列头部的元素，但不移除。
+
+
+双列集合
+1.map（映射）
+
+存储键值对，每个键最多只能映射到一个值。
+常用实现类：HashMap、LinkedHashMap、TreeMap。
+常用方法：
+put(K key, V value)：将键值对添加到 Map 中。
+get(Object key)：获取指定键对应的值。
+containsKey(Object key)：检查 Map 中是否包含指定的键。
+remove(Object key)：从 Map 中移除指定键对应的键值对。
+2.hashtable
+与 HashMap 类似，但是它是线程安全的，效率相对较低。
+常用方法与 HashMap 类似，例如 put(), get(), containsKey(), remove() 等。
+3.Properties
+继承自 Hashtable，用于处理属性文件。
+常用方法：
+getProperty(String key)：获取指定键的值。
+setProperty(String key, String value)：设置指定键的值。
+	
+
+
+
+
+Spring是一个轻量级Java开发框架，最早有Rod Johnson创建，目的是为了解决企业级应用开发的业务逻辑层和其他各层的耦合问题。它是一个分层的JavaSE/JavaEE full-stack（一站式）轻量级开源框架，为开发Java应用程序提供全面的基础架构支持。Spring负责基础架构，因此Java开发者可以专注于应用程序的开发。
+Spring最根本的使命是解决企业级应用开发的复杂性，即简化Java开发。
+
+Spring可以做很多事情，它为企业级开发提供了丰富的功能，但是这些功能的底层都依赖于它的两个核心特性，也就是依赖注入（dependency injection，DI）和面向切面编程（aspect-oriented programming，AOP）
+
+
+为了降低Java开发的复杂性，Spring采取了以下4种关键策略：
+
+基于POJO的轻量级和最小侵入性编程；
+通过依赖注入和面向接口实现松耦合；
+基于切面和惯例进行声明式编程；
+通过切面和模板减少样板式代码。
+Spring框架核心
+Spring设计目标：Spring为开发者提供一个一站式轻量级应用开发平台；
+
+Spring设计理念：在JavaEE开发中，支持POJO和JavaBean开发方式，使应用面向接口开发，充分支持OO（面向对象）设计方法；Spring通过IoC容器实现对象耦合关系的管理，并实现依赖反转，将对象之间的依赖关系交给IoC容器，实现解耦；
+
+Spring框架的核心：IoC容器和AOP模块。通过IoC容器管理POJO对象以及他们之间的耦合关系；通过AOP以动态非侵入的方式增强服务。
+
+Spring的优缺点
+优点
+方便解耦，简化开发
+
+Spring就是一个大工厂，可以将所有对象的创建和依赖关系的维护，交给Spring管理。
+
+AOP编程的支持
+
+Spring提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能。
+
+声明式事务的支持
+
+只需要通过配置就可以完成对事务的管理，而无需手动编程。
+
+方便程序的测试
+
+Spring对Junit4支持，可以通过注解方便的测试Spring程序。
+
+方便集成各种优秀框架
+
+Spring不排斥各种优秀的开源框架，其内部提供了对各种优秀框架的直接支持（如：Struts、Hibernate、MyBatis等）。
+
+降低JavaEE API的使用难度
+
+Spring对JavaEE开发中非常难用的一些API（JDBC、JavaMail、远程调用等），都提供了封装，使这些API应用难度大大降低。
+
+缺点
+Spring明明一个很轻量级的框架，却给人感觉大而全
+Spring依赖反射，反射影响性能
+使用门槛升高，入门Spring需要较长时间
+Spring的应用场景
+应用场景：JavaEE企业应用开发，包括SSH、SSM等
+
+Spring价值：
+
+Spring是非侵入式的框架，目标是使应用程序代码对框架依赖最小化；
+Spring提供一个一致的编程模型，使应用直接使用POJO开发，与运行环境隔离开来；
+Spring推动应用设计风格向面向对象和面向接口开发转变，提高了代码的重用性和可测试性；
+
+
+Spring配置文件
+<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
+<dependency>
+    <groupId>org.springframework</groupId>
+    <artifactId>spring-webmvc</artifactId>
+    <version>5.2.0.RELEASE</version>
+</dependency>
+<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
+<dependency>
+    <groupId>org.springframework</groupId>
+    <artifactId>spring-jdbc</artifactId>
+    <version>5.2.0.RELEASE</version>
+</dependency>
+
+
+HelloSpring
+1.导入jar包
+注 : spring 需要导入commons-logging进行日志记录 . 我们利用maven , 他会自动下载对应的依赖项 .
+解释
+<dependency>
+   <groupId>org.springframework</groupId>
+   <artifactId>spring-webmvc</artifactId>
+   <version>5.1.10.RELEASE</version>
+</dependency>
+
+
+2.编写代码
+2.1编写一个Hello的实体类
+public class Hello {
+   private String name;
+
+   public String getName() {
+       return name;
+  }
+   public void setName(String name) {
+       this.name = name;
+  }
+
+   public void show(){
+       System.out.println("Hello,"+ name );
+  }
+}
+
+2.2编写我们的spring文件，这里我们命名为beans.xml
+
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+      xsi:schemaLocation="http://www.springframework.org/schema/beans
+       http://www.springframework.org/schema/beans/spring-beans.xsd">
+
+   <!--bean就是java对象 , 由Spring创建和管理-->
+   <bean id="hello" class="com.kuang.pojo.Hello">
+       <property name="name" value="Spring"/>
+   </bean>
+
+</beans>
+
+
+3.测试代码
+@Test
+public void test(){
+   //解析beans.xml文件 , 生成管理相应的Bean对象
+   ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
+   //getBean : 参数即为spring配置文件中bean的id .
+   Hello hello = (Hello) context.getBean("hello");
+   hello.show();
+}
+
+思考
+Hello对象是由谁创建的？Hello对象是由spring创建的
+Hello对象的属性数则么设置的？Hello对象的属性是由spring容器设置的
+
+这个过程就叫做控制反转
+控制：谁来控制对象的创建，穿透应用程序的对象是由程序本身控制创建的，使用spring以后，对象变成由spring来创建。
+反转：程序本身不创建对象，而变成被动的接受对象。
+
+依赖注入：就是利用set方法来进行注入的
+IOC是一种编程思想，由主动的编程变成了被动的接受。
+
+
+新增配置
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+      xsi:schemaLocation="http://www.springframework.org/schema/beans
+       http://www.springframework.org/schema/beans/spring-beans.xsd">
+
+   <bean id="MysqlImpl" class="com.kuang.dao.impl.UserDaoMySqlImpl"/>
+   <bean id="OracleImpl" class="com.kuang.dao.impl.UserDaoOracleImpl"/>
+
+   <bean id="ServiceImpl" class="com.kuang.service.impl.UserServiceImpl">
+       <!--注意: 这里的name并不是属性 , 而是set方法后面的那部分 , 首字母小写-->
+       <!--引用另外一个bean , 不是用value 而是用 ref-->
+       <property name="userDao" ref="OracleImpl"/>
+   </bean>
+
+</beans>
+
+测试类
+@Test
+public void test2(){
+   ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
+   UserServiceImpl serviceImpl = (UserServiceImpl) context.getBean("ServiceImpl");
+   serviceImpl.getUser();
+}
+
+
+要实现不同的操作，只需要在xml配置中修改就可以了，所谓的ioc，一句话搞懂就是：对象由spring来创建，管理和装配！
+
+
+
+IOC创建对象的方式
+1通过无参构造方法来创建
+public class User {
+
+   private String name;
+
+   public User() {
+       System.out.println("user无参构造方法");
+  }
+
+   public void setName(String name) {
+       this.name = name;
+  }
+
+   public void show(){
+       System.out.println("name="+ name );
+  }
+
+}
+
+Beans.xml
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+      xsi:schemaLocation="http://www.springframework.org/schema/beans
+       http://www.springframework.org/schema/beans/spring-beans.xsd">
+
+   <bean id="user" class="com.kuang.pojo.User">
+       <property name="name" value="kuangshen"/>
+   </bean>
+
+</beans>
+
+测试类
+
+@Test
+public void test(){
+   ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
+   //在执行getBean的时候, user已经创建好了 , 通过无参构造
+   User user = (User) context.getBean("user");
+   //调用对象的方法 .
+   user.show();
+}
+
+
+
+2.通过有参构造方法来创建
+public class UserT {
+
+   private String name;
+
+   public UserT(String name) {
+       this.name = name;
+  }
+
+   public void setName(String name) {
+       this.name = name;
+  }
+
+   public void show(){
+       System.out.println("name="+ name );
+  }
+
+}
+
+
+Beans.xml由三种编写方式
+<!-- 第一种根据index参数下标设置 -->
+<bean id="userT" class="com.kuang.pojo.UserT">
+   <!-- index指构造方法 , 下标从0开始 -->
+   <constructor-arg index="0" value="kuangshen2"/>
+</bean>
+<!-- 第二种根据参数名字设置 -->
+<bean id="userT" class="com.kuang.pojo.UserT">
+   <!-- name指参数名 -->
+   <constructor-arg name="name" value="kuangshen2"/>
+</bean>
+<!-- 第三种根据参数类型设置 -->
+<bean id="userT" class="com.kuang.pojo.UserT">
+   <constructor-arg type="java.lang.String" value="kuangshen2"/>
+</bean>
+
+3.测试代码
+@Test
+public void testT(){
+   ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
+   UserT user = (UserT) context.getBean("userT");
+   user.show();
+}
+
+结论：在配置文件加载的时候，其中管理的对象都已经初始化了!
+
+
+5.Spring配置
+5.1别名
+Alias设置别名，为bean设置别名，可以设置多个别名
+<!--设置别名：在获取Bean的时候可以使用别名获取--> <alias name="userT" alias="userNew"/>
+
+5.2bean的配置
+<!--bean就是java对象,由Spring创建和管理-->
+
+<!--
+   id 是bean的标识符,要唯一,如果没有配置id,name就是默认标识符
+   如果配置id,又配置了name,那么name是别名
+   name可以设置多个别名,可以用逗号,分号,空格隔开
+   如果不配置id和name,可以根据applicationContext.getBean(.class)获取对象;
+
+class是bean的全限定名=包名+类名
+-->
+<bean id="hello" name="hello2 h2,h3;h4" class="com.kuang.pojo.Hello">
+   <property name="name" value="Spring"/>
+</bean>
+
+5.3import
+团队的合作通过import来实现的
+<import resource="{path}/beans.xml"/>
+
+
+6依赖注入（DI）
+
+依赖注入（Dependency Injection,DI）。
+
+
+依赖 : 指Bean对象的创建依赖于容器 . Bean对象的依赖资源 .
+
+
+注入 : 指Bean对象所依赖的资源 , 由容器来设置和装配 .
+
+
+6.1构造器注入
+6.2set注入（重点）
+要求被注入的属性 , 必须有set方法 , set方法的方法名由set + 属性首字母大写 , 如果属性是boolean类型 , 没有set方法 , 是 is
+Address.java
+ public class Address {
+ 
+     private String address;
+ 
+     public String getAddress() {
+         return address;
+    }
+ 
+     public void setAddress(String address) {
+         this.address = address;
+    }
+ }
+
+Student.java
+ package com.kuang.pojo;
+ 
+ import java.util.List;
+ import java.util.Map;
+ import java.util.Properties;
+ import java.util.Set;
+ 
+ public class Student {
+ 
+     private String name;
+     private Address address;
+     private String[] books;
+     private List<String> hobbys;
+     private Map<String,String> card;
+     private Set<String> games;
+     private String wife;
+     private Properties info;
+ 
+     public void setName(String name) {
+         this.name = name;
+    }
+ 
+     public void setAddress(Address address) {
+         this.address = address;
+    }
+ 
+     public void setBooks(String[] books) {
+         this.books = books;
+    }
+ 
+     public void setHobbys(List<String> hobbys) {
+         this.hobbys = hobbys;
+    }
+ 
+     public void setCard(Map<String, String> card) {
+         this.card = card;
+    }
+ 
+     public void setGames(Set<String> games) {
+         this.games = games;
+    }
+ 
+     public void setWife(String wife) {
+         this.wife = wife;
+    }
+ 
+     public void setInfo(Properties info) {
+         this.info = info;
+    }
+ 
+     public void show(){
+         System.out.println("name="+ name
+                 + ",address="+ address.getAddress()
+                 + ",books="
+        );
+         for (String book:books){
+             System.out.print("<<"+book+">>\t");
+        }
+         System.out.println("\n爱好:"+hobbys);
+ 
+         System.out.println("card:"+card);
+ 
+         System.out.println("games:"+games);
+ 
+         System.out.println("wife:"+wife);
+ 
+         System.out.println("info:"+info);
+ 
+    }
+ }
+
+6.3扩展的注入
+1.常量注入
+ <bean id="student" class="com.kuang.pojo.Student">
+     <property name="name" value="小明"/>
+ </bean>
+
+测试
+ @Test
+ public void test01(){
+     ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
+ 
+     Student student = (Student) context.getBean("student");
+ 
+     System.out.println(student.getName());
+ 
+ }
+
+
+2.bean注入
+ <bean id="addr" class="com.kuang.pojo.Address">
+     <property name="address" value="重庆"/>
+ </bean>
+ 
+ <bean id="student" class="com.kuang.pojo.Student">
+     <property name="name" value="小明"/>
+     <property name="address" ref="addr"/>
+ </bean>
+
+3.数组注入
+ <bean id="student" class="com.kuang.pojo.Student">
+     <property name="name" value="小明"/>
+     <property name="address" ref="addr"/>
+     <property name="books">
+         <array>
+             <value>西游记</value>
+             <value>红楼梦</value>
+             <value>水浒传</value>
+         </array>
+     </property>
+ </bean>
+
+4.list注入
+ <property name="hobbys">
+     <list>
+         <value>听歌</value>
+         <value>看电影</value>
+         <value>爬山</value>
+     </list>
+ </property>
+
+5.map注入
+ <property name="card">
+     <map>
+         <entry key="中国邮政" value="456456456465456"/>
+         <entry key="建设" value="1456682255511"/>
+     </map>
+ </property>
+
+6.set注入
+ <property name="games">
+     <set>
+         <value>LOL</value>
+         <value>BOB</value>
+         <value>COC</value>
+     </set>
+ </property>
+
+7.null注入
+ <property name="wife"><null/></property>
+
+8.properties注入
+ <property name="info">
+     <props>
+         <prop key="学号">20190604</prop>
+         <prop key="性别">男</prop>
+         <prop key="姓名">小明</prop>
+     </props>
+ </property>
+
+9.p命名和c命名注入
+P命名空间注入 : 需要在头文件中加入约束文件
+ 导入约束 : xmlns:p="http://www.springframework.org/schema/p"
+ 
+ <!--P(属性: properties)命名空间 , 直接注入属性-->
+ <bean id="user" class="com.kuang.pojo.User" p:name="狂神" p:age="18"/>
+
+c 命名空间注入 : 需要在头文件中加入约束文件
+ 导入约束 : xmlns:c="http://www.springframework.org/schema/c"
+ <!--C(构造: Constructor)命名空间 , 使用构造器注入-->
+ <bean id="user" class="com.kuang.pojo.User" c:name="狂神" c:age="18"/>
+
+
+测试代码
+ @Test
+ public void test02(){
+     ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
+     User user = (User) context.getBean("user");
+     System.out.println(user);
+ }
+