Java集合那点事，满满干货~

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了Java集合那点事，满满干货~，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含11144字，纯文字阅读大概需要16分钟。

内容图文

说到Java集合，可以说是初学者必踩的坑了。

那么怎么才能学好Java集合呢？个人认为关键是要理清楚思路，从上而下，建立一套完整的思维体系，这样才能更好的去认识事物的本质。

先确立一下学习Java集合的目标：

1.会使用集合存储数据。

2.会遍历集合，把数据取出来。

3.掌握每种集合的特性。

总的集合框架如图所示：

Java集合那点事，满满干货~ - 文章图片

Collection<E>接口

首先从Collectiion 讲起，Collection是所有单列集合的父接口，因此在Collection中定义了单列集合(List和Set)通用的一些方法，这些操作方法可以用于操作多有的单列集合（所有子类都可以使用）。

方法如下(重点)：

* public boolean add(E e): 把给定的对象添加到当前集合中。

* public boolean clear():清空集合中所有的元素。

* public boolean remove(E e):把给定的对象在当前集合中删除。

* public int size():输出集合中元素个数。

* public bollean contains(E e):判断当前集合是否包含指定对象。

* public boolean isEmpty():判断当前集合是否为空。

* public Object [ ] toArray:把集合中的元素储存在数组中

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class DemoCollection{
    public static void main(String[] args){
        //创建集合对象，使用多态。
        Collection<String> coll = new ArrayList<>();//ArrayList是Collection的实现类
        System.out.println(coll);
        coll.add("寒冰射手");
        coll.add("无双剑姬");
        coll.add("满族之王");
        System.out.println(coll);

        boolean b1= coll.remove("寒冰射手");//添加对象
        System.out.println("b1是否移除："+b1);

        boolean b2 = coll.contains("无双剑姬");//判断对象是否存在集合当中
        System.out.println("b2是否包含："+b2);

        int size = coll.size();//返回集合的大小
        System.out.println("size:"+size);

        if(coll.isEmpty()){  //判断集合是否为空
            System.out.println("集合为空");
        }else{
            Object[] arr = coll.toArray();//把集合中的元素存储在数组当中
            for(int i = 0;i<arr.length;i++){
                System.out.println("arr[i]");//输出数组中的元素
            }
        }
        
        //使用迭代器遍历集合
        Iterator<String> it = coll.iterator();
        while(it.hasNext()){
            String str = it.next();
            System.out.println(str);
        }
        
        //coll.clear();清空集合当中的元素
    }
}

List 接口（java.util.List）

List接口继承自Collection接口，一般将List接口的对象称为List集合。List集合中重要是允许出现重复的元素，所有的元素以线性的方式存储。

List接口的特点：

1.有序的集合，存储元素和储存元素的顺序是一致的。

2.有索引，包含了一些带索引的方法（Collection抽取所有子接口的共性，所以不带索引）。

3.允许存储重复的元素。

List接口的常用方法（带索引特有）：

* public void add(int index,E element):将指定元素，添加在集合中的指定位置上。

* public E get (int index):返回集合中指定位置的元素。

* public E remove(int index):返回移除集合指定位置的元素。

* public E set(int index):返回替换集合中指定位置的元素。

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


public class DemoSet {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();//创建List集合对象，使用多态
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        System.out.println(list);
        
        list.add(2,"f");//指定位置添加元素
        System.out.println(list);
        
        list.remove(3);//移除指定位置元素
        System.out.println(list);

        String str = list.get(1);//获取指定位置元素
        System.out.println(str);

        list.set(0,"p");//替换指定位置元素
        System.out.println(list);

        Iterator<String> it = list.iterator();//使用迭代器顺序取出元素，
        while(it.hasNext()){
            String str1 = it.next();
            System.out.println(str1);
        }


    }
}

ArrayList集合

ArrayList为List接口的实现类，底层储存为数组结构，用于元素的增删改查，属于最常用的集合（不同步）

常用方法：

* public boolea add(E e);

* public E get(int index);

* public E remove(int index);

* public int size();

import java.util.ArrayList;
import java.util.Iterator;

public class DemoSet {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        System.out.println(list);
        
       //注意，for循环遍历，长度用list.size
        for (int i = 0; i < list.size(); i++) {
            String str = list.get(i);
            System.out.println(str);
        }
        
       //迭代器遍历
        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            String str1 = it.next();
            System.out.println(str1);
        }

    }
}

LinkedList集合

LinkedList也为List接口的实现类，但其与ArrayList集合不同的是其底层数据存储的结构为链表结构（双向），包含大量操作首位元素的方法，查询慢，增删快。

