实例化->使用构造方法创建对象

初始化->执行init方法：Servlet 的生命期中，仅执行一次 init() 方法，它是在服务器装⼊Servlet 时执行的,即第一次访问这个Servlet才执行

服务->执行service方法，service()方法是 Servlet的核心。每当一个客户请求一个HttpServlet 对象，该对象的service()方法就要被调用

销毁-> 执行destroy方法,destroy() 方法仅执行一次，即在服务器停止且卸装 Servlet 时执行该方法

public interface Servlet {
   void init(ServletConfig var1) throws ServletException;
   ServletConfig getServletConfig();
   void service(ServletRequest var1, ServletResponse var2) throws 
ServletException, IOException;
   String getServletInfo();
    void destroy();
}

HttpServlet里面实现了service方法，里面会根据不同的http method调用不同的方法，所以我们自定义servlet只要重写对应的doXXX方法即可

//XML配置
<servlet>
        <servlet-name>userServlet</servlet-name>
        <servlet-class>net.xdclass.web.UserServlet</servlet-class>
    </servlet>
    
    <servlet-mapping>
        <servlet-name>userServlet</servlet-name>
        <url-pattern>/userServlet</url-pattern>
    </servlet-mapping>

@WebServlet(name = "userServlet",urlPatterns = {"/user1","/user2","/test"})
public class UserServlet extends HttpServlet {
     @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) 
throws ServletException, IOException {
        System.out.println("doGet");
        //实战响应内容
        resp.setContentType("text/html;charset=utf-8");
        PrintWriter printWriter = resp.getWriter();
        printWriter.write("<div> doGet jiguanchen.space 你好！ 
</div>");
    }
}
       
                          
//配置项
//servlet名称，若不指定，则为Servlet的完整类名
  String name() default "";
//路径映射,配置多个，需要/开头
  String[] value() default {};
//路径映射,⽀持配置多个，需要/开头
  String[] urlPatterns() default {};
 //标记容器是否在启动应用时就加载Servlet，默认或数值为负数时表示第一次请求Servlet时再加载；0或正数表示启动应用就加载
  int loadOnStartup() default -1;
 //配置初始参数
  WebInitParam[] initParams() default {};
  //是否支持异步操作模式
  boolean asyncSupported() default false;

public static void testSet(){
        Set<String> set = new HashSet<>();
        set.add("jack");
        set.add("tom");
        set.add("marry");
        set.add("tony");
        set.add("jack");
        Iterator<String> iterator =  set.iterator();
        while (iterator.hasNext()){
            String str = iterator.next();
            System.out.println(str);
        }
    }
    public static void testList(){
        List<String> list = new ArrayList<>();
        list.add("jack");
        list.add("tom");
        list.add("mary");
        list.add("tim");
        list.add("tony");
        list.add("eric");
        list.add("jack");
        Iterator<String> iterator =  list.iterator();
        while (iterator.hasNext()){
            String str = iterator.next();
            System.out.println(str);
        }
    }

public static void testList(){
        List<String> list = new ArrayList<>();
        list.add("jack");
        list.add("tom");
        list.add("mary");
        list.add("tim");
        list.add("tony");
        list.add("eric");
        list.add("jack");
        Iterator<String> iterator =  list.iterator();
        while (iterator.hasNext()){
            String str = iterator.next();
            if("jack".equals(str)){
                list.remove(str);//ConcurrentModificationException并发修改异常
            }
            System.out.println(str);
        }
    }

public class Collections {
    // Suppresses default constructor, ensuring non-
instantiability.
    private Collections() {
    }

排序sort(List list)

//按自然排序升序
List<String> list = new ArrayList<>();
list.add("aaaa");
list.add("zzz");
list.add("gggg"); 
System.out.println(list);
Collections.sort(list);
System.out.println(list);

/*sort(List list, Comparator c) 自定义排序规则，由Comparator控制排序逻辑*/
List<String> list = new ArrayList<>();
list.add("aaaa");
list.add("zzz");
list.add("gggg");
System.out.println(list);
//默认升序
Collections.sort(list, Comparator.naturalOrder());
System.out.println(list);
//降序
Collections.sort(list, Comparator.reverseOrder());
System.out.println(list);

随机排序 shuffle(List list)
    List<String> list = new ArrayList<>();
        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");
        list.add("5");
        list.add("6");
        list.add("7");
        list.add("8");
        list.add("9");
        list.add("10");
        list.add("J");
        list.add("Q");
        list.add("K");
        System.out.println(list);
        Collections.shuffle(list);
        System.out.println(list);

//获取最大元素 max(Collection coll, Comparator comparator)
//获取最小元素 min(Collection coll)

public class CollectionsTest {
    public static void main(String[] args) {
        List<Student> list = new ArrayList<>();
        list.add(new Student("jack", 26));
        list.add(new Student("tom", 29));
        list.add(new Student("mary", 32));
        list.add(new Student("tony", 19));
        list.add(new Student("smith", 41));
        System.out.println(list);
        Student maxAgeStudent =  Collections.max(list, new 
Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.getAge() - o2.getAge();
            }
        });
        
