Java中的各种集合

最新推荐文章于 2024-08-05 23:39:18 发布
最新推荐文章于 2024-08-05 23:39:18 发布
阅读量143 收藏
点赞数
分类专栏： JAVA 文章标签： java 集合论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/v02040212/article/details/108966423
版权

集合

List集合

  • java.util.List接口 extends Collection接口

  • List接口的特点:
    1、有序的集合,存储元素和取出元素的顺序是一致的(存储123 取出123)
    2、有索引,包含了一些带索引的方法
    3、允许存储重复的元素

  • List接口中带索引的方法(特有)

public void add(int index, E element): 将指定的元素，添加到该集合中的指定位置上。
public E get(int index):返回集合中指定位置的元素。
public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。
public E set(int index, E element):用指定元素替换集合中指定位置的元素,返回值的更新前的元素。

  • 注意:
    操作索引的时候,一定要防止索引越界异常

IndexOutOfBoundsException:索引越界异常,集合会报ArrayIndexOutOfBoundsException:数组索引越界异常
StringIndexOutOfBoundsException:字符串索引越界异常

  • 代码示例：
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        //创建一个List集合对象，多态
        List<String> list = new ArrayList<>();
        //使用add方法往集合中添加元素
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("a");
        //打印集合
        System.out.println(list);//[a, b, c, d, a]  不是地址重写了toString

        //public void add(int index, E element): 将指定的元素，添加到该集合中的指定位置上。
        //在c和d之间添加一个lzh
        list.add(3,"lzh");
        System.out.println(list);//[a, b, c, lzh, d, a]

        //public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。
        //移除元素
        String removeE = list.remove(2);
        System.out.println("被移除的元素：" + removeE);//被移除的元素：c
        System.out.println(list);//[a, b, lzh, d, a]

        //public E set(int index, E element):用指定元素替换集合中指定位置的元素,返回值的更新前的元素。
        //把最后一个a,替换为A
        String setE = list.set(4, "A");
        System.out.println("被替换的元素:"+setE);//被替换的元素:a
        System.out.println(list);//[a, b, lzh, d, A]

        //List集合遍历有3种方式
        //使用普通的for循环
        for (int i = 0; i < list.size(); i++) {
            //public E get(int index):返回集合中指定位置的元素。
            String s = list.get(i);
            System.out.println(s);
        }
        System.out.println("====================");
        //使用迭代器
        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            String s = it.next();
            System.out.println(s);
        }
        System.out.println("=====================");
        //使用增强for
        for (String s : list) {
            System.out.println(s);
        }
    }
}

LinkedList集合

  • java.util.LinkedList集合 implements List接口

  • LinkedList集合的特点:
    1、底层是一个链表结构:查询慢,增删快
    2、里边包含了大量操作首尾元素的方法
    3、注意:使用LinkedList集合特有的方法,不能使用多态

  • 代码示例：

import java.util.LinkedList;

public class Main {
    public static void main(String[] args) {
        show01();
        show02();
        show03();
    }

    /**
        - public E removeFirst():移除并返回此列表的第一个元素。
        - public E removeLast():移除并返回此列表的最后一个元素。
        - public E pop():从此列表所表示的堆栈处弹出一个元素。此方法相当于 removeFirst
     */
    private static void show03() {
        //创建LinkedList集合对象
        LinkedList<String> linked = new LinkedList<>();
        //使用add方法往集合中添加元素
        linked.add("a");
        linked.add("b");
        linked.add("c");
        System.out.println(linked);//[a, b, c]

        //String first = linked.removeFirst();
        String first = linked.pop();//与linked.removeFirst()效果相同
        System.out.println("被移除的第一个元素：" + first);
        String last = linked.removeLast();
        System.out.println("被移除的第一个元素：" + last);
        System.out.println(linked);
    }

    /**
        - public E getFirst():返回此列表的第一个元素。
        - public E getLast():返回此列表的最后一个元素。
     */
    private static void show02() {
        //创建LinkedList集合对象
        LinkedList<String> linked = new LinkedList<>();
        //使用add方法往集合中添加元素
        linked.add("a");
        linked.add("b");
        linked.add("c");

        linked.clear();//清空集合中的元素 在获取集合中的元素会抛出NoSuchElementException

        //public boolean isEmpty()：如果列表不包含元素，则返回true。
        if (!linked.isEmpty()) {
            String first = linked.getFirst();
            System.out.println(first);
            String last = linked.getLast();
            System.out.println(last);
        }
    }