常用方法（特有方法，不能使用多态）：

* public void addFirst(E e):将指定元素插入此列表开头。

* public void addLast(E e):将指定元素插入此列表的末尾。

* public E getFirst():返回此列表的第一个元素。

* public E getLast():返回此列表的最后一个元素。

* public E removeFirst():移除并返回此列表第一个元素。

* public E removeLast():移除并返回此列表的最后一个元素。

* public E pop():从此列表所表示的堆栈处弹出一个元素。（等效与removeFirst()方法）

* public void push(E e):将元素推入此列表所表示的堆栈。（等效于add()方法）

* public boolean isEmpty():如果列表不包含元素，则返回true。

import java.util.Iterator;
import java.util.LinkedList;


public class DemoSet {
    public static void main(String[] args) {
        show1();
    }

    public static void show1(){
        LinkedList<String> list = new LinkedList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        list.push("f");
        System.out.println(list);

        String f1 = list.getFirst();
        System.out.println(f1);

        String l1 = list.getLast();
        System.out.println(l1);

        String s1 = list.removeFirst();//等效pop()方法
        System.out.println(s1);

        String s2 = list.removeLast();
        System.out.println(s2);
        
        //list.clear(); 清空集中的元素，在获取集合中元素时会抛出NoSuchElementException

        //使用迭代器遍历Linked中的元素
        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            String str = it.next();
            System.out.println(str);
        }


    }
}

Vector集合

Vector也继承自List接口，底层也是一个实现可增长的对象数组，也可以通过索引来进行访问，但一般Vector使用较少，所以不在这进行详细讲解。

一般方法(特有)：

* public void addElement(E e):添加元素到向量末尾。（等效于add()方法）

* public Enumeration<E> elements():返回该向量枚举。

Set接口

Set接口是Collection接口下第二大分支，也继承Collection接口。

Set接口特点：

1.不允许存储相同的元素

2.没有索引，没有带索引的方法，也不能使用普通的for循环。（一般来说，有索引就可以使用for循环来遍历）

Set方法不在详细描述，基本与Collection接口方法一致。

HashSet

HashSet是Set接口的实现类，由哈希表支持（HashMap实例），它不保证set的迭代顺序，即存储元素和取出元素的顺序有可能不一致。

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

public class DemoSet {
    public static void main(String[] args) {
        Set<Integer> set = new HashSet<>();
        set.add(1);
        set.add(2);
        set.add(3);
        set.add(1);
        Iterator<Integer> it = set.iterator();
        while(it.hasNext()){
            int a = it.next();
            System.out.println(a);
        }
    }
}

关于Set集合不允许重复元素的原理：

Set集合在调用add方法时，add()方法会调用元素的hashCode方法和equals方法判断元素是否重复。

前提：存储的元素必须重写hashCode和equals方法。（如用HashSet存储自定义对象，必须重写equals和hashCode方法）

说一下hashCode()方法：返回一个int型的哈希值(一串数字)。

import java.util.HashSet;

public class DemoSet {
    public static void main(String[] args) {
      HashSet<String> set = new HashSet<>();
      String s1 = new String("abc");
      String s2 = new String("abc");
      set.add(s1);
      set.add(s2);
      set.add("你好");
      set.add("我好");
      set.add("abc");
        System.out.println(set);
    }
}

set.add(s1): add方法会调用s1的hashCode方法，计算“abc”的哈希值，在集合中找有没有和“abc”哈希值一样的元素，发现没有就会把s1储存在集合当中。

set.add(s2):同上操作，发现有哈希冲突后，就会调用s2的equals方法去比较s2.equals(s1),equals返回true，认定两个元素相同，就不会把s2储存在集合当中。

set.add:("你好")：同s1操作相同。

set.add("我好")：哈希值与“你好”相同，但是equals方法返回false，认定“你好”，“我好”不同，就会把“我好”元素挂在“你好”下面，放入集合。

hashSet集合的底层哈希表结构：数组+链表/红黑树。

数组	哈希值1	哈希值2
链表	元素1	元素3
链表	元素2	元素4

LinkedHashSet集合

特点：继承了HashSet集合，其底层是一个哈希表+链表，多了一条链表（记录元素的存储顺序），保证元素有序。

具体方方不再详述，与HashSet相同。

Collections集合工具类：

对集合进行操作，部分方法如下：

* public static <T> boolean addAll(Collection<T> c,T..elements):往集合中添加多个元素。

* public static void shuffle(List<?> List):打乱集合中元素的顺序。

