「java数组集合类」java数组是集合吗

博主：adminadmin 2022-12-22 12:03:07 76

本篇文章给大家谈谈java数组集合类，以及java数组是集合吗对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

java集合是什么？

Java集合是什么：

Java 中的集合类库可以帮助我们在程序设计中实现传统的数据结构。

Java的集合类是一个用来存放对象的容器，有以下特点:

1、Java集合只能存放对象。加入添加了一个基本数据类型，会被自动装箱后存入集合。

2、集合存放的是多个对象的引用，对象本身是在堆内存中的。

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

集合分三种:1、Set 2 、List 3、Map，下面进行具体介绍。

扩展链接：

主要内容：

1)手写ArrayList

2)手写单链表

3)手写LinkedList

4)手写HashMap

5)手写HashSet

6)最新并发集合类

学习目标：

1. 掌握手写ArrayList

2. 掌握手写单链表

3. 掌握手写LinkedList

4. 掌握手写HashMap

5. 掌握手写HashSet

6. 理解最新并发集合类底层原理

视频课程小结：

01_集合提升训练_手写ArrayList_get_size_isEmpty_自定义异常

02_集合提升训练_手写ArrayList_构造方法_add

03_集合提升训练_手写ArrayList_toString_iterator

04_集合提升循环_手写单链表_get

05_集合提升训练_手写单链表_add_remove_toString

06_集合提升训练_手写LinkedList

07_集合提升训练_手写LinkedList_添加内存分配图

08_集合提升训练_HashMap的原理和代码准备

09_集合提升训练_手写HashMap的put

10_集合提升训练_手写HashMap的get_toString

11_集合提升训练_手写HashSet

12_集合提升训练_新一代并发集合类

Java五个最常用的集合类之间的区别和联系

常用的集合类有一下几种：

List结构的集合类：ArrayList类，LinkedList类，Vector类，Stack类

Map结构的集合类：HashMap类，Hashtable类

Set结构的集合类：HashSet类，TreeSet类

Queue结构的集合：Queue接口

HashMap和Hashtable的区别：

HashMap和Hashtable都是java的集合类，都可以用来存放java对象，这是他们的相同点

以下是他们的区别：

1.历史原因：

Hashtable是基于陈旧的Dictionary类的，HashMap是java 1.2引进的Map接口的一个现实。

2.同步性：

Hashtable是同步的，这个类中的一些方法保证了Hashtable中的对象是线程安全的，而HashMap则是异步的，因此HashMap中的对象并不是线程安全的，因为同步的要求会影响执行的效率，所以如果你不需要线程安全的结合那么使用HashMap是一个很好的选择，这样可以避免由于同步带来的不必要的性能开销，从而提高效率，我们一般所编写的程序都是异步的，但如果是服务器端的代码除外。

3.值：

HashMap可以让你将空值作为一个表的条目的key或value

Hashtable是不能放入空值（null）的

ArrayList和Vector的区别：

ArrayList与Vector都是java的集合类，都是用来存放java对象，这是他们的相同点，

区别：

1.同步性：

Vector是同步的，这个类的一些方法保证了Vector中的对象的线程安全的，而ArrayList则是异步的，因此ArrayList中的对象并不 是线程安全的，因为同步要求会影响执行的效率，所以你不需要线程安全的集合那么使用ArrayList是一个很好的选择，这样可以避免由于同步带来的不必 要的性能开销。

2.数据增长：

从内部实现的机制来讲，ArrayList和Vector都是使用数组（Array）来控制集合中的对象，当你向两种类型中增加元素的时候，如果元素的数目超过了内部数组目前的长度他们都需要扩展内部数组的长度，Vector缺省情况下自动增长原来一倍的数组长度，ArrayList是原来的50%，所以最后你获得的这个集合所占的空间总是比你实际需要的要大，所以如果你要在集合中保存大量的数据，那么使用Vector有一些优势，因为你可以通过设置集合的初始大小来避免不必要的资源开销。

总结：

1）如果要求线程安全，使用Vector，Hashtable

2）如果不要求线程安全，使用ArrayList，LinkedList，HashMap

3)如果要求键值对，则使用HashMap，Hashtable

4）如果数据量很大，又要求线程安全考虑Vector

1．ArrayList: 元素单个，效率高，多用于查询

2．Vector: 元素单个，线程安全，多用于查询

