devbox
菜鸟追梦旅行
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

详解Java中集合的List接口实现的ArrayList方法 | Set接口实现的HashSet方法

作者：菜鸟追梦旅行 | 2024-03-07 12:51:01

赞

踩

详解Java中集合的List接口实现的ArrayList方法 | Set接口实现的HashSet方法

集合的概念

      当我们需要保存一组一样（类型相同）的元素的时候，我们应该使用一个容器来存储，数组就是这样一个容器。

● 数组的特点：     

      数组是一组数据类型相同的元素集合；

      创建数组时，必须给定长度，而且一旦创建长度不能改变；

      一旦数组装满元素，就需要创建一个新的数组，将元素复制过去；

● 数组的局限：

        如果装满了，就需要数组复制；

        当我们需要从数组中删除或添加一个元素，需要移动后面的元素；

● 集合的作用：

       在开发实践中，我们需要一些能够动态增长长度的容器来保存我们的数据，java中为了解决数据存储单一的情况，java中就提供了不同结构的集合类，可以让我们根据不同的场景进行数据存储的选择，如Java中提供了 数组实现的集合，链表实现的集合，哈希结构，树结构等。

分类

● 单列集合：一次放进去一个值 ( 对象 )

Collection接口：定义了单列集合共有的方法，其子接口Set和List分别定义了存储方式

● List：可以有重复元素

● Set：不可以有重复元素

● 双列集合： 键    值

集合API

集合体系概述: Java的集合框架是由很多接口、抽象类、具体类组成的，都位于java.util包中。

List 接口及实现类

概念：List继承了Collection接口,有三个实现的类,分别是：

● ArrayList       数组列表

● LinkedList     链表列表

● Vector            数组列表 （是线程安全的）

1.  ArrayList

         ● 底层有一个数组，可以动态扩展数组长度，并提供了一系列方法操作。

特点： 查询快，在中间增加 / 删除慢

注意：集合容器类中默认可以添加Object类型，但是一般建议一个集合对象只保存同一种类型，若保存多个类型后期处理时涉及类型转换问题；所以我们可以通过泛型来加以控制。

  
         ● 泛型：声明类型时可以自定义参数类型
                      ArraysList  <E>
ArrayList的常用方法：

  1. ArrayList<String> arrayList = new ArrayList();
  2.         arrayList.add("a");
  3.         arrayList.add("b");
  4.         arrayList.add("c");
  5.         arrayList.add(3,"a");
  6.        
  7.         arrayList.remove("a");  //根据内容删除匹配的第一个元素,返回值为boolean
  8.         arrayList.remove(1);    //删除并返回指定位置的元素
  9.         arrayList.get(1);         //获取指定位置的元素
  10.         arrayList.set(1,"X");     //替换并返回指定位置的元素
  11.         arrayList.clear();        //清空集合中的元素
  12.         arrayList.isEmpty();      //判断集合元素是否为空
  13.         arrayList.contains("c");  //判断是否包含指定元素
  14.         arrayList.size();         //返回集合中元素个数

2.  LinkedList

● 底层是一个链表结构，查询效率低，但增加 / 删除元素快

LinkedList中方法及功能和ArrayList中的方法大致相同，只不过LinkedList中多了关于队列和栈相关的操作方法。

3.  Vector

和ArrayList一样，底层也是数组实现，不同的是Vector的方法默认加了锁，线程是安全的。

List接口集合迭代

List集合遍历方式有四种：

●  1.  for循环遍历          ● 2.  增强for循环遍历   

  1.         //List集合遍历方式1：for循环
  2.         for (int i = 0; i < arrayList.size(); i++) {
  3.             if ("a".equals(arrayList.get(i))){
  4.                 arrayList.remove("a");//允许修改集合元素
  5.                 i--;            // 要注意索引的变化与元素位置的移动
  6.             }
  7.             
  8.         }
  9.         System.out.println(arrayList);
  10.         System.out.println("----------------");
  11.         
  12.         //List集合遍历方式2：增强for循环
  13.         for (String s:arrayList) {
  14.             System.out.println(s);   //不能修改集合元素
  15.         }

●  3.  迭代器遍历 （Iterator）

  1.         //List集合遍历方式3：使用迭代器遍历
  2.         //获得集合对象的迭代器对象
  3.        Iterator<String> it = arrayList.iterator();
  4.         while(it.hasNext()){
  5.             String s = it.next();//获取下一个院系
  6.             if (s.equals("a")) {
  7.                 it.remove();  //使用迭代器对象删除元素
  8.             }
  9.         }
  10.         System.out.println(arrayList);

