集合知识及简单操作

最新推荐文章于 2024-05-16 10:23:10 发布

Mortal_ApeBoys

最新推荐文章于 2024-05-16 10:23:10 发布

阅读量441

点赞数

文章标签： java

本文链接：https://blog.csdn.net/Mortal_ApeBoys/article/details/124088998

版权

ArrayList

ArrayList 类是一个可以动态修改的数组，与普通数组的区别就是它是没有固定大小的限制，我们可以添加或删除元素。

ArrayList 继承了 AbstractList ，并实现了 List 接口。

ArrayList 类位于 java.util 包中，使用前需要引入它，语法格式如下：

import java.util.ArrayList; // 引入 ArrayList 类

ArrayList<E> objectName =new ArrayList<>();　 // 初始化

package com.qiqinglei.aggregate;

/**
 * 引入java.util.ArrayList包
 */

import java.util.ArrayList;

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

        /**
         * 初始化ArrayList
         */
        ArrayList<Object> objects = new ArrayList<>();
    }

}

E: 泛型数据类型，用于设置 objectName 的数据类型，只能为引用数据类型。
objectName: 对象名。

ArrayList 是一个数组队列，提供了相关的添加、删除、修改、遍历等功能。

添加元素

ArrayList 类提供了很多有用的方法，添加元素到 ArrayList 可以使用 add() 方法:

实例

package com.qiqinglei.aggregate;

/**
 * 引入java.util.ArrayList包
 */
import java.util.ArrayList;

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

        /**
         * 初始化ArrayList
         */
        ArrayList<Object> objects = new ArrayList<>();

        /**
         * 添加元素
         */
        objects.add("字符串");
        objects.add(12);
        objects.add(false);
        
        System.out.println(objects);
    }

}

输出结果：

[字符串, 12, false]

访问元素

访问 ArrayList 中的元素可以使用 get() 方法：

实例

package com.qiqinglei.aggregate;

/**
 * 引入java.util.ArrayList包
 */

import java.util.ArrayList;

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

        /**
         * 初始化ArrayList
         */
        ArrayList<Object> objects = new ArrayList<>();

        /**
         * 添加元素
         */
        objects.add("字符串");
        objects.add(12);
        objects.add(false);

        System.out.println(objects);

        /**
         * 访问元素，查找元素
         */
//        objects.get(2);
        // 查找第二个元素
        System.out.println(objects.get(2));
    }

}

注意：数组的索引值从 0 开始。

以上实例，执行输出结果为：

false

修改元素

如果要修改 ArrayList 中的元素可以使用 set() 方法：

实例

package com.qiqinglei.aggregate;

/**
 * 引入java.util.ArrayList包
 */

import java.util.ArrayList;

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

        /**
         * 初始化ArrayList
         */
        ArrayList<Object> objects = new ArrayList<>();

        /**
         * 添加元素
         */
        objects.add("字符串");
        objects.add(12);
        objects.add(false);


        /**
         * 修改元素
         */
        // 使用set修改元素
        objects.set(2,15);
        System.out.println(objects);
    }

}

以上实例，执行输出结果为：

[字符串, 12, 15]

删除元素

如果要删除 ArrayList 中的元素可以使用 remove() 方法：

实例

package com.qiqinglei.aggregate;

/**
 * 引入java.util.ArrayList包
 */

import java.util.ArrayList;

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

        /**
         * 初始化ArrayList
         */
        ArrayList<Object> objects = new ArrayList<>();

        /**
         * 添加元素
         * add
         */
        objects.add("字符串");
        objects.add(12);
        objects.add(false);
        /**
         * 删除元素
         * remove
         */
        objects.remove(1);
        System.out.println(objects);
    }

}

以上实例，执行输出结果为：

[字符串, false]

计算大小

如果要计算 ArrayList 中的元素数量可以使用 size() 方法：

实例

package com.qiqinglei.aggregate;

/**
 * 引入java.util.ArrayList包
 */

import java.util.ArrayList;

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

        /**
         * 初始化ArrayList
         */
        ArrayList<Object> objects = new ArrayList<>();

        /**
         * 添加元素
         * add
         */
        objects.add("字符串");
        objects.add(12);
        objects.add(false);
        
        /**
         * 计算元素的数量
         * size
         */
        System.out.println( objects.size());
    }

}

