本篇文章为你整理了集合入门（集合入门基础知识视频讲解）的详细内容，包含有集合入门题 集合入门基础知识视频讲解 集合入门讲解 集合快速入门 集合入门，希望能帮助你了解 集合入门。
集合类的特点：提供一种存储空间可变的存储模型，存储的数据容量可以随时发生改变。
Collection：单列（接口）
概述：
是单列集合的顶层接口，表示一组对象，这些对象也成为Cpllection的元素
JDK不提供此接口的任何直接实现，它提供更具体的子接口（如List和Set）实现
实现方法
//创建Collection集合的对象
Collection String c = new ArrayList String
//添加元素：boolean add (E e)
c.add("hello");
c.add("My");
c.add("java");
//输出集合对象
System.out.println(c);
常用方法
System.out.println(c.remove("World"));//true
System.out.println(c.remove("world"));//false
//清空集合所有元素
c.clear();
//判断集合中是否存在指定元素
System.out.println(c.contains("World"));//true
System.out.println(c.contains("javaSE"));//false
//判断集合是否为空
System.out.println(c.isEmpty());
//查看集合长度
System.out.println(c.size());//3
//输出集合对象
System.out.println(c);
遍历
Iterator：迭代器，集合的专用遍历方式
迭代器是通过集合的iterator()方法得到的，所以我们说他是依赖集合而存在的
常用方法
E next():返回迭代中的下一个元素
boolean hasNext():如果迭代器具有更多的元素，返回true
Collection String c=new ArrayList ();
c.add("hello");
c.add("World");
c.add("World");
//返回此集合中的迭代器，通过集合的iterator方法得到
Iterator String it = c.iterator();
//源码：
public Iterator E iterator() {
return new Itr();
private class Itr implements Iterator E {
System.out.println(it.next());
System.out.println(it.next());//抛出异常:NoSuchElementException 元素不存在
//判断是否还有元素；hasNext()
if (it.hasNext()){
System.out.println(it.next());
if (it.hasNext()){
System.out.println(it.next());
if (it.hasNext()){
System.out.println(it.next());
if (it.hasNext()){
System.out.println(it.next());
//用while改进判断
while(it.hasNext()){
//System.out.println(it.next());
String s=it.next();
System.out.println(s);
@Description TODO 创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合
Collection Student students=new ArrayList ();
Student s1=new Student("钟无艳",201,21,"男",80.99);
Student s2=new Student("诸葛亮",202,22,"男",99.99);
Student s3=new Student("伽罗",203,23,"女",80.80);
students.add(s1);
students.add(s2);
students.add(s3);
Iterator Student it = students.iterator();
while (it.hasNext()) {
Student s =it.next();
System.out.println(s.getName() + , + s.getId() + , + s.getAge() + , + s.getSex() + , + s.getGrade());
有序集合（也称为序列），用户可以精确控制列表中每个元素的插入位置，用户可以通过整数索引访问元素，并搜索列表中的元素
与Set集合不同，列表通常允许重复的元素
List String l=new ArrayList ();
l.add("hello");
l.add("world");
l.add("java");
l.add("world");
System.out.println(l);
Iterator String it = l.iterator();
while (it.hasNext()){
String s=it.next();
System.out.println(s);
特有方法：
list.add(1,"javaee");//[hello, javaee, world, java]
list.add(11,"javaee");//[hello, javaee, world, java] //越界异常IndexOutOfBoundsException
list.remove(1); //[hello, world, java]
list.set(1,"javaee"); //[hello, javaee, java]
System.out.println(list.get(1)); //javaee
System.out.println(list);
//用for循环使用get()方法遍历集合
for (int i = 0; i list.size(); i++)
String s=list.get(i);
System.out.println(s);
@Description TODO 创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合
List Student list = new ArrayList ();
Student s1 = new Student("钟无艳", 201, 21, "男", 80.99);
Student s2 = new Student("诸葛亮", 202, 22, "男", 80.99);
Student s3 = new Student("伽罗", 203, 23, "男", 80.99);
list.add(s1);
list.add(s2);
list.add(s3);
Iterator Student it = list.iterator();
while (it.hasNext()) {
Student s =it.next();
System.out.println(s.getName() + , + s.getId() + , + s.getAge() + , + s.getSex() + , + s.getGrade());
System.out.println("--------------------");
for (int i = 0; i list.size(); i++) {
Student s = list.get(i);
System.out.println(s.getName() + , + s.getId() + , + s.getAge() + , + s.getSex() + , + s.getGrade());
并发修改异常
@Description TODO 遍历集合，得到每一个元素，检查是否有“world”这个元素，如果有，就添加一个“javaee”元素
List String list = new ArrayList ();
list.add("hello");
list.add("world");
list.add("java");
Iterator String it = list.iterator();
while (it.hasNext()) {
String s=it.next();//抛出异常：ConcurrentModificationException：并发修改异常
if (s.equals("world")){
list.add("javaee");
for (int i = 0; i list.size() ; i++) {
String s=list.get(i);
if (s.equals("world")){
list.add("javaee");
}//succeed
System.out.println(list);
源码如下：
public interface List E {
Iterator E iterator();
boolean add(E e);
public abstract class AbstractList E {
protected int modCount = 0;
public class ArrayList E extends AbstractList E implements List E {
public E get(int index) {
Objects.checkIndex(index, size);
return elementData(index);
}//没有实际修改集合的次数和预期修改集合的次数的判断
public boolean add(E e) {
modCount++;//实际修改集合次数++
add(e, elementData, size);
return true;
public Iterator E iterator() {
return new Itr();
private class Itr implements Iterator E {
int expectedModCount = modCount;
modCount:实际修改集合的次数
expectedModCount：预期修改集合的次数
开始都为0
public E next() {
checkForComodification();
int i = cursor;
if (i = size)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
if (i = elementData.length)
throw new ConcurrentModificationException();
cursor = i + 1;
return (E) elementData[lastRet = i];
final void checkForComodification() {
if (modCount != expectedModCount)//判断是否相等，modCount++，与expectedModCount不相等
throw new ConcurrentModificationException();
ListIterator :列表迭代器
继承于Iterator，用于程序员沿任意方向遍历列表的迭代器，在迭代期间修改列表，并获取列表中迭代器的当前位置。
E next() ：返回迭代中的下一个元素
boolean hasNext() ：如果迭代具有更多元素，返回true
E previus ：返回列表中上一个元素
bookean hasPrevious() ：如果列表迭代器在相反方向遍历列表时具有更多元素，则返回true
void add(E e) ：将指定的元素插入列表
增强for循环 ：简化数组和Collection集合的遍历
实现Iterable接口的类允许其对象称为增强型for语句的目标
内部原理是一个Iterator迭代器
for(元素数据类型 变量名：数组或Collection集合){
//在此处使用变量即可，该变量就是元素
int[] arr={1,2,3,4,5};
for(int i:arr){
System.out.println(i);
int[] arr = {1, 2, 3, 4, 5};
for (int i : arr) {
System.out.println(i);
System.out.println("--------");
String[] stArray = {"hello", "world", "java"};
for (String s : stArray) {
System.out.println(s);
System.out.println("-----------");
List String list=new ArrayList ();
list.add("hello");
list.add("world");
list.add("java");
for (String s:list){
System.out.println(s);
System.out.println("-----------");
//内部是一个Iterator迭代器
for (String s:list){
if (s.equals("world")){
list.add("javaee"); //并发修改异常：ConcurrentModificationException;因此内部是一个Iterator迭代器
```
至此，共有三种方式遍历集合：①迭代器—集合特有的遍历方式。②普通for—带有索引的遍历方式。③增强for—最方便的遍历方式。
若只为了遍历，选择增强for的方式
若使用到了索引，则选择普通for的方式
数据结构：
栈：先进后出
队列：先进先出
数组：查询快、增删慢的模型
链表：增删快、查询慢的模型
⭐ArrayList（实现类）
ArrayList的底层数据结构是数组 ，查询快、增删慢
LinkedList（实现类）
LinkedList的底层数据结构是链表，查询慢，增删快
LinkedList集合的特有方法
哈希值是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值
Object类中的public int hashCode()可以获取对象的哈希值
对象的哈希值的特点 ：
底层数据结构是哈希表
对集合的迭代顺序不做任何保证，也就是说不保证存储和去除的元素顺序一致
没有带索引的方法，所以不能使用普通for循环遍历
由于是Set集合，所以是不包含重复元素的集合
HashSet String hashSet=new HashSet ();
hashSet.add("hallo");
hashSet.add("world");
hashSet.add("java");
for (String s :hashSet){
System.out.println(s);
HashSet集合保证元素唯一性源码分析
HashSet String hashSet=new HashSet ();
hashSet.add("hallo");
hashSet.add("world");
hashSet.add("java");
-------------------------------------------------
public boolean add(E e) {
return map.put(e, PRESENT)==null;
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h 16);
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
//hash值和元素的hashCode()方法相关
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {
Node K,V [] tab; Node K,V int n, i;
//如果哈希表美亚由初始化，就对其初始化
if ((tab = table) == null (n = tab.length) == 0)
n = (tab = resize()).length;
//根据对象的哈希值计算对象的存储位置，如果该位置没有元素就存储元素
if ((p = tab[i = (n - 1) hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node K,V K k;
存入的元素和以前的元素比较哈希值
如果哈希值不同，会继续向下执行，把元素添加到集合
如果哈希值相同，会调用对象的equals()方法进行比较
如果返回false，说明元素重复，不存储
if (p.hash == hash
((k = p.key) == key (key != null key.equals(k))))
e = p;
else if (p instanceof TreeNode)
e = ((TreeNode K,V )p).putTreeVal(this, tab, hash, key, value);
else {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount = TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
if (e.hash == hash
((k = e.key) == key (key != null key.equals(k))))
break;
p = e;
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
++modCount;
if (++size threshold)
resize();
afterNodeInsertion(evict);
return null;
LinkedHashSet（实现类）
继承于HashSet
由哈希表和链表实现的Set接口，具有可预测的迭代次序
由链表保证元素有序，也就是说元素的存储和取出顺序是一致的
由哈希表保证元素唯一，也就是说没有重复的元素
LinkedHashSet String linkedHashSet=new LinkedHashSet ();
linkedHashSet.add("hello");
linkedHashSet.add("world");
linkedHashSet.add("java");
linkedHashSet.add("world");
for (String s:linkedHashSet){
System.out.println(s);//hello world java
TreeSet（实现类）
特点：
元素有序，这里的顺序不是指存储和去除的顺序，而是按照一定的规则进行排序，具体排序方式取决于构造方法
TreeSet()：根据其元素的自然排序进行排序
TreeSet(Comparator comparator)：根据指定的比较器进行排序
用TreeSet集合存储自定义对象，无参构造方法使用的是自然排序对元素进行排序的
自然排序，就是让元素所属的类实现Comparable接口，重写compareTo(To)方法
重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写
public class Student implements Comparable Student {
@Override
public int compareTo(Student s) {
//return 0;
//return 1;
//return -1;
int num = this.age - s.age;
int num2 = num == 0 ? this.name.compareTo(s.name) : num;
return num2;
---------------------------------------------------------------------
return 0:输出结果为duheng,21 认为s2和s1是同一个元素
return 1:输出结果为duheng,21 love,18 chencui,22 认为s1比s2大，因此按照存储顺序输出
return -1:输出结果为chencui,22 love,18 duheng,21 认为s2比s1大，因此按照存储顺序逆向输出
return num = this.age-s.age: love,18 duheng,21 chencui,22 this即为s2,按照升序排列
return num = s.age-this.age: chencui,22 duheng,21 love,18 this即为s2,按照降序排列
int num = this.age - s.age;
int num2 = num == 0 ? this.name.compareTo(s.name) : num; //年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
return num2;
/* * 存储学生对象并遍历，创建TreeSet集合使用无参构造方法
* 按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序*/
public static void main(String[] args) {
//创建集合对象
TreeSet Student ts = new TreeSet ();
Student s1=new Student("dyxx",21);
Student s2=new Student("love",18);
Student s3=new Student("zhulu",22);
Student s4=new Student("sss",18);
ts.add(s1);
ts.add(s2);
ts.add(s3);
ts.add(s4);
for (Student s:ts){
System.out.println(s.getName()+","+s.getAge());//Exception ClassCastException Comparable
//因此需要让Student实现Comparable接口，并重写方法compareTo方法
比较器排序Comparator的使用
用TreeSet集合存储自定义对象，无参构造方法使用的是自然排序对元素进行排序的
比较器排序，就是让集合构造方法接收Comparator的实现类对象，重写compareTo(To1,To2)方法
重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写
//创建集合对象
TreeSet Student ts = new TreeSet (new Comparator Student () {
@Override
public int compare(Student s1, Student s2) {
int num = s1.getAge() - s2.getAge();
int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
return num2;
Student s1=new Student("duheng",21);
Student s2=new Student("chencui",22);
Student s3=new Student("love",18);
ts.add(s1);
ts.add(s2);
ts.add(s3);
for (Student s:ts){
System.out.println(s.getName()+","+s.getAge());//Exception ClassCastException Comparable
将类型由原来的具体的类型参数化，然后在使用/调用时传入具体的类型，这种参数类型可以用在类、方法和接口中，分别为泛型类、泛型方法、泛型接口
定义格式=：
类型 ：指定一种类型的格式。这里的类型可以看成时形参
类型1，类型2... ：指定多种类型的格式，多种类型之间用逗号隔开。这里的类型可以看成时形参
将来具体调用时候给定的类型可以看成是实参，并且实参的类型只能是引用数据类型
好处：
把运行时期的问题提前到了编译期间
避免了强制类型转换
//创建集合对象
//Collection c=new ArrayList();
Collection String c = new ArrayList ();//100报错：提前报错 迭代器中类型自动为String类型，不需要强转
c.add("hello"); //将字符串赋值给object——向上转型
c.add("world");
c.add("java");
//c.add(100);//自动封装为Integer
// Iterator t = c.iterator();
Iterator String t = c.iterator();
while (t.hasNext()) {
// Object obj=t.next();
// System.out.println(obj);
// String s= (String) t.next();//100:ClassCastException:因此课采用泛型来解决
String s = t.next();
System.out.println(s);
定义格式：
范例：public class Generic T {}
此处的T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型
List ? :表示元素类型未知的List，他的元素可以匹配任何的类型
这种带通配符的List仅表示它是各种泛型List的父类，并不能把元素添加到其中
如果我们不希望List ? 是任何泛型List的父类，只希望它代表某一类泛型List的父类，可以使用类型通配符的上限
类型通配符上限： ?extends 类型
List ? extends Number :他表示的类型是Number或者其子类型
除了可以指定类型通配符的上限，也可以指定类型通配符的下限
类型通配符下限： ?super 类型
List ? super Number :他表示的类型是Number或者其父类型
//类型通配符List ?
List ? list1 = new ArrayList Object
List ? list2 = new ArrayList Number
List ? list3 = new ArrayList Integer
System.out.println("---------");
//类型通配符上限
List ? extends Number list4= new ArrayList Object //上限是Number，不能是Number父类Object
List ? extends Number list5 = new ArrayList Number
List ? extends Number list6 = new ArrayList Integer
//类型通配符下限
List ? super Number list7 =new ArrayList Object
List ? super Number list8 =new ArrayList Number
List ? super Number list9 =new ArrayList Integer //下限是Number，不能是Number的子类Integer
可变参数又称参数个数可变，用作方法的形参出现，那么方法参数个数就是可变的了
格式：修饰符 返回值类型 方法名(数据类型... 变量名){}
范例：public static int sum(int... a){}
public static void main(String[] args) {
System.out.println(sum(10, 20));
System.out.println(sum(10, 20, 30));
System.out.println(sum(10, 20, 30, 40));
System.out.println(sum(10, 20, 30, 40, 50));
System.out.println(sum(10, 20, 30, 40, 50, 60));
System.out.println(sum(10, 20, 30, 40, 50, 60, 70));
public static int sum(int... a) {//a是数组
int sum = 0;
for (int i : a) {
sum += i;
return sum;
public static int sum(int b,int... a){//一个方法有多个参数，包含可变参数的情况下，可变参数放在最后
return 0;
/*public static int sum(int a,int b){
return a+b;
public static int sum(int a,int b,int c){
return a+b+c;
public static int sum(int a,int b,int c,int d){
return a+b+c+d;
可变参数的使用
Arrays工具类中有一个静态方法：
public static T List T asList(T... a):返回由指定数组支持的固定大小的列表
返回的集合不能做增删操作，可以修改
List接口中有一个静态方法：
public static E List E of(E... elements):返回包含任意数量元素的不可变列表
返回的集合不能做增删改操作
Arrays工具类中有一个静态方法：
public static E Set E of(E... elements):返回一个包含任意数量元素的不可变集合
在给元素时不能给重复元素
返回的集合不能做增删操作，没有修改方法
List String list = Arrays.asList("hello", "world", "java");//这样做就不用一个个add了
list.add("javaee"); //UnsupportedOperationException:不支持所请求的操作
list.remove("java"); //UnsupportedOperationException
list.set(1,"javaee");//success 数组大小固定，不能添加删除，但是内容可改变
System.out.println(list);
list.add("javaee"); //UnsupportedOperationException:不支持所请求的操作
list.remove("java"); //UnsupportedOperationException
list.set(1,"javaee");//UnsupportedOperationException of：增删改都不可以
System.out.println(list);
Set String set=Set.of("hello", "world", "java","world"); //IllegalArgumentException:非法或不适当的参数
Set String set=Set.of("hello", "world", "java");
set.add("javaee");//UnsupportedOperationException
set.remove("javaee");//UnsupportedOperationException
//set无索引，没有set方法
Map：双列（接口）
概述：
interface Map K,V K:键的类型；V:值的类型
将键映射到值的对象；不能包含重复的键；每个键可以映射到最多一个值
举例：学生的学号和姓名
201 诸葛
202 亮
203 钟无艳
map.put("194070201","诸葛亮");//put(K key, V value)将指定的值与此映射中的指定键相关联
map.put("194070202","钟无艳");
map.put("194070203","伽罗");
map.put("194070203","刘");//当键重复时，就会修改元素，替代掉以前的值{194070201=杜恒, 194070202=杜, 194070203=陈}
System.out.println(map); //{201=刘, 202=王, 203=李}
Map集合的基本功能
//System.out.println(map.remove("郭靖"));//黄蓉 {杨过=小龙女, 张无忌=赵敏}
//System.out.println(map.remove("郭襄"));//null {杨过=小龙女, 张无忌=赵敏}
//map.clear();// {}慎重使用
//System.out.println(map.containsKey("郭靖"));//true
//System.out.println(map.containsKey("郭襄"));//false
//System.out.println(map.containsValue("小龙女"));//true
//System.out.println(map.containsValue("郭芙"));//false
System.out.println(map.isEmpty());//false
System.out.println(map.size());//3
//输出集合对象
System.out.println(map);
Map集合的获取功能
System.out.println(map.get("张无忌"));//赵敏
System.out.println(map.get("张三丰"));//null
Set String keyset = map.keySet();
for(String key:keyset){
System.out.println(key); //杨过 郭靖 张无忌
Collection String values = map.values();
for (String value:values){
System.out.println(value); //小龙女 黄蓉 赵敏
Map集合的遍历
我们刚才存储的元素时成对出现的，所以可以把Map看成是一个夫妻对的集合
遍历思路
把所有的丈夫集中起来
遍历丈夫的集合，获取到每一个丈夫
根据丈夫去找对应的妻子
转换为Map集合中的操作：
获取所有键的集合，用keySet()方法实现
遍历键去找值，获取到每一个键，用增强for实现
根据键去找值，用get(object key)方法实现
//创建集合对象
Map String, String map = new HashMap ();
//添加元素
map.put("张无忌","赵敏");
map.put("郭靖","黄蓉");
map.put("杨过","小龙女");
Set String keySet = map.keySet();
for (String key:keySet){
String value = map.get(key);
System.out.println(key+","+value);
我们刚才存储的元素时成对出现的，所以可以把Map看成是一个夫妻对的集合
遍历思路
获取所有结婚证的集合
遍历结婚证的集合，获取到每一个结婚证
根据结婚证去找对应的丈夫妻子
转换为Map集合中的操作：
获取所有键值对对象的集合，用entrySet()方法实现
Set Map.entry K,V entrySet():获取所有键值对对象的结合
遍历键值对对象的集合，获取到每一个键每一个键值对对象
用增强for实现，得到每一个Map.Entry
Set Map.Entry String, String entrySet = map.entrySet();
for (Map.Entry String, String s : entrySet) {
String key = s.getKey();
String value = s.getValue();
System.out.println(key + "," + value);
Student value=hm.get(key);
System.out.println(key+","+value.getName()+,+value.getAge());
System.out.println("---------");
Set Map.Entry String, Student entries = hm.entrySet();
for (Map.Entry String,Student me:entries){
String key=me.getKey();
Student value=me.getValue();
System.out.println(key+","+value.getName()+,+value.getAge());
实例：键是String 值是Student
public class HashMapDemo {
public static void main(String[] args) {
HashMap Student, String hm = new HashMap ();
Student s1 = new Student("林青霞", 30);
Student s2 = new Student("汤家凤", 35);
Student s3 = new Student("张曼玉", 36);
Student s4 = new Student("张曼玉", 36);
hm.put(s1, "西安");
hm.put(s2, "北京");
hm.put(s3, "重庆");
hm.put(s3, "重庆");
hm.put(s4, "上海");
Set Student keySet = hm.keySet();
for (Student key : keySet) {
String value = hm.get(key);
System.out.println(key.getName() + , + key.getAge() + , + value);
public class Student {
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null getClass() != o.getClass()) return false;
Student student = (Student) o;
if (age != student.age) return false;
return name != null ? name.equals(student.name) : student.name == null;
@Override
public int hashCode() {
int result = name != null ? name.hashCode() : 0;
result = 31 * result + age;
return result;
public String getName() {
return name;
public void setName(String name) {
this.name = name;
public int getAge() {
return age;
public void setAge(int age) {
this.age = age;
以上就是集合入门（集合入门基础知识视频讲解）的详细内容，想要了解更多 集合入门的内容，请持续关注盛行IT软件开发工作室。
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。