● 4.  ListIterator迭代器：

  1. public static void main(String[] args) {
  2.         ArrayList<String> arrayList = new ArrayList();
  3.         arrayList.add("a");
  4.         arrayList.add("b");
  5.         arrayList.add("c");
  6.         arrayList.add("d");
  7.         /*
  8.          ListIterator迭代器只能对List接口下的实现遍历
  9.          ListIterator(index)可以从指定位置开始向前向后遍历
  10.          */
  11.         ListIterator<String> listIterator= arrayList.listIterator(arrayList.size());
  12.         while(listIterator.hasPrevious()){
  13.             System.out.println(listIterator.previous());//逆序遍历
  14.         }
  15.     }

Set接口

● Set接口也继承了Collection接口，Set中所储存的元素是不重复的，但是是无序的，Set中的元素没有索引。

Set接口的实现类

● HashSet 

● 1. HashSet类中的元素不能重复

  1.  public static void main(String[] args) {
  2.         HashSet set =new HashSet<>();
  3.         set.add("a");
  4.         set.add("a");
  5.         set.add("b");
  6.         set.add("c");    //元素是不重复的
  7.         System.out.println(set);
  8.     }

● 2. HashSet类中的元素是无序的 

  1. public static void main(String[] args) {
  2.         HashSet set =new HashSet<>();
  3.         set.add("c");
  4.         set.add("s");
  5.         set.add("x");
  6.         set.add("d");    //元素是无序的
  7.         System.out.println(set);
  8.  
  9.         set.remove("s");//没有索引，只能根据内容遍历
  10.         set.iterator();//没有索引，要用迭代器遍历
  11.  
  12.     }

 HashSet在添加元素时，是如何判断元素重复的?          *  重点  * 

在底层会先调用hashCode()，注意，Object中的hashCode()返回的是对象的地址，此时并不会调用；此时调用的是类中重写的hashCode(),返回的是根据内容计算的哈希值，遍历时，会用哈希值先比较是否相等，会提高比较的效率；但哈希值会存在问题：内容不同，哈希值相同；这种情况下再调equals比较内容，这样既保证效率又确保安全。

例：

● 这是错误写法，此时默认调用的是Object类中hashCode( )，返回对象地址

  1. import java.util.HashSet;
  2. import java.util.Objects;
  3.  
  4. public class Student {
  5.     private String name ;
  6.     private String num;
  7.  
  8.  
  9.     public Student(String name, String num) {
  10.         this.name = name;
  11.         this.num = num;
  12.     }
  13.  
  14.     @Override
  15.     public String toString() {
  16.         return "Student{" +
  17.                 "name='" + name + '\'' +
  18.                 ", num='" + num + '\'' +
  19.                 '}';
  20.     }
  21.     
  22.         public static void main(String[] args) {
  23.             HashSet<Student> set = new HashSet<>();
  24.             Student s1 = new Student("小王1","10001");
  25.             Student s2 = new Student("小王2","10002");
  26.             Student s3 = new Student("小王3","10003");
  27.             Student s4 = new Student("小王1","10001");
  28.             set.add(s1);
  29.             set.add(s2);
  30.             set.add(s3);
  31.             set.add(s4);
  32.             System.out.println(set);
  33.             
  34.         }
  35.     }

●  正确写法应该是，在Student类中重写hashCode（）和equals（）

  1. package Demo;
  2.  
  3. import java.util.HashSet;
  4. import java.util.Objects;
  5.  
  6. public class Student {
  7.     private String name ;
  8.     private String num;
  9.  
  10.     @Override
  11.     public boolean equals(Object o) {
  12.         if (this == o) return true;
  13.         if (o == null || getClass() != o.getClass()) return false;
  14.         Student student = (Student) o;
  15.         return num.equals(student.num);
  16.     }
  17.  
  18.     @Override
  19.     public int hashCode() {
  20.         return Objects.hash(num);
  21.     }
  22.  
  23.     public Student(String name, String num) {
  24.         this.name = name;
  25.         this.num = num;
  26.     }
  27.  
  28.     @Override
  29.     public String toString() {
  30.         return "Student{" +
  31.                 "name='" + name + '\'' +
  32.                 ", num='" + num + '\'' +
  33.                 '}';
  34.     }
  35.  
  36.         public static void main(String[] args) {
  37.             HashSet<Student> set = new HashSet<>();
  38.             Student s1 = new Student("小王1","10001");
  39.             Student s2 = new Student("小王2","10002");
  40.             Student s3 = new Student("小王3","10003");
  41.             Student s4 = new Student("小王1","10001");
  42.             set.add(s1);
  43.             set.add(s2);
  44.             set.add(s3);
  45.             set.add(s4);
  46.             System.out.println(set);
  47.  
  48.         }
  49.     }
  50.

这样就能避免重复了（此图是s1，s4重复，但只输出s1）

● 补充：如何快速生成hashCode（）和equals（）的重写方法？

右键选择Generate，选择equals（）and hashCode（），选择重写的属性。

● TreeSet

......敬请期待^_^

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/菜鸟追梦旅行/article/detail/205700
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号