JAVA基础总结（八）JAVA 集合框架详细总结

文章目录

一集合概述
- 1、单例集合与双列集合
- 2、集合和数组之间的区别
二、单例集合框架各个接口与类的层次结构
- 1、Collection 接口
- 2、List 集合体系
- - 1、ArrayList 类（重点掌握）
  - 2、LinkedList 类
  - 3、Vector 类（了解一下即可）
- 3、Set 集合体系
- - 1、HashSet 类（重点掌握）
  - 2、LinkedHashSet 类
三、双列集合框架各个接口与类的层次结构
- 1、Map 接口
四、集合的遍历方式
- 1、Iterator （迭代器）
- 2、Java 中集合的遍历方式：

一集合概述

集合：Java中提供的一种容器，可以用来存储多个数据。java集合大致可以分为Set，List，Queue和Map四种体系，也可以分为单例集合和双列集合。

1、单例集合与双列集合

单例集合：Collection 接口下的集合都是单例集合
- 单例集合的特点：集合中的元素都是单独存在的，元素存储时也是一个一个存储的。
双列集合：Map 接口下的集合都是双列集合
- 双列集合的特点：双列集合是每个元素都有键与值两部分组成的集合，记录的是键值对对应关系，即通过键可以找到值，键必须是唯一，值可以重复。元素存储时也是一对一对存储的。

这里需要注意，Set 集合中的数据虽然是单个呈现的，但是其添加方法底层其实是执行了 Map 集合中的 put 方法。所以说，Set集合的数据是以键值对的形式存储的。

2、集合和数组之间的区别

数组和集合类同是容器，他们有何区别：
- 1、数组可以储存基本数据类型的数据和对象，而集合中只能储存对象（但是能以包装类形式存储基本数据类型）。
- 2、数组的长度是固定的（在创建数组对象时需要定义好数组的长度），集合长度是可以改变的（创建集合对象时，不需要定义集合的长度，可以直接向集合中存储数据，集合的长度会随着集合内元素的增长而增长）。
- 3、定义数组时必须指定数组元素类型，集合默认其中所有元素都是 Object 。

注：在开发过程中，当需要创建很多对象的时候，便可以使用集合容器来进行存储。

二、单例集合框架各个接口与类的层次结构

单列集合体系结构：

1、Collection 接口

Collection 接口是所有单列集合的父接口，因此在单列集合中定义的List和set通用的一些方法，这些方法可以操作所有的单列集合。方法如下：

Collection 集合常用方法
- public boolean add(E e)；向集合中添加元素
- public boolean remove(E e); 删除集合中的某个元素
- public void clear(); 清空集合中所有的元素
- public boolean contains(); 判断集合中是否含有xxx元素
- public boolean isEmpty(); 判断集合是否为空
- public int size(); 计算集合的长度
- public Object[] toArray(); 将集合转成一个数组

Demo代码示例：

  public class Demo_Collection {

    public static void main(String[] args) {

        Collection coll = new ArrayList();

        
        coll.add(2);
        coll.add("djf");
        coll.add(coll);
        coll.add(34);
        coll.add(33);

        
        //coll.clear();//这里给注释了，不然集合中数据清空
        coll.remove(0);
        coll.removeAll(coll);

        System.out.println(coll.isEmpty());//判断集合是否为空
        System.out.println("=================================");
        System.out.println(coll.toString());//转换成字符串
        System.out.println("=================================");
        System.out.println(coll.iterator());//获取功能
        System.out.println("=================================");
        System.out.println(coll.size());//元素的个数
        System.out.println("=================================");
        System.out.println(coll.contains(coll));//判断集合中是否包含指定的集合元素
        System.out.println("=================================");

        Object[] obj = coll.toArray();//把集合转换为数组

        System.out.print("{");
        for (int i = 0; i < obj.length; i++) {

            if(i == obj.length -1){
                System.out.print(obj[i]);
            }else {
                System.out.print(obj[i]+",");
            }
        }
        System.out.println("}");
        System.out.println("=================================");
    }
}

运行结果：

2、List 集合体系

       List集合：在使用该集合添加元素时，集合中的元素都是有序的，并且元素的内容是可以重复的。
       每个元素都有索引，可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。
        注：实际开发中常用的是 ArrayList 集合。

List 接口中的成员方法
- 添加功能
  - void add(int index,Object element)：在指定位置添加元素
- 获取功能
  - Object get(int index)：获取指定位置的元素
- 删除功能
  - Object remove(int index)：根据索引删除元素,返回被删除的元素
- 修改功能
  - Object set(int index,Object element)：根据索引修改元素，返回被修饰的元素

