首页 > 其他分享 >数据结构 玩转数据结构 2-7 动态数组

数据结构 玩转数据结构 2-7 动态数组

时间：2022-10-12 09:14:37浏览次数：86  
标签：capacity int 玩转 数组 数据结构 data public size

0　　　　课程地址

https://coding.imooc.com/lesson/207.html#mid=13412

 

1　　　　重点关注

1.1　　　　数组动态伸缩

参见3.1 coding

 

1.2　　　　泛型数组

参见3.2  coding

 

1.3　　　　无参调有参的简洁方式

参见3.2  coding

 

2　　　　课程内容

见3

 

3　　　　Coding

3.1　　　　动态数据伸缩

  • 精简：
//3.3　　数组根据索引添加元素
    public void addElement(int index,E e){

        //这里扩展数组长度写到行首，不在这扩下边异常
        if(size== data.length){

            //todo 并不会，需要把值一条一条的赋进来
            resize(2*size);

        }

        //...
    }

//5.3     数组删除，通常情况下做删除，会在出参把删除的值带出来
    public E remove(int index){
       //...
     //  这块逻辑写到末尾是自己没有想到的，多动脑啊
        if(size == data.length/2){
            resize(data.length/2);
        }

        return outParm;
    }

    //6.1     数组动态伸缩 这里用size更好，想想为什么
    private void resize(int capacity){
        E[] newData = (E[]) new Object[capacity];
        for(int i = 0;i < size;i++){
            newData[i] = data[i];
        }
        data = newData;
    }

 

  • 完整：
package com.company;

import java.util.Arrays;

public class ArrayFan<E> {
    private int size;
    //int类型的数组
    private E[] data;


    //1.1　　创建构造函数，传入容量，则新生成一个数组
    public ArrayFan(int capacity){
        data = (E[]) new Object[capacity];
        size = 0;
    }

    //1.2　　创建无参构造函数
    public ArrayFan(){
        this(10);
    }

    //1.3　　添加传入静态数组的构造函数
    public ArrayFan(E[] param){
        this.data = param;
        long outParm = Arrays.stream(param).filter(e->{
            return e!=null;
        }).count();
        this.size = (int)outParm;
    }

    //2.1　　添加getSize,获取数组元素个数
    public int getSize(){
        return size;
    }

    //2.2　　添加getCapacity,获取数组容量
    public int getCapacity(){
        return data.length;
    }

    //2.3　　添加数组是否为空方法
    public boolean isEmpty(){
        return size==0;
    }

    //3.1　　在数组末尾添加元素
    public void addLast(E e){
        addElement(size,e);
    }

    //3.2　　在数组起始添加元素
    public void addFirst(E e){
        addElement(0,e);
    }

    //3.3　　数组根据索引添加元素
    public void addElement(int index,E e){
        //1     校验异常
        //1.1   如果数组已经满了，则禁止插入
        if(size== data.length){

            //todo 并不会，需要把值一条一条的赋进来
            resize(2*size);
            //throw new IllegalArgumentException("数组已满，禁止插入");
        }

        //1.2   如果传入的索引在已有数组的索引之外，则校验异常
        if(index<0||index>size){
            throw new IllegalArgumentException("索引应在已有数组的索引之间");
        }

        //2     实现根据索引添加元素的逻辑
        //2.1   data同步
        for(int j = size-1;j>=index;j--){
            data[j+1] = data[j];
        }
        data[index] = e;

        //2.2   size同步
        size++;
    }

    //6.1     数组动态伸缩 这里用size更好，想想为什么
    private void resize(int capacity){
        E[] newData = (E[]) new Object[capacity];
        for(int i = 0;i < size;i++){
            newData[i] = data[i];
        }
        data = newData;
    }

    //4.1     数组 toString 范例
    @Override
    public String toString() {
        StringBuffer stringBuffer = new StringBuffer();
        stringBuffer.append(String.format("Array:size = %d,capacity = %d\n",size,data.length));

        stringBuffer.append("[");
        for(int i=0;i<size;i++){
            stringBuffer.append(data[i]);
            if(i!=size-1){
                stringBuffer.append(",");
            }
        }
        stringBuffer.append("]");
        return stringBuffer.toString();
    }

    //4.2     get获取元素
    public E get(int index){
        if(index<0||index>data.length){
            throw new IllegalArgumentException("111");
        }
        return data[index];
    }

    //4.3       set获取元素
    public void set(int index,E e){
        if(index<0||index>data.length){
            throw new IllegalArgumentException("111");
        }
        data[index] = e;
    }

    //5.1     数组包含
    public boolean contails(E e){
        for(int i = 0;i<size;i++){
            if(e.equals(data[i])){
                return true;
            }
        }
        return false;
    }

    //5.2     数组搜索
    public int search(E e){
        for(int i = 0;i<size;i++){
            if(e.equals(data[i])){
                return i;
            }
        }
        return -1;
    }