3．LinkedList:元素单个，多用于插入和删除

4．HashMap: 元素成对，元素可为空

5．HashTable: 元素成对，线程安全，元素不可为空

ArrayList

底层是Object数组，所以ArrayList具有数组的查询速度快的优点以及增删速度慢的缺点。

而在LinkedList的底层是一种双向循环链表。在此链表上每一个数据节点都由三部分组成：前指针（指向前面的节点的位置），数据，后指针（指向后面的节点的位置）。最后一个节点的后指针指向第一个节点的前指针，形成一个循环。

双向循环链表的查询效率低但是增删效率高。

ArrayList和LinkedList在用法上没有区别，但是在功能上还是有区别的。

LinkedList

经常用在增删操作较多而查询操作很少的情况下：队列和堆栈。

队列：先进先出的数据结构。

栈：后进先出的数据结构。

注意：使用栈的时候一定不能提供方法让不是最后一个元素的元素获得出栈的机会。

Vector

（与ArrayList相似，区别是Vector是重量级的组件，使用使消耗的资源比较多。）

结论：在考虑并发的情况下用Vector（保证线程的安全）。

在不考虑并发的情况下用ArrayList（不能保证线程的安全）。

面试经验（知识点）：

java.util.stack（stack即为堆栈）的父类为Vector。可是stack的父类是最不应该为Vector的。因为Vector的底层是数组，且Vector有get方法（意味着它可能访问到并不属于最后一个位置元素的其他元素，很不安全）。

对于堆栈和队列只能用push类和get类。

Stack类以后不要轻易使用。

实现栈一定要用LinkedList。

（在JAVA1.5中，collection有queue来实现队列。）

Set-HashSet实现类：

遍历一个Set的方法只有一个：迭代器（interator）。

HashSet中元素是无序的（这个无序指的是数据的添加顺序和后来的排列顺序不同），而且元素不可重复。

在Object中除了有finalize()，toString()，equals()，还有hashCode()。

HashSet底层用的也是数组。

当向数组中利用add(Object o)添加对象的时候，系统先找对象的hashCode：

int hc=o.hashCode(); 返回的hashCode为整数值。

Int I=hc%n;（n为数组的长度），取得余数后，利用余数向数组中相应的位置添加数据，以n为6为例，如果I=0则放在数组a[0]位置，如果I=1,则 放在数组a[1]位置。如果equals()返回的值为true，则说明数据重复。如果equals()返回的值为false，则再找其他的位置进行比 较。这样的机制就导致两个相同的对象有可能重复地添加到数组中，因为他们的hashCode不同。

如果我们能够使两个相同的对象具有相同hashcode，才能在equals()返回为真。

在实例中，定义student对象时覆盖它的hashcode。

因为String类是自动覆盖的，所以当比较String类的对象的时候，就不会出现有两个相同的string对象的情况。

现在，在大部分的JDK中，都已经要求覆盖了hashCode。

结论：如将自定义类用hashSet来添加对象，一定要覆盖hashcode()和equals()，覆盖的原则是保证当两个对象hashcode返回相同的整数，而且equals()返回值为True。

如果偷懒，没有设定equals()，就会造成返回hashCode虽然结果相同，但在程序执行的过程中会多次地调用equals()，从而影响程序执行的效率。

java集合类哪个函数可以

java集合里面的函数

java集合里面的函数_java集合【1】——— 从集合接口框架说起

百里方欣

原创

关注

0点赞·155人阅读

(一) java集合分类

之前大概分为三种，Set，List，Map三种，JDK5之后，增加Queue.主要由Collection和Map两个接口衍生出来,同时Collection接口继承Iterable接口，所以我们也可以说java里面的集合类主要是由Iterable和Map两个接口以及他们的子接口或者其实现类组成。我们可以认为Collection接口定义了单列集合的规范，每次只能存储一个元素，而Map接口定义了双列集合的规范，每次能存储一对元素。

Iterable接口:主要是实现遍历功能

Collection接口: 允许重复

Set接口：无序，元素不可重复,访问元素只能通过元素本身来访问。

List接口：有序且可重复，可以根据元素的索引来访问集合中的元素。

Queue接口：队列集合

Map接口：映射关系，简单理解为键值对，Key不可重复，与Collection接口关系不大，只是个别函数使用到。

整个接口框架关系如下(来自百度百科)：

