实现一个自己的List结构

最新推荐文章于 2022-08-25 23:52:00 发布
最新推荐文章于 2022-08-25 23:52:00 发布
阅读量572 收藏 1
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Xue95111/article/details/119799795
版权

用JAVA实现一个List

文章目录

数据结构常见的几种类型

数据结构的逻辑结构：数据对象中数据元素之间的相互关系，分为集合结构，线性结构、树形结构和图形结构。
数据结构的物理结构：数据的逻辑结构在计算机中的存储形式，分为顺序存储和链式存储（比如链表）（不连续存储）。

⑴集合结构
该结构的数据元素间的关系是“属于同一个集合”。既多个元素属于一个集合，有三个特性：
1).确定性（集合中的元素必须是确定的）
2).互异性（集合中的元素互不相同。例如：集合A={1，a}，则a不能等于1）
3).无序性（集合中的元素没有先后之分），如集合{3,4,5}和{3,5,4}算作同一个集合。

⑵线性结构
该结构的数据元素之间存在着一对一的关系。
常用的线性结构有：线性表，栈，队列，双队列，数组，串。

⑶树型结构
该结构的数据元素之间存在着一对多的关系。
一颗树可以简单的表示为根节点， 左子树， 右子树。 左子树和右子树又有自己的子树，子树上面有节点。

⑷图形结构
该结构的数据元素之间存在着多对多的关系，也称网状结构。
图形结构，简称“图”，是一种复杂的数据结构。图形结构中，每个结点的前驱结点数和后续结点数可以任意多个。

现在需要自己实现一个线性的类似数组的结构，初始化size，length等信息，添加增删查改，自动扩容等功能，根据不同的需求实现不同的线性存储结构在使用时非常方便。

二、代码实现

1.创建MyList接口

创建一个interface接口类型，将想要实现的功能名称写进接口内，后续在MyList类中实现这些方法。
代码如下：

public interface MyListInterface<E> {
        public void growArry();                //扩容
        public void add(E value);     //末尾插入
        public void deletebyelement(E value);  // 根据输入的值,删除元素
        public void deletebyindex(int index);     // 根据下标删除元素,删除第几个元素
        public void changebyelement(E oldvalue,E newValue);
        public void changebyindex(int index,E newValue);      //下标index 改为newValue
        public MyList findbyelement(E value);   //根据值查找元素
        public Object findbyindex(int index);     // 根据index,查找第几个元素
        public MyList findelement(E value);//查找元素

}

这些只是暂时想到的方法，后面会继续扩展其他的方法。

2.实现MyList类

创建一个类叫做MyList，定义属性并实现接口中的方法。

泛型

在这之前插入一个泛型的概念：泛型，用来灵活地将数据类型应用到不同的类、方法、接口当中。将数据类型作为参数进行传递。
定义格式：

修饰符 class 类名<代表泛型的变量> {  }

例：

class ArrayList<E>{ 
    public boolean add(E e){ }

    public E get(int index){ }
   	....
}

使用泛型： 即什么时候确定泛型。

在创建对象的时候确定泛型

例如，ArrayList<String> list = new ArrayList<String>();

此时，变量E的值就是String类型,那么我们的类型就可以理解为：

class ArrayList<String>{ 
     public boolean add(String e){ }

     public String get(int index){  }
     ...
}

再例如，ArrayList<Integer> list = new ArrayList<Integer>();

此时，变量E的值就是Integer类型,那么我们的类型就可以理解为：

class ArrayList<Integer> { 
     public boolean add(Integer e) { }

     public Integer get(int index) {  }
     ...
}

举例自定义泛型类

public class MyGenericClass<E> {
	//没有E类型，在这里代表 未知的一种数据类型 未来传递什么就是什么类型
	private E e;
     
    public void setMVP(E e) {
        this.e = e;
    }
     
    public E getE() {
        return e;
    }
}

含有泛型的方法

定义格式：

修饰符 <代表泛型的变量> 返回值类型 方法名(参数){  }

