JavaSE集合类

• 概述
• • Java中集合类概述
  • Java中数组与集合的比较
  • Java中集合框架层次结构
• Collection接口
• • Collection接口常用方法
• Set接口
• List接口
• • List接口常用方法
  • ArrayList
  • LinkedList
• Map接口
• • Map接口常用方法
  • HashMap类
  • HashMap与TreeMap的比较
  • HashMap与Hashtable的比较

概述

Java中集合类概述

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

Java中数组与集合的比较

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

Java中集合框架层次结构

Collection接口

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

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接口常用方法

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接口常用方法

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。

看完如果对你有帮助，感谢点赞支持！