(1) Iterable接口

1. 内部定义的方法

java集合最源头的接口，实现这个接口的作用主要是集合对象可以通过迭代器去遍历每一个元素。

源码如下：

// 返回一个内部元素为T类型的迭代器(JDK1.5只有这个接口)

Iterator iterator();

// 遍历内部元素，action意思为动作，指可以对每个元素进行操作(JDK1.8添加)

default void forEach(Consumer super T action) {}

// 创建并返回一个可分割迭代器(JDK1.8添加)，分割的迭代器主要是提供可以并行遍历元素的迭代器，可以适应现在cpu多核的能力，加快速度。

default Spliterator spliterator() {

return Spliterators.spliteratorUnknownSize(iterator(), 0);

}

从上面可以看出，foreach迭代以及可分割迭代，都加了default关键字，这个是Java 8 新的关键字，以前接口的所有接口，具体子类都必须实现，而对于deafult关键字标识的方法，其子类可以不用实现，这也是接口规范发生变化的一点。

下面我们分别展示三个接口的调用：

1.1 iterator方法

public static void iteratorHasNext(){

List list=new ArrayList();

list.add("Jam");

list.add("Jane");

list.add("Sam");

// 返回迭代器

Iterator iterator=list.iterator();

// hashNext可以判断是否还有元素

while(iterator.hasNext()){

//next()作用是返回当前指针指向的元素,之后将指针移向下个元素

System.out.println(iterator.next());

}

}

当然也可以使用for-each loop方式遍历

for (String item : list) {

System.out.println(item);

}

但是实际上，这种写法在class文件中也是会转成迭代器形式，这只是一个语法糖。class文件如下：

public class IterableTest {

public IterableTest() { }

public static void main(String[] args) {

iteratorHasNext();

}

public static void iteratorHasNext() {

List list = new ArrayList();

list.add("Jam");

list.add("Jane");

list.add("Sam");

Iterator iterator = list.iterator();

Iterator var2 = list.iterator();

while(var2.hasNext()) {

String item = (String)var2.next();

System.out.println(item);

}

}

}

需要注意的一点是，迭代遍历的时候，如果删除或者添加元素，都会抛出修改异常，这是由于快速失败【fast-fail】机制。

public static void iteratorHasNext(){

List list=new ArrayList();

list.add("Jam");

list.add("Jane");

list.add("Sam");

for (String item : list) {

if(item.equals("Jam")){

list.remove(item);

}

System.out.println(item);

}

}

从下面的错误我们可以看出，第一个元素是有被打印出来的，也就是remove操作是成功的，只是遍历到第二个元素的时候，迭代器检查，发现被改变了，所以抛出了异常。

Jam

Exception in thread "main" java.util.ConcurrentModificationException

at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)

at java.util.ArrayList$Itr.next(ArrayList.java:859)

at IterableTest.iteratorHasNext(IterableTest.java:15)

at IterableTest.main(IterableTest.java:7)

1.2 forEach方法

其实就是把对每一个元素的操作当成了一个对象传递进来，对每一个元素进行处理。

default void forEach(Consumer super T action) {

Objects.requireNonNull(action);

for (T t : this) {

action.accept(t);

}

}

```java

当然像ArrayList自然也是有自己的实现的，那我们就可以使用这样的写法,简洁优雅。forEach方法在java8中参数是`java.util.function.Consumer`,可以称为**消费行为**或者说**动作**类型。

```java

list.forEach(x - System.out.print(x));

同时，我们只要实现Consumer接口，就可以自定义动作，如果不自定义，默认迭代顺序是按照元素的顺序。

public class ConsumerTest {

public static void main(String[] args) {

List list=new ArrayList();

list.add("Jam");

list.add("Jane");

list.add("Sam");

MyConsumer myConsumer = new MyConsumer();

Iterator it = list.iterator();

list.forEach(myConsumer);

}

static class MyConsumer implements Consumer {

@Override

public void accept(Object t) {

System.out.println("自定义打印：" + t);

}

}

}

输出的结果：

自定义打印：Jam

自定义打印：Jane

自定义打印：Sam

1.3 spliterator方法

这是一个为了并行遍历数据元素而设计的迭代方法，返回的是Spliterator，是专门并行遍历的迭代器。以发挥多核时代的处理器性能，java默认在集合框架中提供了一个默认的Spliterator实现，底层也就是Stream.isParallel()实现的，我们可以看一下源码：

