登录注册

当前位置：首页 > 文章列表 > 文章 > java教程 > Java集合方法怎么使用

Java集合方法怎么使用

来源：亿速云 2024-04-03 15:27:38 0浏览 收藏

文章小白一枚，正在不断学习积累知识，现将学习到的知识记录一下，也是将我的所得分享给大家！而今天这篇文章《Java集合方法怎么使用》带大家来了解一下##content_title##，希望对大家的知识积累有所帮助，从而弥补自己的不足，助力实战开发！


java集合

java集合类存放于java.util包中，是一个用来存放对象的容器

  • 集合只能存放对象

  • 集合存放的是多个对象的引用，对象本身还是存放在堆内存中

  • 集合可以存放不同类型，不限数量的数据类型

集合分类---Set、List、Map三种大体系

  • Set: 无序，不可重复的集合

  • List: 有序，可重复的集合

  • Map：具有映射关系的集合

在JDK5之后，增加了泛型，java集合可以记住容器中对象的数据类型

Set

HashSet

  • 不能保证元素的排列顺序（位置由该值的hashcode决定）

  • 不可重复（指的是hashcode不相同）

  • HashSet不是线程安全的

  • 集合元素可以存null

HashSet类实现set接口，set接口继承Collection接口

HashCode()方法

HashSet集合判断两个元素相等的标准：两个对象通过equals()方法比较相等，并且两个对象的hashCode()方法返回值也相等。

如果两个对象通过equals()方法返回true，这两个对象的hashCode值也应该相同。

如果要set集合存相同类型的对象需使用泛型

package com.aggregate.demo;
import com.sun.corba.se.spi.ior.IORTemplateList;
import java.util.HashSet;
import java.util.Iterator;
public class set {
    public static void main(String[] args) {
        HashSet set = new HashSet<>();
        set.add(1);
        set.add("a");//增加元素
        System.out.println(set);
        set.remove(1);//移除元素
        System.out.println(set);
        System.out.println(set.contains("a"));//判断集合中是否存在该元素
        set.clear();//清空集合
        System.out.println(set);
        //遍历集合
        set.add("a");
        set.add("b");
        set.add("c");
        set.add("d");
        //1.使用迭代器遍历集合
        Iterator iterator = set.iterator();
        while (iterator.hasNext()) {
            System.out.print(iterator.next() + "\t");
        }
        System.out.println("===============");
        //2.for each迭代集合
        for (Object i : set) {
            System.out.print(i + "\t");
        }
        System.out.println("===============");
        System.out.println(set.size());//获取元素的个数
        set.add(null);
        System.out.println(set);
        //使用泛型存相同类型的元素
        HashSet set1 = new HashSet<>();
        set1.add("123");
//      set1.add(2);
    }
}
TreeSet
TreeSet是SortedSet接口的实现类，TreeSet可以确保集合元素处于排序状态。
TreeSet支持两种排序方法：自然排序和定制排序。默认情况下，TreeSet采用自然排序
自然排序
排序：TreeSet会调用集合元素的compareTo(Object obj)方法来比较元素之间的大小关系，然后将集合元素按升序排列
自定义类如何排序？
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
public class Tree {
    public static void main(String[] args) {
        TreeSet treeSet = new TreeSet<>();
        //TreeSet自然排序
        treeSet.add(5);
        treeSet.add(1);
        treeSet.add(3);
        treeSet.add(2);
        treeSet.add(4);
        System.out.println(treeSet);
        treeSet.remove(3);
        System.out.println(treeSet);
        System.out.println(treeSet.contains(0));
        treeSet.clear();
        System.out.println(treeSet);
        Iterator iterator = treeSet.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
        System.out.println("=============");
        for (Integer i : treeSet) {
            System.out.println(i);
        }
        Person P1 = new Person(23, "张三");
        Person P2 = new Person(25, "李四");
        Person P3 = new Person(12, "王五");
        Person P4 = new Person(5, "Lucy");
        Person P5 = new Person(99, "hhhh");
        TreeSet people = new TreeSet<>(new Person());
        people.add(P1);
        people.add(P2);
        people.add(P3);
        people.add(P4);
        people.add(P5);
        for (Person i : people) {
            System.out.println(i.name + "  " + i.age);
        }
    }
}
//把person对象存到TreeSet中并且按照年龄排序
class Person implements Comparator {
    int age;
    String name;
    public Person() {
    }
    public Person(int age, String name) {
        this.age = age;
        this.name = name;
    }
    @Override
    public int compare(Person o1, Person o2) {//年龄正序排序
        if (o1.age > o2.age) {
            return 1;
        } else if (o1.age < o2.age) {
            return -1;
        } else {
            return 0;
        }
    }
}
List
List与ArrayList
List代表一个元素有序、且可重复的集合，集合中的每个元素都有其对应的顺序索引
List允许使用重复元素，可以通过索引来访问指定位置的集合元素
List默认按元素的添加顺序设置元素的索引
List集合里添加了一些根据索引来操作集合元素的方法
ArrayList和Vector
ArrayList和Vector是List接口的两个典型实现
区别：
  • Vector是一个古老的集合，通常建议使用ArrayList
  • ArrayList是线程不安全的，而Vector是线程安全的
  • 即使为保证List集合线程安全，也不推荐使用VectorMap
