关于ArrayList LinkedList remove（）方法的一点思考,更改或删除抽象数据类型的值

最新推荐文章于 2024-07-31 13:49:23 发布
最新推荐文章于 2024-07-31 13:49:23 发布
阅读量525 收藏
点赞数
分类专栏： 学习总结 文章标签： remove（） arraylist linkedlist 构造节点
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43498417/article/details/100184007
版权

对于基本数据类型和常见的抽象数据类型不做考虑
针对的是由程序编写者创建的抽象数据类型

通过查看API文档，提供了一个remove（Object O）方法
在这里插入图片描述
**

一. 首先想到的是逐个比较不同节点里的数据,list.remove(index i);

**

import java.util.*;

/**
 *
 */

public class Main {
    public static class Node{
        int num;
        String val;
        private Node(int num, String val){
            this.num = num;
            this.val = val;
        }
    }



    public static void main(String[] args) {
        ArrayList<Node> list = new ArrayList<>();
        //LinkedList<Node> list = new LinkedList<>();
        list.add(new Node(5,"aa"));
        list.add(new Node(6,"aa"));
        list.add(new Node(7,"aa"));
        list.add(new Node(8,"aa"));
        list.add(new Node(9,"aa"));
        list.add(new Node(10,"aa"));
        list.add(new Node(11,"aa"));
        list.add(new Node(5,"aa"));

        for(Node c:list){
            System.out.print(c.num + c.val +" ");
        }
        System.out.println();
        for(int i = 0; i < list.size(); i++){
            if(list.get(i).num == 5 && list.get(i).val.equals("aa")){
                list.remove(i);
            }
        }
        for(Node c: list){
            System.out.print(c.num + c.val + " ");

        }
    }
}

结果：删除了num== 5，val == “aa”的所有节点
在这里插入图片描述

其实这个是不对的，有个细节没有考虑到，测试一下下面的数据就知道了

        list.add(new Node(5,"aa"));
        list.add(new Node(5,"aa"));
        list.add(new Node(6,"aa"));
        list.add(new Node(7,"aa"));
        list.add(new Node(8,"aa"));
        list.add(new Node(9,"aa"));
        list.add(new Node(10,"aa"));
        list.add(new Node(10,"aa"));
        list.add(new Node(11,"aa"));

结果：
在这里插入图片描述

for(int i = 0; i < list.size(); i++){
            if(list.get(i).num == 5 && list.get(i).val.equals("aa")){
                list.remove(i);
                /**修改的部分*/
                i--;
            }
        }

结果：
在这里插入图片描述

增加更该节点数据的功能，需要在节点类里加入get（），set（）方法；

import java.util.*;

/**
 *
 */

public class Main {
    public static class Node{
        int num;
        String val;
        private Node(int num, String val){
            this.num = num;
            this.val = val;
        }

        public int getNum() {
            return num;
        }

        public void setNum(int num) {
            this.num = num;
        }

        public String getVal() {
            return val;
        }

        public void setVal(String val) {
            this.val = val;
        }
    }



    public static void main(String[] args) {
        ArrayList<Node> list = new ArrayList<>();
        list.add(new Node(5,"aa"));
        list.add(new Node(6,"aa"));
        list.add(new Node(7,"aa"));
        list.add(new Node(8,"aa"));
        list.add(new Node(9,"aa"));
        list.add(new Node(10,"aa"));
        list.add(new Node(11,"aa"));
        list.add(new Node(5,"aa"));

        for(Node c:list){
            System.out.print(c.num + c.val +" ");
        }
        System.out.println();
        /**
     * 更改地方
     */
    for(int i = 0; i < list.size(); i++){
        if(list.get(i).num == 5 && list.get(i).val.equals("aa")){
            list.remove(i);
            /**更改的地方**/
            i--;
            /**更改地方**/
            continue;
        }
        if(list.get(i).num == 10 && list.get(i).val.equals("aa")){
            list.get(i).setVal("uu");
        }
    }
        for(Node c: list){
            System.out.print(c.num + c.val + " ");

        }
    }
}

在这里插入图片描述
**

二.删除第一个搜索到的节点

list.remove(Object o);

 import java.util.*;

/**
 *
 */

public class Main {
    public static class Node{
        int num;
        String val;
        private Node(int num, String val){
            this.num = num;
            this.val = val;
        }

        public int getNum() {
            return num;
        }

        public void setNum(int num) {
            this.num = num;
        }

        public String getVal() {
            return val;
        }

        public void setVal(String val) {
            this.val = val;
        }
    }



