集合：Collection详解.

小鱼儿 2023-09-30 10:37 35阅读 0赞

## 目录： ##

> 一、集合概述  
> 二、集合继承关系图【图重点 要会看源码 背会】  
> 三、Collection接口常用方法  
> 四、关于集合的迭代/遍历【重点】  
> 五、List 和 Set集合存储元素的特点  
> 六、contains方法深刨解析【重点】  
> 七、remove()方法深刨解析  
> 八、关于集合中元素的删除 p518  
> 九、List接口特有方法  
> 十、ArrayList集合初始化容量及扩容  
> 十一：泛型  
> 十二、增强for循环：foreach  
> 十三、演示HashSet集合特点  
> 十四、演示TreeSet集合特点

## 一、集合概述 ##

#### **1.1、什么是集合？有什么用** ####

> 数组其实就是一个集合。集合实际上就是一个容器。可以来容纳其它类型的数据。
> 
> 集合为什么说在开发中使用较多?  
> 集合是一个容器，是一个载体，可以一次容纳多个对象。  
> 在实际开发中，假设连接数据库，数据库当中有10条记录,  
> 那么假设把这10条记录查询出来，在java程序中会将10条  
> 数据封装成10个java对象，然后将10个java对象放到某一个  
> 集合当中，将集合传到前端，然后遍历集合，将一个数据一个  
> 数据展现出来。

#### 1.2、集合中储存什么 ####

> 集合不能直接存储基本数据类型,另外集合也不能直接存储java对象，  
> 集合当中存储的都是java对象的内存地址。(或者说集合中存储的是引用。)  
> list.add(100) ; //自动装箱Integer  
> 注意:  
> 集合在java中本身是一个容器，是一个对象。  
> 集合中任何时候存储的都是"引用”。/ 对象内存地址

**内存图如下：**

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16][]

## 二、集合继承关系图【图重点 要会看源码 背会】 ##

> 在java中集合分为两大类:  
> 一类是单个方式存储元素:  
> 单个方式存储元素，这一类集合中超级父接口: java.util.Collection;  
> 一类是以键值对儿的方式存储元素  
> 以键值对的方式存储元素，这一类集合中超级父接口: java.util.Map;

**第一类：Collection**

## ![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 1][] ##

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 2][]

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 3][]

**第二类：Map**

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 4][]

## 总结：所有的实现类 ##

> ArrayList:底层是数组  
> LinkedList:底层是双向链表  
> Vector:底层是数组，线程安全的，效率较低，使用较少  
> HashSet:底层是HashMap，放到HashSet集合中的元素等同于放到HashMap集合key  
> 部分了  
> TreeSet:底层是TreeMap，放到TreeSet集合中的元素等同于放到TreeMap集合key部  
> 分了  
> HashMap:底层是哈希表  
> Hashtable:底层也是哈希表，只不过线程安全的，效率较低，使用较少了  
> Properties:是线程安全的,并且key和value只能存储字符串String  
> TreeMap:底层是二叉树。TreeMap集合的key可以自动按照大小顺序排序
> 
> List集合存储元素的特点:  
> 有序可重复。  
> 有序:存进去的顺序和取出的顺序相同，每一个元素都有下标  
> 可重复:存进去1，可以再存储一个1
> 
> Set集合存储元素的特点:。  
> 无序不可重复。  
> 无序:存进去的顺序和取出的顺序不一定相同。另外Set集合中元素没有下标  
> 不可重复:存进去1，不能再存储1了
> 
> SortedSet (SortedMap) 集合存储元素特点:。  
> 首先是无序不可重复的(因为继承了Set集合)，但是SortedSet集合中的元素是可排序的  
> 无序:存进去的顺序和取出的顺序不一定相同。另外Set集合中元素没有下标  
> 不可重复:存进去1，不能再存储1了  
> 可排序:可以按照大小顺序排列
> 
> ##  ##

## 三、Collection接口常用方法 ##