Map
用于保存具有映射关系的数据，因此Map集合里保存着两组值，一组值用于保存Map里key，另外一组用于保存Map里的Value
Map中的key和value都可以是任何引用类型的数据
Map中的key不允许重复，即同一个Map对象的任何两个Key通过equals方法比较返回false
key和value之间存在单向一对一关系，即通过指定的key总能找到唯一的，确定的Value
HashMap & Hashtable
HashMap和Hashtable是Map接口的两个典型实现类
区别：
  • Hashtable是一个古老的Map实现类，不建议使用
  • Hashtable是线程安全的Map实现，但HashMap是线程不安全的
  • Hashtable不允许使用null作为key和value，而HashMap可以
与HashSet集合不能保证元素的顺序一样，Hashtable、HashMap也不能保证其中key-value对的顺序
Hashtable、HashMap判断两个key的标准是：key通过equals方法返回true，hashCode值也相等
Hashta5ble相等的标准是：两个Value通过equalHashMap判断两个Value方法返回true
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class MapDemo {
    public static void main(String[] args) {
        Map map = new HashMap();
        map.put("b", 1);//添加数据
        map.put("c", 2);
        map.put("d", 3);
        System.out.println(map);
        System.out.println(map.get("d"));//根据key取值
        map.remove("c");
        System.out.println(map);//根据key键值对
        System.out.println(map.size());//map集合的长度
        System.out.println(map.containsKey("a"));//判断当前的map集合是否包含指定的key
        System.out.println(map.containsValue(10));//判断当前的map集合是否包含指定的value
//        map.clear();//清空集合
        Set keys = map.keySet();//可以获取map集合的key的集合
        map.values();//获取集合的所有value值
        //遍历map集合,通过map.keySet();
        for (String key : keys) {
            System.out.println("key:" + key + ", value:" + map.get(key));
        }
        //通过map.entrySet();遍历集合
        Set> entries = map.entrySet();
        for (Map.Entry entry : entries) {
            System.out.println("key:" + entry.getKey() + ", value:" + entry.getValue());
        }
    }
}
TreeMap
TreeMap存储key-value对时，需要根据key对key-value对进行排序。TreeMap可以保证所有的key-value对处于有序状态
TreeMap的key排序
  • 自然排序：TreeMap的所有的key必须实现Comparable接口，而且所有的key应该是同一个类的对象，否则将会抛出ClassCastException
  • 定制排序（了解）：创建TreeMap时，传入一个Comparator对象，该对象负责对TreeMap中的所有key排序。此时不需要Map的key实现Comparator接口
