list是接口还是类,list(计算机专业术语)详细资料大全

list是接口还是类,list(计算机专业术语)详细资料大全详细介绍

本文目录一览： list 是抽象类 还是 接口

是一个接口，他的上层是abstractList，是一个抽象类
List 是个抽象的啊， 所以才有List list = new ArrayList（）； 用ArrayList来实例化啊
是接口，继承Collection的接口

list、 list有什么区别啊？

List是一个接口，而ArrayList 是一个类。
1、ArrayList 继承并实现了List。List list = new ArrayList();这句创建了一个ArrayList的对象后把上溯到了List。此时它是一个List对象了，有些ArrayList有但是List没有的属性和方法，它就不能再用了。而ArrayList list=new ArrayList；创建一对象则保留了ArrayList的所有属性。
2、为什么一般都使用 List list = new ArrayList ,而不用 ArrayList alist = new ArrayList呢。问题就在于List有多个实现类，如 LinkedList或者Vector等等，现在你用的是ArrayList，也许哪一天你需要换成其它的实现类呢。
3、这时你只要改变这一行就行了：List list = new LinkedList； 其它使用了list地方的代码根本不需要改动。假设你开始用 ArrayList alist = new ArrayList，这下你有的改了，特别是如果你使用了 ArrayList特有的方法和属性。 ,如果没有特别需求的话,最好使用List list = new LinkedList，便于程序代码的重构，这就是面向接口编程的好处。
4、ava的多态，List只是定义了一堆接口，而对于这些接口，有各种各样的实现，比如ArrayList，LinkedList等等，不同的实现，会有自己不同的特性以及追加自己特有的方法。当你仅仅使用List的通用接口方法时，定义成List(也就是面向接口编程)是非常好的习惯。

c#的LIST 到底是接口还是类？

List当然是类了。
IList是接口。
判断方法：
C#里是无法创建接口实例，并且.NET命名规范，Ixxx（字母I打头）是接口的规范命名方式。
C#中List是个类，Java中List是个接口不能被实例化，两种语言有区别。
Java中可以这样写:
List
list
=
null;
或者被一个实现类实现一下也行List
list
=
new
ArrayList
();
但是在Java这样写List
list
=
new
List
();是错的
如果在.net中用C#语言编写可以这样写:
List
list
=
new
List
();
可以引入泛型也可以不引入泛型，根据实际情况。这里只讲用法。

list(计算机专业术语)详细资料大全