> 1、Collection集合中不能直接储存基本数据类型,也不能储存java对象,只能储存java对象的内存地址(引用)
> 
> 2、Collection中的常用方法(因为Collection为父类 所以我们研究父类就相当于研究了子类)  
> boolean add(E e) 向集合中添加元素  
> int size() 获取集合中的元素个数  
> boolean remove(Object e) 删除集合中某个元素  
> boolean contains(Object e) 判断集合中是否包含指定的元素  
> void clear() 清除集合内的元素  
> boolean isEmpty() 判断该集合元素是否为0  
> Object\[\] toArray() 调用这个方法把集合转换成数组 \[了解即可\]

**代码演示如下：**

public class CollectionTest01 {
        public static void main(String[] args) {
            // 创建一个集合对象
            // Collection s =new Collection();   // 接口是抽象的,无法实例化
            // 多态
            Collection c =new ArrayList();  // ArrayList实现了Collection[非抽象类实现抽象类必须子类必须重写抽象类方法]
            // 测试Collection接口中的常用方法
            c.add(100); // 自动装箱 实际上放进去了一个对象的内存地址. Integer x =new Integer(1200); 实际上把引用x放进去了
            c.add(3.14); // 自动装箱
            c.add(new Object()); // 自动装箱
            c.add(new Student()); // 自动装箱
    
            // 集合中的元素个数
            System.out.println("集合中的元素个数："+c.size());   // 4
    
            // 判断集合中是否包含指定的元素
            // 如集合中是否包含3.14
            boolean s =c.contains(3.14);    // 自动装箱
            System.out.println(s);  // true
    
            // 从集合中删除指定元素
            c.remove(3.14);    // 自动装箱
            System.out.println("删除指定元素后集合中的元素个数："+c.size());    // 3
    
            // 清空集合元素
            c.clear();
            System.out.println("清空集合内的元素后集合中的元素个数："+c.size());  // 0
    
            // 判断集合中元素是否为空
            System.out.println("集合中元素是否为空："+c.isEmpty());   // true
        }
    }
    
    class Student{
    
    }

## 四、关于集合的迭代/遍历【重点】 ##

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 5][]

**代码演示如下：**

package com.bjpowernode.javase.collection;
    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Iterator;
    /*
    关于集合迭代/遍历(重点)
     */
    public class CollectionTest02 {
        public static void main(String[] args) {
            // 创建集合对象
            Collection c =new ArrayList();
            // 向集合中添加元素
            c.add(100);
            c.add(3.14);
            c.add("hello");
            c.add(new Object());
    
            // 对集合中的元素进行迭代
            // 第一步：获取集合对象的迭代器对象Iterator
            Iterator i =  c.iterator();
    
            // 第二步：通过以上获取的迭代器对象开始迭代/遍历集合
            // if (i.hasNext()){   // 调用迭代器对象Iterator中的HasNext方法 先判断集合是否还有元素可以迭代
            //    Object o =i.next(); // 注意：add存进去的是什么类型元素,取出来还是什么类型元素(自动装/拆箱)]
            //    System.out.println(o); // 只不过输出的时候会转换成字符串,因为这里println会调用toString()方法
            // }
    
            // 改进
            while (i.hasNext()){
                System.out.println(i.next());
            }
        }
    }

**输出结果：**

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 6][]

## 五、List 和 Set集合存储元素的特点 ##

> List：有序可重复 Set：无序不可重复

**List集合对象代码演示如下：**

package com.bjpowernode.javase.collection;
    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Iterator;
    
    public class CollectionTest03 {
        public static void main(String[] args) {
            // 创建List集合对象
            // ArrayList集合： 有序可重复
    
            // 有序： 存进去的元素顺序和取出来的元素顺序相同
            // 可重复： 比如存过1元素,还可以存1元素
    
            Collection c =new ArrayList(); // (ArrayList实现了List接口 关系看上述图)
            // 往集合中添加元素
            c.add(1); // 自动装箱
            c.add(2);
            c.add(3);
            c.add(4);
            c.add(5);
            c.add(1);
    
            // 对集合中的元素进行迭代
            Iterator it =c.iterator();  // 迭代器对象
            while (it.hasNext()){
                System.out.println(it.next());
            }
        }
    }