import java.util.Map;
import java.util.TreeMap;
public class TreeMapDemo {
    public static void main(String[] args) {
        //TreeMap的自然排序是字典
        Map treemap = new TreeMap();
        treemap.put(4, "a");
        treemap.put(3, "b");
        treemap.put(2, "c");
        treemap.put(1, "d");
        System.out.println(treemap);
        Map map = new TreeMap();
        map.put("a", "a");
        map.put("c", "a");
        map.put("d", "a");
        map.put("b", "a");
        map.put("ab", "a");
        System.out.println(map);

    }
}
操作集合的工具类：Collections
Collections是一个操作Set 、List和Map等集合的工具类
Collections中提供了大量方法对集合元素进行排序、查询和修改等操作，还提供了对集合对象设置不可变，对集合对象实现同步控制等方法
排序操作：
  • reverse(List):反转List中元素的顺序
  • shuffle(List):对List集合元素进行随机排序
  • sort(List):根据元素的自然顺序对指定List集合元素升序排序
  • sort(List,Comparator):根据指定的Comparator产生的顺序对List集合元素进行排序s
  • wap(List，int，int)：将指定list集合中的i处元素和j处元素进行交换
查找、替换
Object max(Collection):根据元素的自然顺序，返回给定集合中的最大元素
Object max(Collection,Comparator):根据Comparator指定的顺序，返回给定集合中的最大元素
Object min(Collection)
Object min(Collection,Comparator)
int frequency(Collection,Object):返回指定集合中指定元素的出现次数
boolean replaceAll(List list,Object oldVal,Object newVal):使用新值替换List对象的所有旧值
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class Test {
    public static void main(String[] args) {
        List list = new ArrayList<>();
        list.add("a");
        list.add("c");
        list.add("d");
        list.add("f");
        list.add("b");
        System.out.println(list);
        Collections.reverse(list);//反转List中元素的顺序
        System.out.println(list);
        Collections.shuffle(list);//对list集合元素进行顺序排序
        System.out.println(list);
        Collections.sort(list);//list集合字典升序排序
        System.out.println(list);
        Student s1 = new Student(14, "张三");
        Student s2 = new Student(12, "李四");
        Student s3 = new Student(13, "王五");
        Student s4 = new Student(11, "小刘");
        List students = new ArrayList();
        students.add(s1);
        students.add(s2);
        students.add(s3);
        students.add(s4);
        for (Student student : students) {
            System.out.println(student.name + "," + student.age);
        }
        Collections.sort(students, new Student());
        System.out.println("==========");
        for (Student student : students) {
            System.out.println(student.name + "," + student.age);
        }
        Collections.swap(list, 1, 3);//将指定list集合中的i处元素和j处元素进行交换
        System.out.println(list);
        System.out.println(Collections.max(list));
        System.out.println(Collections.min(list));
        Student max = Collections.max(students, new Student());
        Student min = Collections.min(students, new Student());
        System.out.println(max.name + ", " + max.age);
        System.out.println(min.name + ", " + min.age);
        System.out.println(Collections.frequency(list, "a"));
        System.out.println(Collections.replaceAll(list, "a", "aa"));
        System.out.println(list);
    }
}
class Student implements Comparator {
    int age;
    String name;
    public Student() {
    }
    public Student(int age, String name) {
        this.age = age;
        this.name = name;
    }
    @Override
    //根据年龄升序排序对象
    public int compare(Student o1, Student o2) {
        if (o1.age > o2.age) {
            return 1;
        } else if (o1.age < o2.age) {
            return -1;
        } else {
            return 0;
        }
    }
}
同步控制
Collections类中提供了多个synchronizedxxx()方法该方法可使指定集合包装成线程同步的集合；从而解决多线程并访问集合时的线程安全问题。
泛型
为什么要有泛型
集合中使用泛型时只有指定类型才可以添加到集合中，类型安全
java中的泛型，只在编译阶段有效。
泛型类
  • 对象实例化时不指定泛型，默认为：object
  • 泛型不同的引用不能相互赋值