迭代数组列表

我们可以使用 for 来迭代数组列表中的元素：

实例

package com.qiqinglei.aggregate;

/**
 * 引入java.util.ArrayList包
 */

import java.util.ArrayList;

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

        /**
         * 初始化ArrayList
         */
        ArrayList<Object> objects = new ArrayList<>();

        /**
         * 添加元素
         * add
         */
        objects.add("字符串");
        objects.add(12);
        objects.add(false);

        /**
         * 使用 for 来迭代数组列表中的元素
         */
        for (int i = 0; i < objects.size(); i++) {
            System.out.println(objects.get(i));

        }


    }

}

以上实例，执行输出结果为：

字符串
12
false

也可以使用 for-each 来迭代元素：

实例

package com.qiqinglei.aggregate;

/**
 * 引入java.util.ArrayList包
 */

import java.util.ArrayList;

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

        /**
         * 初始化ArrayList
         */
        ArrayList<Object> objects = new ArrayList<>();

        /**
         * 添加元素
         * add
         */
        objects.add("字符串");
        objects.add(12);
        objects.add(false);

        /**
         * 使用 for-each 来迭代元素
         */

        for (Object i : objects
             ) {
            System.out.println(i);

        }

    }

}

以上实例，执行输出结果为：

字符串
12
false

其他的引用类型

ArrayList 中的元素实际上是对象，在以上实例中，数组列表元素都是字符串 String 类型。

如果我们要存储其他类型，而只能为引用数据类型，这时我们就需要使用到基本类型的包装类。

基本类型对应的包装类表如下：

基本类型	引用类型
boolean	Boolean
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character

此外，BigInteger、BigDecimal 用于高精度的运算，BigInteger 支持任意精度的整数，也是引用类型，但它们没有相对应的基本类型。

ArrayList<Integer> li=new Arraylist<>();     // 存放整数元素
ArrayList<Character> li=new Arraylist<>();   // 存放字符元素

以下实例使用 ArrayList 存储数字(使用 Integer 类型):

实例

package com.qiqinglei.aggregate;

/**
 * 引入java.util.ArrayList包
 */

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;

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

        /**
         * 初始化ArrayList
         */
        ArrayList<Object> objects = new ArrayList<>();

        /**
         * 添加元素
         * add
         */
        objects.add("字符串");
        objects.add(12);
        objects.add(false);

        System.out.println(objects);

        /**
         * 访问元素，查找元素
         * get
         */
//        objects.get(2);
        // 查找第二个元素
        System.out.println(objects.get(2));

        /**
         * 修改元素
         * set
         */
        // 使用set修改元素
//        objects.set(2,15);
//        System.out.println(objects);

        /**
         * 删除元素
         * remove
         */
        objects.remove(1);
        System.out.println(objects);

        /**
         * 计算元素的数量
         * size
         */

        System.out.println( objects.size());


        /**
         * 使用 for 来迭代数组列表中的元素
         */
        for (int i = 0; i < objects.size(); i++) {
            System.out.println(objects.get(i));

        }
        /**
         * 使用 for-each 来迭代元素
         */

        for (Object i : objects
             ) {
            System.out.println(i);

        }
        ArrayList<Integer> integers = new ArrayList<>();
        integers.add(12);
        integers.add(16);
        integers.add(23);
        integers.add(15);
        integers.add(5);
        integers.add(6);
        integers.add(9);

        for (  int i: integers
             ) {
            System.out.println(i);

        }

        /**
         *   排序  升序
         *   Collections.sort()
         */
        Collections.sort(integers);
        for (Integer i : integers
             ) {
            System.out.println(i);
        }

        ArrayList<String> strings = new ArrayList<>();
        strings.add("CC");
        strings.add("BB");
        strings.add("DD");
        strings.add("SS");
        strings.add("WW");
        Collections.sort(strings);
        for (String s: strings
             ) {
            System.out.println(s);

        }

    }

}

以上实例，执行输出结果为：

BB
CC
DD
SS
WW

ArrayList 排序

Collections 类也是一个非常有用的类，位于 java.util 包中，提供的 sort() 方法可以对字符或数字列表进行排序。