**输出结果：**

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 7][]

**Set集合对象代码演示如下：**

package com.bjpowernode.javase.collection;
    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.HashSet;
    import java.util.Iterator;
    
    public class CollectionTest03 {
        public static void main(String[] args) {
            // 创建Set集合对象
            // HashSet集合： 无序不可重复
    
            // 无序： 存进去的元素顺序和取出来的元素顺序不一定相同
            // 不可重复： 比如存过1元素,不可以再存1元素,再存1的话也拿不出来
    
            Collection c =new HashSet(); // (HashSet实现了Set接口 关系看上述图)
            // 往集合中添加元素
            c.add(1); // 自动装箱
            c.add(2);
            c.add(3);
            c.add(4);
            c.add(5);
            c.add(1);   // 拿不出来了 重复
    
            // 对集合中的元素进行迭代
            Iterator it =c.iterator();  // 迭代器对象
            while (it.hasNext()){
                System.out.println(it.next());
            }
        }
    }

**输出结果：**

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 8][]

## 六、contains方法深刨解析【重点】 ##

> 总结： contains方法是用来判断集合中是否包含某个元素的方法,  
> 那么它在底层是怎么判断集合中是否包含某个元素的呢?  
> 调用了equals方法进行比对。(String类重新了父类equals()方法、equals比较的是对象的中内容)
> 
> ！！！！！以后放入集合中对象级别的元素时比如User类,记得一定要重写equals()方法

**代码演示如下：**

package com.bjpowernode.javase.collection;
    import java.util.ArrayList;
    import java.util.Collection;
    
    public class CollectionTest04 {
        public static void main(String[] args) {
    
            // 创建一个集合对象
            Collection c =new ArrayList();
    
            // 向集合中添加元素
            String s1 =new String("junker");
            c.add(s1);
    
            String s2 =new String("jun");
            c.add(s2);
    
            String s3 = new String("Dog");
            c.add(s3);
    
            System.out.println("集合中元素的个数："+c.size());
    
            // 判断c集合中是否包含s4
            String s4 =new String("jun");
            boolean s =c.contains(s4);    // 虽然集合中存放的是对象的内存地址,但是contains底层调用了equals()方法,String类当中重写了父类Object的equals()方法所以比较的还是对象内容
    
    //注意：父类Object的equals()方法其实比较的还是内存地址,需要我们重写之后才能判断对象内容
            System.out.println(s);  // true    
            /*
    
            总结： contains方法是用来判断集合中是否包含某个元素的方法,
            那么它在底层是怎么判断集合中是否包含某个元素的呢?
                    调用了equals方法进行比对。(String类重新了父类equals()方法、equals比较的是对象的中内容)
    
             */
        }
    }

#### **eg：当存放到集合里面的元素不是String类型的时候：contains比较是否有该元素的时候,记得重写equals方法** ####

**代码演示如下：**

package com.bjpowernode.javase.collection;
    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Objects;
    
    public class CollectionTest05 {
        public static void main(String[] args) {
    
            // 创建集合对象
            Collection c =new ArrayList();
            //向集合中添加元素
            c.add(new User("jun"));
            c.add("junker");
    
            User user =new User("jun");
            // 判断集合当中是否存在了user对象元素
    
            // User类当中没有重写equals()方法时：
            // System.out.println(c.contains(user));   // false
    
            // 结论；false的原因是contains()方法底层调用了equals()方法进行比较两个对象的内容是否相同的,
            // 但是User类没有重写父类Object的equals()方法,而父类当中的equals是用“==”判断两个对象的,“==”判断的是两个对象的内存地址,
            // 因此要判断集合当中两个对象的内容是否重复了 需要对User重写父类的equals()方法 进而比较两个对象的name
    
            // 重写父类的equals()方法后：(比较对象中的内容“jun”)
            System.out.println(c.contains(user));   // true
    
    
        }
    }
    
    class User{
        private String name;
    
        public User(String name) {
            this.name = name;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        // 重写父类Object的equals()方法
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            User user = (User) o;
            return this.name == user.name;
        }
    }