    public static void main(String[] args) {
        ArrayList<Node> list = new ArrayList<>();
        Node node1 = new Node(5,"aa");
        Node node2 = new Node(6,"bb");
        Node node3 = new Node(7,"cc");
        Node node4 = new Node(8,"cc");
        Node node5 = new Node(9,"aa1");
        Node node6 = new Node(10,"cc");

        list.add(node1);
        list.add(node2);
        list.add(node3);
        list.add(node4);
        list.add(node5);
        list.add(node6);
        list.add(node1);


        for(Node c:list){
            System.out.print(c.num + c.val +" ");
        }
        System.out.println();
        /**更改地方*/
        list.remove(node1);
        for (Node node0 : list){
            System.out.print(node0.num +  node0.val + " ");
        }

    }
}

结果：只删除了搜索到的第一个Node1节点
在这里插入图片描述

**

三，重写equel();删除所有节点Node

**

import java.util.ArrayList;
/**
 *
 */

public class Main {
    public static class Node{
        private int num;
        private String val;
        public Node(int num, String val){
            this.num = num;
            this.val = val;
        }

        public int getNum() {
            return num;
        }

        public void setNum(int num) {
            this.num = num;
        }

        public String getVal() {
            return val;
        }

        public void setVal(String val) {
            this.val = val;
        }

        @Override
        public int hashCode() {
            return super.hashCode();
        }

        @Override
        public boolean equals(Object obj) {
            if(this == obj) return true;
            if(obj == null){
                return false;
            }
            if(obj instanceof Node){
                Node node = (Node) obj;
                if(node.num == this.num  && node.val.equals(this.val)){
                    return true;
                }
                return false;
            }
            return false;
        }

    }



    public static void main(String[] args) {
        ArrayList<Node> list = new ArrayList<>();
        list.add(new Node(5,"aa"));
        list.add(new Node(6,"aa"));
        list.add(new Node(7,"aa"));
        list.add(new Node(8,"aa"));
        list.add(new Node(9,"aa"));
        list.add(new Node(10,"aa"));
        list.add(new Node(5,"aa"));

        for(Node c:list){
            System.out.print(c.num + c.val +" ");
        }
        System.out.println();


        Node delete = new Node(5,"aa");
        for (int i = 0; i < list.size(); i++){
            if(delete.equals(list.get(i))) {
                list.remove(i);
                i--;
            }
        }


        for (Node node0 : list){
            System.out.print(node0.num +  node0.val + " ");
        }
        System.out.println();

    }
}

结果：删除所有符合删除条件的节点
在这里插入图片描述
**

四.不重写equal（）；remove（）方法失效

**

import java.util.ArrayList;
/**
 *
 */

public class Main {
    public static class Node{
        private int num;
        private String val;
        public Node(int num, String val){
            this.num = num;
            this.val = val;
        }

//        public int getNum() {
//            return num;
//        }
//
//        public void setNum(int num) {
//            this.num = num;
//        }
//
//        public String getVal() {
//            return val;
//        }
//
//        public void setVal(String val) {
//            this.val = val;
//        }
//
//        @Override
//        public int hashCode() {
//            return super.hashCode();
//        }
//
//        @Override
//        public boolean equals(Object obj) {
//            if(this == obj) return true;
//            if(obj == null){
//                return false;
//            }
//            if(obj instanceof Node){
//                Node node = (Node) obj;
//                if(node.num == this.num  && node.val.equals(this.val)){
//                    return true;
//                }
//                return false;
//            }
//            return false;
//        }

    }



    public static void main(String[] args) {
        ArrayList<Node> list = new ArrayList<>();
        list.add(new Node(5,"aa"));
        list.add(new Node(6,"aa"));
        list.add(new Node(7,"aa"));
        list.add(new Node(8,"aa"));
        list.add(new Node(9,"aa"));
        list.add(new Node(10,"aa"));
        list.add(new Node(5,"aa"));

        for(Node c:list){
            System.out.print(c.num + c.val +" ");
        }
        System.out.println();


        Node delete = new Node(5,"aa");
        list.remove(delete);
//        for (int i = 0; i < list.size(); i++){
//            if(delete.equals(list.get(i))) {
//                list.remove(i);
//                i--;
//            }
//        }


        for (Node node0 : list){
            System.out.print(node0.num +  node0.val + " ");
        }
        System.out.println();

    }
}

结果：
在这里插入图片描述

重写equal（）；

import java.util.ArrayList;
/**
 *
 */

public class Main {
    public static class Node{
        private int num;
        private String val;
        public Node(int num, String val){
            this.num = num;
            this.val = val;
        }

        public int getNum() {
            return num;
        }

