java泛型实现数组 单链表 双链表动态增删改查

最新推荐文章于 2023-07-25 16:57:04 发布
最新推荐文章于 2023-07-25 16:57:04 发布
阅读量338 收藏 1
点赞数 1
分类专栏： JAVA学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42617262/article/details/88664691
版权

泛型实现数组动态增删查改

//Sequence.java
//线性表规范
public interface Sequence<T,E> {//泛型接口
    /**
     * 向线性表中添加元素
     * @param data 要存储的元素
     */
    void add(E data);

    /**
     * 线性表中删除元素
     * @param index 要删除的元素下标
     * @return 是否删除成功
     */
    boolean remove(int index);

    /**
     * 在线性表中查找指定索引的元素
     * @param index 要查找的索引
     * @return
     */
    E get(int index);

    /**
     * 判断线性表中是否有指定元素
     * @param data 要查找的元素内容
     * @return
     */
    boolean contains(E data);

    /**
     * 修改线性表中指定索引的内容
     * @param index 要修改的元素下标
     * @param newData 修改后的内容
     * @return
     */
    E set(int index,E newData);

    /**
     * 返回当前线性表元素个数
     * @return
     */
    int size();

    /**
     * 直接清空线性表内容
     */
    void clear();

    /**
     * 将线性表转为数组
     * @return
     */
    E[] toArray();
}

//SequenceImpl.java

import java.util.Arrays;

public class SequenceImpl<T,E> implements Sequence<T,E> {//泛型类实现泛型接口时保留泛型
    private E[] array;//定义泛型数组
    public static final int MAX_CARACITY=Integer.MAX_VALUE-8;//整型最大值
    private Integer size=0;

    public E[] getArray() {
        return array;
    }

    public void setArray(E[] array) {
        this.array = array;
    }

    @Override
    public void add(E data) {
        ensureArrayNumber(size+1);
        array[size++]=data;
    }

    @Override
    public boolean remove(int index) {
        rangeCheck(index);
        int moveSteps=size-index-1;
        if(moveSteps>0){
            System.arraycopy(array,index,array,index+1,moveSteps);
        }
        array[--size]=null;
        return true;
    }

    @Override
    public E get(int index) {
        rangeCheck(index);
        return array[index];
    }

    @Override
    public boolean contains(E data) {
        for(int i=0;i<size;i++){
            if(array[i]==data){
                return true;
            }
        }
        return false;
    }

    @Override
    public E set(int index, E newData) {
        rangeCheck(index);
        E oldData=array[index];
        array[index]=newData;
        return oldData;
    }

    @Override
    public int size() {
        return this.size;
    }

    @Override
    public void clear() {
        for(int i=0;i<size;i++){
            array[i]=null;
        }
        this.size=0;
    }

    @Override
    public E[] toArray() {
        return array;
    }
    private void ensureArrayNumber(int cap){
        if(cap-array.length>0){
            grow(cap);
        }
    }
    private void grow(int cap){
        int oldData=array.length;
        int newData=oldData<<1;
        if(cap-newData>0){
            newData=cap;
        }
        if(newData-MAX_CARACITY>0){
            throw new IndexOutOfBoundsException("数组越界异常！");
        }
        array=Arrays.copyOf(array,newData);
    }
    private void rangeCheck(int index){
        if(index<0||index>=size){
            throw new IndexOutOfBoundsException("索引异常！");
        }
    }
    public void display(){
        for(Object i:array){
            System.out.print(i+" ");
        }
    }
}

//Study.java
public class Study {
    public static void main(String[] args){
        Sequence<Integer,String>sequence=new SequenceImpl<>();//实例化对象时确定类型
        String[] array={null,null,null};//初始化数组
        ((SequenceImpl<Integer, String>) sequence).setArray(array);//通过setter方法初始化数组
        sequence.add("蛋哥1");
        sequence.add("蛋哥2");
        sequence.add("蛋哥3");
        ((SequenceImpl<Integer, String>) sequence).display();
        System.out.println(" ");
        System.out.println(sequence.contains("蛋哥1"));
        System.out.println(sequence.contains("8"));
        System.out.println(sequence.get(0));
        System.out.println(sequence.set(1,"DDD"));
        System.out.println(sequence.get(1));
        sequence.remove(2);
        ((SequenceImpl<Integer, String>) sequence).display();
        sequence.clear();
        System.out.println(sequence.size());
    }
}