表， 一览表； 明细表； 目录； 名单。 在计算机领域指序列。在程式语言中List 是类库中的一个类，可以简单视之为双向连结串列，以线性列的方式管理物件集合。list 的特色是在集合的任何位置增加或删除元素都很快，但是不支持随机存取。list 是类库提供的众多容器（container）之一，除此之外还有vector、set、map、…等等。list 以模板方式实现（即泛型），可以处理任意型别的变数，包括使用者自定义的资料型态
基本介绍 中文名 ：list 类型 ：计算机专业术语 一般定义 ：一览表; 明细表; 目录; 名单 区别于 ：vector 一般定义,领域定义,提取数组,领域简介,注意事项,常用函式,List控制项, 一般定义 一览表; 明细表; 目录; 名[清、价目]单 领域定义 在程式语言中List 是标准类库中的一个类，可以简单视之为双向炼表，以线性列的方式管理物件集合。list 的特色是在集合的任何位置增加或删除元素都很快，但是不支持随机存取。list 是类库提供的众多容器（container）之一，除此之外还有vector、set、map、…等等。list 以模板方式实现(即泛型)，可以处理任意型别的变数，包括使用者自定义的资料型态例如：它可以是一个放置整数（int）型态的 list、也可以是放置字串（char 或 string）型态的 list、或者放置使用者自定类别（user-defined class）的 list。 有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜寻列表中的元素。 与vector的区别 参考list是双向循环炼表，，每一个元素都知道前面一个元素和后面一个元素。在STL中，list和vector一样，是两个常被使用的容器。和vector不一样的是，list不支持对元素的任意存取。list中提供的成员函式与vector类似，不过list提供对表首元素的操作push_front、pop_front，这是vector不具备的。和vector另一点不同的是，list的叠代器不会存在失效的情况，他不像vector会保留备份空间，在超过容量额度时重新全部分配记忆体，导致叠代器失效；list没有备份空间的概念，出入一个元素就申请一个元素的空间，所以它的叠代器不会失效。 提取数组 list()函式与array()类似，只是它可以在一次操作中从一个数组内提取多个值，同时为多个变数赋值。其形式如下： voidlist(mixed…) 从资料库或档案中提取信息时，这种构造尤其有用。例如，假如你希望格式化并输出从一个文本，档案中读取信息。档案的每一行都包含用户信息，如姓名、职业和喜爱的颜色，每一项用竖线分隔。典型的一行如下所示： Nino Sanzi|profesional golfer|green 可以通过一个简单的循环使用list()来读取每一行，将各部分数据赋给变数，按照需要格式化并输出数据。 领域简介 与 set 不同，列表通常允许重复的元素。更确切地讲，列表通常允许满足 e1.equals(e2) 的元素对 e1 和 e2，并且如果列表本身允许 null 元素的话，通常它们允许多个 null 元素。难免有人希望通过在用户尝试插入重复元素时抛出运行时异常的方法来禁止重复的列表，但我们希望这种用法越少越好。 List 接口在 iterator、add、remove、equals 和 hashCode 方法的协定上加了一些其他约定，超过了 Collection 接口中指定的约定。为方便起见，这里也包括了其他继承方法的声明。 List 接口提供了 4 种对列表元素进行定位（索引）访问方法。列表（像 Java 数组一样）是基于 0 的。注意，这些操作可能在和某些实现（例如 LinkedList 类）的索引值成比例的时间内执行。因此，如果调用者不知道实现，那么在列表元素上叠代通常优于用索引遍历列表。 List 接口提供了特殊的叠代器，称为 ListIterator，除了允许 Iterator 接口提供的正常操作外，该叠代器还允许元素插入和替换，以及双向访问。还提供了一个方法来获取从列表中指定位置开始的列表叠代器。 List 接口提供了两种搜寻指定对象的方法。从性能的观点来看，应该小心使用这些方法。在很多实现中，它们将执行高开销的线性搜寻。 List 接口提供了两种在列表的任意位置高效插入和移除多个元素的方法。 注意事项 尽管列表允许把自身作为元素包含在内，但建议要特别小心：在这样的列表上，equals 和 hashCode 方法不再是定义良好的。 某些列表实现对列表可能包含的元素有限制。例如，某些实现禁止 null 元素，而某些实现则对元素的类型有限制。试图添加不合格的元素会抛出未经检查的异常，通常是 NullPointerException 或 ClassCastException。试图查询不合格的元素是否存在可能会抛出异常，也可能简单地返回 false；某些实现会采用前一种行为，而某些则采用后者。概括地说，试图对不合格元素执行操作时，如果完成该操作后不会导致在列表中插入不合格的元素，则该操作可能抛出一个异常，也可能成功，这取决于实现的选择。此接口的规范中将这样的异常标记为“可选”。 常用函式 booleanadd(Ee) 向列表的尾部添加指定的元素（可选操作）。 voidadd(intindex,Eelement) 在列表的指定位置插入指定元素（可选操作）。 booleanaddAll(Collection
c) 添加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的叠代器返回这些元素的顺序（可选操作）。 booleanaddAll(intindex,Collection
c) 将指定 collection 中的所有元素都插入到列表中的指定位置（可选操作）。 voidclear() 从列表中移除所有元素（可选操作）。 booleancontains(Objecto) 如果列表包含指定的元素，则返回 true。 booleancontainsAll(Collection
c) 如果列表包含指定 collection 的所有元素，则返回 true。 booleanequals(Objecto) 比较指定的对象与列表是否相等。 Eget(intindex) 返回列表中指定位置的元素。 inthashCode() 返回列表的哈希码值。 intindexOf(Objecto) 返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。 booleanisEmpty() 如果列表不包含元素，则返回 true。 Iterator

iterator() 返回按适当顺序在列表的元素上进行叠代的叠代器。 intlastIndexOf(Objecto) 返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。 ListIterator

listIterator() 返回此列表元素的列表叠代器（按适当顺序）。 ListIterator

listIterator(intindex) 返回列表中元素的列表叠代器（按适当顺序），从列表的指定位置开始。 Eremove(intindex) 移除列表中指定位置的元素（可选操作）。 booleanremove(Objecto) 从此列表中移除第一次出现的指定元素（如果存在）（可选操作）。 booleanremoveAll(Collection
c) 从列表中移除指定 collection 中包含的其所有元素（可选操作）。 booleanretainAll(Collection
c) 仅在列表中保留指定 collection 中所包含的元素（可选操作）。 Eset(intindex,Eelement) 用指定元素替换列表中指定位置的元素（可选操作）。 intsize() 返回列表中的元素数。 List

subList(intfromIndex,inttoIndex) 返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。 Object[]toArray() 返回按适当顺序包含列表中的所有元素的数组（从第一个元素到最后一个元素）。

T[]toArray(T[]a) 返回按适当顺序（从第一个元素到最后一个元素）包含列表中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。 List控制项 List控制项在各类程式中,具有数据显示直观,操作方便的特点。所以使用率极高。 FarPoint的List Pro包含最强大的列表框和组合框的开发组件。这些极其强大的控制项允许你显示多达20亿列表项，多行显示单个记录，为便于查看合并单元格文本，搜寻指定的列表项，或使用无限制的键值来进行列表项排序。List Pro具有200多个的属性，可用来进一步自定义控制项的外观。总之，这些特性可让List Pro成为最终的数据查看器（Data Viewer）。