    /**
        - public void addFirst(E e):将指定元素插入此列表的开头。
        - public void addLast(E e):将指定元素添加到此列表的结尾。
        - public void push(E e):将元素推入此列表所表示的堆栈。此方法等效于 addFirst(E)。
     */
    private static void show01() {
        //创建LinkedList集合对象
        LinkedList<String> linked = new LinkedList<>();
        //使用add方法往集合中添加元素
        linked.add("a");
        linked.add("b");
        linked.add("c");
        System.out.println(linked);//[a, b, c]

        //public void addFirst(E e):将指定元素插入此列表的开头。
        linked.addFirst("www");
        linked.push("www");//与linked.addFirst("www")效果一致
        System.out.println(linked);//[www, a, b, c]

        //public void addLast(E e):将指定元素添加到此列表的结尾。此方法等效于 add()
        linked.addLast("com");
        System.out.println(linked);
    }
}

HashSet集合

  • java.util.Set接口 extends Collection接口

  • Set接口的特点:
    1、不允许存储重复的元素
    2、没有索引,没有带索引的方法,也不能使用普通的for循环遍历

  • java.util.HashSet集合 implements Set接口

  • HashSet特点:
    1、不允许存储重复的元素
    2、没有索引,没有带索引的方法,也不能使用普通的for循环遍历
    3、是一个无序的集合,存储元素和取出元素的顺序有可能不一致
    4、底层是一个哈希表结构(查询的速度非常的快)

  • 代码示例：

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

public class MySet {
    public static void main(String[] args) {
        Set<Integer> set = new HashSet<>();
        //使用add方法往集合中添加元素
        set.add(1);
        set.add(3);
        set.add(2);
        set.add(1);
        //使用迭代器遍历Set集合
        Iterator<Integer> it = set.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());//1 2 3
        }
        //使用增强for遍历Set集合
        System.out.println("================");
        for (Integer i : set) {
            System.out.println(i);
        }
    }
}

哈希值

  • 哈希值:是一个十进制的整数,由系统随机给出(就是对象的地址值,是一个逻辑地址,是模拟出来得到地址,不是数据实际存储的物理地址)

  • 在Object类有一个方法,可以获取对象的哈希值

    int hashCode() 返回该对象的哈希码值。

  • hashCode方法的源码:

public native int hashCode();
native:代表该方法调用的是本地操作系统的方法

public class MyHashCode {
    public static void main(String[] args) {
        //Person类继承了Object类，所以可以使用Object类的hashCode方法
        Person p1 = new Person();
        int h1 = p1.hashCode();
        System.out.println(h1); //1163157884

        Person p2 = new Person();
        int h2 = p2.hashCode();
        System.out.println(h2); //1956725890

        /**
            toString方法的源码:
                return getClass().getName() + "@" + Integer.toHexString(hashCode());
         */
        System.out.println(p1);//com.lzh.day03.Person@4554617c
        System.out.println(p2);//com.lzh.day03.Person@74a14482
        System.out.println(p1==p2);//false

        /**
            String类的哈希值
                String类重写Obejct类的hashCode方法
         */
        String s1 = new String("abc");
        String s2 = new String("abc");
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());

        System.out.println("重地".hashCode());//1179395
        System.out.println("通话".hashCode());//1179395
    }
}

Set集合

java.util.Set接口和java.util.List接口一样，同样继承自Collection接口，它与Collection接口中的方法基本一致，并没有对Collection接口进行功能上的扩充，只是比Collection接口更加严格了。与List接口不同的是，Set接口中元素无序，并且都会以某种规则保证存入的元素不出现重复。

Set集合有多个子类，这里我们介绍其中的java.util.HashSet、java.util.LinkedHashSet这两个集合。

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

public class MySet {
    public static void main(String[] args) {
        Set<Integer> set = new HashSet<>();
        //使用add方法往集合中添加元素
        set.add(1);
        set.add(3);
        set.add(2);
        set.add(1);
        //使用迭代器遍历Set集合
        Iterator<Integer> it = set.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());//1 2 3
        }
        //使用增强for遍历Set集合
        System.out.println("================");
        for (Integer i : set) {
            System.out.println(i);
        }
    }
}
  • Set集合取出元素的方式可以采用：迭代器、增强for。

LinkedHashSet集合

java.util.LinkedHashSet集合 extends HashSet集合

  • LinkedHashSet集合特点:

  •     底层是一个哈希表(数组+链表/红黑树)+链表:

  •     多了一条链表(记录元素的存储顺序),保证元素有序

import java.util.HashSet;
import java.util.LinkedHashSet;

public class Main {
    public static void main(String[] args) {
        HashSet<String> set = new HashSet<>();
        set.add("www");
        set.add("abc");
        set.add("abc");
        set.add("itcast");
        System.out.println(set);//[abc, www, itcast]无序,不允许重复

        LinkedHashSet<String> linked = new LinkedHashSet<>();
        linked.add("www");
        linked.add("abc");
        linked.add("abc");
        linked.add("itcast");
        System.out.println(linked);//[www, abc, itcast]有序,不允许重复
    }
}

