精华内容
下载资源
问答
  • 2019-07-10 12:00:22

    集合主要有Collection和Map接口。
    List特点:元素有放入顺序,元素可重复
    Map特点:元素按键值对存储,无放入顺序
    Set特点:元素无放入顺序,元素不可重复(注意:元素虽然无放入顺序,但是元素在set中的位置是有该元素的HashCode决定的,其位置其实是固定的)
    List接口有三个实现类:LinkedList,ArrayList,Vector
    LinkedList:底层基于链表实现,链表内存是散乱的,每一个元素存储本身内存地址的同时还存储下一个元素的地址。链表增删快,查找慢
    ArrayList和Vector的区别:ArrayList是非线程安全的,效率高;Vector是基于线程安全的,效率低
    Set接口有两个实现类:HashSet(底层由HashMap实现),LinkedHashSet
    SortedSet接口有一个实现类:TreeSet(底层由平衡二叉树实现)
    Query接口有一个实现类:LinkList
    Map接口有三个实现类:HashMap,HashTable,LinkeHashMap
    HashMap非线程安全,高效,支持null;HashTable线程安全,低效,不支持null
    SortedMap有一个实现类:TreeMap
    其实最主要的是,list是用来处理序列的,而set是用来处理集的。Map是知道的,存储的是键值对
    set 一般无序不重复.map kv 结构 list 有序 。

    更多相关内容
  • java集合框架--集合接口

    千次阅读 2018-06-29 00:43:03
    java 集合框架使程序处理集合数组的方法标准化...集合接口: 接口 描述 Collection 集合框架的顶层接口,定义了操作对象集合的共同方法 List 继承 Collection,表示有序的,可包括重复元素的列表 ...

    java 集合框架使程序处理集合数组的方法标准化。集合框架包含了一组标准的接口。对这些接口,提供了几个标准的实现工具(LinkedList、HashSet 和 TreeSet);

    集合接口:

    接口描述
    Collection集合框架的顶层接口,定义了操作对象集合的共同方法
    List继承 Collection,表示有序的,可包括重复元素的列表
    Set继承 Collection,表示无序的,无重复元素的列表
    SortSet继承 Set,对Set中元素进行排序
    Queue继承 Collection,定义了队列数据结构的操作方式
    Deque继承了Queue,定义了双向队列数据结构的操作方式

    集合接口类图如下:

    这里写图片描述

    Collection 接口

    Collection 接口是构造集合框架的基础。它声明所有类集合都将拥有的核心方法。因为所有类集合实现 Collection,所以熟悉它的方法对于清楚地理解框架是必要的。

    注意:其中几个方法可能会引发一个 UnsupportedOperationException 异常,这些发生在当类集合不能被修改时。当一个对象与另一个对象不兼容,例如,当企图增加一个不兼容的对象到一个集合中时,将产生一个ClassCastException异常。

    Collection 定义的方法:

    方法描述
    boolean add (Object obj)将 obj加入到调用类集合中。如果Obj被加入到类集合中了,则返回 true,如果未能加入集合,则返回 false。
    booleand addAll(Collection c)将 c 中的所有元素都加入到类集合中,如果操作成功,则返回 true, 否则返回 false。
    void clear()从调用类集合中删除所有元素
    boolean contains(Object obj)如果 obj 是调用类集合中的一个元素,则返回 true,否则返回 false。
    boolean containsAll(Collection c)如果调用类集合包含了 c 中的所有元素,则返回 true,否则返回 false。
    boolean equals(Object obj)如果调用类集合与 obj相等,则返回 true,否则返回 false
    int hashCode()返回调用类集合的散列值
    boolean isEmpty()如果调用类集合时空的,则返回true,否则返回 false。
    Iterator iterator()返回调用类集合的迭代器
    boolean remove(Object obj)从调用类集合中删除 obj 的一个实例。如果这个元素被删除了,则返回 true,否则返回 false
    boolean removeAll(Collection c)从调用类集合中删除 c 的的所有元素。如果类集合被改变了(也就是说元素被删除了),则返回 true,否则返回 false
    boolean retainAll(Collection c)删除调用类集合中除了包含在 c 中的元素之外的所有元素。如果类集合被改变了(也就是说元素被删除了),则返回 true,否则返回 false
    int size()返回调用类集合中元素的个数
    Object[] toArray()返回一个数组,该数组包含了所有存储在调用类集合中的元素
    Object[] toArray(Object array[])返回一个数组,该数组仅仅包含了那些类型与数组元素类型匹配的类集合元素。如果 array的大小与匹配元素的个数相等,则它们被返回到 array,如果 array 的大小比匹配元素的个数小,则将分配并返回一个所需大小的新数组;如果 array 的大小比匹配元素的个数大,在数组中,在类集合元素之后的单元被置为 null。如果任 一类集合元素的类型都不是 array 的子类型,则引发一个 ArrayStoreException异常

    List接口

    List接口继承了 Collection 并声明了类集的新特性。使用一个基于 零 的下标,元素可以通过他们在列表中的位置被插入和访问。一个列表可以包含重复元素。

    处理 由 Collection 定义的方法之外,List 还定义了一些它自己的方法。注意:当类集合不能被修改时,其中的几种方法引发 UnsupportOperationException 异常当一个对象与另一个对象不兼容,例如,当企图增加一个不兼容的对象到一个类集中时,将产生一个ClassCastException异常。

    List 定义的方法:

    方法描述
    void add(int index, Object obj)将 obj 加入到调用列表中。插入位置的下标由 index 传递。任何已存在的,在插入点以及插入点之后的元素将后移。因此,没有元素被覆盖
    booleand addAll(int index, Collection c)将 c 中的所有元素插入到调用列表中。插入位置的下标由 index 传递。任何已存在的,在插入点以及插入点之后的元素将后移。因此,没有元素被覆盖。如果调用列表改变了,则返回 true, 否则返回 false。
    Object get(int index)返回存储在调用类集内指定下标处的对象
    int indexOf(Object obj)返回调用列表中 obj 的第一个实例的下标。如果 obj 不是列表中的元素,则返回 -1
    int lastIndexOf(Object obj)返回调用列表中 obj 的最后一个实例的下标。如果 obj 不是列表中的元素,则返回 -1
    ListIterator listIterator()返回调用列表的迭代器
    ListIterator listIterator(int index)返回调用列表从指定下标处开始的迭代器
    Object remove(int index)删除调用列表中 index 位置的元素并返回删除的元素。删除后,列表被压缩。也就是说,被删除元素后面的元素向前移动
    Object set(int index, Object obj)用 obj对调用列表内由 index 指定的位置进行赋值
    List subList(int start, int end)返回一个列表,该列表包括了调用列表中从 start 到 end - 1 的元素

    Set 和 sortSet 接口
    set 接口定义了一个集合,它继承了 collection 并说明了不允许重复元素的类集的特性。因此,如果试图将仇富元素加到集合时, add() 方法将返回 false,它本身并没有定义任何附件的方法。

    SortSet 接口继承了 Set 并说明了按升序排列的集合的特性。当没有元素包含在调用集合中时,其中的几种方法引发 NoSuchElementException 异常。当对象与集合中的元素不兼容时,引发 ClassCastException 异常。如果试图使用 null 对象,而集合不允许 null 时,将引发 NullPointerException 异常。

    SortedSet定义的方法:

    方法描述
    Comparator comparator()返回排序集合的比较器,如果对该集合使用自然排序,则返回 null
    Object first()返回排序集合的第一个元素
    SortSet headSet(Object end)返回一个包含那些小于 end 的元素的 SortedSet
    Object last()返回排序集合的最后一个元素
    SortSet subSet(Object start, Object end)返回一个 SortedSet,它包括了 从 start 到 end-1 的元素
    SortSet tailSet(Object start)返回一个 SortedSet, 它包含了那些包含在类集合中的大于 等于 start 的元素

    Queue 和 Deque 接口

    Queue< E >接口(E表示集合元素的类型)扩展了 Collection 接口、定义了一个队列数据结构的操作方式。队列定义了一个 “头” 位置, 它是下一个将要被移除的元素。除了从 Collection 继承的操作外,还提供了 插入,提取和检查操作。每个方法都存在两种形式。一种 抛出异常(操作失败时),另一种返回一个特殊值(null 或 false ,具体取决于操作)。插入操作的一种形式是用于专门为有容量限制的 Queue 实现设计的;在大多数实现中,插入操作不会失败。

    Queue定义的方法:

    方法描述
    boolean add(E e)将指定的元素插入此队列(如果立即可行且不会违反容量限制),在成功时返回 true, 如果当前没有可用的空间,则抛出 IllegalStateException
    boolean offer(E e)将指定的元素插入此队列(如果立即可行且不会违反容量限制)当使用有容量显得队列时,此方法通常要优于 add(E),或者可能无法插入元素,而只是抛出一个异常
    E remove()获取并移除此队列的头,如果此队列为空,则抛出一个异常
    E poll()获取并移除此队列的头,如果此队列为空,则返回 null
    E element()获取,但是不移除此队列的头,此队列为空时,将抛出一个异常
    E peek()获取,但是不移除此队列的头,此队列为空时,则返回 null

    remove() 和 poll() 方法可移除 和返回队列的头。到底从队列中移除哪个元素是队列排序策略的功能,而该策略在各种实现中是不同的。 remove() 和 poll() 方法仅在队列为空时其行为有所不同,remove() 方法抛出一个异常,而 poll () 方法则返回 null。

    element () 和 peek() 返回但不移除队列的头。

    Queue 接口并未定义阻塞队列的方法,而这种情况在并发编程中是很常见的。
    BlockingQueue 接口定义了那些等待元素出现或等待队列中有可用空间的方法,这些方法扩展了此接口。

    Queue 实现通常不允许插入null元素。尽管某些实现(如 LinkedList)并不禁止插入null.即使 在允许 null 的实现中,也不应该将 null 插入到 Queue 中。因为 null 也用做 poll 方法的一个特殊返回值,表明队列不包含元素。

    Deque 定义了一个双端队列数据结构,支持在两端插入和移除元素。大多数Deque 实现对于他们能够包含的元素数有没固定的限制,但此接口即支持有容量限制的双端队列,也支持没有固定大小限制的双端队列。

    此接口定义在双端队列两端访问元素的方法,提供插入,移除,和检查元素的方法。每种方法都存在两种形式:一种形式在操作失败时抛出异常,另一种形式返回一个特殊值 (null 或是 false,具体取决于操作)。插入操作的后一种形式是转为使用容量限制的Deque实现设计的;在大多数实现中,插入操作不能失败。

    Deque 定义的方法

    TablesAreCool
    col 3 isright-aligned$1600

    此接口扩展了 Queue 接口。在将双端队列用作队列时,将得到 FIFO (现金先出)行为。
    将原始添加到双端队列的末尾,从双端队列的开头移除元素。
    从Queue 接口继承的方法完全等效于 Deque 方法。
    双端队列也可用作 LIFO(后进先出)堆栈。应优先使用此接口而不是遗留 Stack l类。在将双端队列用作堆栈时,元素被推入双端队列的开头并从双端队列开头弹出。堆栈方法完全等效于Deque 方法。

    虽然 Deque 实现没有严格要求禁止插入 null 元素,但 建议最好不要插入 null 元素。建议任何事实上允许 null 元素的 Deque 实现,用户最好不要利用插入 null 的功能。这是因为各种方法会将null用作特殊的返回值来指示双端队列为空

    展开全文
  • Java基础-Collection集合接口(List及Set)

    千次阅读 2020-12-31 21:27:39
    1.Collection接口的常用方法 1.Collection中能存放什么元素   没有使用泛型之前,collection中可以存储object的所有子类型   使用了泛型之后,collection中只能存储某个具体的类型   集合中不能存储基本数据...

    1.Collection接口的常用方法

    1.Collection中能存放什么元素
      没有使用泛型之前,collection中可以存储object的所有子类型
      使用了泛型之后,collection中只能存储某个具体的类型
      集合中不能存储基本数据类型,也不能存java对象,只能存储java对象的内存地址。

    2.Collection中常用方法:
    注意:collection中包含的方法在它的实现类中也有,也可以使用,是公共的。
    boolean add(Object e)

    //Collection c=new Collection(); //接口是抽象的,无法实例化
    boolean add(Object e) 向集合中添加元素
    int size(); 获取集合中元素的个数
    void clear(); 清空集合中的所有元素
    boolean contains(Object o):判断当前集合中是否包含元素o,包含返回true,不包含返回false
    boolean remove(Object o) 删除集合中的某个元素
    boolean isEmpty() 判断该集合中的元素个数是否为0
    Obect [] toArray() 将集合转换为数组

    public static void main(String[] args) {
        //Collection c=new Collection();      //接口是抽象的,无法实例化
        Collection c=new ArrayList();
        //测试collection接口中的常用方法
        c.add(1200);      //自动装箱,实际上是放进去了一个对象的内存地址。Integer i=new Integer(1200)
        c.add(3.14);      //自动装箱
        c.add(new Object());
        c.add(true);
        //获取集合中元素的个数
        System.out.println("集合中元素的个数"+c.size());
        //清空集合
        c.clear();
        System.out.println("集合中元素的个数"+c.size());
        //再向集合中添加元素
        c.add("hello");
        c.add("world");
        c.add("好客");
        c.add("绿巨人");
        //判断集合中是否包含绿巨人
        boolean flag=c.contains("绿巨人");
        System.out.println(flag);     //true
        boolean flag2=c.contains("绿巨人2");
        System.out.println(flag2);    //false
    
        System.out.println("集合中元素的个数"+c.size());
    
        //删除集合中某个元素
        c.remove("绿巨人");
        System.out.println("集合中元素的个数"+c.size());
    
        //判断集合是否为空
        System.out.println(c.isEmpty());      //false
        c.clear();
        System.out.println(c.isEmpty());      //true
    }
    

    输出
    集合中元素的个数4
    集合中元素的个数0
    true
    false
    集合中元素的个数4
    集合中元素的个数3
    false
    true

    2.Collection集合迭代

    在这里插入图片描述

    public static void main(String[] args) {
              //注意:以下的遍历方式/迭代方式,是所有collection通用的一种方式
              //在Map集合中不能用,在所有的collection以及子类中使用
              //创建集合对象
              Collection c=new ArrayList();//后面的集合无所谓,主要是看前面的collection接口,怎么遍历/迭代
              //添加元素
              c.add("abc");
              c.add("def");
              c.add(100);
              c.add(new Object());
              //对集合Collection进行遍历/迭代
              //第一步:获取集合对象的迭代器对象Iterator
              //collection为什么能调用这个方法,因为继承了Iterable接口,可使用其父类的方法
              Iterator it=c.iterator();
              //第二步:通过以上获取的迭代器对象,开始迭代遍历集合
    /*
     以下两个方法是迭代器Iterator中的方法
     boolean hasNext()如果仍有元素可以迭代,则返回true
     Object next() 返回迭代的下一个元素
     
     void remove() 从迭代器指向的collection中移除迭代器返回的最后一个元素(可选操作)
     * */
              while(it.hasNext()){
                  //不管你当初存进去的是什么,取出来统一都是object
                  Object obj=it.next();
                  System.out.println(obj);
              }
      }
    

    输出
    abc
    def
    100
    java.lang.Object@15db9742

    迭代器是一个对象,有两个方法hasnext()和next()。
    迭代器是通用的。

    public static void main(String[] args) {
        //HashSet集合。无序不可重复
        //无序:存进去和取出的顺序不一定相同
        //不可重复:存进去100,不能再存100
        Collection c=new HashSet();
        c.add(100);
        c.add(200);
        c.add(90);
        c.add(300);
        c.add(600);
        c.add(30);
        c.add(100);
        Iterator it=c.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
    

    输出
    100
    200
    600
    90
    300
    30

    3.contains方法解析

    深入collection集合的contains方法
    boolean contains(Object o)
    判断集合中是否包含某个对象o,如果包含,返回true,如果不包含返回false

    contains底层里面调用了equals方法。

    Collection c=new ArrayList();
    String s1=new String("abc");      //内存地址假设s1=0x1111
    c.add(s1);
    String s2=new String("def");      //内存地址假设s2=0x2222
    c.add(s2);
    
    String x=new String("abc");          //内存地址假设s3=0x3333
    //c集合中是否包含x
    //contains里面调用了equals方法
    System.out.println(c.contains(x));
    

    输出:true
    contains方法是用来判断集合中是否包含某个元素的方法
    那么它在底层是它在底层中是怎么判断集合中是否包含某个元素的呢?
    调用了equals方法进行比对
    equals方法返回true,就表示包含这个元素。
    对于一些对象类型,则需要重写其equals方法。

    4.集合中元素的删除

    public static void main(String[] args) {
        //创建集合
        Collection c=new ArrayList();
        //注意:此时获取的迭代器,指向的是那是集合中没有元素状态下的迭代器 
        //一定要注意:集合结构只要发生改变,迭代器必须重新获取
        Iterator it=c.iterator();
        //添加元素
        c.add(1);
        c.add(2);
        c.add(3);
        while(it.hasNext()){
            Object obj=it.next();
            System.out.println(obj);
        }
    }
    

    当集合结构发生了改变,迭代器没有重新获取时,调用next()方法,会发生异常
    在这里插入图片描述
    重点:
    当集合结构发生改变时,迭代器必须重新获取,如果还是用以前的迭代器,会出现异常
    删除元素之后,集合的结构发生变化,应该重新获取迭代器,但是循环下一次的时候,并没有重新获取迭代器,所以会出现异常

    public static void main(String[] args) {
        //创建集合
        Collection c=new ArrayList();
    
        //添加元素
        c.add("abc");
        c.add("def");
        c.add("ghi");
        Iterator it=c.iterator();
        while(it.hasNext()){
            Object obj=it.next();
            //删除元素之后,集合的结构发生变化,应该重新获取迭代器,但是循环下一次的时候,并没有重新获取迭代器,所以会出现异常
            c.remove(obj);
            System.out.println(obj);
        }
    }
    

    在迭代集合元素的过程中,不能调用集合对象的remove方法,否则会出现异常。
    可以使用迭代器的remove方法

    //创建集合
    Collection c=new ArrayList();
    
    //添加元素
    c.add("abc");
    c.add("def");
    c.add("ghi");
    Iterator it=c.iterator();
    while(it.hasNext()){
        Object obj=it.next();
        it.remove();
        //c.remove(obj);
        System.out.println(obj);
    }
    System.out.println(c.size());
    

    输出0;

    5.List接口的特有方法

    测试list接口的常用方法
    1.list集合存储元素特点:有序且重复
    有序:list集合中的元素有下标,从0开始,以1递增。
    可重复:存储一个1,还可以继续存储1
    2.list既然是collection接口的子接口,那么肯定list接口中有自己“特色”的方法
    以下只列举出list接口特有的常用方法
    void add(int index,E element);
    E get(int index);
    E remove(int index);
    E set(int index,E element);
    void add(int index,E element);在列表的指定位置插入指定元素(第一个参数是下标)

    public static void main(String[] args) {
        //创建list类型的集合
        List myList=new ArrayList();
        //添加元素
        myList.add("A");      //默认是向集合末尾添加元素
        myList.add("B");
        myList.add("C");
        myList.add("D");
        //在列表的指定位置插入指定元素(第一个参数是下标)
        //效率有点低。
        myList.add(1,"king");
        //迭代
        Iterator it=myList.iterator();
        while(it.hasNext()){
            Object et1=it.next();
            System.out.println(et1);
        }
    }
    

    E get(int index);根据下标获取元素

    //根据下标获取元素
    Object firstObj = myList.get(0);
    System.out.println(firstObj);
    //因为有下标,所以List集合有自己比较特殊的遍历方式
    //通过下标遍历,list集合特有的方式,set没有
    for(int i=0;i<myList.size();i++){
        Object obj = myList.get(i);
        System.out.println(obj);
    }
    

    E remove(int index);
    删除指定下标位置的元素

    //删除指定下标位置的元素
    //删除下标为0的元素
    System.out.println(myList.size());
    myList.remove(0);
    System.out.println(myList.size());
    
    //修改指定位置的元素
    myList.set(2, "soft");
    

    以上几个方法不需要死记硬背,理解一下,找帮助文档。

    6.Set接口

    HashSet的特点:无序且不可重复

    //演示HashSset的特点
    Set<String> strs=new HashSet<>();
    //添加元素
    strs.add("hello3");
    strs.add("hello4");
    strs.add("hello1");
    strs.add("hello2");
    strs.add("hello3");
    strs.add("hello3");
    //遍历
    for(String s:strs){
        System.out.println(s);
    }
    

    输出
    hello1
    hello4
    hello2
    hello3
    1.存储时顺序和取出的顺序不同
    2.不可重复
    3.放到hashSet集合的元素实际上是放到HashMap集合的key部分了。
    TreeSet集合存储元素的特点
    无序不可重复的,但是存储的元素可以自动按照大小顺序排序,称为可排序集合

    //创建集合对象
    Set<String> strs=new TreeSet<>();
    //添加元素
    strs.add("A");
    strs.add("B");
    strs.add("Z");
    strs.add("Y");
    strs.add("Z");
    strs.add("K");
    strs.add("M");
    //遍历set集合
    //从小到大自动排序
    for(String s:strs){
        System.out.println(s);
    }
    

    输出
    A
    B
    K
    M
    Y
    Z

    无序指的是存进去的顺序和取出来的顺序不同,元素没有下标
    排序是按照从小到大的顺序排序

    展开全文
  • C#集合接口与集合类

    千次阅读 2016-05-11 00:43:40
    C#开发经常用到.NET框架为我们提供的集合接口和集合类,接下来做一个总结,如有差错,希望各位大神指正。 首先是集合接口,自己画了一张图(嘿嘿,有点丑),来说明集合接口的继承关系。 个人觉得,了解集合...

          C#开发经常用到.NET框架为我们提供的集合接口和集合类,接下来做一个总结,如有差错,希望各位大神指正。

          首先是集合接口,自己画了一张图(嘿嘿,有点丑),来说明集合接口的继承关系。

           个人觉得,了解集合接口,首先要把握他们的继承关系。如上图,所有的集合接口和集合类都继承/实现IEnumerable接口。IEnumerable只有一个方法GetEnumerator。签名如下:

    IEnumerator GetEnumerator()

            这个方法返回值类型为IEnumerator,正是IEnumerator 接口定义了集合遍历的基本方法,使得我们可以通过遍历来访问集合中的元素。

    public interface IEnumerator
    {
        bool MoveNext();
        object Current {  get; }
        void Reset();
    }

    MoveNext方法是将游标移动到下一个位置,Current 属性表示当前项,Reset方法是将游标重置到第一个项的位置。

    其他的各个接口都提供了各种方法,这些都可以直接在开发工具上查看,暂时略过。接下来说说集合类。

    集合类是在实现集合接口的基础上,做进一步的扩展。分为非泛型集合类、泛型集合类、线程安全集合类。

    非泛型集合类:

    1:ArrayList,ArrayList是可变长度的数组,它的出现就是为了弥补数组的长度是固定的这个缺陷。但他也带来了另一个问题,ArrayList可以存储任意类型的数据,所以它也存在装箱拆箱所带来的性能问题。所以,后来.NET2.0以后,就用List<T>取代ArrayList 

    2:HashTable 键值对存取,Key不能重复。通过Key来查找Value时,速度非常快,但是存取时也存在装箱拆箱操作。所以后来就被Dictionary<TKey,TValue>所取代。

    3:Stack 先进后出,个人一直觉得 栈是一个非常伟大的发明。

    4:Queue 先进先出。

    泛型集合类:

    1:List<T> 可变长度,并且是有序的。所以如果在其尾部增加或删除数据,那速度比较快。如果在其头部或中间增加或删除数据,那速度比较慢,因为还要重新排序。

    2:LinkedList<T> 它是一个双向链表,这也是为了弥补List<T>的缺陷而出现的。不管在什么位置删除数据,速度都很快。

    3:HashSet<T> 它是无序的,不允许通过下标访问。当对两个集合进行差集、并集运算的时候,它的性能非常好。

    4:SortedSet<T>它是有序的,与HashSet<T>对应。它可以通过Key来索引,也可以通过下标来索引。但是他的性能比HashTable差。

    5:Stack<T> 先进后出

    6:Queue<T> 先进先出

    7:Dictionary<TKey, TValue> 它是对HashTable的优化,不必进行装箱拆箱操作。多线程情况下推荐使用HashTable,因为Dictionary<TKey, TValue>是非线程安全的,在多线程情况下,要进行lock锁定,这时效率就比较差了。

    线程安全集合类   一般情况下,非线程安全的集合类,可以通过加上lock来锁定。.NET提供了线程安全集合类

    1:ConcurrentDictionary  线程安全的Dictionary

    2:ConcurrentQueue    线程安全版本的Queue

    3:ConcurrentStack    线程安全版本的Stack

    以上是个人对C#集合接口和集合类的总结,部分接口和类可能没有接触到。如有遗漏,欢迎交流补充。

    另外送大家一点福利,鞋服买一送一,扫二维码,加微信

     

     

     

         

     

     

    展开全文
  • java集合——集合接口+迭代器接口

    千次阅读 2015-12-14 21:20:31
    【0】README0.1) 本文描述转自 core java volume 1, 源代码 diy 的, 旨在理解 java集合框架——集合接口+迭代器接口 的相关知识;【1】将集合的接口与实现分离1.1)java集合类库将 接口与实现分离。 我们看一下,...
  • 集合 接口接口的区别

    千次阅读 2017-09-17 19:06:44
    1.Collection和Collections的区别? 2.Set里的元素是不能重复的,那么用...3.List Set,Map是否继承自Collection接口 4.两个对象值相同(x.equals(y)==true),但却有不同的hash code,这句话对不对 5.说出Array
  • Java集合框架&接口方法&集合遍历

    千次阅读 2021-05-24 20:11:14
    一、集合框架的概述 1.集合、数组都是对多个数据进行存储操作的结构,简称Java容器。 说明:此时的存储,主要指的是内存层面的存储,不涉及到持久化的存储(.txt,.jpg,.avi,数据库中) 2.1 数组在存储多个数据方面...
  • 通过Matcher中的find()方法对list集合进行模糊查询操作 1.创建实体对象: public class User { private Integer id; private String name; private String password; public User() { } public User(Integer...
  • Java中的Collection集合接口常用方法

    千次阅读 2018-04-19 20:26:31
    Collection 总接口 --| List 特征 有序 可重复----| ArrayList 底层维护的是一个Object类型的数组,如果使用无参构造方法创建ArrayList集合,默认的容量为10​ 用带有参数的构造方法,创建ArrayList集合,传入的...
  • Java集合接口继承实现图)

    千次阅读 2020-08-08 17:03:17
    Collection接口: Map接口
  • Java集合类的基本接口

    千次阅读 2018-07-04 14:42:19
    java 集合类的基本接口:collection 和 map什么是接口:在软件中接口是一种规范和标准,他们可以约束类的行为,是一些方法特征的集合,但是没有方法的实现,接口其实上也可以看做是一个特殊的抽象类,但是采用和抽象...
  • 集合接口和类型 前面介绍了数组和Array类实现的接口.数组的大小是固定的.如果元素个数是动态的,就应私用集合类. List是与数组相当的集合类.还有其他类型的集合:队列,栈,链表和字典.   大多数集合类都可在System...
  • java集合类框架的基本接口有哪些

    万次阅读 2017-10-13 08:57:47
    java集合类框架的基本接口有哪些? 答:Collection:代表一组对象,每一个对象都是它的子元素 Set:不包括重复元素的Collection List:有顺序的Collection,并且可以包含重复元素 Map:可以把键(key)映射到...
  • 集合3.Collection 接口4. Map接口 1.java存储对象的思路 存储对象可以考虑:①数组②集合 数组存储对象的特点:Student[] stu = new Student[20];stu[1] = new Stuednt(); 弊端:①一旦创建,其长度不可变。②...
  • Java集合体系

    千次阅读 2021-12-11 20:47:50
    任何集合框架都包含三大块内容:对外的接口接口的实现和对集合运算的算法。 Java的集合体系由最上层的接口、中间的一些抽象类、以及最后各种具体的实现类组成。 Java集合的基本接口是Collection接口和Map接口。 ...
  • List集合接口)及其常见实现类

    千次阅读 2019-05-20 15:44:02
    java.util.List接口 extends Collection接口 (一): List接口的特点: 1、有序的Collection,存储和取出元素的顺序是...—public void add(int index,E element):将指定的元素,添加到该集合中的指定位置上。 —pu...
  • 简述集合中List接口及其特点

    千次阅读 2019-07-22 21:45:47
    存储对象可以考虑:1.数组 2.集合 数组存储对象的缺点: 1.一旦创建,其长度不可变 ...List接口: List特有的方法: 1.public void add(int index,E element):将指定到的元素,添加到该集合中的指定位置上 2....
  • Trade.dll 交易接口。这段时间抽空把自己原先在论坛上收集的老版Trade.dll和新版TradeX.dll(行情和交易二合一)整合了一下,做成个大集合,希望那些还在到处奔波寻找的兄弟有些价值,不用整天那么麻烦了
  • Java集合类框架的基本接口有哪些?

    千次阅读 2019-01-08 04:31:22
    Collection类:元素集合,List和Set继承了Collection接口,List是有序元素集合,set是无序元素集合,ArrayList和LinkedList实现了list接口,HashSet实现的是set接口,Set中的元素是不能重复的,List中的元素是可以...
  • 使用PostMan工具进行接口测试时传递集合参数的方法 之前写过 “ 使用PostMan工具进行接口测试时传递Map类型参数的方法 ” ,但未提及List等参数的传递方法,可能有部分入行新人不太会用,索性补上,供大家查阅。 ...
  • 「译」Java集合框架系列教程二:集合接口

    千次阅读 多人点赞 2013-01-19 13:12:32
    译文:Java集合框架系列教程二:集合接口 核心集合接口封装了不同类型的集合,如下图所示。这些接口使得我们可以操作集合而不必关心它们的具体实现细节。核心集合接口是Java集合框架的基础。正如我们可以从下图...
  • 单列集合的根接口Collection接口

    千次阅读 2019-08-22 19:34:50
    Collection集合 1. 集合概述 一般集合如ArrayList,相对于数组而言 数组的长度是固定的,集合的长度是可变的 数组中存储的是同一类型的元素,可以存储基本数据类型数值。集合存储的都是对象。而且对象的类型可以不...
  • Java基础-各种集合类的特性简介

    千次阅读 2020-12-31 19:46:39
    各种集合类的特性简介集合类概述集合中存储什么不同集合对应不同数据结构集合继承结构及特性简介Map集合继承结构及特性简介总结: 集合类概述 什么是集合?有什么用? 数组其实就是一个集合集合实际上一个容器,...
  • 网银接口+微信接口+支付宝接口集合

    热门讨论 2014-12-05 13:45:22
    网银在线接口 + 微信助手接口与ERP集成 + 支付宝接口
  • 集合 集合的特点 集合只能存储对象(引用类型),集合长度可变。集合可以存储不同类型的对象。 java提供了多种集合类。...集合的集成体系 ...Collection——集合的顶层接口 Collection的功能...
  • 文章目录Java集合类 1.体系结构与父类接口介绍1.集合类体系结构2. Collection接口3....集合类体系结构包含如图所示的集合接口及其实现类。 2. Collection接口 从上图中可看出,Collection接口是单列...
  • 集合框架,java中常用的集合类和接口,帮助大家快速掌握java的常用接口和类
  • Collection接口如何遍历集合中的元素 Hello!没技术的大灰狼又来了,今天和小伙伴分享一个Java项目开发中比较常用的存储数据的方法----集合。 想到集合,可能很多小伙伴都会想到数组,那么集合和数组又有什么样的...
  • Java集合框架

    2020-12-22 09:10:04
    Collection接口式Java集合的根接口,是所有集合的父接口。该接口里面提供了很多操作集合的抽象方法。 JDK源码的一个介绍: The root interface in the collection hierarchy. A collection represents a group of...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 905,251
精华内容 362,100
关键字:

集合接口

友情链接: 流水灯.zip