java list是什么

可自动伸缩，可以插入，移除，排序的一个集合类接口
储存的对象可以是任意的
他的一个实现类ArrayList<>的简单用法：
List

list=new ArrayList

();

添加方法:

list.add("a");

list.add("b");

list.add("c");

list.add("d");

移除方法:

list.remove("b");或者 list.removeAt(1) 数字表示下标，和数组下标等义

list.insert(2,"c"); 插入值的方法

其他的高效方法自己慢慢去研究吧！

list是集合arrayList的接口，总的来说，就是作为集合来使用的。

一个接口。

就是一种集合对象，将所有的对象集中到一起存储。

list里面可以放java对象,可以直接放值。

List list = new ArrayList();

list.add("AAA");

list.add(123);

List(Integer)list =new ArrayList(Integer)(); (Integer) 什么意思？

List是一个接口，而ArrayList 是一个类。 ArrayList 继承并实现了List。
List list = new ArrayList();这句创建了一个ArrayList的对象后把上溯到了List。此时它是一个List对象了，有些ArrayList有但是List没有的属性和方法，它就不能再用了。而ArrayList list=new ArrayList();创建一对象则保留了ArrayList的所有属性。
为什么一般都使用 List list = new ArrayList() ,而不用 ArrayList alist = new ArrayList()呢？
问题就在于List有多个实现类，如 LinkedList或者Vector等等，现在你用的是ArrayList，也许哪一天你需要换成其它的实现类呢？，这时你只要改变这一行就行了：List list = new LinkedList(); 其它使用了list地方的代码根本不需要改动。假设你开始用 ArrayList alist = new ArrayList(), 这下你有的改了，特别是如果你使用了 ArrayList特有的方法和属性。 ,如果没有特别需求的话,最好使用List list = new LinkedList(); ,便于程序代码的重构. 这就是面向接口编程的好处
表示了List里面放的对象是什么类型的，这样写就表示了，你List里面放的必须是Integer类型的，别的就会报错，所以，你可以先Integer it = new Integer();list.add(it);这样就相当于再list里面放入了一个Integer对象，你要放别的就不行了，懂了？
这是JAVA中的泛型，意思是指你的 ArrayList 容器只能存储 Integer 类型 或 int ( 因其可以自动封装成Integer )类型的数据，就是一种规范
List 是可以被多个类实现的，ArrayList 只是其中实现的一个而已，
List是一个接口，ArrayList 是一个类。 ArrayList 继承并实现了List。
List list = new ArrayList();这句创建了一个ArrayList的对象后----给到了List。此时它是一个List对象了，有些ArrayList有但是List没有的属性和方法，它就不能再用了（就是他们共同有的方法和属性，可以使用 ；List 有，但是ArrayList没有，则不能用）。
而ArrayList list=new ArrayList();创建一个对象（ArrayList）则保留了ArrayList的所有属性。
Java泛型，用来限制容器中的类型，来实现容器中只放自己想要元素的类型，避免使用使用具体元素类型时需要的强转
List是一个接口，而ArrayList 是一个类。 ArrayList 继承并实现了List。
List list = new ArrayList();这句创建了一个ArrayList的对象后把上溯到了List。此时它是一个List对象了，有些ArrayList有但是List没有的属性和方法，它就不能再用了。而ArrayList list=new ArrayList();创建一对象则保留了ArrayList的所有属性。
扩展资料：
List 接口的大小可变数组的实现，位于API文档的java.util.ArrayList

。实现了所有可选列表操作，并允许包括 null 在内的所有元素。除了实现 List 接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。

每个 ArrayList 实例都有一个容量。该容量是指用来存储列表元素的数组的大小。它总是至少等于列表的大小。

参考资料来源：百度百科-arraylist

List 、Set、 Map有什么区别和联系