//蛋哥1 蛋哥2 蛋哥3  
//true
//false
//蛋哥1
//蛋哥2
//DDD
//蛋哥1 DDD null 0

泛型实现单链表动态增删查改

//Sequence.java
//线性表规范
public interface Sequence<T> {
    /**
     * 向线性表中添加元素
     * @param data 要存储的元素
     */
    void add(T data);

    /**
     * 线性表中删除元素
     * @param index 要删除的元素下标
     * @return 是否删除成功
     */
    boolean remove(int index);

    /**
     * 在线性表中查找指定索引的元素
     * @param index 要查找的索引
     * @return
     */
    T get(int index);

    /**
     * 判断线性表中是否有指定元素
     * @param data 要查找的元素内容
     * @return
     */
    boolean contains(T data);

    /**
     * 修改线性表中指定索引的内容
     * @param index 要修改的元素下标
     * @param newData 修改后的内容
     * @return
     */
    T set(int index,T newData);

    /**
     * 返回当前线性表元素个数
     * @return
     */
    int size();

    /**
     * 直接清空线性表内容
     */
    void clear();

    /**
     * 将线性表转为数组
     * @return
     */
    T[] toArray();
}


//LinkedListImpl.java
public class LinkedListImpl<T> implements Sequence<T> {
    private Integer size=0;
    private ListNode head;
    T[] data;

    public T[] getData() {
        return data;
    }

    public void setData(T[] data) {
        this.data = data;
    }

    class ListNode{
        ListNode next;
        T data;
        public ListNode(ListNode next, T data) {
            this.next = next;
            this.data = data;
        }

        public ListNode() {
        }
    }
    @Override
    public void add(T data) {
        ListNode newNode=new ListNode(head,data);
        head=newNode;
        size++;
    }

    @Override
    public boolean remove(int index) {
        if(head==null){
            return false;
        }
        rangeCheck(index);
        ListNode cul=node(index);
        ListNode dummyHead=new ListNode();
        dummyHead.next=head;
        ListNode prev=dummyHead;
        for(int i=0;i<index;i++){
            prev=prev.next;
        }
        prev.next=cul.next;
        cul.data=null;
        size--;
        return true;
    }

    @Override
    public T get(int index) {
        rangeCheck(index);
        T listData=node(index).data;
        return listData;
    }

    @Override
    public boolean contains(T data) {
        for(int i=0;i<size;i++){
            if(data.equals(node(i).data)){
                return true;
            }
        }
        return false;
    }

    @Override
    public T set(int index, T newData) {
        rangeCheck(index);
        T oldData=node(index).data;
        node(index).data=newData;
        return oldData;
    }

    @Override
    public int size() {
        return this.size;
    }

    @Override
    public void clear() {
        ListNode prev=head;
        for(ListNode temp=prev;temp!=null;temp=temp.next){
            if(head.next!=null){
                head=head.next;
                temp.data=null;
            }else {
                head.data=null;
            }
            size--;
        }
    }

    @Override
    public T[] toArray() {
        int i=0;
        for(ListNode temp=head;temp!=null;temp=temp.next){
            data[i++]=temp.data;
        }
        return data;
    }
    private ListNode node(int index){
        ListNode temp=head;
        for(int i=0;i<index;i++){
            temp=temp.next;
        }
        return temp;
    }
    public void display(){
        for(ListNode temp=head;temp!=null;temp=temp.next){
            System.out.print(temp.data+" ");
        }
    }
    private void rangeCheck(int index){
        if(index<0&&index>=size){
            throw new IndexOutOfBoundsException("越界异常");
        }
    }
}


//Study.java

public class Study {
    public static void main(String[] args){
        Sequence<Integer> sequence=new LinkedListImpl<>();
        int size=sequence.size();
        Integer[]data=new Integer[size];
        ((LinkedListImpl<Integer>) sequence).setData(data);
        sequence.add(1);
        sequence.add(2);
        sequence.add(3);
        ((LinkedListImpl) sequence).display();
        System.out.println(" ");
        System.out.println(sequence.get(1));
        sequence.set(0,99);
        System.out.println(sequence.get(0));
        System.out.println(sequence.contains(99));
        System.out.println(sequence.contains(9));
        sequence.remove(1);
        ((LinkedListImpl) sequence).display();
        System.out.println(" ");
        System.out.println(sequence.size());
        sequence.clear();
        System.out.println(sequence.size());
    }
}