public class Test2 {
    public static void main(String[] args) {
        A a = new A();
        a.setKey("rexx");
        String s = a.getKey();
        System.out.println(s);
    }
}
class A {
    private T key;
    public T getKey() {
        return key;
    }
    public void setKey(T key) {
        this.key = key;
    }
}
泛型接口
定义一个泛型接口
未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中
泛型方法
package com.aggregate.demo;
public class Test3 {
    public static void main(String[] args) {
        B1 b1 = new B1();
        B1 b2 = new B1();
        B2 b3 = new B2();
        Cc cc = new Cc();
        cc.test("xxx");
        //泛型方法，在调用之前没有固定的数据类型
        //在调用时，传入的参数是什么类型，就会把泛型改成什么类型
        //也就是说，泛型方法会在调用时确定泛型具体的数据类型
        Integer integer = cc.test1(2);
        Boolean aBoolean = cc.test1(true);
    }
}
//定义泛型接口
interface IB {
    T test(T t);
}
//未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中
class B1 implements IB {
    @Override
    public T test(T t) {
        return null;
    }
}
//传入实际参数
//如果实现接口时指定接口的泛型的具体数据类型
//这个类实现接口所有方法的位置都要泛型替换实际的具体数据类型
class B2 implements IB {
    @Override
    public String test(String s) {
        return null;
    }
}
//泛型方法
class Cc {
    public void test() {
    }
    //无返回值的泛型方法
    public  void test(T s) {
        T t = s;
    }
    public String test1(String s) {
        return s;
    }
    //有返回值的泛型方法
    public  T test1(T s) {
        return s;
    }
    public void test2(String... strs) {
        for (String s : strs) {
            System.out.println(s);
        }
    }
    //形参为可变参数的泛型方法
    public  void test2(T... strs) {
        for (T str : strs) {
            System.out.println(str);
        }
    }

}
//带泛型的类可以在类里面定义泛型的变量
class Dd {
    private E e;
    //静态的泛型方法
    public static  void test3(T t) {
        //System.out.println(this.e);
        //在静态方法中，不能使用类定义泛型，如果要使用泛型，只能使用静态方法自己定义的泛型
        System.out.println(t);
    }
    //在类上定义的泛型，可以在普通的方法中使用
    public  void test(T s) {
        System.out.println(this.e);
        T t = s;
    }
}
通配符
1.有限制的通配符
  • (无穷小,Person]只允许泛型为Person及Person子类的引用调用
  • [Person,无穷大)只允许泛型为Person及Person父类的引用调用
  • 只允许泛型为实现Comparable接口的实现类的引用调用
枚举类
在某些情况下，一个类的对象是有限而且固定的。例如季节类，只能有4个对象。
手动实现枚举类：
  • private修饰构造器
  • 属性使用private final修饰
  • 把该类的所有实例都使用public static final来修饰
实现接口的枚举类
  • 和普通Java类一样枚举类可以实现一个或多个接口
  • 若需要每个枚举值在调用实现的接口方法呈现出不同的行为方式，则可以让每个枚举值分别来实现该方法
public class Test5 {
    public static void main(String[] args) {
        //Season.SPRING,这段执行就是获取一个Season的对象
        Season spring = Season.SPRING;
        spring.showInfo();
        Season summer = Season.SUMMER;
        summer.showInfo();
        Season spring1 = Season.SPRING;
        //每次执行Season.SPRING获得是相同的对象，枚举类中的每个枚举都是单例模式的
        System.out.println(spring.equals(spring1));
        spring1.test();
    }
}
enum Season implements ITest {
    SPRING("春", "春暖花开"),//此处相当于调用有参的私有构造
    SUMMER("夏", "夏日炎炎"),
    AUTUMN("秋", "秋高气爽"),
    WINTER("冬", "寒风凛冽");

    private final String name;
    private final String desc;
    Season(String name, String desc) {
        this.name = name;
        this.desc = desc;
    }
    public void showInfo() {
        System.out.println(this.name + ":" + this.desc);
    }
    @Override
    public void test() {
        System.out.println("这是实现的ITest接口的test方法");
    }
}

interface ITest {
    void test();
}
Annotation(注解)概述
Annotation其实就是代码里的特殊标记，这些标记可以在编译，类加载，运行时被读取，并执行相应的处理。通过使用Annotation，程序员可以在不改变原有逻辑的情况下，在源文件中嵌入一些补充信息
Annotation可以像修饰符一样被使用，可用于修饰包，类，构造器，方法，成员变量，参数，局部变量的声明，这些信息被保存在Annotation的name=value对中
Anotation能被用来为程序元素（类，方法，成员变量等）设置元数据
基本的Annotation
  • 使用Annotation时要在其前面增加@符号，并把该Annotation当成一个修饰符使用。用于修饰它支持的程序元素
  • 三个基本的Annotation：
    • @Override:限定重写父类方法，该注释只能用于方法
    • Deprecated：用于表示某个程序元素（类、方法等）已过时
    • @SuppressWarnings:抑制编译器警告
