精华内容
下载资源
问答
  • 动态扩展数组长度自定义) 在Java中,创建的数组都是定长的,也就是数组一旦创建,长度就已经确定了,但是我们往往遇到要添加的元素个数,超出了数组的长度,这种情况如何处理了?接下来就介绍一种简单的思路去...

    动态扩展数组长度(自定义)

    在Java中,创建的数组都是定长的,也就是数组一旦创建,长度就已经确定了,但是我们往往遇到要添加的元素个数,超出了数组的长度,这种情况如何处理了?接下来就介绍一种简单的思路去扩展数组的长度。

    一、动态扩展数组的思路

    1)定义一个数组。
    2)向数组中添加元素。
    3)当元素的个数超出了数组的长度的时候,则需要对数组进行动态的扩容
    4)再次新建一个数组,该数组的长度为第一步创建的数组长度基础上再增加50%(初始化数组长度为10,每次增加5)。
    5)在创建完新的数组之后,一定要记得将原有数组中的所有元素,复制到新的数组中。

    二、代码设计(以String数组为例)

    1)代码示例1:定义一个方法,用于向数组中添加元素,元素和数组作为参数传递。

     1 public void addElement(String[] str,String element){
     2     //找出还未存放元素的位置下标,以值为null则认定为可以添加元素
     3     //定义一个变量,用于记录下标值,默认值为-1
     4     int index = -1;
     5     //使用循环,找出第一个为null值得下标
     6     for(int i = 0;i < str.length;i++){
     7         //判断第一个为null得值,则结束循环
     8         if(str[i] == null){
     9             index = i;
    10             break;
    11         }
    12     }
    13     //根据index得值,判断是否有能够存放元素,
    14     if(index != -1){
    15         str[index] = element;
    16     }else{
    17         //如果index等于-1,则说明上面循环中没有找到null得下标位置,说明已经存放不下,则需要动态扩展
    18         //直接调用动态扩展数组得方法,并赋值给str数组
    19         str = arrayLengthen(str);
    20         //使用递归,再次调用添加元素的方法,现在使用的数组,是已经扩容之后的数组
    21         addElement(str,element);
    22     }
    23 }

    2)代码示例2:定义一个函数,用于动态扩展数组得长度,每次给数组增加长度为5,数组作为参数传递

    public String[] arrayLengthen(String[] str){
        //获取数组得长度:
        int len = str.length;
        //新建一个数组,长度为原有数组长度上面再增加5个
        String[] tempArray = new String[len + 5];
        //将原来数组中的所有元素,复制到新建的数组中,使用循环完成。(很重要)
        for(int i = 0;i < str.length;i++){
            tempArray[i] = str[i];
        }
        //将数组返回
        return tempArray;
    }

    3)代码示例3:测试代码

    public static void main(String[] args){
        //新建一个数组,长度为10
        String[] str = new String[10];
        Scanner scanner = new Scanner(System.in);
        //使用死循环输入
        while(true){
            System.out.print("请输入字符串:");
            String element = scanner.next();
            //调用添加数组的方法:
            //静态中调用非静态方法,需要创建对象,这里根据自己的类,自己创建对象即可,略
            addElement(str,element);
        }
    }

    代码中没有遍历输出数组中的元素进行校验,这个步骤自行完成

    转载于:https://www.cnblogs.com/private-lxl/p/11187966.html

    展开全文
  • 我在定义自定义函数时,需要把主程序中的数组传递到自定义函数中使用,但是发现在自定义函数中无法获取这个数组的长度,在网上一查了解到如何数组作为参数传递时只能作为指针传递,没有数组长度那肯定不便于数组的操作....

    我在定义自定义函数时,需要把主程序中的数组传递到自定义函数中使用,但是发现在自定义函数中无法获取这个数组的长度,在网上一查了解到如何数组作为参数传递时只能作为指针传递,没有数组长度那肯定不便于数组的操作.于是我想到了两个方法:

    1,这个方法我觉得太麻烦,所以也不想多说,就是用循环读取指针的值是否为NULL.这个想法只是理论上的,我想应该可以能实现,但是会写很多代码,所以我也就不实验了.

    2,第二种很简单,就是在传递前先获取到数组的长度,然后把它作为参数传递进去就可以了.

    3,后来通过搜索还了解到一个方法,这个是C++才能用的,就是利用定义一个模板就可以把数组引入到自定义函数中,这样就是在自定义函数中也可以获取得到数组的长度了.其实和第2种方法的代码量差不多,只是多了一个模板应用的知识点.

    这里先说一下如何获取数组长度的方法:

    int len= sizeof(a) / sizeof(a[0]);

    第3种方法的代码如下:

    template <class T>    //定义一个模板
    void postValude(T& a)  //利用模板引用数组a
    {
    	int len= sizeof(a) / sizeof(a[0]); //获取数组长度
    	for (int i = 0; i < len; i++)
    		a[i] = i;
    	return;
    }
    
    int main()
    {
    	int a[10] ;   //定义一个有长度的数组
    	postValude(a); //定义函数,这里有了模板就直接引用数组就可以了
    	for (int i = 0; i < 10; i++)
    	{
    		cout << a[i] << endl;  //将数组显示出来看结果是否正确
    	}
        return 0;
    }
    


    展开全文
  • Java自定义动态数组

    千次阅读 2019-02-15 00:38:33
    Java自定义动态数组 1、静态数组向动态数组转变 (1)静态数组数组空间固定长度 这个数组空间总长为4,如果此时新插入一个数据就会报数组空间不足   (2)静态数组如何转变成动态数组 第一步:创建...

    Java自定义动态数组

    1、静态数组向动态数组转变

    (1)静态数组,数组空间固定长度

    这个数组空间总长为4,如果此时新插入一个数据就会报数组空间不足

     

    (2)静态数组如何转变成动态数组

    第一步:创建一个空间是data数组两倍的newData数组(扩容);

    第二步:把data数组中的元素全部赋值到newData数组;

     

    2、数组扩容程序

    // 数组扩容
    private void resize(int newCapacity){
       
    E[] newData = (E[]) new Object[newCapacity];
        for
    (int i = 0; i < size; i++) {
            newData[i] =
    data[i];
       
    }
       
    data = newData;
    }

    数组添加元素:数组空间不够就会扩容(原来空间2倍)

        // 数组指定位置添加元素
       
    public void add(int index, E e) {
    //        if (size == data.length)
    //            throw new IllegalArgumentException("Add failed.Array is full.");
           
    if (index < 0 || index > size)
               
    throw new IllegalArgumentException("Add failed. Require index >= 0 and index <= size");
            if
    (size == data.length)
                resize(
    2 * data.length);
            for
    (int i = size - 1; i >= index; i--)
               
    data[i + 1] = data[i];
           
    data[index] = e;
           
    size++;
       
    }

    数组删除元素:数组空间空闲太大就会缩容(原来空间的1/2)

    // 从数组中删除index位置的元素,返回删除的元素
    public E remove(int index) {
       
    if (index < 0 || index >= size) {
           
    throw new IllegalArgumentException("Remove failed.Index is illegal");
       
    }
       
    E ret = data[index];
        for
    (int i = index + 1; i < size; i++) {
           
    data[i - 1] = data[i];
       
    }
       
    size--;
        
    // loitering objects != memory leak 手动释放内存空间
       
    data[size] = null;
        if
    (size == data.length / 2) {
            resize(
    data.length / 2);
       
    }
       
    return ret;
    }

     

    3、数组整体代码

    public class Array<E> {
       
    // 定义数组变量,data.length表示数组容量capacity
       
    private E[] data;
       
    // 定义数组中存放数据大小
       
    private int size;

       
    // 有参构造方法,传入数组的容量capacity构造动态数组
       
    public Array(int capacity) {
           
    data = (E[])new Object[capacity];
           
    size = 0;
       
    }

       
    // 无参构造方法,默认初始容量为capacity=10
       
    public Array() {
           
    this(10);
       
    }

       
    // 获取数组中元素个数
       
    public int getSize() {
           
    return size;
       
    }

       
    // 获取数组的容量
       
    public int getCapacity() {
           
    return data.length;
       
    }

       
    // 判断数组是否为空
       
    public boolean isEmpty() {
           
    return size == 0;
       
    }

    /*    // 在数组末尾添加元素
        public void addLast(E e) {
            if (size == data.length)
                throw new IllegalArgumentException("AddLast failed.Array is full.");
            data[size] = e;
            size++;
        }*/

        // 在数组末尾添加元素(复用add方法)
       
    public void addLast(E e) {
            add(
    size, e);
       
    }

       
    // 在数组头部添加元素(复用add方法)
       
    public void addFirst(E e) {
            add(
    0, e);
       
    }

       
    // 数组指定位置添加元素
       
    public void add(int index, E e) {
    //        if (size == data.length)
    //            throw new IllegalArgumentException("Add failed.Array is full.");
           
    if (index < 0 || index > size)
               
    throw new IllegalArgumentException("Add failed. Require index >= 0 and index <= size");
            if
    (size == data.length)
                resize(
    2 * data.length);
            for
    (int i = size - 1; i >= index; i--)
               
    data[i + 1] = data[i];
           
    data[index] = e;
           
    size++;
       
    }

       
    // 获取index索引位置的元素
       
    public E get(int index) {
           
    if (index < 0) {
               
    throw new IllegalArgumentException("Get failed.Index is illegal.");
           
    }
           
    return data[index];
       
    }

       
    // 修改index索引位置的元素
       
    public void set(int index, E e) {
           
    if (index < 0 || index >= size) {
               
    throw new IllegalArgumentException("Set failed.Index is illegal.");
           
    }
           
    data[index] = e;
       
    }

       
    // 查找数组中是否存在元素e
       
    public boolean contains(E e) {
           
    for (int i = 0; i < size; i++) {
               
    if (data[i] == e) {
                   
    return true;
               
    }
            }
            
    return false;
       
    }

       
    // 查找数组中元素e所在的索引,如果不存在元素e,则返回-1
       
    public int find(E e) {
           
    for (int i = 0; i < size; i++) {
               
    if (data[i] == e) {
                   
    return i;
               
    }
            }
           
    return -1;
       
    }

       
    // 从数组中删除index位置的元素,返回删除的元素
       
    public E remove(int index) {
           
    if (index < 0 || index >= size) {
               
    throw new IllegalArgumentException("Remove failed.Index is illegal");
           
    }
           
    E ret = data[index];
            for
    (int i = index + 1; i < size; i++) {
               
    data[i - 1] = data[i];
           
    }
           
    size--;
           
    // loitering objects != memory leak 手动释放内存空间
           
    data[size] = null;
            if
    (size == data.length / 2) {
                resize(
    data.length / 2);
           
    }
           
    return ret;
        
    }

       
    // 删除数组第一个元素,返回删除的元素
       
    public E removeFirst() {
           
    return remove(0);
       
    }

       
    // 删除数组最后一个元素
       
    public E removeLast() {
           
    return remove(size - 1);
       
    }

       
    // 删除数组中指定元素e
       
    public void removeElement(E e) {
           
    int index = find(e);
            if
    (index != -1) {
                remove(index)
    ;
           
    }
        }

       
    // 数组扩容
       
    private void resize(int newCapacity){
           
    E[] newData = (E[]) new Object[newCapacity];
            for
    (int i = 0; i < size; i++) {
                newData[i] =
    data[i];
           
    }
           
    data = newData;
       
    }

       
    // 重写父类toString()方法
       
    @Override
       
    public String toString() {
            StringBuilder sb =
    new StringBuilder();
           
    sb.append(String.format("Array: size = %d , capacity = %d\n", size, data.length));
           
    sb.append('[');
            for
    (int i = 0; i < size; i++) {
                sb.append(
    data[i]);
                if
    (i != size - 1) {
                    sb.append(
    ',');
               
    }
            }
            sb.append(
    ']');
            return
    sb.toString();
       
    }
    }

    4、数组测试代码

    public class ArrayTest {
       
    public static void main(String[] args) {
           
    // 测试toString()方法
           
    Array<Integer> arr = new Array(10);
            for
    (int i = 0; i < 10; i++) {
               
    // 测试addLast(int e)方法
                
    arr.addLast(i);
           
    }
            System.
    out.println("添加数组元素:");
           
    System.out.println(arr);

           
    // 测试add(int index, int e)方法
           
    arr.add(1, 200);
           
    System.out.println("在数组指定索引位置插入元素e:");
           
    System.out.println(arr);

           
    // 测试addFirst(int e)方法
           
    arr.addFirst(-10);
           
    System.out.println("在数组头部位置插入元素e:");
           
    System.out.println(arr);

        }
    }

    测试结果如下所示:初始化数组空间大小为10,第一次插入10个元素到数组之后,然后再添加一个元素,此时数组会扩容为原来空间的两倍。

    添加数组元素:

    Array: size = 10 , capacity = 10

    [0,1,2,3,4,5,6,7,8,9]

    在数组指定索引位置插入元素e:

    Array: size = 11 , capacity = 20

    [0,200,1,2,3,4,5,6,7,8,9]

    在数组头部位置插入元素e:

    Array: size = 12 , capacity = 20

    如果感兴趣的童鞋,可以观看我下一篇博客:简单复杂度分析

    展开全文
  • C++传入数组以后不能使用sizeof计算数组长度欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个...

    C++传递数组以后调用sizeof的问题浅析
    代码样例:

    #include "iostream"
    using namespace std;
    
    void Test(int a[]){
    	cout<<sizeof(a)<<"  "<<sizeof(a[0])<<endl;
    }
    
    int main(){
        int a[]={1,2,3,4,5}; 
    	cout<<sizeof(a)<<"   "<<sizeof(a[0])<<endl;	
    	Test(a);
    } 
    

    运行结果如下:
    运行结果

    原因:C++传递数组只是传了一个指向a首地址的指针,并不是a数组的完全复制。

    展开全文
  • 摘要:本文主要写了如何自定义一个长度可变数组 数组是在程序设计中,为了处理方便,把具有相同类型的若干元素按无序的形式组织起来的一种形式 在定义之初,数组长度就被定义 新建数组有很多方式 下面两个都...
  • Export-CSV输出自定义对象数组

    千次阅读 2012-02-15 19:12:12
    Export-CSV是PowerShell的一个cmdlet,通过如下命令我们可以看到相关帮助信息。 Get-Help Export-CSV; 其摘要部分这样写道: ... 将 Microsoft .NET Framework 对象转换为一系列以逗号...那么我们如何自定义的对
  • 提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档 文章目录前言一、用来存放字符串?二、使用步骤1.引入库2.读入数据总结 前言 模拟Java中的ArrayList数据结构 自定义长度可变数组 写了三个版本...
  • MATLAB中如何初始化一个自定义长度的字符串? 比如,我要初始化一个里面有3个0的字符串‘000’。 思路 MATLAB中是没有这样的一个函数,但是有初始化一个数组的函数,比如zeros,ones。 >> A=ones(1,3) A = ...
  • 问题描述如题,在.NET/C# 应用程序开发中如何将两个数组合并成一个数组?方案一如果在.NET 2.0或者以下版本中,由于没有LINQ,所以只能自定义实现将两个数组合并成一个数组的方法。如果数组是可以修改的,那可以在...
  • 本课示例代码 数组(array),是有序的元素序列。若将有限个类型相同的变量的集合命名,那么这个名称...数组创建后长度固定。闹钟设置周几重复,可用布尔型数组。 如果你想参考其他资源,了解如何创建和初始化...
  • 我们在自定义传输协议时,通常都是采用字节数组的方式进行传送,如何正确接收和解码byte数组? 假设我们自定义了传输协议: 字节数组的前4个字节是要传输的数据长度,后面跟数据。我们用mina可以这样处理 1.自定义...
  • 我希望将结果保存到一个新的列名,而不手动编辑列名数组如何完成?谢谢这就是我所尝试的:grpd = df.groupby(['A','B'])grpd['size'] = grpd.size()grpd我得到的错误是:TypeError: 'DataFrameGroupBy' object ...
  • Task 06 数组、切片

    2020-12-19 23:42:45
    数组是具有相同唯一类型的一组已编号且长度固定的数据项序列,这种类型可以是任意的原始类型例如整型、字符串或者自定义类型。 数组元素可以通过索引(位置)来读取(或者修改),索引从 0 开始,第一个元素索引为 0...
  • 如果数组长度未知,可以用list对象存放 更多教学视频和资料下载,欢迎关注以下信息: 我的优酷空间: http://i.youku.com/acetaohai123 我的在线论坛: http://csrobot.gz01.bdysite.com/ ...
  • 如何制作list集合?

    2020-07-25 22:29:59
    class MyArrayList<T> { private int length = 10; //初始化数组,默认为10 private Object[] objArray = new Object[length]; //数组内拥有的数据... //自定义数组长度 public MyArrayList(int length) {
  • 多维数组经典案例

    2020-08-23 18:49:49
    这里写自定义目录标题创建一个长度为6的int型数组,要求元素的值在1-30之间,且是随机赋值。同时,要求元素的值各不相同新的改变功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入...
  • 有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学...
  • 有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学...
  • C++ Code:动态分配数组内存的六种方法

    万次阅读 多人点赞 2017-12-25 10:30:36
     如何快速给数组分配自定义长度的内存,方法有哪些?  本博客提供六种方法介绍,包含各种常用用法,且代码片亲自 编写-注解-编译-通过,对读者负责。 阐述:  提到动态分配C++的数组,我们想到的标签会有:malloc...
  • 三、用malloc函数自定义数组长度 一、为什么需要malloc函数? 用于解决传统数组以下缺点。 ①传统数组的长度必须要事先指定。 ②传统数组的内存无法手动释放。 ③传统数组的长度定义后无法更改 ④无法跨函数使用 二...
  • Java中时间数组的排序问题

    千次阅读 2019-03-27 17:16:57
    准备一个长度是9的日期数组 使用1970年-2000年之间的随机日期初始化该数组 按照这些日期的时间进行升序排序 比如 1988-1-21 12:33:22 就会排在 1978-4-21 19:07:23 前面 因为它的时间更小,虽然日期更大 注意以下...
  • 剑指OFFER-二维数组中的查找题干二分查找1、逐行二分查找2、二维折半查找3、中心二分查找如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建...
  • 有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学...
  •  如何快速给数组分配自定义长度的内存,方法有哪些?  本博客提供六种方法介绍,包含各种常用用法,且代码片亲自 编写-注解-编译-通过,对读者负责。 阐述:  提到动态分配C++的数组,我们想到的标签会有:...
  • 获取我们所需要定义的数组或者列表长度,然后再进一步对数组和列表进行初始化该怎么实现呢?这里我们讨论如何对数组和列表进行动态初始化。难点:二维列表的动态初始化 数组的动态初始化(一维): import numpy as ...
  • 剑指Offer:二维数组中的查找题目描述规律发现运行结果显示如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的...
  • 归并排序

    2015-06-20 16:55:16
    归并排序算法心得 首先归并排序算法有递归归并排序算法和非递归排序算法两种,每种自由的特点各有不同。...解决了排序次数问题,接下来分析如何进行数组的一次归并,根据每次自定义数组长度进行归并,第一次把每个

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 133
精华内容 53
关键字:

如何自定义数组长度