例如，

public class MyGenericMethod {	  
    public <MVP> void show(MVP mvp) {
    	System.out.println(mvp.getClass());
    }
    
    public <MVP> MVP show2(MVP mvp) {	
    	return mvp;
    }
}

使用格式：调用方法时，确定泛型的类型

public class GenericMethodDemo {
    public static void main(String[] args) {
        // 创建对象
        MyGenericMethod mm = new MyGenericMethod();
        // 演示看方法提示
        mm.show("aaa");//泛型为string
        mm.show(123);//泛型为int
        mm.show(12.45);
    }
}

含有泛型的接口

定义格式：

修饰符 interface接口名<代表泛型的变量> {  }

例如，

public interface MyGenericInterface<E>{
	public abstract void add(E e);
	
	public abstract E getE();  
}

使用格式：
创建不确定的格式

public class MyImp2<E> implements MyGenericInterface<E> {
	@Override
	public void add(E e) {
       	 // 省略...
	}

	@Override
	public E getE() {
		return null;
	}
}

确定泛型类型：

/*
 * 使用
 */
public class GenericInterface {
    public static void main(String[] args) {
        MyImp2<String>  my = new MyImp2<String>();  
        my.add("aa");//泛型为String
    }
}

实现MyList


public class MyList<E> implements MyListInterface<E> {
    // 属性 ：
    int length;
    int size;// 个数： 从1开始计算  下标： 从0开始
    // 存储结构 所有类的父类为数据类型
    Object[] arrvalue;
    // 默认长度
    final int defaultlength = 10;

    // 获取长度
    public int getLength() {
        return length;
    }

    // 返回 容器中元素个数
    public int getSize() {
        return size;
    }

    // 初始化
    public MyList() {
        initList();
    }

    // 默认初始化
    private void initList() {
        length = defaultlength;
        arrvalue = new Object[length];
        size = 0;
    }

    // 初始长度
    public MyList(int initLength) {
        if (initLength <= 0) {
            System.err.println("输入长度小于0！");
        }
        if (initLength >= Integer.MAX_VALUE) {
            System.out.println("输入长度大于上限！");
        }
        if (initLength <= defaultlength) {
            initList();
        }
        if (initLength > defaultlength) {
            length = initLength;
            arrvalue = new Object[length];
            size = 0;
        }

    }

    public void growArry() {
        // 扩容 创建一个新的数组 ，比原数组容量更大
        int oldlength = length;
        length = (oldlength / 2) + oldlength;
        Object[] newArrvalue = new Object[length];
        // 然后 将原数组中的所有数据 存入新数组中
        for (int i = 0; i < arrvalue.length; i++) {
            newArrvalue[i] = arrvalue[i];
        }
        // 引用替换
        arrvalue = newArrvalue;


    }
    @Override
    // 添加元素
    public void add(E value) {
        //size 当前越界了
        if (size >= length) {
            growArry();
        }
        arrvalue[size++] = value;
    }

    // 根据下标删除元素,删除第几个元素
    public void deletebyindex(int index) {
        //下标越界了
        if (index > size) {
            System.out.println("数组中元素个数为为：" + size + ",输入的位置没有元素，不可以删除!");
        } else if (index <= 0) {
            System.out.println("此功能为删除第几个元素，输入的值最小应该为1");
        } else {
            System.out.println("success");
            for (int i = index; i < size; i++) {
                Object temp = arrvalue[i];
                arrvalue[i - 1] = temp;
            }
            arrvalue[size - 1] = null;
            size--;
        }

    }

    // 根据输入的值,删除元素
    public void deletebyelement(E value) {
        for (int i = 0; i < size; i++) {
            if (arrvalue[i].equals(value)) {
                deletebyindex(i + 1);
            }
        }
    }

