JavaSE集合类

JavaSE集合类

• 概述
• Collection接口
• Set接口
• List接口
• Map接口

概述

Java中集合类概述

Java中集合类是用来存放对象的
集合相当于一个容器，里面包容着一组对象 —— 容器类
其中的每个对象作为集合的一个元素出现
Java API提供的集合类位于java.util包内

Java中数组与集合的比较

数组也是容器，它是定长的，访问较快，但是数组不会自动扩充
数组可以包含基本数据类型或引用类型的对象，而集合中只能包含引用类型的对象

Java中集合框架层次结构

Collection接口

· 一组称为元素的对象
· 一个Collection中可以放不同类型的数据
· 是Set接口和List接口的父类
· 是否有特定的顺序以及是否允许重复，取决于它的实现
Set － 无序的集合；不允许重复（HashSet）
List － 有序的集合；允许重复（ArrayList，LinkedList）

Collection接口常用方法

方法	含义
boolean add(Object)	集合中加入一个对象，成功时返回true
boolean addAll(Collection)	集合中加入另外一个集合对象
int size()	集合内容纳的元素数量
boolean isEmpty()	集合是否为空
boolean contains(Object)	集合内是否含有参数对象
Iterator iterator()	产生一个迭代器
Object[] toArray()	返回一个包含所有元素的对象数组
boolean remove(Object)	从集合中删除对象
boolean removeAll(Collection)	清空指定集合
boolean containsAll(Collection)	判断集合内是否包含子集
boolean retainAll(Collection)	仅保留此 collection 中那些也包含在指定 collection 的元素

Set接口

Set接口
  · Collection的子接口
  · 用来包含一组 无序无重复 的对象
        无序 — 是指元素存入顺序和集合内存储的顺序不同；
        无重复 — 两个对象e1和e2，如果e1.equals(e2)返回true，则认为e1和e2重复，在set中只保留一个。
Set接口的实现类
  · HashSet — HashSet的特性在于其内部对象的散列存取，即采用哈希技术
  · TreeSet — TreeSet存入的顺序跟存储的顺序不同，但是存储是按照排序存储的
使用foreach方式遍历Set集合

样例代码：

package com.training.csdn;

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

/**
 * Keafmd
 *
 * @ClassName: MySet
 * @Description: Set讲解
 * @author: 牛哄哄的柯南
 * @date: 2020-11-26 19:23
 */
public class MySet {

    public static void main(String[] args) {
        //类的构造
        Set set =  new HashSet(); //面向接口编程

        //add
        set.add(50);
        set.add(60); //int     Integer
        set.add(200);
        set.add(new Integer(200));

        //size() 获取集合长度
        System.out.println("set.size()： "+set.size());


        //使用另外一个集合构造set对象
        Set set2 = new HashSet();
        set2.addAll(set);  // 全部添加进去

        // 打印元素个数
        System.out.println("set2.size()： "+set2.size());


        //isEmpty 是否为空
        System.out.println("set2.isEmpty()： "+set2.isEmpty());

        //判断是否包含某个元素
        System.out.println( "set2.contains(60)： "+set2.contains(60));
        System.out.println( "set2.contains(200)： "+set2.contains(new Integer(200)));


        //迭代器 遍历Set
        Iterator it = set2.iterator();

        while(it.hasNext()){
            Object item = it.next();
            System.out.println("元素： "+item);
        }

        //移除元素， 通过equals 和hashcode 判断是否存在元素
        set.remove(50);
        System.out.println("移除后的元素个数： "+set.size());


        Set set3 = new HashSet();
        set3.add("abc");
        set3.add("def");
        set3.add("ghi");
        set3.add("aaa");



        Set set4 = new HashSet();
        set4.add("abc");
        set4.add("def");
        set4.add("kkk");
        set4.add("aaa");

        System.out.println("set3.size： "+set3.size());

        //  从set3中移除set3和set4的 交集元素
//        set3.removeAll(set4);
//        System.out.println("移除后的集合长度： "+set3.size());
//
//
//        for (Object o : set3) {
//            System.out.println("set3的元素有： "+o);
//        }



        // 保留 set3 和 set4 的交集元素
        set3.retainAll(set4);
        System.out.println("retainAll.size： "+set3.size());

        for (Object o : set3) {
            System.out.println("set3的元素有： "+o);
        }



        //清空set集合
        set3.clear();
        System.out.println(set3.size()); //0
    }


}

运行效果：

set.size()： 3
set2.size()： 3
set2.isEmpty()： false
set2.contains(60)： true
set2.contains(200)： true
元素： 50
元素： 200
元素： 60
移除后的元素个数： 2
set3.size： 4
retainAll.size： 3
set3的元素有： aaa
set3的元素有： abc
set3的元素有： def
0

