Java-集合（Collection、Iterator、List、Set、HashSet、LinkedHashSet、Map）——知识笔记

最新推荐文章于 2024-08-08 22:50:50 发布

繁星StarLight

最新推荐文章于 2024-08-08 22:50:50 发布

阅读量193

点赞数 1

文章标签： java list 笔记 hash

本文链接：https://blog.csdn.net/qq_30068165/article/details/116237837

版权

Java-集合

一、概述
- 1、概念
- 2、数组和集合的区别
二、集合框架的API

一、概述

1、概念

集合、数组都是对多个数据进行存储操作的结构，简称Java容器。（此时的存储，主要指的是内存层面的存储，不涉及持久化的存储（.txt、.jpg，.avi））

2、数组和集合的区别

数组一旦初始化以后，其长度就确定了。集合的长度的可变的。
数组一旦定义好后，其元素的类型也就确定了，我们就只能操作指定类型的数据。集合内可以放不同类型的元素。
数组中提供的方法非常有限，对于添加、删除、插入数据等操作，非常不方便，效率不高。集合提供了多种数据处理方法。
数组存储数据的特点：有序、可重复；对于无序、不可重复的需求不能满足。
获取数组中实际元素的个数的需求，数组没有现成的属性或方法可用。

二、集合框架的API

Java集合可分为Collection和Map两种体系。
Collection接口： 单列数据，定义了存取一组对象的方法的集合。（单列集合，用来存储一个一个的对象）

List： 元素有序、可重复的集合（动态数组）。例如：ArrayList、LinkedList、Vector。
Set： 元素无序、不可重复的集合。例如：HashSet、LinkedHashSet、TreeSet。

Map接口： 双列数据，保存具有映射关系“Key-value对”的集合。（双列集合，用来存储一对"Key - value"一对的数据）。例如：HashMap、LinkedHashMap、TreeMap、Hashtable、Properties。

1、 Collection接口中的API

import org.junit.Test;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
public class Collect {
    @Test
    public void test1(){
        Collection coll = new ArrayList();
        //add(Object e); 将元素e添加到集合coll中
        coll.add("AA");
        coll.add("BB");
        coll.add(123);//自动装箱
        coll.add(new Date());
        //size();
        System.out.println(coll.size());//4
        //addAll();
        Collection coll1 = new ArrayList();
        coll1.add(123);
        coll1.add("ABC");
        coll.addAll(coll1);
        System.out.println(coll.size());//6
        System.out.println(coll);
        //clear(); 清空集合元素
        coll.clear();
        //.isEmpty(); 判断集合是否为空
        System.out.println(coll.isEmpty());
    }
}

contains(Object obj); 判断当前集合中是否包含obj。
containsAll(Collection coll1); 判断形参coll1中的所有元素是否都存在于当前集合中。
remove(Object obj); 从当前集合中移除obj元素。
removeAll(Collection coll1); 差集：从当前集合中移除coll1中所有的元素。
retainAll(Collection coll1); 交集：获取当前集合和coll1集合的交集，并返回给当前集合。
equals(Object obj);
hashCode();
集合 --> 数组 : toArray(); 拓展：数组 --> 集合：调用Arrays的静态方法asList();
iterator(); 返回Iterator接口的实例，用于遍历集合元素。
remove(); 删除集合中的指定元素。

import org.junit.Test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;

public class CollectionTestWays {
    @Test
    public void test1(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("TOM"));
        coll.add(false);
        Person p = new Person("Jerry",20);
        coll.add(p);
        //1. contains(Object obj); 判断当前集合中是否包含obj
        //在判断时会去调用obj对象所在类的equals();
        boolean contains = coll.contains(123);
        System.out.println(contains);//true
        System.out.println(coll.contains(new String("TOM")));//true
//        System.out.println(coll.contains(p));//true
        System.out.println(coll.contains(new Person("Jerry",20)));//false
        //2. containsAll(Collection coll1); 判断形参coll1中的所有元素是否都存在于当前集合中。
        Collection coll1 = Arrays.asList(123,456);
        System.out.println(coll.containsAll(coll1));//true
    }
    @Test
    public void test2(){
        //3. remove(Object obj); 从当前集合中移除obj元素。
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("TOM"));
        coll.add(new Person("Jerry",20));
        coll.add(false);
        coll.remove(1234);//也会调用equals()比对
        System.out.println(coll);
        //4. removeAll(Collection coll1); 差集：从当前集合中移除coll1中所有的元素
        Collection coll1 = Arrays.asList(123,4567);
        coll.removeAll(coll1);
        System.out.println(coll);
    }
    @Test
    public void test3(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("TOM"));
        coll.add(new Person("Jerry",20));
        coll.add(false);
        //5. retainAll(Collection coll1); 交集：获取当前集合和coll1集合的交集，并返回给当前集合。