        public void setNum(int num) {
            this.num = num;
        }

        public String getVal() {
            return val;
        }

        public void setVal(String val) {
            this.val = val;
        }

        @Override
        public int hashCode() {
            return super.hashCode();
        }

        @Override
        public boolean equals(Object obj) {
            if(this == obj) return true;
            if(obj == null){
                return false;
            }
            if(obj instanceof Node){
                Node node = (Node) obj;
                if(node.num == this.num  && node.val.equals(this.val)){
                    return true;
                }
                return false;
            }
            return false;
        }

    }



    public static void main(String[] args) {
        ArrayList<Node> list = new ArrayList<>();
        list.add(new Node(5,"aa"));
        list.add(new Node(6,"aa"));
        list.add(new Node(7,"aa"));
        list.add(new Node(8,"aa"));
        list.add(new Node(9,"aa"));
        list.add(new Node(10,"aa"));
        list.add(new Node(5,"aa"));

        for(Node c:list){
            System.out.print(c.num + c.val +" ");
        }
        System.out.println();


        Node delete = new Node(5,"aa");
        list.remove(delete);
//        for (int i = 0; i < list.size(); i++){
//            if(delete.equals(list.get(i))) {
//                list.remove(i);
//                i--;
//            }
//        }


        for (Node node0 : list){
            System.out.print(node0.num +  node0.val + " ");
        }
        System.out.println();

    }
}

结果：
在这里插入图片描述