Process finished with exit code 0

List接口

List接口常用方法

方法	含义
void add(int index,Object element)	在列表中的index位置，添加element元素
Object get(int index)	返回列表中指定位置的元素
int indexOf(Object o)	在list中查询元素的索引值，如不存在，返回－1。
int lastIndexOf(Object o)	List中如果存在多个重复元素，indexOf()
ListIterator listIterator()	返回列表中元素的列表迭代器
Object remove(int index)	移除列表中指定位置的元素
Object set(int index,Object element)	用指定元素替换列表中指定位置的元素

ArrayList与LinkedList的比较:
存储结构：
ArrayList是线性顺序存储。
LinkedList对象间彼此串连起来的一个链表。
操作性能：
ArrayList适合随机查询的场合。
LinkedList元素的插入和删除操作性高。
LinkedList功能要多一些。

ArrayList

讲解代码：

package com.CSDN.day26;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

/**
 * Keafmd
 *
 * @ClassName: MyArrayList
 * @Description: ArrayList
 * @Author: 牛哄哄的柯南
 * @Date: 2020/11/26 21:01
 **/
public class MyArrayList {
    public static void main(String[] args) {
        //
        List list1 = new ArrayList();
        list1.add("张三");
        list1.add("李四");
        list1.add("李四");
        list1.add("王五");

        System.out.println("list1.size()\t"+list1.size());

        List list2 = new ArrayList(list1);
        System.out.println("list2.size()\t"+list2.size());

        System.out.println("========================================================");
        //通过下标的形式访问每一个元素
//        System.out.println("list1.get(0)\t"+list1.get(0));
//        System.out.println("list1.get(1)\t"+list1.get(1));
//        System.out.println("list1.get(2)\t"+list1.get(2));
        for (int i = 0; i < list1.size(); i++) {
            System.out.println("list1.get("+i+")\t"+list1.get(i));
        }

        System.out.println("=======================增强for遍历=================================");
        for (Object o : list2) {
            System.out.println("item\t"+o);
        }

        System.out.println("=======================Iterator遍历=================================");
        for(Iterator it = list2.iterator(); it.hasNext() ; ){
            System.out.println("iterator Item \t"+it.next());
        }
        System.out.println("=======================forEach遍历=================================");
//        list2.forEach(System.out::println);
        list2.forEach(x->System.out.println("forEach item\t"+x));


        System.out.println("=======================add(index,Object el)=================================");

        List list3 =new  ArrayList();
        list3.add("abc");
        list3.add("def");
        list3.add("jqk");

        //list3 add(index ,el)
        list3.add(1,"insert");
        list3.forEach(x->System.out.println("list3 item\t"+x));
        System.out.println("=======================add(index,Object el)=================================");
        //list3 update(index ,el)
        list3.set(1,"update");
        list3.forEach(x->System.out.println("list3 item\t"+x));

        //indexOf/lastIndexOf ,返回索引位置，如果找不到则返回-1

        System.out.println("list3.indexOf(\"def\")\t"+list3.indexOf("def"));
        //判断def是否重复
        if(list3.indexOf("def") != list3.lastIndexOf("def")){
            System.out.println("def重复了");
        }



        //listIterator
        ListIterator listIter = list3.listIterator(list3.size()-1);
        while (listIter.hasPrevious()){
            System.out.println("listIter.previous()\t"+listIter.previous());
        }
    }

}

运行结果：

list1.size()	4
list2.size()	4
========================================================
list1.get(0)	张三
list1.get(1)	李四
list1.get(2)	李四
list1.get(3)	王五
=======================增强for遍历=================================
item	张三
item	李四
item	李四
item	王五
=======================Iterator遍历=================================
iterator Item 	张三
iterator Item 	李四
iterator Item 	李四
iterator Item 	王五
=======================forEach遍历=================================
forEach item	张三
forEach item	李四
forEach item	李四
forEach item	王五
=======================add(index,Object el)=================================
list3 item	abc
list3 item	insert
list3 item	def
list3 item	jqk
=======================add(index,Object el)=================================
list3 item	abc
list3 item	update
list3 item	def
list3 item	jqk
list3.indexOf("def")	2
listIter.previous()	def
listIter.previous()	update
listIter.previous()	abc

Process finished with exit code 0

LinkedList

讲解代码：

package com.CSDN.day26;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;

/**
 * Keafmd
 *
 * @ClassName: MyLinkedList
 * @Description: LinkedList
 * @Author: 牛哄哄的柯南
 * @Date: 2020/11/26 21:06
 **/