以下实例对字母进行排序：

实例

package com.qiqinglei.aggregate;

/**
 * 引入java.util.ArrayList包
 */

import java.util.ArrayList;
import java.util.Collections;

public class ArrayListTest {
    public static void main(String[] args) {
        ArrayList<Integer> integers = new ArrayList<>();
        integers.add(12);
        integers.add(16);
        integers.add(23);
        integers.add(15);
        integers.add(5);
        integers.add(6);
        integers.add(9);

        for (  int i: integers
             ) {
            System.out.println(i);

        }

        /**
         *   排序  升序
         *   Collections.sort()
         */
        Collections.sort(integers);
        for (Integer i : integers
             ) {
            System.out.println(i);
        }

    }

}

以上实例，执行输出结果为：

以下实例对数字进行排序：

实例

package com.qiqinglei.aggregate;

/**
 * 引入java.util.ArrayList包
 */

import java.util.ArrayList;
import java.util.Collections;

public class ArrayListTest {
    public static void main(String[] args) {
        ArrayList<Integer> integers = new ArrayList<>();
        integers.add(12);
        integers.add(16);
        integers.add(23);
        integers.add(15);
        integers.add(5);
        integers.add(6);
        integers.add(9);

        for (  int i: integers
             ) {
            System.out.println(i);

        }

        /**
         *   排序  升序
         *   Collections.sort()
         */
        Collections.sort(integers);
        for (Integer i : integers
             ) {
            System.out.println(i);
        }

    }

}

以上实例，执行输出结果为：

Java ArrayList 方法

Java ArrayList 常用方法列表如下：

方法	描述
add()	将元素插入到指定位置的 arraylist 中
addAll()	添加集合中的所有元素到 arraylist 中
clear()	删除 arraylist 中的所有元素
clone()	复制一份 arraylist
contains()	判断元素是否在 arraylist
get()	通过索引值获取 arraylist 中的元素
indexOf()	返回 arraylist 中元素的索引值
removeAll()	删除存在于指定集合中的 arraylist 里的所有元素
remove()	删除 arraylist 里的单个元素
size()	返回 arraylist 里元素数量
isEmpty()	判断 arraylist 是否为空
subList()	截取部分 arraylist 的元素
set()	替换 arraylist 中指定索引的元素
sort()	对 arraylist 元素进行排序
toArray()	将 arraylist 转换为数组
toString()	将 arraylist 转换为字符串
ensureCapacity()	设置指定容量大小的 arraylist
lastIndexOf()	返回指定元素在 arraylist 中最后一次出现的位置
retainAll()	保留 arraylist 中在指定集合中也存在的那些元素
containsAll()	查看 arraylist 是否包含指定集合中的所有元素
trimToSize()	将 arraylist 中的容量调整为数组中的元素个数
removeRange()	删除 arraylist 中指定索引之间存在的元素
replaceAll()	将给定的操作内容替换掉数组中每一个元素
removeIf()	删除所有满足特定条件的 arraylist 元素
forEach()	遍历 arraylist 中每一个元素并执行特定操作

泛型

迭代器

java Iterator（迭代器）

Java Iterator（迭代器）不是一个集合，它是一种用于访问集合的方法，可用于迭代 ArrayList 和 HashSet 等集合。

Iterator 是 Java 迭代器最简单的实现，ListIterator 是 Collection API 中的接口，它扩展了 Iterator 接口。

迭代器 it 的两个基本操作是 next 、hasNext 和 remove。

调用 it.next() 会返回迭代器的下一个元素，并且更新迭代器的状态。

调用 it.hasNext() 用于检测集合中是否还有元素。

调用 it.remove() 将迭代器返回的元素删除。

Iterator 类位于 java.util 包中，使用前需要引入它，语法格式如下：

import java.util.Iterator; // 引入 Iterator 类

获取一个迭代器

集合想获取一个迭代器可以使用 iterator() 方法:

实例

package com.qiqinglei.aggregate;

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