RLiBin
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LinkedList 源码分析02之remove()、iterator()
weixin_44245828的博客
11-16 472
1. 删除类 1.1
AbstractDataTypes-：抽象数据类型
02-10
抽象数据类型（Abstract Data Type，简称ADT）是计算机科学中的一个重要概念，它是指通过一组操作来定义的数据结构。在编程语言中，ADT是一种逻辑上的数据结构，它定义了数据的操作集，而不涉及这些操作的具体实现。...
ArrayList 与 LinkedList remove方法
09-22 2917
如果使用下标操作remove(index)，ArrayList明显有优势，尤其下表是在LinkedList中间的时候，头尾效率还差不了太多。 如果使用元素操作remove(Object)，remove(index)，两种List都要遍历后才可以删除，LinkedList优势就很明显了
LinkedList remove(Integer index) remove(E e) remove(int i)
crslee的专栏
04-04 764
LinkedList remove(Integer index) remove(E e) remove(int i) Integer为对象类型不是int类型。 所以会走 remove(E e) 这个多态方法 所以对于Integer：  remove((int)index) 转型就可以了。
java linkedlist 删除_Java LinkedList.remove() 删除数据
weixin_33417904的博客
02-12 4340
首页>基础教程>集合框架>LinkedList类Java LinkedList.remove() 删除数据方法remove()：获取并移除此列表的头(第一个元素)。remove(int index)：移除此列表中指定位置处的元素。remove(Objec o)：从此列表中移除首次出现的指定元素(如果存在)。removeFirst()：移除并返回此列表的第一个元素。re...
LinkedList中的remove方法
热门推荐
93吸血鬼的学习笔记
11-04 1万+
实在是太坑爹了！！！！！jdk7的api里面，他有三个remove方法 return type method Description E remove() Retrieves and removes the head (first element) of this list. E remove(int index) Removes the element at th
List-Implementation:我自己的列表抽象数据类型的实现
05-02
在Java中，列表抽象数据类型（ADT）通常通过接口`java.util.List`来定义，它提供了丰富的操作方法，如添加、删除、查找元素等。在这个“List-Implementation”项目中，我们看到作者尝试实现自己的列表ADT，这有助于...
Java中为何要使用ArrayList
09-07
ArrayList的主要特点是它维护了一个动态的、基于数组的列表，允许开发者在列表的任何位置插入或删除元素，同时提供了丰富的操作方法，使得对列表的操作变得更加便捷。本文将深入探讨为何Java开发中要使用ArrayList...
Java中LinkedList详解和使用示例_动力节点Java学院整理
08-30
LinkedList是Java集合框架中的一种数据结构，它是List接口的一个实现，同时也实现了Deque接口，因此它不仅可以作为线性列表使用，还可以作为栈、队列或双端队列。下面我们将深入探讨LinkedList的特点、构造函数以及...
创建一个 LinkedList项目.docx
07-10
可以使用 `remove()`、`removeFirst()`、`removeLast()` 或 `remove(Object o)` 等方法删除元素，删除操作只需要改变节点间的引用关系，效率较高。 5. 访问元素： LinkedList 支持迭代器进行遍历，也可以使用 `...
《Java基础-集合：深入了解Java中LinkedList类的使用及实用技巧（最全篇）》
最新发布
大大大钢琴
07-31 918
LinkedList类是双向列表,列表中的每个节点都包含了对前一个和后一个元素的引用.，它和ArrayList一样实现了List接口，但是她执行插入和删除操作时比ArrayList更加高效，因为她是基于链表的，但同时也决定了她在随机访问方面要比ArrayList弱一点。
LinkedList源码（remove）解析：
WJ13282897835的博客
06-08 427
LinkedList public E remove(int index)方法源码解析：
数据结构--remove方法对LinkedList类的使用注意
nupt_Wang的专栏
03-05 3912
直接上代码： package com.itany.linkedList; import java.util.Iterator; import java.util.LinkedList; import java.util.List; public class Test { /* * remove方法对LinkedList类的使用注意 * 将表中所有值为偶数的项删除
Java 中removelinked_Java中LinkedList的remove方法真的耗时O(1)吗？
weixin_42502363的博客
02-24 355
这个问题其实来源于Leetcode的一道题目，也就是上一篇日志LRU Cache。在使用LinkedList超时后，换成ArrayList居然AC了，而问题居然是在于List.remove(Object o)这个方法。我们知道，链表和数组相比，最主要的特点就是add和remove的操作是O(1)的。Java中的链表一般使用LinkedList这个类型，数组一般使用ArrayList。它们同时im...
Java之LinkedList源码分析（第八篇：修改元素）
王员外的博客
09-01 1267
无论是LinkedList，还是ArrayList，毕竟他们都表示线性表，所以API一致，只是具体的实现不同！今天学习一下LInkedList的修改元素。
Java的LinkedList使用remove（）方法无法删除对应整数位置的元素
qq_52651584的博客
10-16 548
LinkedList的remove（）方法有很多重载，可以把鼠标移动到这个方法上方让编译器显示这个方法的参数信息以确定在这里使用的是哪个重载。 例如，如果remove（i）的i中是一个int的包装类Integer而不是int类型的话，该起就会提示你调用的方法是remove（Object o），意为查找这个linkedlist里面有没有和这个o相等的元素，如果有则删除。这就和i代表的整数值无关了。 因此要改成remove（i.intValue（）），i.intValue将Integer转换为i
LinkedList源码中add()和remove()方法
闰土的博客
11-01 1251
LinkedList底层结构 （1）LinkedList底层维护了一个双向链表,链表是一个有序集合 （2）LinkedList中维护了两个属性first和last，分别指向首节点和尾节点 （3）节点（Node）对象里面维护了prev、next、item三个属性，prev指向前一个节点，next指向后一个节点，item存储数据。 （4）LinkedList的元素的添加和删除，不是通过数组完成的，效率高 add()方法 （1）add()添加第一个元素(element = 1),下面是测试代码 LinkedLi
ArrayList和LinkedList的增删改查效率的区别？
weixin_45980070的博客
06-19 784
Arraylist的底层是动态数组，增加是通过一个一个遍历后为null这才会增加，删除是通过后一个覆盖前面要删除的那一下标的方式，一直持续到最后才行，这样就十分的浪费时间。所以ArrayList适合做改，查的工作。 LinkedList的底层是双向链表的结构，看LinkedList的双向链表结构导致查询修改比较慢，但是新增和删除的话效率是比较高的，因为只涉及到指向节点的指针的改变，找到相应的节点之后进行替换设置好指针的前后指向地址，不需要像ArrayList那样需要对数组位置的变动。所有LinkedLis.
单链表LinkedList的增删改查
wardo_l的博客
03-04 511
数组作为数据存储结构有一定的缺陷。在无序数组中，搜索性能差，在有序数组中，插入效率又很低（插入位置后面的元素需要集体后移），而且这两种数组的删除效率（集体前移）都很低，并且数组在创建后，其大小是固定了，设置的过大会造成内存的浪费，过小又不能满足数据量的存储。 数组是一种通用的数据结构，能用来实现栈、队列等很多数据结构。而链表也是一种使用广泛的通用数据结构，它也可以用来作为实现栈、队列等数据结构的基础，基本上除非需要频繁的通过下标来随机访问各个数据，否则很多使用数组的地方都可以用链表来代替。 注意：链表是
Java面试必备：List、Set接口解析与ArrayList、LinkedList对比
ArrayList是ArrayList类，继承自AbstractList，实现了List接口，提供了丰富的操作方法，比如添加、删除、修改等，它是Array的一种更高级的抽象。 5. **Map接口**：Map存储的是键值对，每个键都是唯一的，键值对之间...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值