public class MyLinkedList {
    public static void main(String[] args) {
        //
        List list1 = new LinkedList();
        list1.add("张三");
        list1.add("李四");
        list1.add("李四");
        list1.add("王五");

        System.out.println("list1.size()\t"+list1.size());

        List list2 = new LinkedList(list1);
        System.out.println("list2.size()\t"+list2.size());

        System.out.println("========================================================");
        //通过下标的形式访问每一个元素
//        System.out.println("list1.get(0)\t"+list1.get(0));
//        System.out.println("list1.get(1)\t"+list1.get(1));
//        System.out.println("list1.get(2)\t"+list1.get(2));
        for (int i = 0; i < list1.size(); i++) {
            System.out.println("list1.get("+i+")\t"+list1.get(i));
        }

        System.out.println("=======================增强for遍历=================================");
        for (Object o : list2) {
            System.out.println("item\t"+o);
        }

        System.out.println("=======================Iterator遍历=================================");
        for(Iterator it = list2.iterator(); it.hasNext() ; ){
            System.out.println("iterator Item \t"+it.next());
        }
        System.out.println("=======================forEach遍历=================================");
//        list2.forEach(System.out::println);
        list2.forEach(x->System.out.println("forEach item\t"+x));


        System.out.println("=======================add(index,Object el)=================================");

        List list3 =new  LinkedList();
        list3.add("abc");
        list3.add("def");
        list3.add("jqk");

        //list3 add(index ,el)
        list3.add(1,"insert");
        list3.forEach(x->System.out.println("list3 item\t"+x));
        System.out.println("=======================add(index,Object el)=================================");
        //list3 update(index ,el)
        list3.set(1,"update");
        list3.forEach(x->System.out.println("list3 item\t"+x));

        //indexOf/lastIndexOf ,返回索引位置，如果找不到则返回-1

        System.out.println("list3.indexOf(\"def\")\t"+list3.indexOf("def"));
        //判断def是否重复
        if(list3.indexOf("def") != list3.lastIndexOf("def")){
            System.out.println("def重复了");
        }

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

        ListIterator listIter = list3.listIterator();
        while (listIter.hasNext()){
            System.out.println("listIter.next()\t"+listIter.next());
        }
        System.out.println("=============================");
        //listIterator
//        ListIterator listIter2 = list3.listIterator(list3.size());
//        while (listIter2.hasPrevious()){
//            System.out.println("listIter2.previous()\t"+listIter2.previous());
//        }


        LinkedList lList = new LinkedList();
        lList.addAll(list3);

        Object popItem = lList.pop(); //如果没有元素会抛异常
        Object pollItem = lList.poll();

        System.out.println(pollItem);



    }

}

运行结果：

list1.size()	4
list2.size()	4
========================================================
list1.get(0)	张三
list1.get(1)	李四
list1.get(2)	李四
list1.get(3)	王五
=======================增强for遍历=================================
item	张三
item	李四
item	李四
item	王五
=======================Iterator遍历=================================
iterator Item 	张三
iterator Item 	李四
iterator Item 	李四
iterator Item 	王五
=======================forEach遍历=================================
forEach item	张三
forEach item	李四
forEach item	李四
forEach item	王五
=======================add(index,Object el)=================================
list3 item	abc
list3 item	insert
list3 item	def
list3 item	jqk
=======================add(index,Object el)=================================
list3 item	abc
list3 item	update
list3 item	def
list3 item	jqk
list3.indexOf("def")	2
================================================
listIter.next()	abc
listIter.next()	update
listIter.next()	def
listIter.next()	jqk
=============================
update

Process finished with exit code 0

Map接口

Map内存储的是键/值对这样以成对的对象组(可以把一组对象当成一个元素)，通过“键”对象来查询“值”对象。
Map是不同于Collection的另外一种集合接口。
Map中，key值是唯一的(不能重复)，而key对象是与value对象关联在一起的。
Map接口有两个实现：
HashMap — key/value对 是按照Hash算法存储的。
TreeMap — key/value对是排序 (按key排序)存储的。

Map接口常用方法

方法	含义
Object put(Object key,Object value)	将指定的值与此映射中的指定键相关联
void putAll(Map t)	将映射t中所有映射关系复制到此映射中
Object get(Object key)	返回此映射中映射到指定键的值
Object remove(Object key)	若存在此键的映射关系,将其从映射中移除
boolean containsKey(Object key)	若此映射包含指定键的映射关系，返回 true
boolean containsValue(Object value)	若此映射为指定值映射一个或多个键,返回 true
int size()	返回此映射中的键-值映射对数
void clear()	从此映射中移除所有映射关系
boolean isEmpty()	若此映射未包含键-值映射关系,返回 true
Set keySet()	返回此映射中包含的键的 set 视图

HashMap类

HashMap类是Map接口的实现类 基于哈希表的 Map 接口的实现

Student 类：

package com.CSDN.day26;