public class IteratorTest {
    public static void main(String[] args) {
        // 创建集合
        ArrayList<String> strings = new ArrayList<>();
        // 添加元素
        strings.add("DD");
        strings.add("CC");
        strings.add("WW");
        strings.add("QQ");
        strings.add("LL");
        strings.add("YY");
        strings.add("TT");
        // 获取一个迭代器
        Iterator<String> it = strings.iterator();
        // 输出集合中的第一个元素
        System.out.println(it.next());
    }
}

执行以上代码，输出结果如下：

DD

循环集合元素

让迭代器 it 逐个返回集合中所有元素最简单的方法是使用 while 循环：

while(it.hasNext()) {
    System.out.println(it.next());
}

以下输出集合 sites 中的所有元素：

实例

package com.qiqinglei.aggregate;

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

public class IteratorTest {
    public static void main(String[] args) {
        // 创建集合
        ArrayList<String> strings = new ArrayList<>();
        // 添加元素
        strings.add("DD");
        strings.add("CC");
        strings.add("WW");
        strings.add("QQ");
        strings.add("LL");
        strings.add("YY");
        strings.add("TT");
        // 获取一个迭代器
        Iterator<String> it = strings.iterator();
		// 输出集合中所有的元素
          while (it.hasNext()){
            System.out.println(it.next());
        }
    }
}

执行以上代码，输出结果如下：

DD
CC
WW
QQ
LL
YY
TT

删除元素

要删除集合中的元素可以使用 remove() 方法。

以下实例我们删除集合中小于 10 的元素：

实例

package com.qiqinglei.aggregate;

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

public class IteratorClass {
    public static void main(String[] args) {
        // 创建一个集合
        ArrayList<Integer> integers = new ArrayList<>();
        // 添加元素
        integers.add(12);
        integers.add(16);
        integers.add(23);
        integers.add(15);
        integers.add(5);
        integers.add(6);
        integers.add(9);
        // 获取迭代器
        Iterator<Integer> it = integers.iterator();
        // 循环输出集合元素
        while (it.hasNext()) {
            Integer next = it.next();
            // 删除大于10 的元素
            if (next > 10) {
                it.remove();
            }
        }
        System.out.println(integers);

    }
}

执行以上代码，输出结果如下：

[5, 6, 9]

LinkedList

Java LinkedList

链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的地址。

链表可分为单向链表和双向链表。

一个单向链表包含两个值: 当前节点的值和一个指向下一个节点的链接。

一个双向链表有三个整数值: 数值、向后的节点链接、向前的节点链接。

Java LinkedList（链表）类似于 ArrayList，是一种常用的数据容器。

与 ArrayList 相比，LinkedList 的增加和删除的操作效率更高，而查找和修改的操作效率较低。

以下情况使用 ArrayList :

频繁访问列表中的某一个元素。
只需要在列表末尾进行添加和删除元素操作。

以下情况使用 LinkedList :

你需要通过循环迭代来访问列表中的某些元素。
需要频繁的在列表开头、中间、末尾等位置进行添加和删除元素操作。

LinkedList 继承了 AbstractSequentialList 类。

LinkedList 实现了 Queue 接口，可作为队列使用。

LinkedList 实现了 List 接口，可进行列表的相关操作。

LinkedList 实现了 Deque 接口，可作为队列使用。

LinkedList 实现了 Cloneable 接口，可实现克隆。

LinkedList 实现了 java.io.Serializable 接口，即可支持序列化，能通过序列化去传输。

LinkedList 类位于 java.util 包中，使用前需要引入它，语法格式如下：

// 引入 LinkedList 类
import java.util.LinkedList; 

LinkedList<E> list = new LinkedList<E>();   // 普通创建方法
或者
LinkedList<E> list = new LinkedList(Collection<? extends E> c); // 使用集合创建链表

创建一个简单的链表实例：

// 引入 LinkedList 类

实例

package com.qiqinglei.aggregate;

import java.util.LinkedList;

public class LinkedListClass {
    public static void main(String[] args) {
        // 创建链表实例
        LinkedList<String> strings = new LinkedList<>();
        strings.add("AA");
        strings.add("GG");
        strings.add("JJ");
        strings.add("BB");
        strings.add("MM");
        strings.add("XX");
        System.out.println(strings);

    }
}

以上实例，执行输出结果为：

[AA, GG, JJ, BB, MM, XX]