## 七、remove()方法深刨解析 ##

> remove()方法底层调用的也是equals()方法 因此我们以后往集合里面存放元素的时候一定要重写equals()方法

**代码演示如下：**

## 八、关于集合中元素的删除 p518 ##

**代码演示如下：**

package com.bjpowernode.javase.collection;
    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Iterator;
    /*
        重点： 当集合的结构发生改变时,迭代器必须重新获取,如果还是用以前的老的迭代器对象 那么会出现异常：ConcurrentModificationException
    
        重点： 在迭代集合元素的过程中,不能调用集合对象的remove方法删除元素
     */
    
    public class CollectionTest06 {
        public static void main(String[] args) {
    
            // 创建集合对象
            Collection c =new ArrayList();
    
            // 向集合中添加元素(集合的结构)
            c.add("adf");
            c.add("qwe");
            c.add("zxc");
            c.add("ghj");
    
            // 获取迭代器对象
            Iterator it =c.iterator();// 此时迭代器相当于一个快照 已经把上面集合的结构闪拍下来了
            while (it.hasNext()){
                Object o =it.next();
                // c.remove("adf");   //异常 此处不可以使用集合c.remove()的方法删除元素, 因为迭代器已经把上面当时的结构闪拍下来了,不能对其修改了 想要修改还需要再次获取迭代器对象
                // 但可以通过迭代器对象进行删除元素
                it.remove();
                System.out.println(o);
            }
            System.out.println(c.size());    // 0
        }
    }

**输出结果如下：**

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 9][]

## 九、List接口特有方法【重点】 ##

> 测试ist接口中常用方法  
> 1、List集合存储元素特点:有序可重复  
> 有序:List集合中的元素有下标。  
> 从0开始，以1递增。  
> 可重复:存储-个1 ,还可以再存储1.
> 
> 2、List既然是Collection接口的子接口,那么肯定List接口有自己“特有”的方法：  
> 一下只列出List接口特有的常用的方法：  
> void add(int index,E element)  
> E get(int index)  
> int indexOf(Object o)  
> int lastIndexOf(Object o)  
> E remove(int index)  
> E set(int index,E element) // E为Object

**代码演示如下：**

package com.bjpowernode.javase.collection;
    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List;
    
    
    public class CollectionTest07 {
        public static void main(String[] args) {
            // 创建List类型的集合
            List l =new ArrayList();
    
            // 添加元素
            l.add("A"); // List接口继承Collection接口,所以继承了Collection中的方法
            l.add("B");
    
            // 1、List接口当中独有的方法  void add(int index,E element)
            l.add(1,"hello");
            // 由结果可知： 在列表的指定位置插入指定元素(第一个元素是下标)
            // 这个方法使用不多,因为对于ArrayTest集合来说效率比较低(因为ArrayTest底层是数组,当在数组中插入一个元素后,后面的数组元素需要自动排序)
    
            // 迭代
            Iterator it =l.iterator();
            while (it.hasNext()){
                System.out.println(it.next());
            }
    
            // 2、E get(int index)   根据下标获取元素
            System.out.println(l.get(0));   // A    集合中0下标中的元素
    
            // 因为有下标 所以List集合有自己比较特殊的遍历方式
            // 通过下标遍历[List集合特有的方式,Set没有]
            System.out.println("====== List独有的遍历方式======");
            for (int i=0;i<l.size();i++){
                System.out.println(l.get(i));
            }
            System.out.println("==============================");
    
            // 3、int indexOf(Object o)
            // 获取指定对象第一次出现处的索引
            System.out.println(l.indexOf("B")); // 2
    
            // 4、E remove(int index)
            // 删除指定下标位置的元素
            // 删除下标为0的元素
            l.remove(2);
            System.out.println(l.size());   // 2
    
            // 5、 E set(int index,E element) // E为Object
            // 修改指定位置的元素
            l.set(0,"world");
            for (int i=0;i<l.size();i++){
                System.out.println(l.get(i));
            }
    
        }
    }