/**
 * Keafmd
 *
 * @ClassName: Student
 * @Description:
 * @Author: 牛哄哄的柯南
 * @Date: 2020/11/26 21:16
 **/
public class Student {
    String name;
    int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

讲解代码：

package com.CSDN.day26;

import java.util.*;

/**
 * Keafmd
 *
 * @ClassName: MyMap
 * @Description: Map
 * @Author: 牛哄哄的柯南
 * @Date: 2020/11/26 21:15
 **/
public class MyMap {
    public static void main(String[] args) {

        //对象的创建
        Map<String,Student> map = new HashMap<>();


        List<Student> stuList = new ArrayList();
        stuList.add(new Student("张飞",50));
        stuList.add(new Student("张飞1",36));
        stuList.add(new Student("张飞2",20));
        stuList.add(new Student("张飞3",58));

        //如果要查找某一个元素的属性，需要遍历集合后查找元素才能获取舒心
        for (Student student : stuList) {
            if("张飞3".equals(student.getName())){
                System.out.println("student.age\t"+student.getAge());
                break;
            }
        }



        //put key不可以重复
        map.put("张飞",new Student("张飞",50));
        map.put("张飞1",new Student("张飞1",36));
        map.put("张飞2",new Student("张飞2",20));
        map.put("张飞3",new Student("张飞3",58));

        //get根据key获取指定的元素,底层使用hash计算索引，快速查找元素
        Student stu = (Student) map.get("张飞3");
        System.out.println(stu.getAge());


        /**
         * int size()
         * void clear()
         * boolean isEmpty()
         */

//        map.clear();
        System.out.println("map.size\t"+map.size());
        System.out.println("map.isEmpty\t"+map.isEmpty());

        Map map2 = new HashMap();
        map2.put("张飞3",new Student("张飞3",999));
        map2.put("张飞4",new Student("张飞4",20));
        Student zf5 = new Student("张飞5", 58);
        map2.put("张飞5",zf5);


        map.putAll(map2);
        System.out.println("map.size\t"+map.size());

        System.out.println("map.get(\"张飞3\")\t"+map.get("张飞3").getAge());

        System.out.println("map.containsKey(\"张飞\")\t"+map.containsKey("张飞"));
        System.out.println("map.containsKey(\"张飞99\")\t"+map.containsKey("张飞99"));


        System.out.println("map.containsValue(new Student(\"张飞5\",58)\t"+map.containsValue(zf5));

        System.out.println("========================size==============================");
        System.out.println("map.size\t"+map.size());
        map.remove("张飞3");
        System.out.println("map.size\t"+map.size());

        //HashMap的遍历

        Set<String> keySet = map.keySet();
        for (String key : keySet) {
            System.out.printf("key:%s\tvalue:%s\r\n",key,map.get(key).toString());
        }

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

        Set<Map.Entry<String, Student>> entrySet = map.entrySet();
        for (Map.Entry<String, Student> stringStudentEntry : entrySet) {
            String key = stringStudentEntry.getKey();
            Student value = stringStudentEntry.getValue();
            System.out.printf("key:%s\tvalue:%s\r\n",key,value.toString());
        }
    }
}

运行结果：

student.age	58
58
map.size	4
map.isEmpty	false
map.size	6
map.get("张飞3")	999
map.containsKey("张飞")	true
map.containsKey("张飞99")	false
map.containsValue(new Student("张飞5",58)	true
========================size==============================
map.size	6
map.size	5
key:张飞5	value:Student{name='张飞5', age=58}
key:张飞4	value:Student{name='张飞4', age=20}
key:张飞	value:Student{name='张飞', age=50}
key:张飞2	value:Student{name='张飞2', age=20}
key:张飞1	value:Student{name='张飞1', age=36}
================================================
key:张飞5	value:Student{name='张飞5', age=58}
key:张飞4	value:Student{name='张飞4', age=20}
key:张飞	value:Student{name='张飞', age=50}
key:张飞2	value:Student{name='张飞2', age=20}
key:张飞1	value:Student{name='张飞1', age=36}

Process finished with exit code 0

HashMap与TreeMap的比较

HashMap基于哈希表实现。
TreeMap基于树实现。
HashMap可以通过调优初始容量和负载因子，优化HashMap空间的使用。
TreeMap没有调优选项，因为该树总处于平衡状态
HashMap性能优于TreeMap。

HashMap与Hashtable的比较

Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现。
Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的。
HashMap允许将null作为一个entry的key或者value，而Hashtable不允许用null。

看完如果对你有帮助，感谢点赞支持！
如果你是电脑端，看到右下角的 “一键三连” 了吗，没错点它[哈哈]

加油！

共同努力！

Keafmd

本文地址：https://blog.csdn.net/weixin_43883917/article/details/109997700