         Student mixAgeStudent =  Collections.mix(list, new 
Comparator<Student>()       {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.getAge() - o2.getAge();
            }
        });
       System.out.println(maxAgeStudent.toString());
    }
}
class Student {
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    private int age;
    private String name;
    public void setAge(int age) {
        this.age = age;
    }
    public int getAge() {
        return age;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

    List<String> list = new ArrayList<>();
        list.add("SpringBoot课程");
        list.add("架构课程");
        list.add("微服务SpringCloud课程"); //设置为只读List集合
        list = Collections.unmodifiableList(list);
        System.out.println(list);
        Set<String> set = new HashSet<>();
        set.add("Mysql教程");
        set.add("Linux服务器器器器教程");
        set.add("Git教程");
        //设置为只读Set集合
        set = Collections.unmodifiableSet(set);
        System.out.println(set);
        Map<String, String> map = new HashMap<>();
        map.put("key1", "课程1");
        map.put("key2", "课程2");
        //设置为只读Map集合
        map = Collections.unmodifiableMap(map);
        System.out.println(map);

//什么是Comparable
public interface Comparable<T> {
    public int compareTo(T o);
}
//是一个接口，定制排序规则
//对它的每个类的对象进行整体排序，里面compareTo方法是实现排序的具体方法
//比如TreeSet、SortedSet、Collections.sort()方法调用进行排序
//String、Integer等类默认实现了这个接口，所以可以排序(看源码)

//详解comparable方法
//⽤于比较次对象和指定对象的顺序，o为要比较的对象
//返回int类型
//大于0, 表示this大于传进来的对象o ,则往后排，即升序
//等于0，表示this等于传进来的对象o
//小于0，表示this小于传进来的对象o

//需求：根据学生的年龄进行排序
public class TestCom {
    public static void main(String [] args) {
        Set<Student> studentSet = new TreeSet<>();
        studentSet.add(new Student("jack",32));
        studentSet.add(new Student("tom",22));
        studentSet.add(new Student("mary",35));
        studentSet.add(new Student("tim",11));
        studentSet.add(new Student("tony",49));
        studentSet.add(new Student("dd",30));
        System.out.println(studentSet);
     }
}
 class Student implements Comparable{
    private int age;
    private String name;
    public void setAge(int age) {
 
 
 
 
 
        this.age = age;
    }
    public int getAge() {
        return age;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public Student(String name,int age){
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
    @Override
    public int compareTo(Object o) {
        if(o instanceof Student){
            Student student = (Student)o;
            return this.age - student.age;
        }
        //返回的数是0代表两个对象相同
        return 0;
    }
}

Map<String,String> map = new HashMap<>();

//往map里面放key - value;
map.put("小明","广东广州");
map.put("小东","广东深圳");

//根据key获取value
map.get("小东");

//判断是否包含某个key
map.containsKey("小明");

//返回map的元素数量
map.size();

//清空容器器
map.clear();

//获取所有value集合
map.values();

//返回所有key的集合
map.keySet()
    
//返回一个Set集合，集合的类型为Map.Entry,是Map声明的一个内部接口，接⼝为泛型，定义为Entry<K,V>，
    
//它表示Map中一个实体(一个key-value对),主要有getKey(),getValue方法
Set<Map.Entry<String,String>> entrySet =  map.entrySet();

//判断map是否为空
map.isEmpty();

//创建对象,HashSet和TreeSet api一样
Set<Integer> set = new HashSet<>();
//往容器里面添加对象
set.add("jack");
//清空元素 
set.clear();
//返回⼤小  
set.size();
//根据对象删除元素
set.remove("jack");
//是否为空
set.isEmpty();