    //5.3     数组删除，通常情况下做删除，会在出参把删除的值带出来
    public E remove(int index){
        if(index<0||index>=size){
            throw new IllegalArgumentException("111");
        }

        E outParm = data[index];
        for(int i=index;i<size-1;i++){
            data[i] = data[i+1];
        }
        //这块不塞值也没有任何影响，因为size已经--了，不会访问到size之外的元素
        data[size-1]= null;
        size--;

        if(size == data.length/2){
            resize(data.length/2);
        }

        return outParm;
    }

    //5.4       删除首个元素
    public E removFirst(){
        return remove(0);
    }

    //5.5       删除最后的元素
    public E removLast(){
        return remove(size-1);
    }

    //5.6       删除指定的元素
    public void removElement(E e){
        int index = -1;
        //判断删除的元素是否存在
        for(int i=0;i<size;i++){
            if(e.equals(data[i])){
                index = i;
                break;
            }
        }
        if(index>=0){
            remove(index);
        }else{
            throw new IllegalArgumentException("删除的元素未找到");
        }
    }


}

 

  • 测试
  public static void main(String[] args) {
        ArrayFan<Integer> arrayFan = new ArrayFan<>();
        for(int i = 0; i< 10;i++){
            arrayFan.addLast(i);
        }

        arrayFan.addLast(100);
        System.out.println(arrayFan);

        arrayFan.removLast();
        System.out.println(arrayFan);

        arrayFan.removLast();
        System.out.println(arrayFan);

    }

 

  • 测试结果：
---- IntelliJ IDEA coverage runner ---- 
sampling ...
include patterns:
exclude patterns:
Array:size = 11,capacity = 20
[0,1,2,3,4,5,6,7,8,9,100]
Array:size = 10,capacity = 10
[0,1,2,3,4,5,6,7,8,9]
Array:size = 9,capacity = 10
[0,1,2,3,4,5,6,7,8]
Class transformation time: 0.0472355s for 141 classes or 3.350035460992908E-4s per class

Process finished with exit code 0

 

3.2　　　　泛型数组

  • 精简（完整见3.1）
public class ArrayFan<E> {
    private int size;
    //int类型的数组
    private E[] data;


    //1.1　　创建构造函数，传入容量，则新生成一个数组
    public ArrayFan(int capacity){
        data = (E[]) new Object[capacity];
        size = 0;
    }

    //1.2　　创建无参构造函数
    public ArrayFan(){
        this(10);
    }

    //1.3　　添加传入静态数组的构造函数
    public ArrayFan(E[] param){
        this.data = param;
        long outParm = Arrays.stream(param).filter(e->{
            return e!=null;
        }).count();
        this.size = (int)outParm;
    }

}

 

标签：capacity,int,玩转,数组,数据结构,data,public,size
From： https://www.cnblogs.com/1446358788-qq/p/16783275.html

相关文章

  • java二维数组
    java二维数组数组一经定义就不能改变长度packagearray;​publicclassArrayDemo04{  publicstaticvoidmain(String[]args){    int[][]num={{1......
  • java数组进阶
    java数组进阶数组一经定义就不能改变长度packagearray;​publicclassArrayDemo03{  publicstaticvoidmain(String[]args){    int[]numbers={1,2......
  • java中的数组
    java中的数组数组一经定义就不能改变长度packagearray;​publicclassArrayDemo02{  publicstaticvoidmain(String[]args){    //声明定义数组的方......
  • 数据结构 链表(第7、8天)
    链表这里面的链表题比较简单，只要会遍历链表、删除链表节点、反转链表这些基本操作就行。必要时可以画图辅助理解。141.环形链表给定一个链表，判断是否有环。思路：快慢指......
  • 如何快速学习Go的切片和数组数据类型
    本文已收录​​如何快速学习Go的struct数据类型​​。涵盖PHP、JavaScript、Linux、Golang、MySQL、Redis和开源工具等等相关内容。什么是数组数组是属于同一类型的元素的集......
  • 搜索中常见数据结构与算法探究（一）
    1前言ES现在已经被广泛的使用在日常的搜索中，Lucene作为它的内核值得我们深入研究，比如FST，下面就用两篇分享来介绍一些本文的主题：第一篇主要介绍数据结构和算法基础和分析方......
  • 漫画：什么是树状数组？
    我们学习数据结构的目的在于将我们的算法变得更快。由PeterM.Fenwick提出的树状数组BIT结构就是一个优秀的数据结构，BIT全称BinaryIndexedTrees结构，而不是所说的......
  • 数据结构—抽象数据类型的表示与实现
    1、预定义常量及类型：//函数结果状态代码#defineOK1#defineERROR0#defineOVERFLOW-2//Status是函数返回值类型，其值是函数结果状态代码typedefintStatus;2......
  • 玩转TCP
    玩转TCP目前已经有了Netty基础，正在学习Go的net包，以此出发进行TCP的学习。沾包和半包当不存在任何的处理方式的时候一份数据可能会超出MSS，那这样可能就会超出我们的一......
  • 14、Java——迷你图书管理器（对象+数组）
    ​ 目录​​⛳️项目需求​​​​⛳️覆盖知识​​​​⛳️开发思路 ​​​​⛳️开发步骤​​​​❤️1、数据初始化​​​​❤️2、BookMethod类中定义各种方法​​​​⛳️部......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99