更多的情况下我们使用 ArrayList 访问列表中的随机元素更加高效，但以下几种情况 LinkedList 提供了更高效的方法。

在列表开头添加元素：

实例

package com.qiqinglei.aggregate;

import com.google.common.base.Strings;

import java.util.LinkedList;

public class LinkedListClass {
    public static void main(String[] args) {
        // 创建链表实例
        LinkedList<String> strings = new LinkedList<>();
        strings.add("AA");
        strings.add("GG");
        strings.add("JJ");
        strings.add("BB");
        strings.add("MM");
        strings.add("XX");
        // 在开头添加元素
        strings.addFirst("FF");
        System.out.println(strings);

    }
}

以上实例，执行输出结果为：

[FF, AA, GG, JJ, BB, MM, XX]

在列表结尾添加元素：

实例

package com.qiqinglei.aggregate;

import com.google.common.base.Strings;

import java.util.LinkedList;

public class LinkedListClass {
    public static void main(String[] args) {
        // 创建链表实例
        LinkedList<String> strings = new LinkedList<>();
        strings.add("AA");
        strings.add("GG");
        strings.add("JJ");
        strings.add("BB");
        strings.add("MM");
        strings.add("XX");
        System.out.println(strings);
        // 在开头添加元素
        strings.addFirst("FF");
        System.out.println(strings);
        // 在末尾添加元素
        strings.addLast("LL");
        System.out.println(strings);

    }
}

以上实例，执行输出结果为：

[FF, AA, GG, JJ, BB, MM, XX, LL]

在列表开头移除元素：

实例

package com.qiqinglei.aggregate;

import com.google.common.base.Strings;

import java.util.LinkedList;

public class LinkedListClass {
    public static void main(String[] args) {
        // 创建链表实例
        LinkedList<String> strings = new LinkedList<>();
        strings.add("AA");
        strings.add("GG");
        strings.add("JJ");
        strings.add("BB");
        strings.add("MM");
        strings.add("XX");
        System.out.println(strings);
        // 在开头添加元素
        strings.addFirst("FF");
        System.out.println(strings);
        // 在末尾添加元素
        strings.addLast("LL");
        System.out.println(strings);
        // 移除头部元素
        strings.removeFirst();
        System.out.println(strings);
        // 移除末尾元素
//        strings.removeLast();
//        System.out.println(strings);

    }
}

以上实例，执行输出结果为：

[AA, GG, JJ, BB, MM, XX, LL]

在列表结尾移除元素：

实例

package com.qiqinglei.aggregate;

import com.google.common.base.Strings;

import java.util.LinkedList;

public class LinkedListClass {
    public static void main(String[] args) {
        // 创建链表实例
        LinkedList<String> strings = new LinkedList<>();
        strings.add("AA");
        strings.add("GG");
        strings.add("JJ");
        strings.add("BB");
        strings.add("MM");
        strings.add("XX");
        System.out.println(strings);
        // 在开头添加元素
        strings.addFirst("FF");
        System.out.println(strings);
        // 在末尾添加元素
        strings.addLast("LL");
        System.out.println(strings);
        // 移除头部元素
        strings.removeFirst();
        System.out.println(strings);
        // 移除末尾元素
       strings.removeLast();
       System.out.println(strings);

    }
}

以上实例，执行输出结果为：

[AA, GG, JJ, BB, MM, XX]

获取列表开头的元素：

实例

package com.qiqinglei.aggregate;

import com.google.common.base.Strings;

import java.util.LinkedList;

public class LinkedListClass {
    public static void main(String[] args) {
        // 创建链表实例
        LinkedList<String> strings = new LinkedList<>();
        strings.add("AA");
        strings.add("GG");
        strings.add("JJ");
        strings.add("BB");
        strings.add("MM");
        strings.add("XX");
        System.out.println(strings);
        // 在开头添加元素
        strings.addFirst("FF");
        System.out.println(strings);
        // 在末尾添加元素
        strings.addLast("LL");
        System.out.println(strings);
        // 移除头部元素
        strings.removeFirst();
        System.out.println(strings);
        // 移除末尾元素
        strings.removeLast();
        System.out.println(strings);

        // 获取开头元素
        System.out.println(strings.getFirst());
       
    }
}