**输出结果：**

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 10][]

## 十、ArrayList集合初始化容量及扩容 ##

> ArrayList集合：  
> 1、默认初始化容量10(底层先创建一个长度为0的数组,当添加第一个元素的时候,初始化容量为10)  
> 2、集合底层是一个Object\[\]数组  
> 3、构造方法  
> new ArrayList(); 默认初始化容量10  
> new ArrayList(20); 手动初始化容量20  
> 4、ArrayList集合的扩容：  
> 原容量的1.5倍  
> ArrayList集合底层是数组,怎么优化？  
> 尽可能少的扩容,因为数组扩容效率比较低,建议使用ArrayList集合的时候  
> 预估计元素的个数,给定一个初始化容量【扩容前面StringBuffer讲过,扩容是把第一个满元素的数组放到一个更大的数组当中,所以还要放效率会低】

public class CollectionTest08 {
        public static void main(String[] args) {
    
            // 默认初始化容量是10
            // 数组的长度是10
            List l =new ArrayList();
    
            // 指定初始化容量
            // 数组的长度是20
            List list =new ArrayList(20);
        }
    }

## ArrayList集合另外一个构造方法 ##

**代码演示如下：**

package com.bjpowernode.javase.collection;
    import java.util.*;
    
    public class CollectionTest09{
        public static void main(String[] args) {
            // 初始化容量10
            List l =new ArrayList();
    
            // 指定初始化容量100
            List l1 =new ArrayList(100);
    
            // 创建一个HashSet集合
            Collection c =new HashSet();
            // 向HashSet集合中添加元素
            c.add(1);
            c.add(2);
            c.add(3);
            c.add(4);
            c.add(5);
    
            // 通过构造方法就可以把HashSet集合转换成ArrayList集合
            List list =new ArrayList(c);    List接口特有的迭代/循环元素方法
            for (int i=0;i<list.size();i++){
                System.out.println(list.get(i));
            }
    }
    }

## 十一：泛型 ##

> 1、JDK5. 0之后推出的新特性:泛型  
> 2、泛型这种语法机制，只在程序编译阶段起作用，只是给编译器参考的。 (运行阶段泛型没用! )  
> 3、使用了泛型好处是什么?  
> 第一:集合中存储的元素类型统一了。  
> 第二:从集合中取出的元素类型是泛型指定的类型,不需要进行大量的“向下转型”!
> 
> 4、泛型的缺点是什么?  
> 导致集合中存储的元素缺乏多样性!  
> 大多数业务中,集合中元素的类型还是统一的。 所以这种泛型特性被大家所认可。

**没使用泛型之前的代码如下：**

package com.bjpowernode.javase.collection;
    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List;
    
    public class GenericTest01 {
        public static void main(String[] args) {
            // 创建一个List集合对象
            List list =new ArrayList();
    
            // 创建元素对象
            Animal a =new Dog();    // 多态
            Animal b =new Cat();
            // 向集合中添加元素
            list.add(a);
            list.add(b);
    
            // 迭代集合
            Iterator it =list.iterator();
            while (it.hasNext()){   // HasNext() 判断集合中是否还有元素了
                Object obj =it.next(); // 拿到元素
    
                // obj.move();  // 无法调用move()方法 因为Object类当中没有move()方法   想要调用move()方法 那么我们需要向下转型
                if (obj instanceof Animal){ // 也可以obj instanceof Dog 指向特定的对象    obj能指向Animal是因为Animal继承了Object类
                    Animal animal =(Animal)obj;
                    animal.move();
                }
            }
        }
    }
    
    class Animal{
        public void move(){
            System.out.println("animal can move~");
        }
    }
    
    class Dog extends Animal{
        // Dog特有的方法
        public void eat(){
            System.out.println("Dog 真可爱~");
        }
    }
    
    class Cat extends Animal{
        // Cat特有的方法
        public void CatchMouse(){
            System.out.println("Cat 真棒~");
        }
    }

**输出结果：**

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 11][]

**当使用泛型之后代码如下：**