自定义Annotation
自定义新的Annotation类型使用@interface关键字
Annotation的成员变量在Annotation定义中以无参数方法的形式来声明。其方法名和返回值定义了该成员的名字和类型
可以在定义Annotation的成员变量时为其指定初始值，指定成员变量的初始值可使用default关键字
没有成员定义的Annotation称为标记；包含成员变量的Annotation称为元数据的Annotation
import java.lang.annotation.*;
import java.util.ArrayList;
import java.util.List;
public class Test6 {
    public static void main(String[] args) {
        new TestB().test01();
        @SuppressWarnings({})
        List list = new ArrayList();
    }
}
class TestA {
    public void test() {
    }
}
class TestB extends TestA {
    @TestAnn(id = 100, desc = "姓名")
    String name;
    @Override
    public void test() {
        super.test();
    }
    @Deprecated
    public void test01() {
    }
}
@Target(ElementType.FIELD)//这个注解类是给其他类的属性做注解
@Retention(RetentionPolicy.RUNTIME)//定义注解的声明周期
@Documented
@interface TestAnn {
    public int id() default 0;
    public String desc() default "";
}
今天带大家了解了的相关知识，希望对你有所帮助；关于文章的技术知识我们会一点点深入介绍，欢迎大家关注golang学习网公众号，一起学习编程~
                
                

                                        java
                                    

                                

                    
版本声明
本文转载于：亿速云 如有侵犯，请联系study_golang@163.com删除
                

                                

                                        

                        
                            揭秘 Java 和 Kubernetes 的交汇点：应用程序现代化的关键揭秘 Java 和 Kubernetes 的交汇点：应用程序现代化的关键                        
                        

                            
上一篇

                            
揭秘 Java 和 Kubernetes 的交汇点：应用程序现代化的关键

                        

                    

                                        

                        
                            go mod 如何从提交 id 生成版本和时间戳
                        
                        

                            
下一篇

                            
go mod 如何从提交 id 生成版本和时间戳

                        

                    

                                    

            
        
                

            

                

                    查看更多
                    
最新文章

                

            

            
        

    
    

        
        

            

                查看更多
                
课程推荐

            

            
    
                                
  • 
                    
                        前端进阶之JavaScript设计模式
                                            
                    
    
                        
    前端进阶之JavaScript设计模式
    
                        
    
                            设计模式是开发人员在软件开发过程中面临一般问题时的解决方案，代表了最佳的实践。本课程的主打内容包括JS常见设计模式以及具体应用场景，打造一站式知识长龙服务，适合有JS基础的同学学习。                        
    
                        
    542次学习
    
                    
    
                
    • 
                                
  • 
                    
                        GO语言核心编程课程
                                            
                    
    
                        
    GO语言核心编程课程
    
                        
    
                            本课程采用真实案例，全面具体可落地，从理论到实践，一步一步将GO核心编程技术、编程思想、底层实现融会贯通，使学习者贴近时代脉搏，做IT互联网时代的弄潮儿。                        
    
                        
    508次学习
    
                    
    
                
    • 
                                
  • 
                    
                        简单聊聊mysql8与网络通信
                                            
                    
    
                        
    简单聊聊mysql8与网络通信
    
                        
    
                            如有问题加微信：Le-studyg；在课程中，我们将首先介绍MySQL8的新特性，包括性能优化、安全增强、新数据类型等，帮助学生快速熟悉MySQL8的最新功能。接着，我们将深入解析MySQL的网络通信机制，包括协议、连接管理、数据传输等，让                        
    
                        
    497次学习
    
                    
    
                
    • 
                                
  • 
                    
                        JavaScript正则表达式基础与实战
                                            
                    
    
                        
    JavaScript正则表达式基础与实战
    
                        
    
                            在任何一门编程语言中,正则表达式,都是一项重要的知识,它提供了高效的字符串匹配与捕获机制,可以极大的简化程序设计。                        
    
                        
    487次学习
    
                    
    
                
    • 
                                
  • 
                    
                        从零制作响应式网站—Grid布局
                                            
                    
    
                        
    从零制作响应式网站—Grid布局
    
                        
    
                            本系列教程将展示从零制作一个假想的网络科技公司官网，分为导航，轮播，关于我们，成功案例，服务流程，团队介绍，数据部分，公司动态，底部信息等内容区块。网站整体采用CSSGrid布局，支持响应式，有流畅过渡和展现动画。                        
    
                        
    484次学习
    
                    
    
                
    • 
                            

        

        

        

            查看更多
            