// stream使用的就是spliterator

default Stream stream() {

return StreamSupport.stream(spliterator(), false);

}

default Spliterator spliterator() {

return Spliterators.spliterator(this, 0);

}

public static Stream stream(Spliterator spliterator, boolean parallel) {

Objects.requireNonNull(spliterator);

return new ReferencePipeline.Head(spliterator,

StreamOpFlag.fromCharacteristics(spliterator),

parallel);

}

使用的方法如下：

public static void spliterator(){

List list = Arrays.asList("1", "2", "3","4","5","6","7","8","9","10");

// 获取可迭代器

Spliterator spliterator = list.spliterator();

// 一个一个遍历

System.out.println("tryAdvance: ");

spliterator.tryAdvance(item-System.out.print(item+" "));

spliterator.tryAdvance(item-System.out.print(item+" "));

System.out.println("\n-------------------------------------------");

// 依次遍历剩下的

System.out.println("forEachRemaining: ");

spliterator.forEachRemaining(item-System.out.print(item+" "));

System.out.println("\n------------------------------------------");

// spliterator1:0~10

Spliterator spliterator1 = list.spliterator();

// spliterator1:6~10 spliterator2:0~5

Spliterator spliterator2 = spliterator1.trySplit();

// spliterator1:8~10 spliterator3:6~7

Spliterator spliterator3 = spliterator1.trySplit();

System.out.println("spliterator1: ");

spliterator1.forEachRemaining(item-System.out.print(item+" "));

System.out.println("\n------------------------------------------");

System.out.println("spliterator2: ");

spliterator2.forEachRemaining(item-System.out.print(item+" "));

System.out.println("\n------------------------------------------");

System.out.println("spliterator3: ");

spliterator3.forEachRemaining(item-System.out.print(item+" "));

}

tryAdvance() 一个一个元素进行遍历

forEachRemaining() 顺序地分块遍历

trySplit()进行分区形成另外的 Spliterator，使用在并行操作中，分出来的是前面一半，就是不断把前面一部分分出来

结果如下：

tryAdvance:

1 2

-------------------------------------------

forEachRemaining:

3 4 5 6 7 8 9 10

------------------------------------------

spliterator1:

8 9 10

------------------------------------------

spliterator2:

1 2 3 4 5

------------------------------------------

spliterator3:

6 7

还有一些其他的用法在这里就不列举了，主要是trySplit()之后，可以用于多线程遍历。理想的时候，可以平均分成两半，有利于并行计算，但是不是一定平分的。

2. Collection接口 extend Iterable

Collection接口可以算是集合类的一个根接口之一，一般不能够直接使用，只是定义了一个规范，定义了添加，删除等管理数据的方法。继承Collection接口的有List，Set,Queue,不过Queue定义了自己的一些接口，相对来说和其他的差异比较大。

2.1 内部定义的方法

源码如下：

boolean add(Object o) //添加元素

boolean remove(Object o) //移除元素

boolean addAll(Collection c) //批量添加

boolean removeAll(Collection c) //批量移除

void retainAll(Collection c) // 移除在c中不存在的元素

void clear() //清空集合

int size() //集合大小

boolean isEmpty() //是否为空

boolean contains(Object o) //是否包含在集合中

boolean containsAll(Collection c) //是否包含所有的元素

Iterator iterator() // 获取迭代器

Object[] toArray() // 转成数组

default boolean removeIf(Predicate super E filter) {} // 删除集合中复合条件的元素，删除成功返回true

boolean equals(Object o)

int hashCode()

default Spliterator spliterator() {} //获取可分割迭代器

default Stream stream() {} //获取流

default Stream parallelStream() {} //获取并行流

里面获取并行流的方法parallelStream(),其实就是通过默认的ForkJoinPool(主要用来使用分治法(Divide-and-Conquer Algorithm)来解决问题)，提高多线程任务的速度。我们可以使用ArrayList来演示一下平行处理能力。例如下面的例子，输出的顺序就不一定是1,2,3...，可能是乱序的，这是因为任务会被分成多个小任务，任务执行是没有特定的顺序的。

List list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);

list.parallelStream()

.forEach(out::println);

2.2 继承Collection的主要接口

graph LR;

Collection --List-有顺序,可重复