可变参数

  • 可变参数:是JDK1.5之后出现的新特性

  • 使用前提:
    当方法的参数列表数据类型已经确定,但是参数的个数不确定,就可以使用可变参数.

  • 使用格式：定义方法时使用

修饰符 返回值类型 方法名(数据类型…变量名){}

  • 可变参数的原理:
    可变参数底层就是一个数组,根据传递参数个数不同,会创建不同长度的数组,来存储这些参数
    传递的参数个数,可以是0个(不传递),1,2…多个

  • 代码示例：

public class Main {
    public static void main(String[] args) {
        int i = add(10,20,30,40,50,60,70,80,90,100);
        System.out.println(i);
    }
    /**
        定义计算(0-n)整数和的方法
        已知:计算整数的和,数据类型已经确定int
        但是参数的个数不确定,不知道要计算几个整数的和,就可以使用可变参数
        add(); 就会创建一个长度为0的数组, new int[0]
        add(10); 就会创建一个长度为1的数组,存储传递来过的参数 new int[]{10};
        add(10,20); 就会创建一个长度为2的数组,存储传递来过的参数 new int[]{10,20};
        add(10,20,30,40,50,60,70,80,90,100); 就会创建一个长度为2的数组,存储传递来过的参数 new int[]{10,20,30,40,50,60,70,80,90,100};
     */
    public static int add(int...arr) {
        /*System.out.println(arr);//[I@4554617c 底层是一个数组
        System.out.println(arr.length);*/

        //定义一个初始化变量，记录累加求和
        int sum = 0;
        for (int i : arr) {
            //累加求和
            sum += i;
        }
        return sum;
    }
}
  • 可变参数的注意事项：
    1、一个方法的参数列表,只能有一个可变参数
    2、如果方法的参数有多个,那么可变参数必须写在参数列表的末尾

Collections集合

  • java.utils.Collections是集合工具类，用来对集合进行操作。部分方法如下：

public static boolean addAll(Collection c, T… elements):往集合中添加一些元素。
public static void shuffle(List<?> list) 打乱顺序:打乱集合顺序。

  • 代码示例：
import java.util.ArrayList;
import java.util.Collections;

public class Main {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();

        //public static <T> boolean addAll(Collection<T> c, T... elements):往集合中添加一些元素。
        Collections.addAll(list,"a","b","c","d","e");
        System.out.println(list);//[a, b, c, d, e]

        //public static void shuffle(List<?> list) 打乱顺序:打乱集合顺序。
        Collections.shuffle(list);
        System.out.println(list);
    }
}
  • sort排序

public static void sort(List list，Comparator<? super T> ):将集合中元素按照指定规则排序

  • 代码示例：
import java.util.ArrayList;
import java.util.Collections;

public class MyCollections{
    public static void main(String[] args) {
        ArrayList<Integer> list01 = new ArrayList<>();
        list01.add(1);
        list01.add(3);
        list01.add(2);
        System.out.println(list01);//[1, 3, 2]

        //public static <T> void sort(List<T> list，Comparator<? super T> ):将集合中元素按照指定规则排序
        Collections.sort(list01);   //默认是升序
        System.out.println(list01);

        ArrayList<String> list02 = new ArrayList<>();
        list02.add("a");
        list02.add("c");
        list02.add("b");
        System.out.println(list02);

        Collections.sort(list02);   //默认是升序
        System.out.println(list02);
    }
}

  • 注意sort(List list)使用前提：
    被排序的集合里边存储的元素,必须实现Comparable,重写接口中的方法compareTo定义排序的规则

  • 练习：创建一个学生类，存储到ArrayList集合中完成指定排序操作。

Student 初始类：

public class Student implements Comparable<Student> {
    private String name;
    private 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 +
               '}';
    }

	//如果想要集合中的元素完成排序，那么必须要实现比较器Comparable接口。
	@Override
    public int compareTo(Student o) {
        return this.age-o.age;//升序
    }
}

测试类：

public class Demo {