以上实例，执行输出结果为：

AA

获取列表结尾的元素：

实例

package com.qiqinglei.aggregate;

import com.google.common.base.Strings;

import java.util.LinkedList;

public class LinkedListClass {
    public static void main(String[] args) {
        // 创建链表实例
        LinkedList<String> strings = new LinkedList<>();
        strings.add("AA");
        strings.add("GG");
        strings.add("JJ");
        strings.add("BB");
        strings.add("MM");
        strings.add("XX");
        System.out.println(strings);
        // 在开头添加元素
        strings.addFirst("FF");
        System.out.println(strings);
        // 在末尾添加元素
        strings.addLast("LL");
        System.out.println(strings);
        // 移除头部元素
        strings.removeFirst();
        System.out.println(strings);
        // 移除末尾元素
        strings.removeLast();
        System.out.println(strings);

        // 获取开头元素
        System.out.println(strings.getFirst());
        // 获取末尾元素
        System.out.println(strings.getLast());
    }
}

以上实例，执行输出结果为：

XX

迭代元素

我们可以使用 for 配合 size() 方法来迭代列表中的元素：

实例

package com.qiqinglei.aggregate;

import com.google.common.base.Strings;

import java.util.LinkedList;

public class LinkedListClass {
    public static void main(String[] args) {
        // 创建链表实例
        LinkedList<String> strings = new LinkedList<>();
        strings.add("AA");
        strings.add("GG");
        strings.add("JJ");
        strings.add("BB");
        strings.add("MM");
        strings.add("XX");
    
        // 使用for循环配合size()方法遍历迭代列表元素
        for (int  size =  strings.size(), i = 0; i < size; i++) {

            System.out.println(strings.get(i));

        }
        
    }
}

size() 方法用于计算链表的大小。

以上实例，执行输出结果为：

AA
GG
JJ
BB
MM
XX

也可以使用 for-each 来迭代元素：

实例

package com.qiqinglei.aggregate;

import com.google.common.base.Strings;

import java.util.LinkedList;

public class LinkedListClass {
    public static void main(String[] args) {
        // 创建链表实例
        LinkedList<String> strings = new LinkedList<>();
        strings.add("AA");
        strings.add("GG");
        strings.add("JJ");
        strings.add("BB");
        strings.add("MM");
        strings.add("XX");
     
        // 使用for-each 遍历迭代列表元素
        for (String s:strings
             ) {
            System.out.println(s);

        }
    }
}

以上实例，执行输出结果为：

AA
GG
JJ
BB
MM
XX

常用方法

方法	描述
public boolean add(E e)	链表末尾添加元素，返回是否成功，成功为 true，失败为 false。
public void add(int index, E element)	向指定位置插入元素。
public boolean addAll(Collection c)	将一个集合的所有元素添加到链表后面，返回是否成功，成功为 true，失败为 false。
public boolean addAll(int index, Collection c)	将一个集合的所有元素添加到链表的指定位置后面，返回是否成功，成功为 true，失败为 false。
public void addFirst(E e)	元素添加到头部。
public void addLast(E e)	元素添加到尾部。
public boolean offer(E e)	向链表末尾添加元素，返回是否成功，成功为 true，失败为 false。
public boolean offerFirst(E e)	头部插入元素，返回是否成功，成功为 true，失败为 false。
public boolean offerLast(E e)	尾部插入元素，返回是否成功，成功为 true，失败为 false。
public void clear()	清空链表。
public E removeFirst()	删除并返回第一个元素。
public E removeLast()	删除并返回最后一个元素。
public boolean remove(Object o)	删除某一元素，返回是否成功，成功为 true，失败为 false。
public E remove(int index)	删除指定位置的元素。
public E poll()	删除并返回第一个元素。
public E remove()	删除并返回第一个元素。
public boolean contains(Object o)	判断是否含有某一元素。
public E get(int index)	返回指定位置的元素。
public E getFirst()	返回第一个元素。
public E getLast()	返回最后一个元素。
public int indexOf(Object o)	查找指定元素从前往后第一次出现的索引。
public int lastIndexOf(Object o)	查找指定元素最后一次出现的索引。
public E peek()	返回第一个元素。
public E element()	返回第一个元素。
public E peekFirst()	返回头部元素。
public E peekLast()	返回尾部元素。
public E set(int index, E element)	设置指定位置的元素。
public Object clone()	克隆该列表。
public Iterator descendingIterator()	返回倒序迭代器。
public int size()	返回链表元素个数。
public ListIterator listIterator(int index)	返回从指定位置开始到末尾的迭代器。
public Object[] toArray()	返回一个由链表元素组成的数组。
public T[] toArray(T[] a)	返回一个由链表元素转换类型而成的数组。