List-有顺序,可重复 --LinkedList-使用链表实现,线程不安全

List-有顺序,可重复 --ArrayList-数组实现,线程不安全

List-有顺序,可重复 --Vector-数组实现,线程安全

Vector-数组实现,线程安全 --Stack-堆栈,先进后出

Collection--Set-不可重复,内部排序

Set-不可重复,内部排序--HashSet-hash表存储

HashSet-hash表存储--LinkHashSet-链表维护插入顺序

Set-不可重复,内部排序--TreeSet-二叉树实现,排序

Collection--Queue-队列,先进先出

2.2.1 List extend Collection

继承于Collection接口，有顺序，取出的顺序与存入的顺序一致，有索引，可以根据索引获取数据，允许存储重复的元素，可以放入为null的元素。

最常见的三个实现类就是ArrayList，Vector,LinkedList，ArrayList和Vector都是内部封装了对数组的操作，唯一不同的是，Vector是线程安全的，而ArrayList不是，理论上ArrayList操作的效率会比Vector好一些。

里面是接口定义的方法：

int size(); //获取大小

boolean isEmpty(); //判断是否为空

boolean contains(Object o); //是否包含某个元素

Iterator iterator(); //获取迭代器

Object[] toArray(); // 转化成为数组(对象)

T[] toArray(T[] a); // 转化为数组(特定位某个类)

boolean add(E e); //添加

boolean remove(Object o); //移除元素

boolean containsAll(Collection c); // 是否包含所有的元素

boolean addAll(Collection extends E c); //批量添加

boolean addAll(int index, Collection extends E c); //批量添加，指定开始的索引

boolean removeAll(Collection c); //批量移除

boolean retainAll(Collection c); //将c中不包含的元素移除

default void replaceAll(UnaryOperator operator) {}//替换

default void sort(Comparator super E c) {}// 排序

void clear();//清除所有的元素

boolean equals(Object o);//是否相等

int hashCode(); //计算获取hash值

E get(int index); //通过索引获取元素

E set(int index, E element);//修改元素

void add(int index, E element);//在指定位置插入元素

E remove(int index);//根据索引移除某个元素

int indexOf(Object o); //根据对象获取索引

int lastIndexOf(Object o); //获取对象元素的最后一个元素

ListIterator listIterator(); // 获取List迭代器

ListIterator listIterator(int index); // 根据索引获取当前的位置的迭代器

List subList(int fromIndex, int toIndex); //截取某一段数据

default Spliterator spliterator(){} //获取可切分迭代器

上面的方法都比较简单，值得一提的是里面出现了ListIterator，这是一个功能更加强大的迭代器，继承于Iterator,只能用于List类型的访问，拓展功能例如：通过调用listIterator()方法获得一个指向List开头的ListIterator，也可以调用listIterator(n)获取一个指定索引为n的元素的ListIterator,这是一个可以双向移动的迭代器。

操作数组索引的时候需要注意，由于List的实现类底层很多都是数组，所以索引越界会报错IndexOutOfBoundsException。

说起List的实现子类：

ArrayList：底层存储结构是数组结构，增加删除比较慢，查找比较快，是最常用的List集合。线程不安全。

LinkedList：底层是链表结构，增加删除比较快，但是查找比较慢。线程不安全。

Vector：和ArrayList差不多，但是是线程安全的，即同步。

2.2.2 Set extend Collection

Set接口，不允许放入重复的元素，也就是如果相同，则只存储其中一个。

下面是源码方法：

int size(); //获取大小

boolean isEmpty(); //是否为空

boolean contains(Object o); //是否包含某个元素

Iterator iterator(); //获取迭代器

Object[] toArray(); //转化成为数组

T[] toArray(T[] a); //转化为特定类的数组

boolean add(E e); //添加元素

boolean remove(Object o); //移除元素

boolean containsAll(Collection c); //是否包含所有的元素

boolean addAll(Collection extends E c); //批量添加

boolean retainAll(Collection c); //移除所有不存在于c集合中的元素

boolean removeAll(Collection c); //移除所有在c集合中存在的元素

void clear(); //清空集合

boolean equals(Object o); //是否相等

int hashCode(); //计算hashcode

default Spliterator spliterator() {} //获取可分割迭代器

主要的子类：

HashSet

允许空值

通过HashCode方法计算获取hash值，确定存储位置，无序。