    public static void main(String[] args) {
        // 创建四个学生对象 存储到集合中
        ArrayList<Student> list = new ArrayList<Student>();

        list.add(new Student("rose",18));
        list.add(new Student("jack",16));
        list.add(new Student("abc",16));
        list.add(new Student("ace",17));
        list.add(new Student("mark",16));


        /*
          让学生 按照年龄排序 升序
         */
        Collections.sort(list);//要求 该list中元素类型  必须实现比较器Comparable接口

        for (Student student : list) {
            System.out.println(student);
        }
    }
}
lzh(๑′ᴗ‵๑)
关注
专栏目录
Java中的集合框架
08-31
Java集合框架还包括其他重要接口和类，如Queue（队列）、Deque（双端队列）、SortedSet（排序集合）和NavigableMap（导航映射），以及各种实用类如ArrayList、LinkedList、HashSet、HashMap等的实现细节。...
java中的集合
weixin_64189867的博客
06-09 2810
Java的集合框架是由很多接口、抽象类、具体类组成的，都位于java.util包中。
java集合（超详细）
热门推荐
zdl66的博客
08-12 5万+
所有的集合类和集合接口都在java.util包下。 在内存中申请一块空间用来存储数据，在Java中集合就是替换掉定长的数组的一种引用数据类型。
一篇文章来你学完Java中的集合（超详细）
最新发布
2301_79842503的博客
08-05 1356
存储的是引用：Java集合存储的是对象的引用，而不是对象本身。操作的是引用：对集合的操作（如添加、获取、更新、删除）实际上是在操作这些引用。影响垃圾回收：集合中存储的引用会影响对象的垃圾回收过程，因为只要引用存在，对象就不会被回收。ListJava中的Set集合主要用于存储不重复的元素。Set接口继承自Collection接口，但它不保证维护任何特定的顺序（除非该集合是某个特定类型的，比如，它按照元素被插入的顺序来遍历元素）。Set接口的实现类主要有HashSetTreeSet等。
Java中的集合
weixin_52071901的博客
06-13 8256
java-api，day01
java集合详解
weixin_51991393的博客
06-15 3321
键不能重复，值可以重复，每一个键只能找到自己对应的值。
java中各种集合的用法
05-24
java中各种集合的用法 Java集合Collection、List、Set、Map使用详解
基于java中集合的概念(详解)
08-29
迭代器是集合的特有遍历方法，可以取出集合中的元素。集合接口是 Java 中的接口，定义了集合的基本操作，例如添加、删除、查找等。 集合可以分为两种：List 和 Set。List 是一种有序的集合，元素可以重复，例如 ...
Java中数组与集合的相互转换实现解析
08-25
Java中数组与集合的相互转换实现解析 Java中数组和集合是两种不同的数据结构，数组是一种固定长度的数据结构，而集合是一种可变长度的数据结构。它们之间的转换是非常重要的，在实际开发中经常会遇到这种情况。...
Java 得到集合中所有子集
08-31
在Java编程中，得到集合中所有子集是一个常见的算法问题，尤其在数据结构和算法面试中经常出现。本文将深入探讨如何使用Java实现这一功能，同时解析相关知识点。 首先，我们要明白子集的概念。在数学中，如果一个...
Java集合详解(含JDK8源码)
qq_62767608的博客
03-29 4218
Java集合底层源码讲解
Java集合系列详解
wang_yong_hui_1234的博客
03-25 5665
一，集合简介 Java中的集合可以分为四种体系： List：代表有序、重复的集合 Set：代表无序、不可重复的集合 Map：代表具有映射关系的集合 Queue：体系集合，代表一种队列集合实现 二，Java集合类的关系 Java中的集合类主要有两个接口派生：Collection和Map Collection类图如下： Map类图如下： 三，Collection接口 1，Set体系 Set是一种...
java集合详解（长达两万字）
晚笛的博客
05-13 8373
collection接口和Map接口详解(包含底层源码解析)
Java集合全解【完整版】
Lov1_BYS的博客
01-12 1万+
Java集合：单列集合、双列集合等接口及实现子类原理、方法讲解
Java集合（全）
小杨的博客
05-03 1万+
一.Java集合框架概述 一方面，面向对象语言对事物的体现都是以对象的形式，为了方便对多个对象的操作，就要对对象进行存储。另一方面，使用Array存储对象方面具有一些弊端，而Java集合就像一种容器，可以动态的把多个对象的引用放入容器中。 1.数组Array存储 （1）数组在内存存储方面的特点： ①数组初始化以后，长度就确定了。 ②数组声明的类型，就决定了进行元素初始化的类型。 （2）数组在存储数据方面的弊端： ①数组初始化以后，.........
第十四章 Java集合
你好, 我在学java的博客
11-13 5562
创建TreeSet对象时如果传入了一个Comparator对象，就用实现的compare方法去除重复元素，如果方法返回0，就认为不应该添加；如果没有传入Comparator对象，则以添加对象的实现的Comparable接口的compareTo方法去除重复元素；原因：创建TreeSet对象时如果传入了一个Comparator对象，就用实现的compare方法比较；如果没有传入Comparator对象，则以添加对象的实现的Comparable接口的compareTo方法比较；第二次添加时，遍历所有的key。
Java泛型与集合深度解析
"Java泛型和集合是Java编程语言中的核心特性，用于增强类型安全性和代码复用。这本书由Maurice Naftalin和Philip Wadler撰写，深入探讨了这些主题，旨在帮助开发者更好地理解和利用Java的泛型以及集合框架。" 在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值