List 接口有三个子类对象：
- ArrayList 集合—— 添加元素，是有序，可重复，有索引的。(重点掌握)
- LinkedList 集合—— 添加元素，是有序，可重复，有索引的。(次之)
- Vector 集合—— 查询快，增删慢；运行效率慢、线程安全。（了解）

1、ArrayList 类（重点掌握）

ArrayList 集合 :
- 底层数据结构是数组，查询快，增删慢。
- 线程不安全，效率高。

Demo代码示例：

import java.util.ArrayList;
import java.util.List;

public class Demo_ArrayList  {

    public static void main(String[] args) {

        List list = new ArrayList();

       List list = new ArrayList();

        list.add(111);//添加集合中的元素
        list.add(1,222);//在指定位置添加元素
        list.add(2,"ef");
        list.add(list);
        list.add(333);
        list.add(333);
        list.add(333);
        //JDK5之后便开始自行封装
        // 等同于：list.add(Integer.valueOf(333));
        System.out.println("集合中的元素有："+list);

        System.out.println("=======================");

        list.remove(4);//删除指定下标的元素
        System.out.println("删除集合中下标为4的元素："+list);

        System.out.println("=======================");

        System.out.println("获取集合中下标为2的元素："+list.get(2));//获取指定位置的元素

        System.out.println("=======================");

        list.set(0,100);//修改指定下标的元素
        System.out.println("将下标为0的元素进行修改:"+list);

    }
}

运行结果：

2、LinkedList 类

LinkedList 类的成员方法
- 添加功能
  - public void addFirst(E e); 将指定的元素插到列表开头。
  - public void addLat(E e); 将指定的元素插到列表结尾。此方法等效于add()方法
  - public void push(E e); 将元素推入此列表所示的堆栈。此方法等效于addFirst()方法
- 获取功能
  - public E getFirst(); 返回此列表的第一个元素
  - public E getLast(); 返回此列表的最后一个元素
- 删除功能
  - public E removeFirst(); 移除并返回此列表的第一个元素
  - public E removeLast(); 移除并返回此列表的最后一个元素
- 修改功能
  - Object set(int index,Object element)：根据索引修改元素，返回被修饰的元素
- 判断功能
  - public boolean isEmpty(); 如果列表为空返回true

Demo代码示例：

import java.util.LinkedList;

public class sss {
    
        public static void main(String[] args) {
            show01();
            show02();
            show03();
        }
   
        public static void show01(){
            //        注：LinkedList特有的方法不能使用多态！
            //        List list = new LinkedList<>(); 是不对的
            LinkedListlist = new LinkedList<>();

            // add()添加元素
            list.add("a");
            list.add("b");
            list.add("c");
            System.out.println(list);//[a, b, c]
 
            //addFirst(E e); 将指定的元素插到列表开头。
            list.addFirst("hhh");
            //public void push(E e); 将元素推入此列表所示的堆栈。 等效于addFirst()
            list.push("hhh");
            System.out.println(list);
 
            //addLast(E e); 将指定的元素插到列表结尾。 等效于add()
            list.addLast("com");
            System.out.println(list);
 
        }
         
        public static void show02(){
            LinkedListlist = new LinkedList<>();
            // add()添加元素
            list.add("a");
            list.add("b");
            list.add("c");
            //        list.clear(); // 清空集合中所有元素
            if(! list.isEmpty()){
                //  public E getFrist(); 返回此列表的第一个元素
                System.out.println(list.getFirst());//a
                // public E getLast(); 返回此列表的最后一个元素
                System.out.println(list.getLast());//c
            }
        }
        
        public static void show03(){
            LinkedListlist = new LinkedList<>();
            // add()添加元素
            list.add("a");
            list.add("b");
            list.add("c");
            System.out.println(list.pop());
            //public E pop(E e); 入此列表所示的堆栈中弹出一个元素。 等效于 removefirst()
            //System.out.println(list.pop());   
            System.out.println(list.removeFirst());//a
            System.out.println(list.removeLast());//c
            System.out.println(list);//[b]
        }
    }

运行结果：

注：使用 LinkedList 集合特有的方法，不能使用多态。

3、Vector 类（了解一下即可）

Vector 集合:
- 底层数据结构是数组，查询快，增删慢。
- 线程安全，效率低。

Vector 类独有的成员方法：

添加功能
- public void addElement(Object obj)
获取功能
- public Object elementAt(int index)
- public Enumeration elements()

Demon 代码示例：

public class VectorDemo {
    public static void main(String[] args) {
          // 创建集合对象
            Vector v = new Vector();

            // 添加功能
            v.addElement("hello");
            v.addElement("world");
            v.addElement("java");

            System.out.println(v);

            System.out.println("=========================================");

            System.out.println(v.elements());//获取对象

            System.out.println("=========================================");

            System.out.println(v.elementAt(2));
    }
}