* public static <T> void sort(List<T> list):将集合中元素按默认规则排序元素。（升序）

*注意:如果是自定义类型，使用sort()需要重写compaerTo()方法.

* public static <T> void sort(List<T>,Comparator<?super T>) ：将集合中元素按指定规则排序。

例如：Collections.addAll(list,"a","b".....)(静态方法调用，直接类名.方法)。

Map<K,V>集合(有点懒，包括其子类就放一块讲完啦)

<key,value>双列集合，通多键值对方式组成。通过建可以找到其值。

Map集合的特点：

1.Map集合是一个双列集合，一个元素包含两个值（key,value）。

2.Map集合中的元素，key和value的数据类型可以相同，也可以不同。

3.Map集合中的元素，键是不允许重复的，但是值是可以重复的。

常用方法：

* public V put(K key,V value):把指定的键与值添加到Map集合当中。（存储键值对时，键相同，值不同，后添加的值会把原来的值覆盖）

* public V remove (Object key):把指定的键所对应的值对元素在Map集合中删除，返回被删除元素的值。

* public V get(Obejec key):获取键所对应的值

* boolean containsKey(Object key)：判断集合中是否包含指定的键。

* public Set<K> keySet():获取Map集合中的所有键，并把它放入Set集合。（重要）

* public Set<Map.Entry<K,V>> entrySet():把键值对的对象（Entry）放入Set集合中。（重要）

import java.util.*;

public class DemoSet {
    public static void main(String[] args) {
      Map<String,String> map = new HashMap<>();
      map.put("a","a");
      map.put("b","b");
      map.put("c","c");
      map.put("d","d");
      map.put("a","f");
      System.out.println(map);

      String str1 = map.get("a");
      System.out.println(str1);

      String str2 = map.remove("c");
      System.out.println(str2);
      System.out.println(map);

      boolean flag = map.containsKey("c");
      System.out.println("键C是否存在："+flag);

      //遍历键值对,注意和之前的集合遍历不太一样
      Set<String> set = map.keySet();
      Iterator<String> it = set.iterator();
      while(it.hasNext()){
        String key = it.next();
        String value = map.get(key);
        System.out.println(key+"="+value);
      }
      System.out.println("------------------------------------");//华丽的分割线 Map.Entry为其Map内置接口
      //使用entrySet遍历
      Set<Map.Entry<String, String>> entry = map.entrySet();
      Iterator<Map.Entry<String, String>> iterator = entry.iterator();
      while(iterator.hasNext()){
        Map.Entry<String, String> next = iterator.next();
        System.out.println(next);
      }
      System.out.println("------------------------------------");//华丽的分割线
      //也可使用增强for循环遍历
      for(Map.Entry<String, String> s1:map.entrySet()){
        System.out.println(s1);
      }

    }
}

*注意：Map.Entry<k,v>：在Map接口中由一个内部接口Entry，当Map集合一创建，就会创建一个Entry对象，用来记录键值对。

可以把Map.Entry<K,V>,理解成一种引用类型，在增强for循环中去遍历使用，用来接收传来的键值对。

HashMap集合

HashMap<k,v>集合为Map<k,v>接口的实现类，其底层为哈希表。为无顺序集合的集合，即存取顺序不一致，线程不安全，不同步，多线程。

Hashmap存储自定义类型键，自定义类型的键就要重写hashcode方法和equals方法，保证键的唯一性。值可以重复。（具体不详述）

LinkedHashMap集合

LinkedHashMap是HashMap的子类。其底层是哈希表+链表（保证迭代顺序），它是一个有序的集合，存取顺序一致。

Hashtable集合

Hashtable为Map接口的实现类，其底层也为哈希表，同步且为单线程集合，不常用。Hashtable 不能存取null值。

如果在Hashtable集合中存放null，则会抛出NullPointerException异常。

但是Hashtable的子类Properties集合依然活跃，Properties是唯一和IO流相结合的集合。

内容总结

以上是互联网集市为您收集整理的Java集合那点事，满满干货~全部内容，希望文章能够帮你解决Java集合那点事，满满干货~所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/641522.html

来源：【匿名】

【上一篇】Java规约之方法设计【下一篇】JAVA/JSP学习系列之五

更多 ►

【Java集合那点事，满满干货~】教程文章相关的互联网学习教程文章

集合：存储对象数据的集合容器。一、单列集合----------| Collection 单例集合的根接口----------------| List 如果是实现了List接口的集合类，具备的特点：有序，可重复。---------------------| ArrayList ArrayList底层是使用了Object数组实现的。特点：查询速度快，增删慢。---------------------| LinkedList LinkedList底层是使用了链表数据结构实现的。特点：查询速度慢，增删快---------------------| Vector 底层是...