LinkedHashSet

HashSet的子类

有顺序

TreeSet

如果无参数构建Set，则需要实现Comparable方法。

亦可以创建时传入比较方法，用于排序。

2.2.3 Queue extend Collection

队列接口，在Collection接口的接触上添加了增删改查接口定义，一般默认是先进先出，即FIFO，除了优先队列和栈，优先队列是自己定义了排序的优先顺序，队列中不允许放入null元素。

下面是源码：

boolean add(E e); //插入一个元素到队列，失败时返回IllegalStateException (如果队列容量不够)

boolean offer(E e); //插入一个元素到队列，失败时返回false

E remove(); //移除队列头的元素并移除

E poll(); //返回并移除队列的头部元素，队列为空时返回null

E element(); //返回队列头元素

E peek(); //返回队列头部的元素，队列为空时返回null

主要的子接口以及实现类有：

Deque(接口):Queue的子接口，双向队列，可以从两边存取

ArrayDeque：Deque的实现类，底层用数组实现，数据存贮在数组中

AbstractQueue：Queue的子接口，仅实现了add、remove和element三个方法

PriorityQueue：按照默认或者自己定义的顺序来排序元素，底层使用堆(完全二叉树)实现，使用动态数组实现，

BlockingQueue： 在java.util.concurrent包中，阻塞队列，满足当前无法处理的操作。

(2) Map接口

定义双列集合的规范Map，每次存储一对元素，即key和value。

key的类型可以和value的类型相同，也可以不同，任意的引用类型都可以。

key是不允许重复的，但是value是可以重复的，所谓重复是指计算的hash值系统。

下面的源码的方法：

V put(K key, V value); // 添加元素

V remove(Object key); // 删除元素

void putAll(Map extends K, ? extends V m); // 批量添加

void clear() // 移除所有元素

V get(Object key); // 通过key查询元素

int size(); // 查询集合大小

boolean isEmpty(); // 集合是否为空

boolean containsKey(Object key); // 是否包含某个key

boolean containsValue(Object value); // 是否包含某个value

Set keySet(); // 获取所有key的set集合

Collection values(); // 获取所有的value的set集合

Set entrySet(); // 返回键值对的set，每一个键值对是一个entry对象

boolean equals(Object o); // 用于比较的函数

int hashCode(); // 计算hashcode

default V getOrDefault(Object key, V defaultValue) // 获取key对应的Value，没有则返回默认值()

default void forEach(BiConsumer super K, ? super V action) {} // 遍历

default void replaceAll(BiFunction super K, ? super V, ? extends V function) {} // 批量替换

// 缺少这个key的时候才会添加进去

// 返回值是是key对应的value值，如果不存在，则返回的是刚刚放进去的value

default V putIfAbsent(K key, V value) {}

default boolean remove(Object key, Object value) {} // 移除元素

default boolean replace(K key, V oldValue, V newValue) {} // 替换

default V replace(K key, V value) {} //替换

// 和putIfAbsent有点像，只不过传进去的mappingFunction是映射函数，也就是如果不存在key对应的value，将会执行函数，函数返回值会被当成value添加进去，同时返回新的value值

default V computeIfAbsent(K key,Function super K, ? extends V mappingFunction) {}

// 和computeIfAbsent方法相反，只有key存在的时候，才会执行函数，并且返回

default V computeIfPresent(K key,BiFunction super K, ? super V, ? extends V remappingFunction) {}

// 不管如何都会执行映射函数，返回value

default V compute(K key,BiFunction super K, ? super V, ? extends V remappingFunction) {}

default V merge(K key, V value,BiFunction super V, ? super V, ? extends V remappingFunction) {}

值得注意的是，Map里面定义了一个Entry类，其实就是定义了一个存储数据的类型，一个entry就是一个.

Map的常用的实现子类：

HashMap：由数组和链表组成，线程不安全，无序。

LinkedHashMap：如果我们需要是有序的，那么就需要它，时间和空间效率没有HashMap那么高，底层是维护一条双向链表，保证了插入的顺序。

ConcurrentHashMap：线程安全，1.7JDK使用锁分离，每一段Segment都有自己的独立锁，相对来说效率也比较高。JDK1.8抛弃了Segment，使用Node数组+链表和红黑树实现，在线程安全控制上使用Synchronize和CAS，可以认为是优化的线程安全的HashMap。