3、Set 集合体系

Set 集合的特点：向集合中添加的元素，是无序的，不可重复的，无索引的(索引的操作不能用)。

Set 接口有三个子类对象：
- HashSet 集合—— 添加的元素，是无序的，不重复的，无索引的。(重点掌握)
- LinkedHashSet 集合—— 添加的元素，是有序的，不重复的，无索引的。(次之)
- TreeSet 集合—— 不重复，无索引，按照大小默认升序排序！！(可排序集合)（废弃）

1、HashSet 类（重点掌握）

Set 集合的使用方式和 List 集合一样，只有数据存储的形式不一样。

Demo代码示例：

public class HashSetDemo {
    public static void main(String[] args) {
  // 创建集合对象
            HashSet hs = new HashSet();

            // 创建并添加元素
            hs.add("hello");
            hs.add("world");
            hs.add("java");
            hs.add("world");
            System.out.println(hs);
      }
}

运行结果：

查看结果可知，集合中的元素并没有按照存储顺序来存储，并且相同的数据也没有成功。

2、LinkedHashSet 类

概述
- 底层数据结构由哈希表和链表组成
- 由链表保证元素有序(存储和取出是一致)
- 由哈希表保证元素唯一性

Demo代码示例：

import java.util.LinkedHashSet;

public class HashSetDemo {
    public static void main(String[] args) {
        // 创建集合对象
        LinkedHashSet hs = new LinkedHashSet();
        // 创建并添加元素
        hs.add("hello");
        hs.add("world1");
        hs.add("java1");
        hs.add("world2");
        hs.add("world");
        hs.add("java");
        hs.add("world");

        System.out.println(hs);
    }
}

运行结果：

三、双列集合框架各个接口与类的层次结构

双列集合结构

1、Map 接口

Map集合的特点
- Map是一个双列集合，其中每个元素表示一个键值对作为 ;
- Map集合中的元素，key和value的数据类型可以相同，也可以不同
- Map集合中的元素，key不允许出现重复，value可以重复
- Map集合中的元素，key和value是一一对应的（映射）

Map 接口的成员方法：

public V put(K key , V value)：把指定的键(key)和指定的值(value)添加到Map集合中
public V remove(Object key)：把指定的key所对应的value从Map集合中删除，返回被删元素的值
public V get(Object key)：在集合中获取指定key对应value的元素
boolean containsKey(Object key)：判断集合中是否含有xxxkey
boolean containsValue(Object key)：判断集合中是否含有xxxvalue
public Set KeySet()：把Map中所有的key打包成（存储到）set集合返回
public Set< Map.Entry > entrySet()：获取Map中所有key和value对象的集合（Entry）存储在集合 Set 中
Map 接口有三个子类对象：
- HashMap 集合(重点掌握)
  - 键是哈希表结构，可以保证键的唯一性。
  - 线程不安全，效率高。
  - 允许null键和null值。
- LinkedHashMap 集合(次之)
  - 使用 Map 接口的哈希表和链接列表实现，具有可预知的迭代顺序。
  - 由哈希表保证键的唯一性，不可重复。
  - 由链表保证键盘的有序(存储和取出的顺序一致)。
  - 线程安全，效率低。
  - 不允许null键和null值。
- TreeMap 集合—— 键是红黑树结构，可以保证键的排序和唯一性（废弃）

Demo代码示例：

public class Demo_Map {

    public static void main(String[] args) {

        Map map = new HashMap();

        // put(K key,V value):添加元素。
        map.put(19,"瓜娃子");
        map.put(23,"张三");
        map.put(29,"李四");
        map.put(25,"王五");
        map.put(59,"赵六");

        System.out.println("map:"+map);
        System.out.println("==============================================================================");

        // public V get(Object key) 根据指定的键，在Map集合中获取对应的值。
        System.out.println("根据key获取到的value是:"+map.get(29));
        System.out.println("==================================================");

        //boolean containsKey(Object key)：判断集合是否包含指定的键
        System.out.println("集合中是否存在对应的key:"+map.containsKey(22));
        System.out.println("==================================================");

        //Set keySet():获取集合中所有键的集合
        System.out.println("获取map集合中所有的key存储在set集合中:"+map.keySet());
        System.out.println("==================================================");

        //boolean containsValue(Object value):判断集合是否包含指定的值
        System.out.println("集合中是否存在对应的value:"+map.containsValue("张三"));
        System.out.println("==================================================");

        //remove(Object key)：根据键删除键值对元素，并把值返回
        map.remove("王五");
        System.out.println("map:"+map);
        System.out.println("==================================================");

        //void clear():移除所有的键值对元素
        map.clear();
        System.out.println("map:"+map);
        System.out.println("==================================================");

        //boolean isEmpty()：判断集合是否为空
        System.out.println("集合是否为空?:"+map.isEmpty());
        System.out.println("==================================================");

        //int size()：返回集合中的键值对的对数（集合长度查询）
        System.out.println("集合的长度:"+map.size());
    }
}