//3 2 1  
//2
//99
//true
//false
//99 1  
//2
//0

泛型实现双链表动态增删查改

//Sequence.java
//线性表规范
public interface Sequence<T> {
    /**
     * 向线性表中添加元素
     * @param data 要存储的元素
     */
    void add(T data);

    /**
     * 线性表中删除元素
     * @param index 要删除的元素下标
     * @return 是否删除成功
     */
    boolean remove(int index);

    /**
     * 在线性表中查找指定索引的元素
     * @param index 要查找的索引
     * @return
     */
    T get(int index);

    /**
     * 判断线性表中是否有指定元素
     * @param data 要查找的元素内容
     * @return
     */
    boolean contains(T data);

    /**
     * 修改线性表中指定索引的内容
     * @param index 要修改的元素下标
     * @param newData 修改后的内容
     * @return
     */
    T set(int index,T newData);

    /**
     * 返回当前线性表元素个数
     * @return
     */
    int size();

    /**
     * 直接清空线性表内容
     */
    void clear();

    /**
     * 将线性表转为数组
     * @return
     */
    T[] toArray();
}

//LinkedListImpl.java
public class LinkedListImpl<T> implements Sequence<T> {
    private ListNode head;
    private ListNode tail;
    private Integer size=0;
    private T[] array;

    public T[] getArray() {
        return array;
    }

    public void setArray(T[] array) {
        this.array = array;
    }

    class ListNode{
        T data;
        ListNode next;
        ListNode prev;

        public ListNode(T data, ListNode next, ListNode prev) {
            this.data = data;
            this.next = next;
            this.prev = prev;
        }

        public ListNode() {
        }
    }
    @Override
    public void add(T data) {
        ListNode newNode=new ListNode(data,null,tail);
        if(head==null){
            head=newNode;
        }else{
            tail.next=newNode;
        }
        tail=newNode;
        size++;
    }

    @Override
    public boolean remove(int index) {
        if(head==null){
            return false;
        }
        rangeCheck(index);
        ListNode cul=node(index);
        ListNode next=cul.next;
        ListNode prev=cul.prev;
        ListNode dummyHead=new ListNode();
        dummyHead.next=head;
        ListNode node=dummyHead;
        for(ListNode temp=head;temp!=cul;temp=temp.next){
            node=node.next;
        }
        if(prev==null){
            head=next;
            next=null;
        }else {
            node.next=next;
            prev=null;
        }
        if(next!=null){
            next.prev=prev;
            next=null;
        }
        cul.data=null;
        size--;
        return true;
    }

    @Override
    public T get(int index) {
        rangeCheck(index);
        return node(index).data;
    }

    @Override
    public boolean contains(T data) {
        for(int i=0;i<size;i++){
            if(data.equals(node(i).data)){
                return true;
            }
        }
        return false;
    }

    @Override
    public T set(int index, T newData) {
        rangeCheck(index);
        T oldData=node(index).data;
        node(index).data=newData;
        return oldData;
    }

    @Override
    public int size() {
        return this.size;
    }

    @Override
    public void clear() {
        ListNode dummyHead=new ListNode();
        dummyHead.next=head;
        if(head.next==null){
            head.data=null;
        }else{
            for(ListNode temp=head;temp!=null;temp=temp.next){
                if(head.next!=null){
                    head=head.next;
                    temp.prev=null;
                }
                temp.data=null;
                size--;
            }
        }
    }