package com.bjpowernode.javase.collection;
    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List;
    
    public class GenericTest01 {
        public static void main(String[] args) {
            // 创建一个List集合对象
            // 使用泛型List<Animal>之后,表示List集合中只允许存储Animal类型的数据
            List<Animal> list =new ArrayList<Animal>();    
    //JDK8后new ArrayList<Animal> 中的Animal能省略,引入了自动类型推断机制(又称为：钻石表达式)
            // 创建元素对象（只能存放Animal类型的数据）
            Animal a =new Dog();    // 多态
            Animal b =new Cat();
            // 向集合中添加元素
            list.add(a);
            list.add(b);
            // 储存其他类型数据的话会报错
            // list.add("9");
    
            // 迭代集合
            // 这个表示迭代器迭代的是Animal类型
            Iterator<Animal> it =list.iterator();
            while (it.hasNext()){   // HasNext() 判断集合中是否还有元素了
                Animal animal =it.next(); // 拿到元素(Animal类型不再是Object类型)
                // 所以此处不再运行转型就可以拿到子类继承的方法了
                animal.move();
    
                /*但是要想拿到子类特有的方法 还是需要向下转型
                 if (animal instanceof Dog){
                   Dog dog =(Dog)animal;
                    dog.eat();
                 }*/
    
            }
        }
    }
    
    class Animal{
        public void move(){
            System.out.println("animal can move~");
        }
    }
    
    class Dog extends Animal{
        // Dog特有的方法
        public void eat(){
            System.out.println("Dog 真可爱~");
        }
    }
    
    class Cat extends Animal{
        // Cat特有的方法
        public void CatchMouse(){
            System.out.println("Cat 真棒~");
        }
    }

**输出结果：**

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 12][]

## 十二、增强for循环：foreach ##

> foreach有一个缺点：没有下标,在需要使用下标的循环中,不建议使用增强for循环

**对数组使用foreach代码演示如下：**

package com.bjpowernode.javase.collection;
    
    public class ForEachTest01 {
        public static void main(String[] args) {
    
            // 创建一个一维数组
            int [] arr ={1,2,3,4,5};
    
            // for循环遍历(普通for)
            for (int i=0;i<arr.length;i++){
                System.out.println(arr[i]);
            }
    
            System.out.println("=================================");
    
            // 增强for (foreach)
            // 以下是语法
                /*
                for(元素类型 变量名 : 数组或集合){      //变量名就是数组或集合中的元素
                    sout(变量名);
                }
                 */
            // foreach有一个缺点：没有下标,在需要使用下标的循环中,不建议使用增强for循环
            for (int data:arr){     // data就是数组中的元素(数组中的每一个元素)
                System.out.println(data);
            }
        }
    }

**输出结果：**

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 13][]

**对集合使用foreach代码演示如下：**

package com.bjpowernode.javase.collection;
    
    import java.util.*;
    
    public class ForEachTest02 {
        public static void main(String[] args) {
    
            // 创建List集合
            List<String> list =new ArrayList<>();   // 使用泛型方式
    
            // 向集合中添加元素(因为使用了泛型,所以只能存放String类型数据)
            list.add("hello");
            list.add("world");
    
            // 遍历 ：第一种使用迭代器方式
            Iterator<String> it =list.iterator();   // 对String类型数据进行遍历
                while (it.hasNext()){
                    String s =it.next();    // 因为使用了泛型对String类型迭代,所以此处返回的不再是Object类型
                    System.out.println(s);
                }
    
            // 遍历：第二种for循环遍历(因为List集合有一个调用下标可以拿到元素的方法,因此可以for循环) 独有的
            for (int i=0;i<list.size();i++){
                System.out.println(list.get(i));
            }
    
            // 遍历：第三种foreach循环遍历
            for (String data:list){     // 因为集合中存放的是String类型   list是集合
                System.out.println(data);
            }
    
        }
    }

**输出结果：**

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 14][]

## 十三、演示HashSet集合特点 ##

>     HashSet集合：
>         无序不可重复
>          2、无序： 这里的无序指的是存进去的顺序和取出来的顺序不同,并且没有下标