Java集合框架常用类总结【图】

一、队列 queue常用方法：二、List 三、Set 四、Map 原文：https://www.cnblogs.com/yangfei629/p/13081677.html

java 集合（Vector）不做重点

Vector：　　　　底层也是维护了一个Object数组，实现与ArrayList是一样的，　　　　但其线程是安全的，效率低。除了比较老的系统，是不会用到的。笔试题：ArrayList 和 Vector 的区别。相同点：都是底层维护了一个Object数组。（看源码）不同点：ArrayList 是线程不同步地，操作效率高。（1.2）后来代替了Vector　　　　Vector 线程同步的，操作效率低。（1.0）原文：http://www.cnblogs.com/lifehrx/p/5797057.html

Java基础知识强化之集合框架笔记53：Map集合之Map集合的遍历键值对对象找键和值【代码】【图】

1. Map集合的遍历（键值对对象找键和值）Map -- 夫妻对思路： A: 获取所有结婚证的集合 B: 遍历结婚证的集合，得到每一个结婚证 C: 根据结婚证获取丈夫和妻子转换： A: 获取所有键值对对象的集合 B: 遍历键值对对象的集合，得到每一个键值对对象 C: 根据键值对对象获取键和值 2. 代码示例： 1package cn.itcast_01;2 3import java.util.HashMap;4import java.util.Map;5import java.util.Set;6 7/* 8 * 看看我们开始的一个方...

java基础——集合【代码】【图】

集合与数组的区别： 1.数组是固定长度的；集合的长度是可变的。 2.数组可以存储基本数据类型，也可以存储引用数据类型；集合只能存储引用数据类型。 3.数组存储元素必须是同一个数据类型；集合存储的对象可以是不同数据类型。 java集合主要有3种重要的类型： ●List：是一个有序集合，可以存放重复的数据。 ●Set: 是一个无序集合，不允许存放重复的数据。 ●Map: 是一个无序集合，集合中包含一个键对象和一个值对象，键对象不...

Java源码之集合框架（图）【图】

百度java 集合图时，搜出来一张图，图的蛮不错的，现在借用一下。图片来自：http://blog.csdn.net/bondsui/article/details/8520078原文：http://blog.csdn.net/itismelzp/article/details/50554921

java中求两个数组（集合）的交集，并集，差集【代码】

对于两个数组arr1=[1,3,4,5,8,9]arr2=[2,3,7,8,9]求出交集与并集test.java 1import java.util.ArrayList;2import java.util.Collections;3 4 5publicclass test1 {6publicstaticvoid main(String[] args) {7 ArrayList<Integer> tmplist=new ArrayList<Integer>();8int[] arr1={1,3,4,5,8,9};9int[] arr2={2,3,7,8,9}; 10 tmplist=Intersection(arr1,arr2); 11 OutPut(tmplist); 12 tmplist.clear(); 13 tmplist...

java复习 --集合类【图】

List接口：可以存放重复内容；set接口：不能存放重复内容，重复内容依靠hashcode和equal两个方法来区分；Queue：队列；SortedSet接口：对集合中的数据进行排序； List接口：List子类：ArrayList,VectorArrayList和Vector的区别：LinkedList类和queue接口LinedList 链表的操作类Queue接口是Collection的子接口 Set接口：Set接口是collection接口的子接口，但是和Collection或者List接口不同的是：set不能加入重复元素。set的主要方法...

java集合之LinkedList【代码】

1.LinkedList是什么？有什么特点　　LinkedList是一种可以在任何位置进行高效地插入和移除操作的有序序列，它是基于双向链表实现的。LinkedList 是一个继承于AbstractSequentialList的双向链表。它也可以被当作堆栈、队列或双端队列进行操作。LinkedList 实现 List 接口，能对它进行队列操作。LinkedList 实现 Deque 接口，即能将LinkedList当作双端队列使用。LinkedList 实现了Cloneable接口，即覆盖了函数clone()，能克隆。Linke...

java中的集合类【图】

实线边框的是实现类，比如ArrayList，LinkedList，HashMap等，折线边框的是抽象类，比如AbstractCollection，AbstractList，AbstractMap等，而点线边框的是接口，比如Collection，Iterator，List等。上述所有的集合类，都实现了Iterator接口，这是一个用于遍历集合中元素的接口，主要包含hashNext(),next(),remove()三种方法。它的一个子接口LinkedIterator在它的基础上又添加了三种方法，分别是add(),previous(),hasPrevious()。也...

java 数据类型：集合接口Collection之队列Queue:PriorityQueue ;Dequeue【图】

什么是Queue集合：Queue用于模拟队列这种数据结构，队列通常是“先进先出”（FIFO）的容器。队列的头部保存在队列中存放时间最长的元素，尾部保存存放时间最短的元素。 Queue接口定义了如下几个方法：void add(Object e):将制定的元素加入队列的尾部Object element(): 获取队列的头部元素，但不要删除改元素boolean offer(Object e): 将制定元素加入此队列的尾部。当使用有容量限制的队列的时候，该方法比add方法更好Object peek(...

Java自学-集合框架 HashMap和Hashtable的区别【代码】【图】

HashMap和Hashtable之间的区别步骤 1 : HashMap和Hashtable的区别HashMap和Hashtable都实现了Map接口，都是键值对保存数据的方式区别1： HashMap可以存放 null Hashtable不能存放null 区别2： HashMap不是线程安全的类 Hashtable是线程安全的类package collection;import java.util.HashMap; import java.util.Hashtable;public class TestCollection {public static void main(String[] args) {//HashMap和Hashtable都实现了Map接...

Java并发(四):并发集合ConcurrentHashMap的源码分析【代码】【图】

之前介绍了Java并发的基础知识和使用案例分析,接下来我们正式地进入Java并发的源码分析阶段,本文作为源码分析地开篇,源码参考JDK1.8OverView:　　JDK1.8源码中的注释提到:ConcurrentHashMap是一种提供完整的并发检索和对于并发更新有高预测性的散列表,遵循了与HashMap相同的功能性规格,并包含与HashTable每个方法都对应的方法.虽然所有操作都是线程安全的,但检索操作并不牵涉任何锁,不支持任何锁住整个散列表来保护所有的访问.　　...

Java基础——集合【代码】

存储对象可以考虑：数组，集合　　数组存储对象特点：Student[] stu = new Student[23]; str[0] = new Student();... 　　　　弊端：1.一旦创建，其长度不可改变　　　　　　　2.真实的数组存放的对象的个数是不可知的Java集合可分为Collection和Map两种体系： Collection接口：　　List接口：有序的，可重复元素相当于“动态”数组　　　　添加进List集合中的元素（或对象）所在的类一定要重写equals()方法；　　　　|---Ar...

java28：集合类2【代码】

增强for 循环 java 1.5 之后：用于遍历集合和数组（简化了遍历集合和数组的操作）for(ELEMENT_TYPE e : LIST_ARRAY){} 新循环是使用迭代器的形式实现的不要通过集合删除元素 for(String str : list){ System.out.println(str); list.remove(str);//报错不能删除 }package day28;import java.util.ArrayList; import java.util.Collection;public class Demo01 {public static void main...

首页 / JAVA / Java集合那点事，满满干货~

Java集合那点事，满满干货~

内容导读

内容图文

内容总结

内容备注

内容手机端

【Java集合那点事，满满干货~】教程文章相关的互联网学习教程文章

一、Java集合知识

Java集合框架常用类总结【图】

java 集合（Vector）不做重点

Java基础知识强化之集合框架笔记53：Map集合之Map集合的遍历键值对对象找键和值【代码】【图】

java基础——集合【代码】【图】

Java源码之集合框架（图）【图】

java中求两个数组（集合）的交集，并集，差集【代码】

java复习 --集合类【图】

java集合之LinkedList【代码】

java中的集合类【图】

java 数据类型：集合接口Collection之队列Queue:PriorityQueue ;Dequeue【图】

Java自学-集合框架 HashMap和Hashtable的区别【代码】【图】

Java并发(四):并发集合ConcurrentHashMap的源码分析【代码】【图】

Java基础——集合【代码】

java28：集合类2【代码】

JAVA - 相关标签

集合 - 相关标签

JAVA - 技术教程分类

JAVA - 最新教程

JAVA - 最热教程

首页 / JAVA / Java集合那点事， 满满干货~

Java集合那点事， 满满干货~

内容导读

内容图文

内容总结

内容备注

内容手机端

【Java集合那点事， 满满干货~】教程文章相关的互联网学习教程文章

JAVA - 相关标签

集合 - 相关标签

JAVA - 技术教程分类

JAVA - 最新教程

JAVA - 最热教程

首页 / JAVA / Java集合那点事，满满干货~

Java集合那点事，满满干货~

【Java集合那点事，满满干货~】教程文章相关的互联网学习教程文章