    // 根据下标删除元素,查找第几个元素
    public Object findbyindex(int index) {

        Object result = null;
        //下标越界了
        if (index > size) {
            System.out.println("数组中元素个数为为：" + size + ",输入的位置没有元素，不可以查找!");
        } else if (index <= 0) {
            System.out.println("此功能为查找第几个元素，输入的值最小应该为1");
        } else {

            System.out.println("success");
            result = arrvalue[index - 1];
            System.out.println("第" + index + "个元素是：" + result);
        }
        return result;
    }

    public MyList findelement(E value) {
        MyList result = new MyList();
        for (int i = 0; i < size; i++) {
            if (arrvalue[i].equals(value)) {
                result.add(i+1);
            }
        }
        return result;
    }

    public MyList findbyelement(E value) {
        MyList result = findelement(value);
        if(result.arrvalue[0]==null){
            System.out.println("List中没有元素"+value);

        } else{
            System.out.print("第");
            for (int i = 0; i < result.size; i++) {
                if (i == result.size - 1) {
                    System.out.print(result.arrvalue[i]);
                } else {
                    System.out.print(result.arrvalue[i] + ",");
                }
            }
            System.out.println("个元素是"+value);
        }
        return result;

    }

    public void changebyindex(int index,E newValue) {
        //下标越界了
        if (index > size) {
            System.out.println("数组中元素个数为为：" + size + ",输入的位置没有元素，不可以修改!");
        } else if (index <= 0) {
            System.out.println("此功能为修改第几个元素，输入的值最小应该为1");
        } else {
            arrvalue[index - 1]=newValue;
            System.out.println("成功将第"+index+"个元素修改为"+newValue);
        }

    }

    public void changebyelement(E oldvalue,E newValue) {

        MyList result = findelement(oldvalue);
        if(result.arrvalue[0]==null){
            System.out.println("List中没有元素"+oldvalue);

        } else{
            System.out.print("将第");
            for (int i = 0; i < result.size; i++) {
                arrvalue[(int)(result.arrvalue[i])-1]=newValue;
                if (i == result.size - 1) {
                    System.out.print(result.arrvalue[i]);
                } else {
                    System.out.print(result.arrvalue[i] + ",");
                }
            }
            System.out.println("的元素"+oldvalue+"成功修改为元素"+newValue);
        }

    }


    public static void main(String[] args) {
        MyList myList = new MyList(12);
        myList.add(2);
        for (int i = 0; i < 6; i++) {
            myList.add(i);
            myList.add(2);
        }
        myList.add(2);
        for (int i = 0; i < myList.size; i++) {
            System.out.println(myList.arrvalue[i]);
        }
        myList.changebyelement(2,10);
        for (int i = 0; i < myList.size; i++) {
            System.out.println(myList.arrvalue[i]);
        }
//            System.out.println(a);
        System.out.println(myList.getSize());

    }

}

总结

在使用线性数据结构时可以自己写一个类，添加不同的方法功能可以更加的快捷方便的对数据进行处理。