运行结果：

注：三种 Map 集合使用的方式都是一样的，只是存储的数据的形式不一样而已。在开发中主要使用的是 HashMap 集合。

四、集合的遍历方式

和数组不一样，集合有着很多的种类，每种集合的元素存储和获取的方式都不相同。但集合遍历的方式和数组一样都可以使用传统的循环结构去遍历集合中的元素。
因为集合的种类较为繁多，如果只使用这些遍历方式的话，实现的过程便会相当的繁琐。但是 Java 中提供了一个接口-- Iterator 接口（迭代器），该接口提供了专门服务与集合的方法。辅助循环结构来遍历集合中的元素。

1、Iterator （迭代器）

迭代器 (Iterator)：它不是一个容器而是接口，它是一种用于访问容器的方法，可用于迭代 List、Set 和 Map 等容器。
迭代：即 Collection 集合的通用获取方式。再获取元素之前先要判断集合中是否有元素，如果有就将这个元素去取出来，继续再判断，直到集合所有元素被取出来为止。即：一个一个的往外拿。
- 作用：帮我们遍历或者拿到容器里边的数据。

Iterator 接口常用的方法：
- next()：取出集合的下一个元素
- hasNext()：判断是否存在下一个元素
- remove() ：删除元素

迭代器的使用步骤：

使用集合中的的方法 iterator() 获取迭代器的实现类对象，使用 Iterator 接口接收（多态）
使用 Tterator 接口中的方法 hashnext() 判断还有没有下一个元素
使用 Tterator 接口中的方法 next() 取出集合的下一个元素

2、Java 中集合的遍历方式：

for 循环

Demo 代码示例：

public class Test {
     public static void main(String[] args) {
         //创建一个集合对象
         Collectioncol = new ArrayList();
         //添加元素
         col.add("小明");
         col.add("小红");
         col.add("小蓝");
         col.add("小绿");
       
  		  for (int i = 0; i < col.size(); i++) {
            	System.out.println(col.toArray()[i]);
            }
      }
 }

运行结果：

while 循环 (搭配迭代器)

Demo 代码示例：

public class Test {
     public static void main(String[] args) {
         //创建一个集合对象
         Collectioncol = new ArrayList();
		         //添加元素
		         col.add("小明");
		         col.add("小红");
		         col.add("小蓝");
		         col.add("小绿");
       
       //创建迭代器子类对象
  		Iterator it = col.iterator(); // 实际返回的肯定是子类对象，这里是多态
  		
	        while (it.hasNext()) {
	            String s = (String) it.next();
	            System.out.println(s);
	        }

      }
 }

运行结果：

增强 for 循环 (for -each 循环)

专门用来遍历数组和集合的，所有的数组跟单列集合都可以使用。它的内部原理就是一个迭代器 Iterator ，所以在遍历过程中，不能对集合元素进行增删操作。

语法：

for(类型 变量 : 数组/集合){// 数组或者集合里的每一项赋值给这个变量
     // 循环体
 }

单例集合 Demo 代码示例：

public class Test {
 public static void main(String[] args) {

        String[] student = {"小明","小红","小蓝"};
        //        // 传统遍历方式
        //        for (int i = 0; i < student.length; i++) {
        //            System.out.println(student[i]);
        //        }

        // 增强for
        for(String c : student){
            System.out.println(c);
        }

        System.out.println("============================");

        List list = new ArrayList();
        list.add(123);
        list.add(234);
        list.add(456);
        for(Integer n : list){
            System.out.println(n);
        }

    }
 }

多列集合 Demo 代码示例：

public class Test {
    public static void main(String[] args) {
        Map map = new HashMap();
        map.put("Java基础总结", "https://blog.csdn.net/shiyu_951/article/details/122297797");
        map.put("集合总结", "https://blog.csdn.net/shiyu_951/article/details/125511152");
        for (Map.Entry entry : map.entrySet()) {
            String mapKey = entry.getKey();
            String mapValue = entry.getValue();
            System.out.println(mapKey + "：" + mapValue);
        }
    }
 }

增强 for 循环的好处：简化了数组和集合的遍历。
增强 for 循环的弊端：增强for的目标不能为null。
如何解决呢?对增强for的目标先进行不为null的判断，然后在使用。

JAVA基础总结（八）JAVA 集合框架详细总结

Java相关栏目本月热门文章