HashTable：对比与HashMap主要是使用关键字synchronize，加上同步锁，线程安全。

(二)总结

这些集合原始接口到底是什么？为什么需要？

我想，这些接口其实都是一种规则/规范的定义，如果不这么做也可以，所有的子类自己实现，但是从迭代以及维护的角度来说，这就是一种抽象或者分类，比如定义了Iterator接口，某一些类就可以去继承或者实现，那就得遵守这个规范/契约。可以有所拓展，每个子类的拓展不一样，所以每个类就各有所长，但是都有一个中心，就是原始的集合接口。比如实现Map接口的所有类的中心思想都不变，只是各有所长，各分千秋，形成了大千集合世界。

【作者简介】：

秦怀，公众号【秦怀杂货店】作者，技术之路不在一时，山高水长，纵使缓慢，驰而不息。个人写作方向：Java源码解析，JDBC，Mybatis，Spring，redis，分布式，剑指Offer，LeetCode等，认真写好每一篇文章，不喜欢标题党，不喜欢花里胡哨，大多写系列文章，不能保证我写的都完全正确，但是我保证所写的均经过实践或者查找资料。遗漏或者错误之处，还望指正。

平日时间宝贵，只能使用晚上以及周末时间学习写作，关注我，我们一起成长吧~

怎么才能了解JAVA集合类?集合类是什么?

数组是集合的一种,是集合的一个子集,你理解了数组就理解了集合.

理解集合类

集合类存放于java.util包中。

集合类存放的都是对象的引用，而非对象本身，出于表达上的便利，我们称集合中的对象就是指集合中对象的引用（reference)。