//        Collection coll1 = Arrays.asList(123,456,789);
//        coll.retainAll(coll1);
//        System.out.println(coll);
        //6. equals(Object obj);
        Collection coll1 = new ArrayList();
        coll1.add(123);
        coll1.add(456);
        coll1.add(new String("TOM"));
        coll1.add(new Person("Jerry",20));
        coll1.add(false);
        System.out.println(coll.equals(coll1));
    }
    @Test
    public void test4(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("TOM"));
        coll.add(new Person("Jerry",20));
        coll.add(false);
        //7. hashCode();
        System.out.println(coll.hashCode());
        //8. 集合 --> 数组 : toArray();
        Object[] arr = coll.toArray();
        for (int i = 0; i < arr.length ; i++) {
            System.out.println(arr[i]);
        }
        //拓展： 数组 --> 集合：调用Arrays的静态方法asList();
        List<String> list = Arrays.asList("AA", "BB", "CC");
        System.out.println(list);
        List arr1 = Arrays.asList(new int[]{123, 456});
        System.out.println(arr1.size());//被识别为一个值，size为1
        //包装类对象时可识别为2个数
        List arr2 = Arrays.asList(new Integer[]{123, 456});
        System.out.println(arr2.size());//size为2
        //9. iterator(); 返回Iterator接口的实例，用于遍历集合元素。放在IteratorTest.java中测试
    }
	@Test
    public void test5(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("TOM"));
        coll.add(new Person("Jerry",20));
        coll.add(false);

        //删除集合中的"TOM"元素
        /*
        如果还未调用next()或在上一次调用next方法之后已经调用了remove方法，再调用remove都会报IllegalStateException
         */
        Iterator iterator = coll.iterator();
        while (iterator.hasNext()){
            Object obj = iterator.next();
            if (obj.equals("TOM")){
                iterator.remove();
            }
        }
        //重新遍历集合
        iterator = coll.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

2、 Iterator迭代器接口

概述： Iterator对象称为迭代器（设计模式的一种），主要用于遍历Collection集合中的元素。是一种既能访问一个容器（container）对象中各个元素，又能不暴露该对象内部细节的方法。

实现方式： Collection接口继承了java.lang.Iterator接口，该接口有一个iterator()方法，那么所有实现了Collection接口的集合类都有一个iterator()方法，用以返回一个实现了Iterator接口的对象。

注意事项：Iterator仅用于遍历集合。

Iterator本身并不提供承装对象的能力。如果需要创建Iterator对象，则必须有一个被迭代的集合。
集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前。

import CollectionTest.Person;
import org.junit.Test;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/*
* 集合元素的遍历操作，使用Iterator接口
* 内部的方法： hasNext() 和 next()
* */
public class InteratorTestWay {
    @Test
    public void test1(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("TOM"));
        coll.add(new Person("Jerry",20));
        coll.add(false);
        Iterator iterator = coll.iterator();
        //方式一：
        //next() ①指针下移 ②将下移以后集合位置上的元素返回
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
        //报异常：NoSuchElementException
//        System.out.println(iterator.next());

        //方式二：不推荐！！
//        for (int i = 0; i < coll.size(); i++) {
//            System.out.println(iterator.next());
//        }

        /*方式三：推荐！！
            iterator.hasNext() 判断是否还有下一个元素
         */
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

Iterator遍历集合的两种错误使用写法：

@Test
public void test(){
	Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("TOM"));
        coll.add(new Person("Jerry",20));
        coll.add(false);
        