ArrayList 与LinkedList

ArrayList特点：新增，删除速度慢，因为ArrayList底层是数组结构，添加数据是有可能造成数组的拷贝，删除时，有可能造成数据的移动，查询速度快，因为底层是线性链表结构，下标是有序的

LinkedList特点：新增，删除速度快，查询速度慢。因为LinkedList底层是双向链表结构新增，删除时不会发生数据的改变，查询速度慢因为，双向链表结构数据下标是无序的，查询时需要先将数据下标进行排序

Set 与 List

List ：有序可重复，有序是指按照新增的顺序存储，重复是指，存储元素的值可以重复

Set：无序不可重复，无序指的是不会按照新增的顺序存储，不可重复是，存储的元素的值不可以重复。

HashSet：无序不可重复，无序指的是不会按照新增的顺序存储，不可重复是，存储的元素的值不可以重复。

LinkedHashSet：有序不可重复，有序是指按照新增的顺序存储，不可重复是，存储的元素的值不可以重复。

TreeSet

Map

Java HashMap

HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。

HashMap 实现了 Map 接口，根据键的 HashCode 值存储数据，具有很快的访问速度，最多允许一条记录的键为 null，不支持线程同步。

HashMap 是无序的，即不会记录插入的顺序。

HashMap 继承于AbstractMap，实现了 Map、Cloneable、java.io.Serializable 接口。