    @Override
    public T[] toArray() {
        int i=0;
        for(ListNode temp=head;temp!=null;temp=temp.next){
            array[i++]=temp.data;
        }
        return array;
    }
    private void rangeCheck(int index){
        if(index<0||index>=size){
            throw new IndexOutOfBoundsException("越界异常");
        }
    }
    private ListNode node(int index){
        ListNode cul=head;
        ListNode cull=head;
        if(cul!=null&&cull!=null&&cul.next!=null){
            cul=cul.next.next;
            cull=cull.next;
        }
        int k=0;
        for(ListNode temp=head;temp!=cull;temp=temp.next){
            k++;
        }
        ListNode p=head;
        ListNode q=tail;
        if(index>k){
            for(int i=size-1;i>index;i--){
                q=q.prev;
            }
            return q;
        }else{
            for(int i=0;i<index;i++){
                p=p.next;
            }
            return p;
        }
    }
    public void display(){
        for(ListNode temp=head;temp!=null;temp=temp.next){
            System.out.print(temp.data+" ");
        }
    }
}


//Study.java

public class Study {
    public static void main(String[] args){
        Sequence<String> sequence=new LinkedListImpl<>();
        int size=sequence.size();
        String[] array=new String[size];
        ((LinkedListImpl<String>) sequence).setArray(array);
        sequence.add("罗志祥");
        sequence.add("小猪");
        sequence.add("xixi");
        ((LinkedListImpl) sequence).display();
        System.out.println();
        System.out.println(sequence.get(0));
        sequence.set(2,"红雷");
        System.out.println(sequence.get(2));
        sequence.remove(1);
        ((LinkedListImpl) sequence).display();
        System.out.println();
        System.out.println(sequence.contains("luozhixiang"));
        System.out.println(sequence.contains("罗志祥"));
        sequence.clear();
        System.out.println(sequence.size());
    }
}