AI推荐

        

        
    
                        
  • 
                
                    AI Make Song：零门槛AI音乐创作平台，助你轻松制作个性化音乐
                
                
    
                    
    AI Make Song
    
                    
    
                        AI Make Song是一款革命性的AI音乐生成平台，提供文本和歌词转音乐的双模式输入，支持多语言及商业友好版权体系。无论你是音乐爱好者、内容创作者还是广告从业者，都能在这里实现“用文字创造音乐”的梦想。平台已生成超百万首原创音乐，覆盖全球20个国家，用户满意度高达95%。                    
    
                    
    26次使用
    
                
    
            
    • 
                        
  • 
                
                    SongGenerator.io：零门槛AI音乐生成器，快速创作高质量音乐
                
                
    
                    
    SongGenerator
    
                    
    
                        探索SongGenerator.io，零门槛、全免费的AI音乐生成器。无需注册，通过简单文本输入即可生成多风格音乐，适用于内容创作者、音乐爱好者和教育工作者。日均生成量超10万次，全球50国家用户信赖。                    
    
                    
    21次使用
    
                
    
            
    • 
                        
  • 
                
                     BeArt AI换脸：免费在线工具，轻松实现照片、视频、GIF换脸
                
                
    
                    
    BeArt AI换脸
    
                    
    
                         探索BeArt AI换脸工具，免费在线使用，无需下载软件，即可对照片、视频和GIF进行高质量换脸。体验快速、流畅、无水印的换脸效果，适用于娱乐创作、影视制作、广告营销等多种场景。                    
    
                    
    23次使用
    
                
    
            
    • 
                        
  • 
                
                    SEO标题协启动：AI驱动的智能对话与内容生成平台 - 提升创作效率
                
                
    
                    
    协启动
    
                    
    
                        SEO摘要协启动（XieQiDong Chatbot）是由深圳协启动传媒有限公司运营的AI智能服务平台，提供多模型支持的对话服务、文档处理和图像生成工具，旨在提升用户内容创作与信息处理效率。平台支持订阅制付费，适合个人及企业用户，满足日常聊天、文案生成、学习辅助等需求。                    
    
                    
    23次使用
    
                
    
            
    • 
                        
  • 
                
                    Brev AI：零注册门槛的全功能免费AI音乐创作平台
                
                
    
                    
    Brev AI
    
                    
    
                        探索Brev AI，一个无需注册即可免费使用的AI音乐创作平台，提供多功能工具如音乐生成、去人声、歌词创作等，适用于内容创作、商业配乐和个人创作，满足您的音乐需求。                    
    
                    
    25次使用
    
                
    
            
    • 
                    

    

        
        

            

                查看更多
                
相关文章

            

            
        

    




    

        

            

                关于我们
                免责声明
                意见反馈
                联系我们
                内容提交
            

            
Golang学习网：公益在线Go学习平台，帮助Go学习者快速成长！

            

                技术交流群
            

            

                Copyright 2023 http://www.17golang.com/ All Rights Reserved ｜ 苏ICP备2023003363号-1
            

        

        

            
    
                
                
  • 
                    
    
                        Golang学习网
                    
    
                    
    关注公众号
    
                    
    Golang学习网
    
                
    • 
                
    
            

        

        

    







    

      

        
      

      
      
      
      

        

        

          
微信登录更方便

        

        

          
    
            
  • 密码登录
    •  
            
  • 注册账号
    • 
          

          

            

              

                
                                

                  
                

                

                  
                

                

                  

                    
                  

                
                    
                
              

                

                  忘记密码
                

                

                  
                

              

            

            
          

        

        
登录即同意 用户协议 和 隐私政策

      

		
		

			

			
返回登录

			

			
    
				
  • 重置密码
    • 
			

			

				

				

          

          
        

					
          

            

              
            

            
                发送验证码