Xue95111
关注
两个list如何根据一个list中的属性去过滤掉另一个list中不包含这部分的属性，用流实现
舒一笑的博客
08-16 1万+
你可以使用Java 8的流来实现这个功能。假设你有两个包含对象的List，每个对象有一个属性，你想根据一个List中的属性值来过滤掉另一个List中不包含这个属性值的对象。下面是一种使用流的方式来实现这个功能在上面的例子中，我们有两个List：list1包含了MyClass对象，每个对象有一个属性property；list2包含了一些属性值。我们使用流来筛选list1中的对象，只保留那些property值在list2中存在的对象，最后将筛选后的结果收集到filteredList中。AB。
编程实现ADT List 基本操作13个（一）顺序结构
宇宙观光巴士站
11-01 3935
编程实现 ADT List 基本操作13个（一） ADT List如下 ADT List { 数据对象:D = {ai|ai∈ElemSet,i=1, 2, …, n, n≥0} 数据关系:R = {<ai-1, a>|ai-1, ai∈D, i=2, …, n} 基本操作: //1.初始化、销毁和清空操作 InitList( &L ) 操作结果:构造一个空的线性表L DestroyList( &L ) 初始条件:线性表L已存在 操作结果:销毁线性
STL中list类的自己简单实现
qq_55143256的博客
04-20 1286
前面写了STL中关于string类和vector类的简单实现,要想成体系学习的小伙伴可以看一看(48条消息) STL中vector类的自我简单实现_芜湖开冲～的博客-CSDN博客https://blog.csdn.net/qq_55143256/article/details/124241928(48条消息) STL中vector类的自我简单实现_芜湖开冲～的博客-CSDN博客https://blog.csdn.net/qq_55143256/article/details/124241928 今天我们继
实现一个简单地list类
贵在坚持,我相信只要我努力,未来肯定是美好的!
04-25 250
实现简单的list原理:代码实现: 原理: list的储存原理其实就是储存在一个双向带头循环链表,我们只要根据这个进行实现就可以了. 代码实现: 对于简单的list的实现=构造函数+析构函数+输入函数 #include<string> using namespace std; template <class T> struct ListNode{ //这里是类的私有类的体现,我们简化类的private进行了封装 T _data; //存放的数据 ListNod.
简单实现list
金金金金金的博客
05-26 444
// list作为一个带头结点的双向循环链表，初始状态时有一个空的节点组成双向循环链表。 // 它的优点是插入、删除等操作时不会使其他迭代器失效（甚至进行操作的那个迭代器也不会失效） // STL算法，使用定制的迭代器而不能使用原生态的指针 // list实现四种函数构造，resize,push_back,push_front,pop_back,pop_front,insert,erase 1.list实现 #pragma once namespace bite { // list底层是链表，所以先.
一个简单的List实现
Smart的专栏
08-11 782
list和vector是STL库中两个最基本的容器，以下代码模拟实现一个简单的list：#ifndef _MYLIST_ #define _MYLIST_#include<iostream> using namespace std;class ListIsEmpty{}; class ArgIsIll{};template<typename T> class Node{ public: No
实现一个简单的list类
几度枉生_
07-16 213
list------序列式容器-----可前后双向迭代 list可以在常数范围内任意位置进行插入和删除 底层：带头节点的双向循环链表 双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向访问 list不支持任意位置的随机访问，访问效率O（n） 比如 :要访问第n个元素，需要从已知位置（头部或尾部）进行迭代 list构造函数： list() 构造空的list list (size_type n, const value_type& val = value_type()) 构造的lis
List数据结构的实现(JDK1.8)
热门推荐
qq_41424688的博客
09-19 3万+
Java深入篇~04.List数据结构的实现(JDK1.8) 上一篇文章 前言        通常程序总是根据运行之后才知道的某些条件去创建对象。在此之前并不知道所需对象的数量,甚至也不知道对象的类型。为了解决这个问题,则需要在任意时刻任意位置来创建这个所需要的对象。这样一来,数组是肯定行不通的。因为数组的尺寸是固定的不可改变的。所以在大多数编程语言里面都会提供某种方法来解决。比如C++有STL,而Java则有一套容器类。  &
顺序表(SequenceList)数据结构的基本操作实现详解
HenryBlog
08-17 4480
目录一、前言二、整体设计框架三、函数实现四、完整代码 一、前言 数据结构非常之多，后续小编会逐个更新，简单的存储数据一般有顺序表，链表（单链表和双链表），串等 创建完数据结构后不仅要存储数据，以后还需要查找数据，如果高效的进行查找也需要搜索树，哈希表等这样的结构来实现 有很多人有这样一个疑问：是先学数据结构还是先学算法？ 其实数据结构和算法是不分家的，数据结构中包含一些算法，有些算法的解决又离不开数据结构，比如实现Dijkstra最短路径问题是基于Graph的数据结构实现的 二、整体设计框架 实现顺序表，
数据结构 List（数组实现）C++
cccccchao的博客
06-02 1922
写在前面： 好久没有写博客了，趁着这个周末作业不算太多，好好总结一下这学期学过的的数据结构好了。 话说，，临近学期末了，我才明白，数据结构学下来，所得的成果应该是众多自己写的头文件，，，应该还不晚8，，QAQ 简介： 数组实现的List。 与双链表实现的相比，随机访问效率高，但插入和删除元素的效率低。 因为必须初始化一个大小，所以有溢出风险。 代码： const int max_list=50; ...
C++自己实现list
不断的谦逊，不断的努力
07-21 1010
C++自己实现list　　前两个博客发表了自己写的stack（栈）和queue（队列），感觉比较简单，今天想试着实现list，结果发现，不是那么容易，感觉自己对STL的底层不是很了解，真要自己实现还真的很难，看STL的源代码，那个晕啊...那代码也写得太难理解了，当然跟我不了解有
实现简单的List
zhaopengvv的博客
08-25 88
实现简单的List
放弃了std::list，自己实现了一个简单的list
鱼塘鱼汤的专栏
03-16 626
原因 在项目中前人使用了std::list来做一个队列式，支持头或者尾的push操作。使用场景是视频的录制： 生产者：从摄像头采集数据，然后push_front到队列头，如果超过了最大限制，则pop_back队列尾的元素，实现丢帧操作 消费者：从队列里面back拿到桢，然后pop_back删除末尾桢。 所有的list的操作均加入了互斥锁。理论上应该是没有多线程访问的问题的。然而在线上表现却...
数据结构与算法_part_2 —— 自己创建一个List类，并实现各种方法
Le0v1n 的博客
06-06 766
数据结构与算法_part_2 —— 自己创建一个List类，并实现各种方法
STL 之 list源代码自行实现（iterator）
思緒凌亂
11-17 5775
一：起因 （1）数据结构里面两种非常重要的存储结构，线性结构中的连续存储结构（代表vector数组）和非连续存储结构（代表list链表），他们两者被广泛的应用在 各个领域，是最基本最基础的两种存储结构； （2）vector 已经简单的实现了，请看STL 之 vector的实现     之前还实现了STL的string类，请看 STL 之 string 的实现 （3）之前的友元类只是停留在理
自己实现C++list容器
pangpangchai的博客
09-27 525
最近在研究stl源码剖析，于是乎自己动手实现了一个自己的list容器，当然是最简单的list和标准库的list有很大差距，尽请吐槽。全部源代码在github上：github.com/shadowhecker/list/tree/master/workspace/list，有喜欢的请star。该list容器实现了标准库的全部功能，内存管理自己编辑了一个simple_allocator封装了alloc
java中自己实现一个ArrayList
wanghuiwei888的博客
12-22 1083
import java.util.Arrays; import java.util.Iterator; public class MyList implements Iterable{  /*   * 设计一种容器:可以不初始化长度,长度可以自动拓展   */  private int length = 10;//定义初始化容量大小的变量  private Object[]
LIst与自己动手写ArryList实现类
学海无涯
08-26 442
List中常用的实现类有ArryList、LinkedList和Vector。Vector是线程安全的常用于接收数据库查询后返回数据，当然线程安全就代表速度慢效率低。而ArryList 是线程不安全的，并且其底层实现是采用数组实现的，所以查询快速但是添加，删除慢。LinkedList 是线程不安全的，其底层采用链表实现，所以查询慢但是添加删除块。 自己手写ArryLIst类（简易版）。 pub...
七、自定义实现List框架
qq23001186的博客
03-21 262
目录前言一、数组扩容技术二、自定义实现List 前言 本文先介绍数组扩容技术，因为在自定义实现List框架的时候需要用到 一、数组扩容技术 1.Arrays.copyOf Arrays的copyOf()方法Arrays.copyOf功能是实现数组的复制，返回复制后的数组。参数是被复制的数组和复制的长度，不会影响原来的数组。 copyOf()的第二个自变量指定要建立的新数组长度，如果新数组的长度超过原数组的长度，则保留数组默认值 public static void main( Stri
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值