//罗志祥 小猪 xixi 
//罗志祥
//红雷
//罗志祥 红雷 
//false
//true
//0
猪饲夫妇、
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java反射泛型，实现数据库的动态增删改查等功能
06-08
在Java中运用反射+泛型，实现数据库的动态增删改查等功能，可以是Mysql, 也可以是SQL Server，oracle 也行。本代码是支持SQL Server和oracle的。
Java 如何创建泛型对象与泛型数组
yake1965
06-16 1893
在 Java 中，是不能直接创建泛型对象和泛型数组的。原因是 Java 有类型擦除，任何泛型类型在擦除之后就变成了 Object 类型，因此创建泛型对象就相当于创建了一个 Object 类型的对象。创建 Object 类型的对象通常没有任何意义，所以直接创建泛型对象的行为被编译器禁止。泛型数组也是一样。不能创建泛型对象，意味着下面的代码是非法的。从某种意义上说，Java 实际上并没有真正实现泛型。Java 中的泛型只是基于面向对象语言共有的允许“向上引用”的语法而已。
6.0、Java泛型 - 泛型与数组
m0_52433668的博客
03-19 661
可以声明带泛型的数组引用，但是不能直接创建带泛型的数组对象；
【Java泛型】泛型数组
深漂小码哥
01-22 4826
1.概述 可以声明带泛型的数组引用，但是不能直接创建带泛型的数组对象，可以通过java.lang.reflect.Array的newInstance(Class<T>, int )创建T[]数组 2.示例 import java.lang.reflect.Array; public class Fruit<T> { private T[] array; public Fruit(Class<T> clz, int length) {
在 Java 中，如何创建泛型对象与泛型数组
暗诺星刻的博客
09-16 8370
很多人应该很清楚，在 Java 中，是不能直接创建泛型对象和泛型数组的。原因是 Java 有类型擦除，任何泛型类型在擦除之后就变成了 Object 类型，因此创建泛型对象就相当于创建了一个 Object 类型的对象。创建 Object 类型的对象通常没有任何意义，所以直接创建泛型对象的行为被编译器禁止。泛型数组也是一样。
Java入门--简单学会泛型动态数组的编写
S1mpleFeather的博客
07-25 656
要实现一个泛型动态数组，我们首先需要定义一个泛型类，使用尖括号（）来表示泛型参数T，T可以是任意的引用类型。然后，我们需要定义一个内部的数组来存储元素，由于Java不支持直接创建泛型数组，我们需要使用Object类型的数组，并在合适的地方进行强制类型转换。此外，我们还需要定义两个变量来记录数组的长度和元素的个数，分别为length和size。最后，我们需要提供一个构造方法来初始化数组，并检查参数是否合法。T[] array;//内部数组int size;//元素个数int length;
Java 泛型总结（二）：泛型与数组
08-31
数组与泛型的关系还是有点复杂的，Java 中不允许直接创建泛型数组。本文分析了其中原因并且总结了一些创建泛型数组的方式。具有很好的参考价值。下面跟着小编一起来看下吧
java增删改查JDBC封装类(泛型封装)
02-28
java增删改查JDBC封装类(泛型封装),这个是高度封装化的，增删改查，直接用到我的项目中去的。
java 用泛型参数类型构造数组详解及实例
08-31
主要介绍了java 用泛型参数类型构造数组详解及实例的相关资料,需要的朋友可以参考下
Java编程思想里的泛型实现一个堆栈类 分享
09-05
介绍了Java编程思想里的泛型实现一个堆栈类，有需要的朋友可以参考一下
java泛型数组
03-17
泛型数组的创建
Java 泛型数组(十)
奋斗的菇凉的博客
06-25 889
Java 泛型数组
java泛型详解
qq_53518630的博客
10-16 3400
也就是说，所操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别称为泛型类、泛型接口和泛型方法。[访问修饰符] interface 接口名 {//获取集合中的元素，直接使用泛型类型接收数据即可，不需要强制类型转换。//获取集合中的元素，默认为Object类型，强制转换为相应的数据类型。//创建集合并指定泛型，约束集合只能存储String类型的数据。泛型在java中有很重要的地位，并且编程中也是非常常见的，在。泛型1 泛型成员1;泛型1 泛型成员1;
java 如何创建泛型数组_Java中泛型数组创建总结
weixin_42567279的博客
02-13 3511
在java中，可以声明一个泛型数组，不能通过直接通过T[] tarr=new T[10]的方式来创建数组，最简单的方式便是通过Array.newInstance(Classtype,int size)的方式来创建数组例如下面的程序。public class ArrayMaker {private Class type;public ArrayMaker(Class type) {this.type...
Java 泛型数组
七七的博客
03-03 917
泛型数组的创建 一、可以声明带泛型的数组引用，但是不能直接创建带泛型的数组对象 public static void main(String[] args) { // 可以声明泛型数组引用ArrayList<String>[] listArr = new ArrayList[5] // 不能直接创建带泛型的数组对象ArrayList<String>[] listArr...
java泛型数组_Java中创建泛型数组
weixin_42515796的博客
02-12 606
Java中创建泛型数组使用泛型时，我想很多人肯定尝试过如下的代码，去创建一个泛型数组T[] array = new T[];当我们写出这样的代码时编译器会报Cannot create a generic array of T，初学泛型时，看到这个错就以为Java中不能创建泛型数组，随着不断的深入，当看到Tinking in Java中的泛型时，Java中是可以创建泛型的，真的是无知限制了自己的想象...
【java】实现链表的增删查（含泛型）
aaaayl的博客
05-05 241
链表是线性的数据结构，其在内存中是随机存储的。查找的时间复杂度为O(n),增删(不计入查找)的时间复杂度是O(1)。 1、使用泛型创建Node.class public class Node <E> { E data; Node<E> next; public Node(E data){ this.data=data; }...
java泛型数组_Java 泛型总结（二）：泛型与数组
weixin_30280259的博客
02-12 859
简介上一篇文章介绍了泛型的基本用法以及类型擦除的问题，现在来看看泛型和数组的关系。数组相比于Java 类库中的容器类是比较特殊的，主要体现在三个方面：数组创建后大小便固定，但效率更高数组能追踪它内部保存的元素的具体类型，插入的元素类型会在编译期得到检查数组可以持有原始类型 ( int，float等 )，不过有了自动装箱，容器类看上去也能持有原始类型了那么当数组遇到泛型会怎样？ 能否创建泛型数组呢？...
Java泛型实现单链表
小仙女的博客
05-31 1128
class GenericLink&lt;T&gt;{ public Entry&lt;T&gt; head;//定义头结点 class Entry&lt;T&gt;{ private T data;//数据 private Entry&lt;T&gt; next; public Entry(){//初始化结点 data = null; next = null...
java 泛型数组参数
最新发布
09-07
使用泛型数组参数可以实现更加灵活和通用的方法设计。 在定义方法时，可以使用泛型参数来代替数组元素的具体类型。例如，可以定义一个方法来打印任意类型的数组元素： ```java public static <T> void printArray...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值