		//错误方式一：
        Iterator iterator = coll.iterator();
        while((iterator.next()) != null){
        	System.out.println(iterator.next());
        	//造成跳着输出，还会出现NoSuchElemnetException
        }
		
		//错误方式二：
		//集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前。
		while(coll.iterator().hasNext()){
			System.out.println(coll.iterator.next());
			//无限循环输出集合中的第一个数值
		}
}

3、 Collection子接口之一：List接口

概述：

鉴于Java中数组用来存储数据的局限性，我们通常使用List替代数组。
List集合类中元素有序、且可重复，集合中的每个元素都有其对应的顺序索引。
List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素。
JDK API中List接口的实现类常用的有：ArrayList、LinkedList和Vector。
必须重写equals()方法

常用方法

在这里插入图片描述

总结：常用方法：

增：add(Object obj)
删：remove(index e) / remove(Object obj)
改：set(int index,Object ele)
查：get(int index)
插：add(int index, Object ele)
长度：size()
遍历：①Iterator迭代器方式 ②增强for循环 ③普通的循环

/*
*  List：存储有序的、可重复的数据（动态数组）。
*       ArrayList：作为List接口的主要实现类；线程不安全的，效率高的。底层使用Object[] elementData存储。
*       LinkedList：对于频繁的插入、删除操作，使用此类效率比ArrayList高；底层使用双向链表存储。
*       Vector：作为List接口的古老实现类；线程安全的，效率低的。底层使用Object[] elementData存储。使用时必须重写equals()方法
*
* 面试题：ArrayList、LinkedList、Vector三者的异同
*   相同点：三个类都是实现了List接口，存储数据的特点相同：存储有序的、可重复的数据。
*   不同点：见上。
*
* List接口方法:
List除了从Collection集合继承的方法外，List 集合里添加了一些根据索引来
操作集合元素的方法。
➢void add(int index, Object ele): 在index位置插入ele元素
➢boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
➢Object get(int index):获取指定index位置的元素
➢int indexOf(Object obj):返回obj在集合中首次出现的位置
➢int lastIndexOf(Object obj):返回obj在当前集合中未次出现的位置
➢Object remove(int index):移除指定index位置的元素，并返回此元素
➢Object set(int index, Object ele):设置指定index位置的元素为ele
➢List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的左闭右开区间的子集合
*
* 总结：常用方法：
* 增：add(Object obj)
* 删：remove(index e) / remove(Object obj)
* 改：set(int index,Object ele)
* 查：get(int index)
* 插：add(int index, Object ele)
* 长度：size()
* 遍历：①Iterator迭代器方式 ②增强for循环 ③普通的循环
*/
import CollectionTest.Person;
import org.junit.Test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
public class ListTestWay {
    //遍历
    @Test
    public void test3(){
        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add("AA");
        //方式一：Iterator迭代器方式
        Iterator iterator = list.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        System.out.println("*******************************");
        //方式二：增强for循环
        for (Object obj : list){
            System.out.println(obj);
        }
        //方式三：普通的循环
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
    @Test
    public void test1(){
        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add("AA");
        list.add(new Person("TOM",20));
        list.add(456);
        System.out.println(list);
        //void add(int index, Object ele): 在index位置插入ele元素
        list.add(1, "BB");
        System.out.println(list);
        //boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
        List list1 = Arrays.asList(1, 2, 3);
        list.addAll(list1);
        System.out.println(list.size());//9
        //Object get(int index):获取指定index位置的元素
        System.out.println(list.get(1));//BB
    }
    @Test
    public void test2(){
        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add("AA");
        list.add(new Person("TOM",20));
        list.add(456);
        //int indexOf(Object obj):返回obj在集合中首次出现的位置。如果不存在返回-1。
        int index = list.indexOf(456);
        System.out.println(index);
        //int lastIndexOf(Object obj):返回obj在当前集合中未次出现的位置。如果不存在返回-1。
        int index1 = list.lastIndexOf(456);
        System.out.println(index1);
        //Object remove(int index):移除指定index位置的元素，并返回此元素。
        Object obj = list.remove(1);
        System.out.println(obj);
        System.out.println(list);
        //Object set(int index, Object ele):设置指定index位置的元素为ele
        list.set(1, "CC");
        System.out.println(list);
        //List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的左闭右开区间的子集合
        List subList = list.subList(2, 4);
        System.out.println(subList);
        System.out.println(list);
    }
}

4、 Collection子接口之二：Set接口

概述

Set接口是Collection的子接口，Set接口没有提供额外的方法。
Set接口不允许包含相同的元素，如果试把两个相同的元素加入同一个Set集合中，则添加操作失败。
Set判断两个对象是否相同不是使用 == 运算符，而是根据 equals() 方法。
必须重写equals()、hashCode()方法

Set接口的框架：