**代码演示如下：**

package com.bjpowernode.javase.collection;
    import java.util.HashSet;
    import java.util.Iterator;
    import java.util.Set;
    
    /*
    HashSet集合：
        无序不可重复
     */
    public class HashSetTest01 {
        public static void main(String[] args) {
            Set<String> set =new HashSet<>(); // 泛型
    
            // 向Set集合中添加元素
            set.add("hello1");
            set.add("hello2");
            set.add("hello3");
            set.add("hello4");
            set.add("hello5");
            set.add("hello5");
            set.add("hello5");
            set.add("hello5");
            set.add("hello5");
    
            // 迭代
            for (String data:set){
                System.out.println(data);
            }
        }
    }

**输出结果：**

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 15][]

## 十四、演示TreeSet集合特点 ##

>     TreeSet集合储存元素特点：
>         1、无序不可重复,但是储存的元素可以自动按照大小顺序排序！
>         称为：可排序集合
>     
>         2、无序： 这里的无序指的是存进去的顺序和取出来的顺序不同,并且没有下标

**代码演示如下：**

package com.bjpowernode.javase.collection;
    import java.util.*;
    
    public class TreeSetTest01 {
        public static void main(String[] args) {
            // 创建集合对象
            Set<String> set =new TreeSet<>();
    
            // 添加元素
            set.add("B");
            set.add("A");
            set.add("D");
            set.add("C");
            set.add("E");
            set.add("E");
            set.add("E");
            set.add("E");
            set.add("E");
    
            // 遍历
            for (String data:set){
                System.out.println(data);
            }
    
        }
    }

**输出结果：**

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 16][]

[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/9af9607efb1243a7b0551e8d06ba7fe5.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAbHdqXzA3,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 1]: https://img-blog.csdnimg.cn/f7bdeb04240440adbbb1f0f4e8a05fe2.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAbHdqXzA3,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 2]: https://img-blog.csdnimg.cn/e16edeff1ed741dd920f5f321029eff3.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAbHdqXzA3,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 3]: https://img-blog.csdnimg.cn/86b98c4cdcd24bae909b60fd2ac0127e.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAbHdqXzA3,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 4]: https://img-blog.csdnimg.cn/80f49ec055d3447faa80582b44b49a7f.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAbHdqXzA3,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 5]: https://img-blog.csdnimg.cn/4c078c555f554efd9be5f68f3a7357b7.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAbHdqXzA3,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 6]: https://img-blog.csdnimg.cn/7609b6deb95f4036948e2b1ca9af2fa4.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAbHdqXzA3,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 7]: https://img-blog.csdnimg.cn/eca7a3c1dcbb4e71be7522017ed50f15.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAbHdqXzA3,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 8]: https://img-blog.csdnimg.cn/9aab76c94b1148c0974ea8affaf68892.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAbHdqXzA3,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 9]: https://img-blog.csdnimg.cn/9494a05434bd4128a548b656a445d3ab.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAbHdqXzA3,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 10]: https://img-blog.csdnimg.cn/46e4e52e38a6405e931904f95abf2194.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAbHdqXzA3,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 11]: https://img-blog.csdnimg.cn/afa47a0a849d45a0a151a3ca69990b3b.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAbHdqXzA3,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 12]: https://img-blog.csdnimg.cn/8f7c8a1a7c31402a9b8d0c58ab4b1b44.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAbHdqXzA3,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 13]: https://img-blog.csdnimg.cn/87a2ca06344a4a7496d3adc64a400423.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAbHdqXzA3,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 14]: https://img-blog.csdnimg.cn/e3fdeeec15b04469bd2e6af8829e28f4.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAbHdqXzA3,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 15]: https://img-blog.csdnimg.cn/ce30a2ac8b0d4f9fb8322218330f35e5.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAbHdqXzA3,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 16]: https://img-blog.csdnimg.cn/022223b63de74a428447420e2a5c9510.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAbHdqXzA3,size_20,color_FFFFFF,t_70,g_se,x_16