集合类型主要有3种：set(集）、list(列表）和map(映射)。

(1)集

集（set）是最简单的一种集合，它的对象不按特定方式排序，只是简单的把对象加入集合中，就像往口袋里放东西。

对集中成员的访问和操作是通过集中对象的引用进行的，所以集中不能有重复对象。

集也有多种变体，可以实现排序等功能，如TreeSet，它把对象添加到集中的操作将变为按照某种比较规则将其插入到有序的对象序列中。它实现的是SortedSet接口，也就是加入了对象比较的方法。通过对集中的对象迭代，我们可以得到一个升序的对象集合。

(2)列表

列表的主要特征是其对象以线性方式存储，没有特定顺序，只有一个开头和一个结尾，当然，它与根本没有顺序的集是不同的。

列表在数据结构中分别表现为：数组和向量、链表、堆栈、队列。

关于实现列表的集合类，是我们日常工作中经常用到的，将在后边的笔记详细介绍。

(3)映射

映射与集或列表有明显区别，映射中每个项都是成对的。映射中存储的每个对象都有一个相关的关键字（Key）对象，关键字决定了对象在映射中的存储位置，检索对象时必须提供相应的关键字，就像在字典中查单词一样。关键字应该是唯一的。

关键字本身并不能决定对象的存储位置，它需要对过一种散列(hashing)技术来处理，产生一个被称作散列码(hash code)的整数值，散列码通常用作一个偏置量，该偏置量是相对于分配给映射的内存区域起始位置的，由此确定关键字/对象对的存储位置。理想情况下，散列处理应该产生给定范围内均匀分布的值，而且每个关键字应得到不同的散列码。

集合类简介

java.util中共有13个类可用于管理集合对象，它们支持集、列表或映射等集合，以下是这些类的简单介绍

集：

HashSet： 使用HashMap的一个集的实现。虽然集定义成无序，但必须存在某种方法能相当高效地找到一个对象。使用一个HashMap对象实现集的存储和检索操作是在固定时间内实现的.

TreeSet： 在集中以升序对对象排序的集的实现。这意味着从一个TreeSet对象获得第一个迭代器将按升序提供对象。TreeSet类使用了一个TreeMap.

列表：

Vector： 实现一个类似数组一样的表，自动增加容量来容纳你所需的元素。使用下标存储和检索对象就象在一个标准的数组中一样。你也可以用一个迭代器从一个Vector中检索对象。Vector是唯一的同步容器类??当两个或多个线程同时访问时也是性能良好的。

Stack: 这个类从Vector派生而来，并且增加了方法实现栈??一种后进先出的存储结构。

LinkedList: 实现一个链表。由这个类定义的链表也可以像栈或队列一样被使用。

ArrayList: 实现一个数组，它的规模可变并且能像链表一样被访问。它提供的功能类似Vector类但不同步。

映射：

HashTable： 实现一个映象，所有的键必须非空。为了能高效的工作，定义键的类必须实现hashcode()方法和equal()方法。这个类是前面java实现的一个继承，并且通常能在实现映象的其他类中更好的使用。

HashMap： 实现一个映象，允许存储空对象，而且允许键是空（由于键必须是唯一的，当然只能有一个）。

WeakHashMap： 实现这样一个映象：通常如果一个键对一个对象而言不再被引用，键/对象对将被舍弃。这与HashMap形成对照，映象中的键维持键/对象对的生命周期，尽管使用映象的程序不再有对键的引用，并且因此不能检索对象。

TreeMap： 实现这样一个映象，对象是按键升序排列的。

Set和List都是由公共接口Collection扩展而来，所以它们都可以使用一个类型为Collection的变量来引用。这就意味着任何列表或集构成的集合都可以用这种方式引用，只有映射类除外（但也不是完全排除在外，因为可以从映射获得一个列表。）所以说，把一个列表或集传递给方法的标准途径是使用Collection类型的参数

java存储数据一定要拿集合和数组存吗

Java有哪些数据存储方式？基本数据类型分别为byte，short，int，long，double，float，char，boolean。String自定义封装类(PO,VO 等实体类)数组，存储一组数据，可以是基本数据类型，也可以是引用数据类型，但只能是同一类型，并且大小一定。集合类，作用与数组类似，也可以存储一组数据。

java里的数组和集合的区别是什么？

数组是JAVA语言内置的数据类型，它是一个线性的序列，所以它可以快速的访问其他的元素。但是速度是要有代价的，当你创建了一个数组之后，它的容量就固定了，而且在其生命周期里是不能改变的。还有一点，JAVA里面的数组是会做边界检查的，所以当你越界访问时，会抛出RuntimeException，所以不用担心在C或C++因为不做边界检查而出现的问题了，当然边界检查是以牺牲效率为代价的。数组与其它容器类的区别体现在三个方面：效率、类型识别和可以持有primitives。

JAVA里面提供的其他容器还包括List，Set和Map。他们处理对象的时候就好像这些这些对象都没有自己的类型一样，容器将它所含的元素都看成是JAVA中所有类的根类Object类型的，这样我们只需创建一种容器，就能把所有的类型的对象全部放进去。但是当取出的时候，那就需要我们自己进行类型转换了，不过在JAVA Tiger版里面新引入了“泛型”的概念，结合容器类一起使用就可以解决类型转换的问题，关于“泛型”这就不详细讲解了。从上面的角度来看，这种做法很不错，但是就是苦了primitives，如果是常量的话，可以把primitive转换成wrapper类然后放进容器里面，如果是变量的话，那就只能放在你自己的类里了。与其他容器类相比，数组会在编译的时候作类型检查，从而防止你插入错误类型的对象，或者在提取对象的时候把对象的类型给搞错了，JAVA在编译和运行的时候都能阻止你将一个不恰当的消息传给对象。至于效率，数组无疑是要高于其他容器类的，因为有些容器类的实现就是基于数组的，比如ArrayList。不论从类型检查还是效率的角度来考虑，我们首选数组来作为容器都是没错的，但是数组的缺点就是功能太弱了，所以才会有容器类的出现。

要多说几句的就是，java.util包里面有一个Arrays类，它包括了一组可以用于数组的static的工具方法，其中最基本的是四个方法：用来比较两个数组是否相等的equals()；用来填充数组的fill()；用来对数组进行排序的sort()；以及用于在一个已经排序的数组中查找元素的binarySearch()。所有这些方法都对primitives和Object进行了重载。此外还有一个asList()方法，它接受一个数组，然后把它转成一个List容器。JAVA标准类库还提供了一个System.arraycopy()的静态方法，它能以较快的速度拷贝数组，对primitive和Object都进行了重载，但是注意当对Object数组进行拷贝时，进行的是浅拷贝(shallow copy)。

java数组集合类的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java数组是集合吗、java数组集合类的信息别忘了在本站进行查找喔。

The End

发布于：2022-12-22，除非注明，否则均为首码项目网原创文章，转载请注明出处。

标签：