  Collection接口：单例集合，用来存储一个一个的对象

  -----Set接口：存储无序的、不可重复的数据

      -----HashSet：作为Set接口的主要实现类；线程不安全的；可以存储null值

          ------LinkedHashSet：作为HashSet的子类；遍历其内部数据时，可以按照添加的顺序遍历

      -----TreeSet：可以按照添加对象的指定属性，进行排序。

注意：Set接口中没有额外定义新的方法，使用的都是Collection中声明的方法。

要求1：向Set中添加的数据，其所在的类一定要重写hashCode()和equals()。
要求2：重写的hashCode()和equals()尽可能保持一致性：相等的对象必须具有相等的散列码。
重写两个方法的小技巧：对象中用作equals()方法比较的Field，都应该来计算hashCode值。

HashSet 和 LinkedHashSet

二、添加元素的过程：以HashSet为例
我们向HashSet中添加元素a,首先调用元素a所在类的HashCode()方法，计算元素a的哈希值，此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置（即为：索引位置），判断数组此位置上是否已有元素：
------如果此位置上没有其他元素，则元素a添加成功。 --情况1
------如果此位置上有其他元素b（或以链表形式存在的多个元素），则比较元素a与元素b的hash值：
------------如果hash值不相同，则元素a添加成功。 --情况2
------------如果hash值相同，进而需要调用元素a所在类的equals()方法：
-------------------equals()返回true，元素a添加失败
-------------------equals()返回false，则元素a添加成功。 --情况3

对于添加成功的情况2和情况3而言：元素a与已经存在指定索引位置上数据以链表的方式存储。

JDK 7：元素a放到数组中，指向原来的元素。
JDK 8：原来的元素在数组中，指向元素a。

总结：七上八下
图片来自尚硅谷

import CollectionTest.Person;
import org.junit.Test;

import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Set;

/*
 *  1.Set接口的框架：
 *       Collection接口：单例集合，用来存储一个一个的对象
 *           Set接口：存储无序的、不可重复的数据
 *               HashSet：作为Set接口的主要实现类；线程不安全的；可以存储null值
 *                   LinkedHashSet：作为HashSet的子类；遍历其内部数据时，可以按照添加的顺序遍历
 *               TreeSet：可以按照添加对象的指定属性，进行排序。
 *   注意：Set接口中没有额外定义新的方法，使用的都是Collection中声明的方法。
 *   要求1：向Set中添加的数据，其所在的类一定要重写hashCode()和equals()。
 *   要求2：重写的hashCode()和equals()尽可能保持一致性：相等的对象必须具有相等的散列码。
 *    重写两个方法的小技巧：对象中用作equals()方法比较的Field，都应该来计算hashCode值。
*/
public class SetTestWay {
    /*
     * 一、Set：存储无序的、不可重复的数据
     * 以HashSet为例说明：
     * 1.无序性：不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值决定的。
     * 2.不可重复性：保证添加的元素按照equals()判断时，不能返回true，即：相同的元素只能添加一个。
     *
     * 二、添加元素的过程：以HashSet为例
     *  我们向HashSet中添加元素a,首先调用元素a所在类的HashCode()方法，计算元素a的哈希值，
     *  此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置（即为：索引位置），
     *  判断数组此位置上是否已有元素：
     *      如果此位置上没有其他元素，则元素a添加成功。 --情况1
     *      如果此位置上有其他元素b（或以链表形式存在的多个元素），则比较元素a与元素b的hash值：
     *          如果hash值不相同，则元素a添加成功。 --情况2
     *          如果hash值相同，进而需要调用元素a所在类的equals()方法：
     *              equals()返回true，元素a添加失败
     *              equals()返回false，则元素a添加成功。 --情况3
     *
     *  对于添加成功的情况2和情况3而言：元素a与已经存在指定索引位置上数据以链表的方式存储。
     *  JDK 7：元素a放到数组中，指向原来的元素。
     *  JDK 8：原来的元素在数组中，指向元素a。
     *  总结：七上八下
     */
    @Test
    public void test1(){
        Set set = new HashSet();
        set.add(456);
        set.add(123);
        set.add("AA");
        set.add("CC");
        set.add(new Person("TOM",20));
        set.add(129);

        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
    //LinkedHashSet的使用
    //LinkedHashSet作为HashSet的子类，在添加数据的同时，每个数据还维护了两个引用，记录此数据前一个数据和后一个数据。
    //优点：对于频繁的遍历操作，LinkedHashSet效率高于HashSet。
    @Test
    public void test2(){
        Set set = new LinkedHashSet();
        set.add(456);
        set.add(123);
        set.add("AA");
        set.add("CC");
        set.add(new Person("TOM",20));
        set.add(129);

        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

TreeSet（非重点）

1.向TreeSet中添加的数据，要求是相同类的对象
2.两种排序方式：自然排序（实现Comparable接口）和定制排序。

自然排序中，比较两个对象是否相同的标准为：compareTo()返回0。不再是equals()。
定制排序中，比较两个对象是否相同的标准为：compare()返回0。不再是equals()。

import CollectionTest.Person;
import org.junit.Test;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
public class TreeSetWay {
    /*
    1.向TreeSet中添加的数据，要求是相同类的对象
    2.两种排序方式：自然排序（实现Comparable接口） 和 定制排序
        自然排序中，比较两个对象是否相同的标准为：compareTo()返回0。不再是equals()。
        定制排序中，比较两个对象是否相同的标准为：compare()返回0。不再是equals()。
    */
    @Test
    public void test1(){
        TreeSet set = new TreeSet();
        //失败：不能添加不同类的对象
//        set.add(123);
//        set.add(465);
//        set.add("AA");
//        set.add(new Person("TOM",18));
        //举例一：
//        set.add(34);
//        set.add(-34);
//        set.add(43);
//        set.add(11);
//        set.add(8);
        //举例二：
        set.add(new Person("Tom",12));
        set.add(new Person("Jerry",39));
        set.add(new Person("Lucy",18));
        set.add(new Person("Mike",35));
        set.add(new Person("Anna",19));
        set.add(new Person("Anna",20));
        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
    @Test
    public void test2(){
        Comparator com = new Comparator() {
            //按照年龄从小到大排序
            @Override
            public int compare(Object o1, Object o2) {
                if (o1 instanceof Person && o2 instanceof Person){
                    Person p1 = (Person) o1;
                    Person p2 = (Person) o2;
                    return Integer.compare(p1.getAge(),p2.getAge());
                }else {
                    throw new RuntimeException("输入的数据类型不匹配");
                }
            }
        };
        TreeSet set = new TreeSet(com);//括号内放入比较对象
        set.add(new Person("Tom",12));
        set.add(new Person("Jerry",39));
        set.add(new Person("Lucy",18));
        set.add(new Person("Mike",35));
        set.add(new Person("Anna",19));
        set.add(new Person("Anna",20));
        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

5、 Map接口

图片来源：尚硅谷康师傅

繁星StarLight

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java-集合（Collection、Iterator、List、Set、HashSet、LinkedHashSet、Map）——知识笔记

集合、数组都是对多个数据进行存储操作的结构，简称Java容器。（此时的存储，主要指的是内存层面的存储，不涉及持久化的存储（.txt、.jpg，.avi））鉴于Java中数组用来存储数据的局限性，我们通常使用List替代数组。List集合类中元素有序、且可重复，集合中的每个元素都有其对应的顺序索引。List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素。JDK API中List接口的实现类常用的有：ArrayList、LinkedList和Vector。
复制链接

扫一扫