首先list与set都继承于Collection，list序列的形式存储元素。所以取出来的顺序可能和放入顺序不同。set的特点是无法存放重复的元素。map一个映射不能包含重复的键；每个键最多只能映射一个值。以键值对存放数据以上三个都是接口且不能被实例化。
List：
1.可以允许重复的对象。
2.可以插入多个null元素。
3.是一个有序容器，保持了每个元素的插入顺序，输出的顺序就是插入的顺序。
4.常用的实现类有 ArrayList、LinkedList 和 Vector。ArrayList 最为流行，它提供了使用索引的随意访问，而 LinkedList 则对于经常需要从 List 中添加或删除元素的场合更为合适。
Set：
1.不允许重复对象
2. 无序容器，你无法保证每个元素的存储顺序，TreeSet通过 Comparator 或者 Comparable 维护了一个排序顺序。
3. 只允许一个 null 元素
4.Set 接口最流行的几个实现类是 HashSet、LinkedHashSet 以及 TreeSet。最流行的是基于 HashMap 实现的 HashSet；TreeSet 还实现了 SortedSet 接口，因此 TreeSet 是一个根据其 compare() 和 compareTo() 的定义进行排序的有序容器。
map：
1.Map不是collection的子接口或者实现类。Map是一个接口。
2.Map 的 每个 Entry 都持有两个对象，也就是一个键一个值，Map 可能会持有相同的值对象但键对象必须是唯一的。
3. TreeMap 也通过 Comparator 或者 Comparable 维护了一个排序顺序。
4. Map 里你可以拥有随意个 null 值但最多只能有一个 null 键。
5.Map 接口最流行的几个实现类是 HashMap、LinkedHashMap、Hashtable 和 TreeMap。（HashMap、TreeMap最常用）
扩展资料：
java集合类
集合类存放于java.util包中。
集合类存放的都是对象的引用，而非对象本身，出于表达上的便利，我们称集合中的对象就是指集合中对象的引用（reference)。
集合类型主要有3种：set(集）、list(列表）和map(映射)。
集合接口分为：Collection和Map，list、set实现了Collection接口
参考资料：java集合类百度百科
Set
set是三者中最简单的集合，他的存储是没有顺序的（其实是有的，是亿靠hashCode来确定的），他里边的内容和我们存储顺序没有直接的关系，而且set里边的对象不能重复。所以要加入set的对象一定要判断他们是否已经重复了。1. HashSet : 为快速查找设计的Set。存入HashSet的对象必须定义hashCode()。2. TreeSet : 保存次序的Set, 底层为树结构。使用它可以从Set中提取有序的序列。3. LinkedHashSet :具有HashSet的查询速度，且内部使用链表维护元素的顺序(插入的次序)。于是在使用迭代器遍历Set时，结果会按元素插入的次序显示。
Set set=new HashSet();String s1=new String("hello");String s2=s1;String s3=new String("world");set.add(s1);set.add(s2);set.add(s3);System.out.println(set.size());//打印集合中对象的数目 为 2。
Map
map是一个键值对映射的集合，他每次存储一个对象的时候，都需要为该对象存一个key，例如map.put(“123”,”menghaibin”)。而我们取值的时候也只需要取利用key，就能返回我们需要的对象。 常用方法如下：
Object put(Object key, Object value)： 向集合中加入元素Object remove(Object key)： 删除与KEY相关的元素void clear()：从映像中删除所有映射
而java类库中包含了几种不同的map：HashMap,LinkedHashMap,TreeMap,　IdentifyHashMap这几种Map，他们的区别和联系又是什么呢：4. HashMap : Map基于散列表的实现。插入和查询“键值对”的开销是固定的。5. LinkedHashMap :类似于HashMap，但是迭代遍历它时，取得“键值对”的顺序是其插入次序，或者是最近最少使用(LRU)的次序。只比HashMap慢一点。而在迭代访问时发而更快，因为它使用链表维护内部次序。6. TreeMap :基于红黑树数据结构的实现。查看“键”或“键值对”时，它们会被排序(次序由Comparabel或Comparator决定)。TreeMap的特点在于，你得到的结果是经过排序的。TreeMap是唯一的带有subMap()方法的Map，它可以返回一个子树。
List
List按对象进入的顺序保存对象，不做排序或编辑操作,容许他们有重复对象，LinkedList，ArrayList，Vector 。
1. LinkedList：底层基于链表实现，链表内存是散乱的，每一个元素存储本身内存地址的同时还存储下一个元素的地址。链表增删快，查找慢
2. ArrayList和Vector的区别：ArrayList是非线程安全的，效率高；Vector是基于线程安全的，效率低.
List list = new ArrayList();list.add("zhangsan");list.add("lisi"); for(int i=0; i
<list.size();i++){system.out.println(list.get(i));
扩展资料

1 List接口有三个实现类：

1.1 LinkedList基于链表实现，链表内存是散列的，增删快，查找慢；1.2 ArrayList基于数组实现，非线程安全，效率高，增删慢，查找快；1.3 Vector基于数组实现，线程安全，效率低，增删慢，查找慢；

2 Map接口有四个实现类：2.1 HashMap基于 hash 表的 Map 接口实现，非线程安全，高效，支持 null 值和 null 键；2.2 HashTable线程安全，低效，不支持 null 值和 null 键；2.3 LinkedHashMap是 HashMap 的一个子类，保存了记录的插入顺序；2.4 SortMap 接口TreeMap，能够把它保存的记录根据键排序，默认是键值的升序排序

3 Set接口有两个实现类：3.1 HashSet底层是由 Hash Map 实现，不允许集合中有重复的值，使用该方式时需要重写 equals()和 hash Code()方法；3.2 LinkedHashSet继承于 HashSet，同时又基于 LinkedHashMap 来进行实现，底层使用的是 LinkedHashMap

list 和set 有共同的父类 它们的用法也是一样的 唯一的不太就是set中不能有相同的元素 list中可以

list和set的用途非常广泛 list可以完全代替数组来使用

map 是独立的合集 它使用键值对的方式来储存数据 键不能有重复的 值可以用

map不像上边两种集合那个用的广泛 不过在servlet 和jsp中 map可是绝对的重中之重 页面之间传值全靠map

你这个问题可大可小

小了说：List Set Map都是接口，前两个继承至Collection接口，Map为独立接口

大了说就是集合类的一章内容

Set下有HashSet，LinkedHashSet，TreeSet

List下有ArrayList，Vector，LinkedList

Map下有Hashtable，LinkedHashMap，HashMap，TreeMap

还有Collection接口下还有个Queue接口，有PriorityQueue类

数据结构的东西永远都是有个最优选择的问题，还是细细看下这章吧，百度只能解决问题，系统学习你就对自己不负责了

List可以有重复的对象，因为有顺序的，每个对象都带下标

Set不可以有重复的对象

Map是键值成对的

1、List接口对Collection进行了简单的扩充，它的具体实现类常用的有ArrayList和LinkedList。

你可以将任何东西放到一个List容器中，并在需要时从中取出。ArrayList从其命名中可以看出它是一种类似数组的形式进行存储，因此它的随机访问速度极快，而LinkedList的内部实现是链表，它适合于在链表中间需要频繁进行插入和删除操作。在具体应用时可以根据需要自由选择。

前面说的Iterator只能对容器进行向前遍历，而ListIterator则继承了Iterator的思想，并提供了对List进行双向遍历的方法。 2、Set接口也是Collection的一种扩展，而与List不同的时，在Set中的对象元素不能重复，也就是说你不能把同样的东西两次放入同一个Set容器中。它的常用具体实现有HashSet和TreeSet类。

HashSet能快速定位一个元素，但是你放到HashSet中的对象需要实现hashCode()方法，它使用了前面说过的哈希码的算法。而TreeSet则将放入其中的元素按序存放，这就要求你放入其中的对象是可排序的，这就用到了集合框架提供的另外两个实用类Comparable和Comparator。

一个类是可排序的，它就应该实现Comparable接口。有时多个类具有相同的排序算法，那就不需要在每分别重复定义相同的排序算法，只要实现Comparator接口即可。

集合框架中还有两个很实用的公用类：Collections和Arrays。Collections提供了对一个Collection容器进行诸如排序、复制、查找和填充等一些非常有用的方法，Arrays则是对一个数组进行类似的操作。 3、Map是一种把键对象和值对象进行关联的容器，而一个值对象又可以是一个Map，依次类推，这样就可形成一个多级映射。

对于键对象来说，像Set一样，一个Map容器中的键对象不允许重复，这是为了保持查找结果的一致性;如果有两个键对象一样，那你想得到那个键对象所对应的值对象时就有问题了，可能你得到的并不是你想的那个值对象，结果会造成混乱，所以键的唯一性很重要，也是符合集合的性质的。

当然在使用过程中，某个键所对应的值对象可能会发生变化，这时会按照最后一次修改的值对象与键对应。对于值对象则没有唯一性的要求。你可以将任意多个键都映射到一个值对象上，这不会发生任何问题（不过对你的使用却可能会造成不便，你不知道你得到的到底是那一个键所对应的值对象）。

Map有两种比较常用的实现：HashMap和TreeMap。HashMap也用到了哈希码的算法，以便快速查找一个键，TreeMap则是对键按序存放，因此它便有一些扩展的方法，比如firstKey(),lastKey()等，你还可以从TreeMap中指定一个范围以取得其子Map。

键和值的关联很简单，用pub(Object key,Object value)方法即可将一个键与一个值对象相关联。用get(Object key)可得到与此key对象所对应的值对象

扩展资料：

解疑：

1、什么是Iterator

一些集合类提供了内容遍历的功能，通过java.util.Iterator接口。这些接口允许遍历对象的集合。依次操作每个元素对象。当使用 Iterators时，在获得Iterator的时候包含一个集合快照。通常在遍历一个Iterator的时候不建议修改集合本省。

2、Iterator与ListIterator有什么区别？

Iterator：只能正向遍历集合，适用于获取移除元素。ListIerator：继承Iterator，可以双向列表的遍历，同样支持元素的修改。

3、什么是HaspMap和Map？

Map是接口，Java 集合框架中一部分，用于存储键值对，HashMap是用哈希算法实现Map的类。

4、HashMap与HashTable有什么区别？对比Hashtable VS HashMap

两者都是用key-value方式获取数据。Hashtable是原始集合类之一（也称作遗留类）。HashMap作为新集合框架的一部分在Java2的1.2版本中加入。它们之间有一下区别：

● HashMap和Hashtable大致是等同的，除了非同步和空值（HashMap允许null值作为key和value，而Hashtable不可以）。

● HashMap没法保证映射的顺序一直不变，但是作为HashMap的子类LinkedHashMap，如果想要预知的顺序迭代（默认按照插入顺序），你可以很轻易的置换为HashMap，如果使用Hashtable就没那么容易了。

● HashMap不是同步的，而Hashtable是同步的。

● 迭代HashMap采用快速失败机制，而Hashtable不是，所以这是设计的考虑点。

5、在Hashtable上下文中同步是什么意思？

同步意味着在一个时间点只能有一个线程可以修改哈希表，任何线程在执行hashtable的更新操作前需要获取对象锁，其他线程等待锁的释放。

6、什么叫做快速失败特性

从高级别层次来说快速失败是一个系统或软件对于其故障做出的响应。一个快速失败系统设计用来即时报告可能会导致失败的任何故障情况，它通常用来停止正常的操作而不是尝试继续做可能有缺陷的工作。当有问题发生时，快速失败系统即时可见地发错错误告警。

在Java中，快速失败与iterators有关。如果一个iterator在集合对象上创建了，其它线程欲“结构化”的修改该集合对象，并发修改异常 （ConcurrentModificationException） 抛出。

7、怎样使Hashmap同步？

HashMap可以通过Map m = Collections.synchronizedMap（hashMap）来达到同步的效果。

8、什么时候使用Hashtable，什么时候使用HashMap

基本的不同点是Hashtable同步HashMap不是的，所以无论什么时候有多个线程访问相同实例的可能时，就应该使用Hashtable，反之使用HashMap。非线程安全的数据结构能带来更好的性能。

如果在将来有一种可能—你需要按顺序获得键值对的方案时，HashMap是一个很好的选择，因为有HashMap的一个子类 LinkedHashMap。所以如果你想可预测的按顺序迭代（默认按插入的顺序），你可以很方便用LinkedHashMap替换HashMap。

反观要是使用的Hashtable就没那么简单了。同时如果有多个线程访问HashMap，Collections.synchronizedMap（）可以代替，总的来说HashMap更灵活。

9、为什么Vector类认为是废弃的或者是非官方地不推荐使用？或者说为什么我们应该一直使用ArrayList而不是Vector

你应该使用ArrayList而不是Vector是因为默认情况下你是非同步访问的，Vector同步了每个方法，你几乎从不要那样做，通常有想要同步的是整个操作序列。同步单个的操作也不安全（如果你迭代一个Vector，你还是要加锁，以避免其它线程在同一时刻改变集合）。

而且效率更慢。当然同样有锁的开销即使你不需要，这是个很糟糕的方法在默认情况下同步访问。你可以一直使用Collections.sychronizedList来装饰一个集合。

事实上Vector结合了“可变数组”的集合和同步每个操作的实现。这是另外一个设计上的缺陷。Vector还有些遗留的方法在枚举和元素获取的方法，这些方法不同于List接口，如果这些方法在代码中程序员更趋向于想用它。

尽管枚举速度更快，但是他们不能检查如果集合在迭代的时候修改了，这样将导致问题。尽管以上诸多原因，Oracle也从没宣称过要废弃Vector。

参考资料：

STLset容器——百度百科

Collection接口——百度百科

list （计算机专业术语） ——百度百科

List集合是什么类型的集合

list是一个泛型集合，也就是你可以用它来装任何东西。List l = new ArrayList();这时候这个l集合你可以装任何东西，整形，字符串，对象都可以。List

i= new ArrayList

(),这个集合就只能装整形数据，因为你以为它指明了类型了。

List集合类型为泛型

List集合包括JavaList接口以及List接口的所有实现类。List集合中的元素允许重复，各元素的顺序放是对象插入的顺序，类似Java中的数组，用户可通过使用索引(元素在集合中的位置)来访问集合中的元素。

List的最重要的特征就是有序；它会确保以一定的顺序保存元素。List在Collection的基础上添加了大量方法，使之能在序列中间插入和删除元素。（只对LinkedList推荐使用。）

List可以制造ListIterator对象，你除了能用它在List的中间插入和删除元素之外，还能用它沿两个方向遍历List。

扩展资料

LinkedList：LinkedList是线程不安全的，对顺序访问进行了优化。在List中间插入和删除元素的代价也不高。随机访问的速度相对较慢。（用ArrayList吧。）

此外它还有addFirst()，addLast()，getFirst()，getLast()，removeFirst()和removeLast()等方法（这些方法，接口和基类均未定义），能把它当成栈（stack），队列（queue）或双向队列（deque）来用。

参考资料来源：百度百科-JAVA集合框架

参考资料来源：百度百科-JavaList集合

list与arraylist 区别

1、List是一个接口，而ListArray是一个类。
2、ListArray继承并实现了List。
3、所以List不能被构造，但可以向上面那样为List创建一个引用，而ListArray就可以被构造。
List list; //正确 list=null;
List list=new List(); // 是错误的用法
List list = new ArrayList();这句创建了一个ArrayList的对象后把上溯到了List。此时它是一个List对象了，有些ArrayList有但是List没有的属性和方法，它就不能再用了。
4、而ArrayList list=new ArrayList();创建一对象则保留了ArrayList的所有属性。
这是一个例子：
import java.util.*;
public class TestList{
public static void main(String[] args){
List list = new ArrayList();
ArrayList arrayList = new ArrayList();
list.trimToSize(); //错误，没有该方法。
arrayList.trimToSize(); //ArrayList里有该方法。
}
}
扩展资料：
ArrayList就是传说中的动态数组，用MSDN中的说法，就是Array的复杂版本，它提供了如下一些好处：[list=disc]
动态的增加和减少元素
实现了ICollection和IList接口
灵活的设置数组的大小
2、如何使用ArrayList
最简单的例子：
ArrayList List = new ArrayList();
for( int i=0;i<10;i++ ) //给数组增加10个Int元素
List.Add(i);
//..程序做一些处理
List.RemoveAt(5);//将第6个元素移除
for( int i=0;i<3;i++ ) //再增加3个元素
List.Add(i+20);
Int32[] values = (Int32[])List.ToArray(typeof(Int32));//返回ArrayList包含的数组
这是一个简单的例子，虽然没有包含ArrayList所有的方法，但是可以反映出ArrayList最常用的用法
3、ArrayList重要的方法和属性
（1）构造器
ArrayList提供了三个构造器：
public ArrayList();
默认的构造器，将会以默认（16）的大小来初始化内部的数组
public ArrayList(ICollection);
用一个ICollection对象来构造，并将该集合的元素添加到ArrayList
public ArrayList(int);
用指定的大小来初始化内部的数组
（2）IsSynchronized属性和ArrayList.Synchronized方法
IsSynchronized属性指示当前的ArrayList实例是否支持线程同步，而ArrayList.Synchronized静态方法则会返回一个ArrayList的线程同步的封装。
如果使用非线程同步的实例，那么在多线程访问的时候，需要自己手动调用lock来保持线程同步，例如：
ArrayList list = new ArrayList();
//...
lock( list.SyncRoot ) //当ArrayList为非线程包装的时候，SyncRoot属性其实就是它自己，但是为了满足ICollection的SyncRoot定义，这里还是使用SyncRoot来保持源代码的规范性
{
list.Add( “Add a Item” );
}
如果使用ArrayList.Synchronized方法返回的实例，那么就不用考虑线程同步的问题，这个实例本身就是线程安全的，实际上ArrayList内部实现了一个保证线程同步的内部类，ArrayList.Synchronized返回的就是这个类的实例，它里面的每个属性都是用了lock关键字来保证线程同步。
****
但是，使用这个方法（ArrayList.Synchronized）并不能保证枚举的同步，例如，一个线程正在删除或添加集合项，而另一个线程同时进行枚举，这时枚举将会抛出异常。所以，在枚举的时候，你必须明确使用 SyncRoot 锁定这个集合。
Hashtable与ArrayList关于线程安全性的使用方法类似。
****
参考资料：百度百科-arraylist
list是有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。
与 set 不同，列表通常允许重复的元素。更确切地讲，列表通常允许满足 e1.equals(e2) 的元素对 e1 和 e2，并且如果列表本身允许 null 元素的话，通常它们允许多个 null 元素。难免有人希望通过在用户尝试插入重复元素时抛出运行时异常的方法来禁止重复的列表，但我们希望这种用法越少越好。
List 接口在 iterator、add、remove、equals 和 hashCode 方法的协定上加了一些其他约定，超过了 Collection 接口中指定的约定。为方便起见，这里也包括了其他继承方法的声明。
List 接口提供了 4 种对列表元素进行定位（索引）访问方法。列表（像 Java 数组一样）是基于 0 的。注意，这些操作可能在和某些实现（例如 LinkedList 类）的索引值成比例的时间内执行。因此，如果调用者不知道实现，那么在列表元素上迭代通常优于用索引遍历列表。
List 接口提供了特殊的迭代器，称为 ListIterator，除了允许 Iterator 接口提供的正常操作外，该迭代器还允许元素插入和替换，以及双向访问。还提供了一个方法来获取从列表中指定位置开始的列表迭代器。
List 接口提供了两种搜索指定对象的方法。从性能的观点来看，应该小心使用这些方法。在很多实现中，它们将执行高开销的线性搜索。
List 接口提供了两种在列表的任意位置高效插入和移除多个元素的方法。
注意：尽管列表允许把自身作为元素包含在内，但建议要特别小心：在这样的列表上，equals 和 hashCode 方法不再是定义良好的。
某些列表实现对列表可能包含的元素有限制。例如，某些实现禁止 null 元素，而某些实现则对元素的类型有限制。试图添加不合格的元素会抛出未经检查的异常，通常是 NullPointerException 或 ClassCastException。试图查询不合格的元素是否存在可能会抛出异常，也可能简单地返回 false；某些实现会采用前一种行为，而某些则采用后者。概括地说，试图对不合格元素执行操作时，如果完成该操作后不会导致在列表中插入不合格的元素，则该操作可能抛出一个异常，也可能成功，这取决于实现的选择。此接口的规范中将这样的异常标记为“可选”。
ArrayList除了实现 List 接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。（此类大致上等同于 Vector 类，除了此类是不同步的。）
size、isEmpty、get、set、iterator 和 listIterator 操作都以固定时间运行。add 操作以分摊的固定时间 运行，也就是说，添加 n 个元素需要 O(n) 时间。其他所有操作都以线性时间运行（大体上讲）。与用于 LinkedList 实现的常数因子相比，此实现的常数因子较低。
每个 ArrayList 实例都有一个容量。该容量是指用来存储列表元素的数组的大小。它总是至少等于列表的大小。随着向 ArrayList 中不断添加元素，其容量也自动增长。并未指定增长策略的细节，因为这不只是添加元素会带来分摊固定时间开销那样简单。
在添加大量元素前，应用程序可以使用 ensureCapacity 操作来增加 ArrayList 实例的容量。这可以减少递增式再分配的数量。
注意，此实现不是同步的。如果多个线程同时访问一个 ArrayList 实例，而其中至少一个线程从结构上修改了列表，那么它必须 保持外部同步。（结构上的修改是指任何添加或删除一个或多个元素的操作，或者显式调整底层数组的大小；仅仅设置元素的值不是结构上的修改。）这一般通过对自然封装该列表的对象进行同步操作来完成。如果不存在这样的对象，则应该使用 Collections.synchronizedList 方法将该列表“包装”起来。这最好在创建时完成，以防止意外对列表进行不同步的访问：
List list = Collections.synchronizedList(new ArrayList(...)); 此类的 iterator 和 listIterator 方法返回的迭代器是快速失败的：在创建迭代器之后，除非通过迭代器自身的 remove 或 add 方法从结构上对列表进行修改，否则在任何时间以任何方式对列表进行修改，迭代器都会抛出 ConcurrentModificationException。因此，面对并发的修改，迭代器很快就会完全失败，而不是冒着在将来某个不确定时间发生任意不确定行为的风险。
注意，迭代器的快速失败行为无法得到保证，因为一般来说，不可能对是否出现不同步并发修改做出任何硬性保证。快速失败迭代器会尽最大努力抛出 ConcurrentModificationException。因此，为提高这类迭代器的正确性而编写一个依赖于此异常的程序是错误的做法：迭代器的快速失败行为应该仅用于检测 bug。
List是接口 定义了一些方法 但是方法没有被实现 ArrayList是一个类 实现了List这个接口 List里边定义的方法 在ArrayList里边都实现了 同时List也可以被别的类所实现 例如Vector， Vector和ArrayList对List定义的方法的实现就有所区别。
List是一个接口，描述了一个有序的允许有重复值得集合，
ArrayList 是List接口的一个实现,其内部使用数组实现,相似的还有LinkedList, 内部使用链表实现 .
List 是接口,ArrayList 是接口的实现类.
List和ArrayList的区别在于：
1、在编程语言中ArrayList类是.Net Framework提供的用于数据存储和检索的专用类。List 类可以简单视之为双向连结串行，以线性列的方式管理物件集合。List类是ArrayList类的泛型等效类。
2、ArrayList继承了IList接口，所以它可以很方便的进行数据的添加，插入和移除。List的大部分用法都与ArrayList相似，List类也继承了IList接口。
3、在ArrayList中可以插入不同类型的数据。ArrayList会把所有插入其中的数据都当作为object类型来处理，这其中存在装箱与拆箱的操作，会对系统造成性能上的损耗。而List需要声明其数据的对象类型。声明后插入其他类型数据，IDE就会报错，且不能通过编译。
4、在使用ArrayList中的数据来处理问题的时候，很可能会报类型不匹配的错误，即ArrayList不是类型安全的。而List已经声明过其数据的对象类型，是类型安全的，避免了前面讲的类型安全问题与装箱拆箱的性能问题。
5、ListArray就可以被构造。而List不能被构造，但可以为List创建一个引用。
扩展资料：
一、List泛型
通过允许指定泛型类或方法操作的特定类型，泛型功能将类型安全的任务从程序员转移给了编译器。不需要编写代码来检测数据类型是否正确，因为会在编译时强制使用正确的数据类型。减少了类型强制转换的需要和运行时错误的可能性。泛型提供了类型安全但没有增加多个实现的开销。
二、装箱与拆箱的概念：
1、装箱：就是将值类型的数据打包到引用类型的实例中 比如将int类型的值123赋给object对象o
int i=123; object o=(object)i;
2、拆箱：就是从引用数据中提取值类型 比如将object对象o的值赋给int类型的变量i
object o=123; int i=(int)o;
3、装箱与拆箱的过程是很损耗性能的。
参考资料：拆箱——百度百科