HashMap 的 key 与 value 类型可以相同也可以不同，可以是字符串（String）类型的 key 和 value，也可以是整型（Integer）的 key 和字符串（String）类型的 value。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aAuZ4bUV-1649606416418)(https://static.runoob.com/images/mix/java-map.svg)]

HashMap 中的元素实际上是对象，一些常见的基本类型可以使用它的包装类。

基本类型对应的包装类表如下：

基本类型	引用类型
boolean	Boolean
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character

HashMap 类位于 java.util 包中，使用前需要引入它，语法格式如下：

import java.util.HashMap; // 引入 HashMap 类

以下实例我们创建一个 HashMap 对象 Sites，整型（Integer）的 key 和字符串（String）类型的 value：

HashMap<Integer, String> Sites = new HashMap<Integer, String>();

添加元素

HashMap 类提供了很多有用的方法，添加键值对(key-value)可以使用 put() 方法:

put()方法：如果key不存在就是新增，存在就是修改

key：无序不可重复，

value：可以重复

实例

package com.qiqinglei.HashMap;

import org.junit.jupiter.api.Test;

import java.util.HashMap;

public class HashMapTest {
    @Test
    public void test(){
        HashMap<Integer, String> hashMap = new HashMap<>();
        hashMap.put(1,"value1");
        hashMap.put(2,"value2");
        hashMap.put(3,"value3");
        hashMap.put(4,"value4");
        System.out.println(hashMap);
    }
}

执行以上代码，输出结果如下：

{1=value1, 2=value2, 3=value3, 4=value4}

以下实例创建一个字符串（String）类型的 key 和字符串（String）类型的 value：

实例

// 引入 HashMap 类
import java.util.HashMap;

public class RunoobTest {
public static void main(String[] args) {
// 创建 HashMap 对象 Sites
HashMap<String, String> Sites = new HashMap<String, String>();
// 添加键值对
Sites.put(“one”, “Google”);
Sites.put(“two”, “Runoob”);
Sites.put(“three”, “Taobao”);
Sites.put(“four”, “Zhihu”);
System.out.println(Sites);
}
}

执行以上代码，输出结果如下：

{four=Zhihu, one=Google, two=Runoob, three=Taobao}

访问元素

我们可以使用 get(key) 方法来获取 key 对应的 value:

实例

// 引入 HashMap 类
import java.util.HashMap;

执行以上代码，输出结果如下：

Taobao

删除元素

我们可以使用 remove(key) 方法来删除 key 对应的键值对(key-value):

实例

// 引入 HashMap 类
import java.util.HashMap;

执行以上代码，输出结果如下：

{1=Google, 2=Runoob, 3=Taobao}

删除所有键值对(key-value)可以使用 clear 方法：

实例

// 引入 HashMap 类
import java.util.HashMap;

执行以上代码，输出结果如下：

{}

计算大小

如果要计算 HashMap 中的元素数量可以使用 size() 方法：

实例

// 引入 HashMap 类
import java.util.HashMap;

执行以上代码，输出结果如下：

迭代 HashMap

可以使用 for-each 来迭代 HashMap 中的元素。

如果你只想获取 key，可以使用 keySet() 方法，然后可以通过 get(key) 获取对应的 value，如果你只想获取 value，可以使用 values() 方法。

实例

// 引入 HashMap 类
import java.util.HashMap;

public class RunoobTest {
public static void main(String[] args) {
// 创建 HashMap 对象 Sites
HashMap<Integer, String> Sites = new HashMap<Integer, String>();
// 添加键值对
Sites.put(1, “Google”);
Sites.put(2, “Runoob”);
Sites.put(3, “Taobao”);
Sites.put(4, “Zhihu”);
// 输出 key 和 value
for (Integer i : Sites.keySet()) {
System.out.println("key: " + i + " value: " + Sites.get(i));
}
// 返回所有 value 值
for(String value: Sites.values()) {
// 输出每一个value
System.out.print(value + ", ");
}
}
}

执行以上代码，输出结果如下：

key: 1 value: Google
key: 2 value: Runoob
key: 3 value: Taobao
key: 4 value: Zhihu
Google, Runoob, Taobao, Zhihu,

Java HashMap 方法

hashmap

Java HashMap 常用方法列表如下：

方法	描述
clear()	删除 hashMap 中的所有键/值对
clone()	复制一份 hashMap
isEmpty()	判断 hashMap 是否为空
size()	计算 hashMap 中键/值对的数量
put()	将键/值对添加到 hashMap 中
putAll()	将所有键/值对添加到 hashMap 中
putIfAbsent()	如果 hashMap 中不存在指定的键，则将指定的键/值对插入到 hashMap 中。
remove()	删除 hashMap 中指定键 key 的映射关系
containsKey()	检查 hashMap 中是否存在指定的 key 对应的映射关系。
containsValue()	检查 hashMap 中是否存在指定的 value 对应的映射关系。
replace()	替换 hashMap 中是指定的 key 对应的 value。
replaceAll()	将 hashMap 中的所有映射关系替换成给定的函数所执行的结果。
get()	获取指定 key 对应对 value
getOrDefault()	获取指定 key 对应对 value，如果找不到 key ，则返回设置的默认值
forEach()	对 hashMap 中的每个映射执行指定的操作。
entrySet()	返回 hashMap 中所有映射项的集合集合视图。
keySet()	返回 hashMap 中所有 key 组成的集合视图。
values()	返回 hashMap 中存在的所有 value 值。
merge()	添加键值对到 hashMap 中
compute()	对 hashMap 中指定 key 的值进行重新计算
computeIfAbsent()	对 hashMap 中指定 key 的值进行重新计算，如果不存在这个 key，则添加到 hasMap 中
computeIfPresent()	对 hashMap 中指定 key 的值进行重新计算，前提是该 key 存在于 hashMap 中。

LinkedHashMap

LinkedHashMap

ConcurrentHashMap

Mortal_ApeBoys

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
集合知识及简单操作

ArrayListArrayList 类是一个可以动态修改的数组，与普通数组的区别就是它是没有固定大小的限制，我们可以添加或删除元素。ArrayList 继承了 AbstractList ，并实现了 List 接口。ArrayList 类位于 java.util 包中，使用前需要引入它，语法格式如下：import java.util.ArrayList; // 引入 ArrayList 类ArrayList<E> objectName =new ArrayList<>(
复制链接

扫一扫