java容器 订阅
容器可以管理对象的生命周期、对象与对象之间的依赖关系,您可以使用一个配置文件(通常是XML),在上面定义好对象的名称、如何产生(Prototype 方式或Singleton 方式)、哪个对象产生之后必须设定成为某个对象的属性等,在启动容器之后,所有的对象都可以直接取用,不用编写任何一行程序代码来产生对象,或是建立对象与对象之间的依赖关系。 展开全文
容器可以管理对象的生命周期、对象与对象之间的依赖关系,您可以使用一个配置文件(通常是XML),在上面定义好对象的名称、如何产生(Prototype 方式或Singleton 方式)、哪个对象产生之后必须设定成为某个对象的属性等,在启动容器之后,所有的对象都可以直接取用,不用编写任何一行程序代码来产生对象,或是建立对象与对象之间的依赖关系。
信息
性    质
Java 所编写的程序
包    含
List、ArrayList、Vector及map
用    途
管理对象的生命周期的依赖关系
中文名
JAVA容器
JAVA容器执行JAVA的应用程序
容器(Container)容器是一个Java 所编写的程序,原先必须自行编写程序以管理对象关系,容器都会自动帮您做好。常用容器WebSphere,WebLogic,Resin,Tomcat,Glassfish----------------------------------
收起全文
精华内容
下载资源
问答
  • Java容器总结

    2019-03-16 01:43:44
    NULL 博文链接:https://newtime.iteye.com/blog/431572
  • java容器超详细

    2020-12-21 03:06:51
    java容器是前人为我们提供的一套用于存储数据和对象的工具。如果你学过C++的STL,可以与之类比。java容器又可以称为Java Collection Framework(JCF)。里面除了存储对象的容器之外,还提供了一套用于处理和操作容器...
  • java容器介绍 本文目录java容器介绍泛型的简单介绍Comparable和ComparatorCollectionListArrayListLinkedListVectorSetHashSetLinkedHashSet+...
  • Java容器常见面试题

    千次阅读 多人点赞 2019-04-16 16:21:03
    1. Java 容器都有哪些? Java 容器分为 Collection 和 Map 两大类,其下又有很多子类,如下所示是Collection和Map的继承体系: 具体如下结构: Collection List ArrayList LinkedList Vector Stack Set ...

    1. Java 容器都有哪些?

    • Java 容器分为 Collection 和 Map 两大类,其下又有很多子类,如下所示是Collection和Map的继承体系:
      在这里插入图片描述
      在这里插入图片描述
    1. 具体如下结构:
    • Collection
      • List
        • ArrayList
        • LinkedList
        • Vector
        • Stack
      • Set
        • HashSet
        • LinkedHashSet
        • TreeSet
    • Map
      • HashMap
        • LinkedHashMap
      • TreeMap
      • ConcurrentHashMap
      • Hashtable

    2. ArrayList和LinkList的区别?

    1. ArrayList(数组结构)
      1. 优点:get和set调用花费常数时间,也就是查询的速度快
      2. 缺点:新项的插入和现有项的删除代价昂贵,也就是添加删除的速度慢
    2. LinkedList(链表结构)
      1. 优点:新项的插入和和现有项的删除开销很小,即添加和删除的速度快
      2. 缺点:对get和set的调用花费昂贵,不适合做查询
    3. 面试中经常问到一些深入的东西,比如:
      1. 是否保证线程安全: ArrayList 和 LinkedList 都是不同步的,也就是不保证线程安全;
      2. 底层数据结构: Arraylist 底层使用的是Object数组;LinkedList 底层使用的是双向循环链表数据结构;
      3. 插入和删除是否受元素位置的影响: ① ArrayList 采用数组存储,所以插入和删除元素的时间复杂度受元素位置的影响。 比如:执行add(E e)方法的时候, ArrayList 会默认在将指定的元素追加到此列表的末尾,这种情况时间复杂度就是O(1)。但是如果要在指定位置 i 插入和删除元素的话(add(int index, E element))时间复杂度就为 O(n-i)。因为在进行上述操作的时候集合中第 i 和第 i 个元素之后的(n-i)个元素都要执行向后位/向前移一位的操作。 ② LinkedList 采用链表存储,所以插入,删除元素时间复杂度不受元素位置的影响,都是近似 O(1)而数组为近似 O(n)。
      4. 是否支持快速随机访问: LinkedList 不支持高效的随机元素访问,而ArrayList 实现了RandmoAccess 接口,所以有随机访问功能。快速随机访问就是通过元素的序号快速获取元素对象(对应于get(int index)方法)。
      5. 内存空间占用: ArrayList的空间浪费主要体现在在list列表的结尾会预留一定的容量空间,而LinkedList的空间花费则体现在它的每一个元素都需要消耗比ArrayList更多的空间(因为要存放直接后继和直接前驱以及数据)。

    3. List、Set、Map 之间的区别是什么?

    1. List、Set、Map 的区别主要体现在两个方面:元素是否有序、是否允许元素重复。
    2. 三者之间的区别,如下表:
      在这里插入图片描述

    4. HashMap 和 Hashtable 有什么区别?

    1. 存储:HashMap 运行 key 和 value 为 null,而 Hashtable 不允许。
    2. 线程安全:Hashtable 是线程安全的,而 HashMap 是非线程安全的。
    3. 推荐使用:在 Hashtable 的类注释可以看到,Hashtable 是保留类不建议使用,推荐在单线程环境下使用 HashMap 替代,如果需要多线程使用则用 ConcurrentHashMap 替代。

    5. Comparable和Comparator区别?

    1. Comparable接口
      1. 实现Comparable接口类表示这个类型的对象可以进行比较大小的。 这种可以比较大小的对象可以进行自然排序。
    2. Comparator接口
      1. 比较器用于实现对象任意属性进行比较大小。
      2. 在排序时候可以通过指定属性比较器实现任意属性排序。
    3. 在排序时候Comparable接口用于进行自然排序,而Comparator接口进行自定义排序,自定义排序更加灵活方便而常用。
    4. 设计上Comparable不推荐使用,因为对程序本身具有侵入性。

    6. 简述HashMap的工作原理?

    1. HashMap是面向查询优化的数据结构,查询性能优异。
    2. 在其内部利用数组存储数据。
    3. 插入数据时,先根据Key的HashCode计算出数组的下标位置,再利用Key的equals()方法检查是否以存在重复的Key,如果不重复直接存储到数组中,如果重复就作为链表存储到散列桶中。
    4. 插入的数据和数组容量的比值大于加载因子则进行数组扩容,并重新散列,默认的加载因子为“0.75”。
    5. 查询时,先根据Key的HashCode计算出数组的下标位置,再利用Key的equals()方法检查到Key的位置,如果找到返回Key对应的Value,否则返回Null。
    6. 由于利用Key的HashCode直接计算出数据的存储位置,由于直接确定数据的存储位置,相对于其他查找方式,查询效率非常高。

    7. Iterator 怎么使用?有什么特点?

    1. Iterator 接口提供遍历任何 Collection 的接口。我们可以从一个 Collection 中使用迭代器方法来获取迭代器实例。迭代器取代了 Java 集合框架中的 Enumeration,迭代器允许调用者在迭代过程中移除元素。
    2. Iterator 使用代码如下:
      	List<String> list = new ArrayList<>();
      	Iterator<String> it = list. iterator();
      	while(it. hasNext()){
      		String obj = it. next();
      		 System. out. println(obj);
      	}
      
    3. Iterator 的特点是更加安全,因为它可以确保,在当前遍历的集合元素被更改的时候,就会抛出 ConcurrentModificationException 异常。

    8. ArrayList 和 Vector 的区别是什么?

    1. 线程安全:Vector 使用了 Synchronized 来实现线程同步,是线程安全的,而 ArrayList 是非线程安全的。
    2. 性能:ArrayList 在性能方面要优于 Vector。
    3. 扩容:ArrayList 和 Vector 都会根据实际的需要动态的调整容量,只不过在 Vector 扩容每次会增加 1 倍,而 ArrayList 只会增加 50%。

    9. Collection 和 Collections 有什么区别?

    1. Collection 是一个集合接口,它提供了对集合对象进行基本操作的通用接口方法,所有集合都是它的子类,比如 List、Set 等。
    2. Collections 是一个包装类,包含了很多静态方法,不能被实例化,就像一个工具类,比如提供的排序方法: Collections. sort(list)。

    10. HashMap 的实现原理?

    1. HashMap 基于 Hash 算法实现的,我们通过 put(key,value)存储,get(key)来获取。
    2. 当传入 key 时,HashMap 会根据 key. hashCode() 计算出 hash 值,根据 hash 值将 value 保存在 bucket 里。
    3. 当计算出的 hash 值相同时,我们称之为 hash 冲突,HashMap 的做法是用链表和红黑树存储相同 hash 值的 value。
    4. 当 hash 冲突的个数比较少时,使用链表否则使用红黑树。
    5. HashMap 对应的线程安全类是 ConcurrentHashMap
    展开全文
  • Java容器框架(一)--概述篇

    千次阅读 2018-09-18 21:58:46
    于是趁此闲暇之际,对Java容器进行一个整体的描述,一方面是为了对Java容器能有一个整体的思维,另一方面也是为了在平常工作中能够通过不同的场景对容器类的使用做到游刃有余。 我们知道Java容器类基本上都是在java...

    1. 概述

    在Java开发中,我们经常使用到一些容器类例如ArrayList、HashMap等,很少去了解其他一些容器类或者说对Java容器有一个整体的了解。于是趁此闲暇之际,对Java容器进行一个整体的描述,一方面是为了对Java容器能有一个整体的思维,另一方面也是为了在平常工作中能够通过不同的场景对容器类的使用做到游刃有余。

    我们知道Java容器类基本上都是在java.util包下,有一个Collection接口,它是Java容器的顶级接口(除了Map),在编辑器中打开Collection接口,然后快捷键(IDEA默认是Ctrl+h)查看该接口的实现类,可以看到在util包下有List、Set和Queue三大接口,Java容器中大部分类都实现了这三大接口中的一个或多个,容器中除了这三大接口,当然还有另一个重要的接口了即Map。因此Java容器的最顶层结构如下图:

    下面我会对这四大接口及下面的子类做一个详细的介绍,在介绍之前,允许我借用网上一张图片,能够对容器类有一个大致的轮廓(图中暂时缺少map系列,在介绍map的时候会给对应的类图)。

    2. List集合

    List集合,通过名字大概能够猜测到它是一个线性结构的列表,学过数据结构都知道线性表有两种存储方式即顺序存储(数组)和链式存储(链表),其实List集合正式这种线性结构集合的实现,List集合它是一个存放可重复、无序(不会对存放的数据进行排序)的线性结构数据集合。

    通过同样的方法在编辑器中打开List接口,查看其实现类,可以看到大致有如下实现类:AbstractList、ArrayList、Vector、LinkedList、CopyOnWriteArrayList(多线程中)。List容器类结构图大致如下:

    那么问题来了,List容器这些子类都有些什么作用呢?

    此处只是简单介绍List子类的一些作用或实现原理,并不从源码角度进行分析,在之后的文章中会对部分子类进行源码分析。

    • AbstractList

    看类名就能过猜测到该类为一个抽象类,它继承自AbstractCollection类实现了List接口,是 ArrayList 和 AbstractSequentiaList 的父类。内部实现了List的部分方法,同时也提供了Iterator, ListIterator 迭代器的实现类,分别为 Itr, ListItr。ListItr继承自Itr,从某种角度可以视为Itr的扩展。详情可以参见Java 集合深入理解(6):AbstractList

    • ArrayList

    该类相信大家再熟悉不过,继承自AbstractList抽象类,实现List、RandomAccess等接口,内部是由数组实现,容量大小不固定,元素的顺序和存放的顺序一致,遍历元素可以通过随机读写(RandomAccess)和迭代器(Iterator)两种方式,由于数组的特性,当然RandomAccess方式要由于Iterator。

    • LinkedList

    在List家族,除了对ArrayList非常熟悉之外,估计就到LinkedList了。LinkedList基于双向链表实现,非常适用于数据插入和删除,对数据遍历较慢,和ArrayList恰好相反。

    • Vector

    Vector 和 ArrayList 一样,也是基于数组来实现,区别是Vector是线程安全的,通过源码可以看到Vector很多方法都是使用synchronized来修饰。

    • Stack

    通过类名可以知道该类实现了栈的功能,Stack继承自Vector,因此也是由数组来实现,并且线程安全。

    • CopyOnWriteArrayList

    该类是并发容器(java.util.concurrent)中的类,它的原理是当我们向容器中添加元素的时候,不直接往当前容器添加,而是先将当前容器进行Copy,复制出一个新的容器,然后新的容器里添加元素,添加完元素之后,再将原容器的引用指向新的容器。这样的意义主要在于当并发读取容器内容时不需要加锁,但是写内容的时候需要保证同步并且需要开辟新的内存空间,因此比较适合读多写少的并发场景。

    3. Set集合

    什么是Set集合,它有什么特性?

    先来看看代码中的英文说明:

    A collection that contains no duplicate elements. More formally, sets contain no pair of elements <code>e1</code> and e2 such that  e1.equals(e2), and at most one null element.

    大概意思就是:该集合中存放一些不能重复的元素。正式一点来说,就是不能存在这样一对元素(例如:e1.equals(e2)返回为true),并且容器中最对可以有一个为null的元素。

    Set集合下的类大致有:SortedSet(接口)、AbstractSet(抽象类)、HashSet、LinkedHashSet、NavigableSet(接口)、TreeSet等等,如下图所示:

    我们一起来了解了解这些接口或类所具有的作用。

    • AbstractSet

    AbstractSet之余Set很类似于AbstractList之余List,主要起着一个骨架的作用,它继承AbstractCollection,实现Set接口,它其实仅仅只实现了equals、hasCode、removeAll三个方法。

    • HashSet

    我们首先看看类结构:

    public class HashSet<E>  extends  AbstractSet<E>  implements  Set<E>, Cloneable, java.io.Serializable

    继承自AbstractSet,实现了Set接口,它内部代码并不多,使用HashMap来存储数据。当对HashSet添加一个元素E时,其实就是向HashMap中添加一个键值对,键就是E,值为一个通用的Object对象,这也就很能理解HashSet不能存放相同元素的原因了吧,同时也可以 知道访问的顺序和插入的顺序有可能是不一样的。

    • LinkedHashSet

    类结构如下:

    public class LinkedHashSet<E> extends HashSet<E> implements Set<E>, Cloneable, java.io.Serializable

    LinkedHashSet继承自HashSet,调用的构造器其实就是HashSet的构造器,只不过它是用LinkedHashMap来存储数据,因此它的特性和LinkedHashMap很相似,可以保证遍历顺序序和插入顺序序一致。

    • SortedSet&NavigableSet

    Set容器本身没有排序能力,当类实现了SortedSet或NavigableSet接口,则提供了排序方案。

    • TreeSet

    TreeSet类结构如下:

    public class TreeSet<E> extends AbstractSet<E> implements NavigableSet<E>, Cloneable, java.io.Serializable

    实现了NavigableSet,由于NavigableSet继承自SortedSet,因此TreeSet具有排序的功能。TreeSet内部使用NavigableMap来存放数据,默认情况下,是使用TreeMap来保存数据,因此它的特性和TreeMap的特性是很类似的。

    通过对Set集合的了解,我们发现Set的子类与Map的子类有这千丝万缕的关系,要知道Set子类的实现原理必当先了解Map子类的实现原理,下面我们来大概了解下Map家族。

    4. Map集合

    先一言不合来张Map类图:

    看看函数的命名,有没有发现与Set里面很相似(当然我更加相信是Set是参考Map),下面对Map家族稍作了解。

    • Map:键值对映射的接口,该映射不包括重复的键,一个键对应一个值。
    • SortedMap:有序的键值对接口,继承Map接口。
    • NavigableMap:继承SortedMap,具有针对给定搜索目标返回最接近匹配项的导航方法的接口。
    • AbstractMap:实现了Map中的绝大部分函数接口,它减少了Map的实现类的重复编码。
    • TreeMap: 有序散列表,实现SortedMap 接口,底层通过红黑树实现。
    • Dictionary:任何可将键映射到相应值的类的抽象父类。
    • HashTable: 基于“拉链法”实现的散列表,多线程安全,大部分方法都是使用synchronized修饰的。
    • HashMap: 是基于“拉链法”实现的散列表,底层采用“数组+链表”实现。
    • LinkedHashMap: HashMap无法保证数据的存与取顺序一致,LinkedHashMap正式弥补了这样的缺点,内部通过维护一条双向循环链表来保证数据的插入和访问顺序。
    • WeakHashMap:基于“拉链法”实现的散列表,和HashMap不同的是它保存的键都是弱键,也就是说映射的存在并不阻止对键进行垃圾回收,键没有值自然也丢弃。
    • ConcurrentHashMap:该类是在java.util.concurrent包中,主要是考虑多线程安全的情况,我们都知道HashMap多线程是不安全的,而HashTable虽然多线程安全但是效率太低,于是就出现了ConcurrentHashMap。它是采用锁分段技术保证线程安全。

    到这里,Map家族基本上介绍完了,回头一看,发现还有一个家族没有分析,那就是Queue家族,常规操作,仍然来看看Queue家族的成员。

    5. Queue集合

    Queue即队列,所谓队列就是一个先入先出(FIFO)的数据结构,它也是一个线性表,只不过在队列的尾部插入数据,头部删除数据,Queue家族体系如下图所示:

    • Deque

    Deque是Queue的子接口,Queue是队列,Deque它是一个双向队列,也就是说它支持从两端删除或插入元素。它下面的实现类主要有ArrayDeque和LinkedList以及concurrent包下的ConcurrentLinkedDeque,ArrayDeque看类名想必大家就能知道一个基于数组实现,LinkedList前面有介绍基于链表实现。ConcurrentLinkedDeque是Java7中引入的,实现了非阻塞式并发列表,它内部的链表节点都声明为volatile类型来保证数据一致性。

    • BlockingQueue

    它类结构如下:public interface BlockingQueue<E> extends Queue<E>,类图中没有将其包含,可以视为阻塞队列,用户可以为该队列设置一个初始容量(即该队列中最多能够放入多少个数据)。当BlockingQueue为空时,获取元素线程被阻塞直到BlockingQueue变为非空;当BlockingQueue满时,添加元素线程被阻塞直到Queue不满。它下面的主要实现类有ArrayBlockingQueue、LinkedBlockingQueue等。

    总结

    至此,Java容器内容大致介绍完成,Java容器大致可以分为四大家族,有些家族之间紧密相连。List家族即线性表,它的子类有通过数组来实现的顺序表及通过链式结构来实现的链表两种类型;Queue家族即队列,也属于一种操作受限的线性表,支持先进先出原则,当然也有子类实现了两端都支持删除和插入元素的功能;Map家族即键值对,支持key-value的形式存放数据;Set家族它子类中大部分都是通过Map家族中的类来完成,Set中存放的值作为Map中的key,实例化一个全局的Object对象作为所有key的值,无非就是能够通过Map来存放单个数据的能力。以上仅为个人见解,如有理解错误的地方,欢迎指正。

    参考文献

    https://blog.csdn.net/u011240877/article/details/52834074

    https://blog.csdn.net/qq_33642117/article/details/52040345

    https://blog.csdn.net/jeffleo/article/details/55000077

    https://www.cnblogs.com/zaizhoumo/p/7786793.html

    展开全文
  • Java容器

    万次阅读 多人点赞 2014-04-11 20:28:40
    在学Java以前,一说到存放东西,第一个想到的就是使用数组,使用数组,在数据的存取方面的却也挺方便,其存储效率高访问快,但是它也受到了一些限制,比如说数组的长度以及...答案是肯定的,这就是Java容器java容器

           在学Java以前,一说到存放东西,第一个想到的就是使用数组,使用数组,在数据的存取方面的却也挺方便,其存储效率高访问快,但是它也受到了一些限制,比如说数组的长度以及数组的类型,当我需要一组string类型数据的同时还需要Integer类型的话,就需要定义两次,同时,数组长度也受到限制,即使是动态定义数组长度,但是长度依然需要固定在某一个范围内,不方便也不灵活。

           如果说我想要消除上面的这个限制和不方便应该怎么办呢?Java是否提供了相应的解决方法。答案是肯定的,这就是Java容器,java容器是javaAPI所提供的一系列类的实例,用于在程序中存放对象,主要位于Java.util包中,其长度不受限制,类型不受限制,你在存放String类的时候依然能够存放Integer类,两者不会冲突。

            容器API类图结果如下所示:

             

    Collection接口

            Collection是最基本的集合接口,一个Collection代表一组Object,即Collection的元素。一些Collection允许相同的元素而另一些不行。一些能排序而另一些不行。Java SDK不提供直接继承自Collection的类,Java SDK提供的类都是继承自Collection的“子接口”如List和Set。

    举例:

    import java.util.*;
    public class TestA{
    	public static void main(String[] args)
    	{
    		Collection<String> lstcoll=new ArrayList<String>();
      	lstcoll.add("China");
      	lstcoll.add(new String("ZD"));
      	
     		System.out.println("size="+lstcoll.size());
        System.out.println(lstcoll);
    	}
    }
    结果:

           

    List接口

           List是有序的Collection,使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引(元素在List中的位置,类似于数组下标)来访问List中的元素,也就是说它是有顺序的,类似于Java的数组。和Set不同,List允许有相同的元素。J2SDK所提供的List容器类有ArrayList、LinkedList等。
    实例:
    import java.util.*;
    public class TestB{
    	public static void main(String[] args)
    	{
    		List<String> l1=new LinkedList<String>();
    		for(int i=0;i<=5;i++){
    			l1.add("a"+i);
    		}
    		System.out.println(l1);
    		l1.add(3,"a100");
    		System.out.println(l1);
    		l1.set(6,"a200");
    		System.out.println(l1);
    		System.out.println((String)l1.get(2)+" ");
    		l1.remove(1);
    		System.out.println(l1);
    	}
    }
    运行结果:
             

    ArrayList

            ArrayList其实就相当于顺式存储,它包装了一个数组 Object[],当实例化一个ArrayList时,一个数组也被实例化,当向ArrayList中添加对象时,数组的大小也相应的改变。这样就带来以下有特点:
           快速随即访问,你可以随即访问每个元素而不用考虑性能问题,通过调用get(i)方法来访问下标为i的数组元素。
           向其中添加对象速度慢,当你创建数组时并不能确定其容量,所以当改变这个数组时就必须在内存中做很多事情。
           操作其中对象的速度慢,当你要向数组中任意两个元素中间添加对象时,数组需要移动所有后面的对象。

    LinkedList

            LinkedList相当于链式存储,它是通过节点直接彼此连接来实现的。每一个节点都包含前一个节点的引用,后一个节点的引用和节点存储的值。当一个新节点插入时,只需要修改其中保持先后关系的节点的引用即可,当删除记录时也一样。这样就带来以下有特点:
           操作其中对象的速度快,只需要改变连接,新的节点可以在内存中的任何地方。
           不能随即访问,虽然存在get()方法,但是这个方法是通过遍历接点来定位的,所以速度慢。

    Set接口

          Set是一种不包含重复的元素的Collection,即任意的两个元素e1和e2都有e1.equals(e2)=false,Set最多有一个null元素。
          Set的构造函数有一个约束条件,传入的Collection参数不能包含重复的元素。
          Set容器类主要有HashSet和TreeSet等。

    HashSet

           此类实现 Set 接口,由哈希表(实际上是一个 HashMap 实例)支持。它不保证 set 的迭代顺序;特别是它不保证该顺序恒久不变。此类允许使用 null 元素。
    举例:
    import java.util.*;
    public class TestC{
    	public static void main(String[] args)
    	{
    		Set <String> s=new HashSet<String>();
    		s.add("Hello");
        
        //相同元素
    		s.add("Hello");
    
    		System.out.println(s);
    	}
    }
    结果:
            

    Map接口

            值得注意的是Map没有继承Collection接口,Map接口是提供key到value的映射。一个Map中不能包含相同的key,每个key只能映射一个value。即是一一映射,Map接口提供3种集合的视图,Map的内容可以被当作一组key集合,一组value集合,或者一组key-value映射。
            Map接口的实现类主要是包括HashMap和TreeMap等。

    HaspMap

             添加数据使用put(key, value),取出数据使用get(key), HashMap是允许null,即null value和null key。但是将HashMap视为Collection时(values()方法可返回Collection),其迭代子操作时间开销和HashMap的容量成比例。因此,如果迭代操作的性能相当重要的话,不要将HashMap的初始化容量设得过高,或者load factor过低。
    举例:
    import java.util.*;
    public class TestD{
    	public static void main(String[] args)
    	{
    		Map <String,String> M=new HashMap <String,String>();
    		M.put("one",new String("1"));
    		M.put("two",new String("2"));
    		System.out.println(M);
    	}
    }
    结果:
          

    总结

           Java容器实际上只有三种:Map , List, Set;但每种接口都有不同的实现版本.它们的区别可以归纳为由什么在背后支持它们.也就是说,你使用的接口是由什么样的数据结构实现的.
    List的选择:
             比如:ArrayList和LinkedList都实现了List接口.因此无论选择哪一个,基本操作都一样.但ArrayList是由数组提供底层支持.而LinkedList是由双向链表实现的.所以,如果要经常向List里插入或删除数据,LinkedList会比较好.否则应该用速度更快的ArrayList。
    Set的选择
             HashSet总是比TreeSet 性能要好.而后者存在的理由就是它可以维持元素的排序状态.所以,如果需要一个排好序的Set时,才应该用TreeSet。
    Map选择:
            同上,尽量选择HashMap。

         

    关于J2SE的总结结束了。以下是我在学习J2SE时的一系列总结。
             Java内存简单分析
             Java异常处理
              Java常用类
              Java容器
              Java流
              Java之GUI编程(一)


    展开全文
  • Java容器介绍

    千次阅读 2019-07-02 09:59:14
    一、《Java编程思想》第四版容器介绍 1、不包含抽象类和遗留构件 出自书的第十一章“持有对象”,英文版的“HoldingYourObjects”,章末总结部分。 总计只有四种容器:List、Set、Map、Queue。他们各有两到三个...

    一、《Java编程思想》第四版容器介绍

    1、不包含抽象类和遗留构件

    出自书的第十一章“持有对象”,英文版的“Holding YourObjects”,章末总结部分。

    总计只有四种容器:List、Set、Map、Queue。他们各有两到三个实现版本。常用的容器用黑色的粗线框表示。

    点线框表示接口,实线框表示普通的(具体的)类。

    带有空心箭头的点线表示一个特定的类实现了一个接口。

    实心箭头表示某个类可以生成箭头所指向类的对象。例如,任意的Collection可以生成Iterator,而List可以生成ListIterator(也能生成普通的Iterator,因为List继承自Collection)。

    2、包含抽象类和遗留构件 

    出自第17章,“容器深入研究”,英文版“Container in Depth”。

    二、Collection单对象接口说明

    1、Collection中包含的方法

    Collection不包含随机访问元素的get()方法。因为,Collection包含Set,而Set是自己维护内部顺序的(随机则没有意义)。因此,如果想要检查Collection中的元素,就必须使用迭代器实现。 

    2、包含的子接口、类 

    (1)List说明:

    常用List:

    • ArrayList,采用顺序式的结果进行数据的保存。长于随机访问元素,但在List中间插入和删除元素是较慢。这跟它的存储机制有关,添加或者删除某个元素时,要移动该元素所在位置之后的所有元素。
    • LinkedList,保存的是前后元素,即,它的每一个节点中保存的是两个元素对象,分别对应于它的上一个及下一个节点,所以LinkedList占用的内存空间比ArrayList大。同时LinkedList比ArrayList多实现了一个Queue队列数据接口。通过代价较低的在List中进行的插入和删除操作,提供了优化的顺序访问。但在随机访问方面相对比较慢。

    旧的子类:

    • Vector,该类中的部分方法使用了synchronized关键字声明(同步操作)。

    (2)Set说明: 

    • Set(interface),存入Set的每个元素都必须是唯一的。加入Set的元素必须定义equals()方法以确保对象的一致性。Set与Collection有同样的接口。 
    •  HashSet,为快速查找而设计的Set,散列存放,没有顺序。存入HashSet的元素必须定义hashCode()
    • TreeSet,保持次序的Set,底层为树结构。元素必须实现Comparable接口(进行排序操作)。
    • LinkedHashSet,具有HashSet的查找速度,内部使用链表维护元素的次序(按照插入的次序)。元素必须定义hashCode()。

    三、Map接口说明

    ——注:子类中可添加HashTable。 

    (1) 对Map中使用的键的要求与对Set中的元素的要求一样。

    • 任何键都必须具有一个equals()方法;
    • 如果键被用于散列Map,那么它必须还具有恰当的hashCode方法;
    • 如果键被用于TreeMap,那么它必须实现Comparable。

    (2)关于HashTable的补充说明:

    • 该类出现于JDK1.0,在JDK1.2时多实现了一个Map接口,从而得以保存下来继续使用;
    • 使用HashTable子类实例化的Map集合中,保存的key或value都不允许出现null,否则会出现“NullPointerException”异常。
    HashMap与HashTable的区别
    No.区别点HashMapHashTable

    1

    推出时间JDK1.2,属于新类JDK1.0,属于旧类
    2性能采用异步处理采用同步处理
    3数据安全非线程安全线程安全
    4设置null允许key或value为null

    不允许设置null

    (3)《Thinging in Java》中的英文对照图表:

    四、Queue

    包括两个实现:LinkedListPriorityQueue。

    五、参考

    1、Java集合框架的讲解

    2、Java集合与框架总结与学习

    3、HashTable和HashMap的区别详解

     

     

    展开全文
  • Java容器有哪些?哪些是同步容器,哪些是并发容器?一、基本概念新的改变功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格...
  • 18.java 容器都有哪些?

    千次阅读 2020-07-27 18:34:52
    JAVA容器类概述 1.常用容器分类 JAVA中的容器类主要分为两大类,一类是Map类,一类是Collections类,他们有一个共同的父接口Iterator,它提供基本的遍历,删除元素操作。Iterator还有一个子接口LinkIterator,它...
  • java 容器都有哪些?

    万次阅读 多人点赞 2019-07-27 18:36:57
    容器可以说是Java Core中比较重要的一部分了。 数组,String,java.util下的集合容器 ============================================================================== 数组长度限制为 Integer.Integer.MAX_...
  • Java容器类详解

    万次阅读 2018-04-18 21:26:36
    Java的容器 在Java中,我们想要保存对象可以使用很多种手段。最简单的就是数组。...Java容器类库是用来保存对象的,他有两种不同的概念: Collection,独立元素的序列,这些元素都服从一条或多条规则。Lis...
  • java容器都有哪些?

    万次阅读 2019-09-03 20:50:29
    java容器类类库的用途是"保存对象"。摘自: “Thinking in Java”. Java集合类是一种特别有用的工具类,可以用于存储数量不等的对象,并可以实现常用的数据结构,如栈,队列等.Java集合就像一种容器,可以把多个对象(实际...
  • Java容器概述

    千次阅读 2018-10-22 16:41:50
    Java容器(Container) 什么是容器? 容器可以管理对象的生命周期、对象与对象之间的依赖关系。 直白点说容器就是一段Java程序,能够帮助你管理对象间的关系,而不需要你自行编写程序处理。 维基百科定义: 在计算机...
  • JAVA 容器用法详解

    2012-05-02 22:37:35
    JAVA 容器用法详解,关于JAVA容器的详细讲解
  • Java容器研究及优化篇(一)

    千次阅读 2016-10-19 17:11:05
    Java容器研究及优化篇(一) 在Java环境中,一切都是以对象角色而存在,我们需要一种机制来集中管理这些对象,并对其中每个对象进行方便的插入、检索、修改及删除操作,这种机制称之为集合,也叫做容器。而我们最为...
  • Java容器(数据结构)—数组详解及运用 一.数组的定义: 数组是一种用于存放 **相同对象 **, 连续存放 , 大小不可改变的 一种容器. ##二. 数组的应用场景(优点) 1.需要的对象数量固定,或在某个范围 2.不需要改变容器...
  • 本文主要讲解Swing程序设计中容器、面板及四大布局管理器的详细使用、包括实例...之前在进行Java的窗体开发时经常会把容器、面板与布局管理混淆,从而不能正确的使用这三种属性对窗体应用进行布局。所以今天在这里记录.
  • Java集合容器面试题(2020最新版)

    万次阅读 多人点赞 2020-03-01 11:08:34
    文章目录集合容器概述什么是集合集合的特点集合和数组的区别使用集合框架的好处常用的集合类有哪些?List,Set,Map三者的区别?List、Set、Map 是否继承自 Collection 接口?List、Map、Set 三个接口存取元素时,各...
  • java 容器源码 Java-Container-Source-Code Java常用容器底层源码分析 本项目包含: 各个容器底层源码及注释 还没想到
  • 总结 : 十分钟快速理解Java容器

    千次阅读 2018-03-30 13:43:23
    首先看一下Java容器的概念 容器可以管理对象的生命周期、对象与对象之间的依赖关系,您可以使用一个配置文件(通常是XML),在上面定义好对象的名称、如何产生(Prototype 方式或Singleton 方式)、哪个对象产生...
  • 同时,使用java容器,编译java文件,并且运行java程序。 二、docker运行nginx镜像实例 1.nginx简介 ngnix为持久运行的容器,本文实现在后台运行该镜像,同时进入容器内部,查看容器内部细节。 2.拉取nginx镜像 ...
  • 你必须知道的几种java容器(集合类)

    万次阅读 多人点赞 2015-08-25 21:23:43
    一、基本概念Java容器类类库的用途是“持有对象”,并将其划分为两个不同的概念:1)Collection:一个独立元素的序列,这些元素都服从一条或者多条规则。 List必须按照插入的顺序保存元素,而set不能有重复的元素。...
  • java容器组件之间关系

    千次阅读 2018-11-19 15:39:27
    也是一个容器类。这个框子可以嵌入几个玻璃窗。JFrame自带了一个玻璃窗。可以通过语句 Container c=getContentPane(); 获得该内容窗格。 也可以定制一个新的玻璃面板替换原来的自带的玻璃窗,代码如下: JPanel ...
  • 前面的文章中详细介绍了Java容器框架,在此基础上,本文对Java中的同步容器与并发容器做一些介绍。fail-fast机制快速报错机制(fail-fast)能够防止多个进程同时修改同一个容器的内容。如果在你迭代遍历某个容器的...
  • Java容器有哪些?

    千次阅读 2017-10-25 20:13:27
    网易面试:问:Java容器有哪些,你聊一聊吧Java容器:数组,String,java.util下的集合容器数组长度限制为 Integer.Integer.MAX_VALUE;String的长度限制: 底层是char 数组 长度 Integer.MAX_VALUE 线程安全的List:存放...
  • JAVA 容器类应用

    2008-10-17 09:09:28
    JAVA 容器类应用JAVA 容器类应用JAVA 容器类应用JAVA 容器类应用JAVA 容器类应用JAVA 容器类应用JAVA 容器类应用
  • Java 容器与数组

    千次阅读 2014-08-31 14:35:55
    数组和其它容器的区别主要有三个:效率,类型,和存放基本类型的能力.JAVA中的数组是一种效率最高的存储和随机访问对象引用序列的方式.它就是一个简单的线性序列,所以访问是非常快.但它也损失了其他的特性.当创建一个...
  • java容器简介

    千次阅读 2018-06-30 21:29:35
    容器是一个java所编写的程序,原先必须自行编写代码与管理对象关系,现在容器都会帮您做好。常用容器 WebSphere, WebLogic,Resin, Tomcat, GlassFish, Jetty, JBoss。 服务器 参考:...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 851,410
精华内容 340,564
关键字:

java容器

java 订阅