精华内容
下载资源
问答
  • 详解Java静态数组

    千次阅读 2021-02-12 23:31:16
    说到Java静态数组,我们第一时间可能就会想到相应的动态数组,两者看上去挺相似,实质却大不一样。Java静态数组是一定义出来就创建了,而动态数组则是定义时不创建,使用时才创建,一定意义上节省了内存空间。本文...

    说到Java静态数组,我们第一时间可能就会想到相应的动态数组,两者看上去挺相似,实质却大不一样。Java静态数组是一定义出来就创建了,而动态数组则是定义时不创建,使用时才创建,一定意义上节省了内存空间。本文我们主要来讲一讲相对比较简单的Java静态数组。

    实际上我们之前学习的大部分数组都是静态数组,然而在很多的时候,静态数组根本不能满足我们编程的实际需要,比方说我需要在程序运行过程中动态的向数组中添加数据,这时我们的静态数组大小是固定的,显然就不能添加数据,要动态添加数据必须要用到动态数组,动态数组中的各个元素类型也是一致的,不过这种类型已经是用一个非常大的类型来揽括—Object类型。

    Java静态数组,顾名思义,是静态不变的,在内存中位于栈区,是在定义时就已经在栈上分配了固定大小,在运行时这个大小不能改变,如:int

    a[10];

    在函数执行完以后,系统自动销毁;

    动态数组是malloc或者new出来的,位于内存的堆区,它的大小是在运行时给定,并且可以改变其,如:

    int *a;

    a = new

    int[10];动态数组,其创建麻烦,使用完必须由程序员自己通过free或者delete释放,否则严重会引起内存泄露。new[]/delete[]

    #include

    #include

    void fun( int *p )

    {

    sizeof( p ) / sizeof( p[0] );

    }

    int main( void )

    展开全文
  • java(四)创建静态数组

    千次阅读 2021-02-12 09:47:03
    一、静态数组要分配内存空间语法:type[] ary = new type[number];int[] ary; 声明数组是什么类型;内存空间为5的数组;ary=new int[5];用法:public class XueArray {// 执行程序public static void main(String[] ...

    一、静态数组要分配内存空间

    语法:type[] ary = new type[number];

    int[] ary; 声明数组是什么类型;内存空间为5的数组;

    ary=new int[5];

    用法:

    public class XueArray {

    // 执行程序

    public static void main(String[] args) {

    int[] arrInt = new int[5]; // 数组长度为5

    byte[] arrByte = new byte[5];

    String[] arrString = new String[5];

    double[] arrDouble = new double[5];

    System.out.println("arrDouble[0] = " + arrDouble[0]); // 0.0

    System.out.println("arrInt[0] = " + arrInt[0]); // 0

    System.out.println("arrString[0] = " + arrString[0]); // null

    System.out.println("arrByte[0] = " + arrByte[0]); // 0

    }

    }

    第一种

    int[] ary ={1,2,3,4} ;

    // Arrays.toString(ary) 转化可打印的数组

    System.out.println(Arrays.toString(ary)); // 输出 [1,2,3,4]

    第二种

    int[] ary = new int[]{1,2,3,4};

    System.out.println(Arrays.toString(ary)); // 输出 [1,2,3,4]

    三、创建一个二维数组

    int[][] erAry = new int[][]{{1, 2}, {3, 4}}; // [[1,2],[3,4]]

    四、数组常见操作方法(Arrays)

    控制台打印一维数组(Arrays.toString(ary))

    int[] ary={1,2,3,4};

    System.out.println("ary = " + Arrays.toString(ary));

    数组拷贝:(System.arraycopy(ary1,index,ary2,index,length))

    System.arraycopy() 新数组和旧数组地址不一样

    ary2=ary1 新数组和就数组地址一样

    {

    int[] ary = {1, 2, 3, 4};

    int[] ary2 = new int[4];

    int[] ary3 = new int[4];

    ary3 = ary; // ary3根arr是同一个地址

    System.arraycopy(ary, 0, ary2, 0, 4);

    ary[0] = 10;

    System.out.println("ary2 = " + Arrays.toString(ary2)); // [1,2,3,4]

    System.out.println("ary3 = " + Arrays.toString(ary3)); // [10,2,3,4]

    System.out.println("ary = " + Arrays.toString(ary)); // [10,2,3,4]

    }

    遍历数组

    for循环

    forEach

    int[] ary = {1, 2, 3, 4, 5, 6};

    for (int i = 0; i < ary.length; i++) {

    System.out.println("item = " + ary[i]);

    }

    for (int item : ary) {

    System.out.println("item = " + item);

    }

    替换元素(Arrays.fill())

    替换所有元素

    public static void main(String[] args) {

    int[] ary = {1, 2, 3, 4, 5, 6};

    Arrays.fill(ary,9);

    System.out.println("aryAry = " + Arrays.toString(ary)); // [9,9,9,9,9,9]

    }

    替换单独元素

    public static void main(String[] args) {

    int[] ary = {1, 2, 3, 4, 5, 6};

    Arrays.fill(ary,2,3,9);

    System.out.println("aryAry = " + Arrays.toString(ary)); // [1,2,9,4,5,6]

    }

    数组排序(Arrays.sort(ary))

    字符串是按字典来排序;

    数字是按从小到大排序

    复制数组 (Arrays.copyOf(ary,length))

    复制新的数组不是同一个地址

    // 执行程序

    public static void main(String[] args) {

    int[] ary = {1, 2, 3, 4, 5, 6};

    int[] ary1 = Arrays.copyOf(ary, 3);

    ary[0]=100;

    System.out.println("ary1 = " +Arrays.toString(ary1) ); // [1,2,3]

    }

    五、基本算法

    冒泡算法

    原理:冒泡排序也是一种交换排序算法。冒泡排序的过程,是把数组元素中较小的看作是“较 轻”的,对它进行“上浮”操作。从底部开始,反复地对数组进行“上浮”操作 n 次,最后 得到有序数组。

    public void sort(int[] ary) {

    int index;

    for (int i = 1; i < ary.length; i++) {

    // 先拿出第一项出来

    index = 0;

    // 判断是否最大值

    for (int j = 1; j <= ary.length - i; j++) {

    // 如果匹配到最大值把index索引替换了

    if (ary[j] > ary[index]) {

    index = j;

    }

    }

    int temp = ary[ary.length - i]; // 拿出来最后一项存起来

    ary[ary.length - i] = ary[index]; // 最后一项赋值最大的的值

    ary[index] = temp; // 最大项的位置给最后一项

    }

    System.out.println("ary = " + Arrays.toString(ary));

    }

    数组反转

    思路:最后一个和第一个换位置,第二个和倒数第二个,所以循坏长度为总长度的一半

    public void reverse(int[] ary) {

    int len = ary.length;

    for (int i = 0; i < len / 2; i++) {

    int temp = ary[i]; // 第一项存起来

    ary[i] = ary[len - 1 - i]; // 第一项等于最后一项

    ary[len - 1 - i] = temp; // 最后一项等于第一项

    }

    }

    展开全文
  • c语言静态数组创建栈

    2021-05-22 14:14:46
    static_shuzu_stack.h/**构造静态数组栈*/#ifndef STATIC_SHUZU_STACK#define STATIC_SHUZU_STACK#define STACK_TYPE int//定义栈数据类型#define STACK_SIZE 9//定义栈静态数据长度//push入栈void push(STACK_TYPE ...

    static_shuzu_stack.h

    /*

    *构造静态数组栈

    */

    #ifndef STATIC_SHUZU_STACK

    #define STATIC_SHUZU_STACK

    #define STACK_TYPE int//定义栈数据类型

    #define STACK_SIZE 9//定义栈静态数据长度

    //push入栈

    void push(STACK_TYPE value);

    //pop出栈

    void pop(void);

    //top 获得栈顶元素

    STACK_TYPE top(void);

    //is_full //判断栈是否满

    int is_full(void);

    //is_empty //判断栈是否空

    int is_empty(void);

    #endif /*STATIC_SHUZU_STACK*/

    static_shuzu_stack.c

    /*

    *构造静态数组栈

    */

    #include

    #include "static_shuzu_stack.h"

    #include

    static STACK_TYPE stack[STACK_SIZE]; //定义栈

    static int top_element=-1; //定义栈顶位置

    //push入栈

    void push(STACK_TYPE value)

    {

    assert(!is_full());

    top_element++;

    stack[top_element]=value;

    }

    //pop出栈

    void pop(void)

    {

    assert(!is_empty());

    top_element--;

    }

    //top 获得栈顶元素

    STACK_TYPE top(void)

    {

    return stack[top_element];

    }

    //is_full //判断栈是否满

    int is_full(void)

    {

    return top_element==STACK_SIZE;

    }

    //is_empty //判断栈是否空

    int is_empty(void)

    {

    return top_element==-1;

    }

    /*

    *    可以设定从栈底开始存放数据,这样在push()时需要在添加之后再将top_element++,

    *    但是在出栈的时候需要首先将top_elemnt--,然后再将top_element--;

    *    影响了效率

    */

    static_shuzu_stacktest.c

    /*

    *    编写测试用例

    */

    #include

    #include "static_shuzu_stack.h"

    void main()

    {

    int i=0;

    for(i=0;i<=10;i++)

    {

    if(is_full())

    {

    printf("stack is full now\n");

    break;

    }

    push(i);

    printf("top of stack is %d\n",top());

    }

    for(i=0;i<=10;i++)

    {

    if(is_empty())

    {

    printf("stack is empty now\n");

    break;

    }

    printf("top of stack is %d\n",top());

    pop();

    }

    }

    编译:gcc -o staticTest static_shuzu_stack.c  static_shuzu_stacktest.c

    输出结果:

    top of stack is 0

    top of stack is 1

    top of stack is 2

    top of stack is 3

    top of stack is 4

    top of stack is 5

    top of stack is 6

    top of stack is 7

    top of stack is 8

    top of stack is 9

    stack is full now

    top of stack is 9

    top of stack is 8

    top of stack is 7

    top of stack is 6

    top of stack is 5

    top of stack is 4

    top of stack is 3

    top of stack is 2

    top of stack is 1

    top of stack is 0

    stack is empty now

    展开全文
  • 1. 静态数组在内存中位于栈区,是在定义时就已经在栈上分配了固定大小,在运行时这个大小不能改变,如:int a[10]; 动态数组是malloc或者new出来的,位于内存的堆区,它的大小是在运行时给定,并且可以改变其,如:...

    1. 静态数组在内存中位于栈区,是在定义时就已经在栈上分配了固定大小,在运行时这个大小不能改变,如:int a[10];
       动态数组是malloc或者new出来的,位于内存的堆区,它的大小是在运行时给定,并且可以改变其,如:
        int *a;

        int  m_num = 10;   
        a = new int[m_num ];


    2. 静态数组的大小是在编译期间就确定,并且分配的,其内存在使用结束后由计算机自动释放,效率高;动态数组是在程序运行时,由程序员根据实际需要从堆内存中动态申请的,使用结束后由程序员进行释放,效率低。

    3. 在函数内部声明的静态数组不可能通过函数返回,因为生存期的问题,函数调用完其内部变量占用的内存就被释放了。如果想通过函数返回一个数组,可以在函数中用new动态创建该数组,然后返回其首地址。静态数组是在栈中申请的,而函数中的局部变量也是在栈中的,而new动态数组是在堆中的分配的,所以函数返回后,栈中的申请的内存被自动释放,而堆中申请的内存如果没有delete就不会自动释放。

    另外:
    在堆中申请空间有两种方式:C的malloc和C++的new。
    对于基本数据类型的数组来说,这两种申请空间的方式没有什么太大的区别:
    int *pa, *pb;
    pa = (int *)malloc(sizeof(int) * 10); // 正确
    pb = new int[10]; // 正确

    但是,如果类数组的话,一定要用new来分配空间,而不是malloc。
    MyClass *pa, *pb;
    pa = (MyClass *)malloc(sizeof(MyClass) * 10); // 错误
    pb = new MyClass[10]; // 正确
    因为采用malloc调用的只是分配了一块sizeof(MyClass) * 10大小的空间,其他什么事情都没做;采用new调用,不但分配了空间(自动计算),而且还调用了每个MyClass的构造函数,对于类来说,构造函数是很重要的,如果没有调用构造函数而使用该类变量的话,可能会出现预想不到的结果。
    注意:在用new []申请空间后,需要用delete []释放空间。
               为什么不是delete,而是delete []?
               对于基本数据类型的数组来说,delete只释放了pa[0]的空间,而delete []正确地释放了所有的空间。
               对于类的数组来说,delete只调用了pa[0]的析构函数,并是放了空间,
               而delete []调用了所有元素的析构函数,并且正确地释放了所有的空间。

    展开全文
  • 静态数组实现堆栈

    2021-07-16 16:22:50
    1、要使用静态数组实现堆栈,首先要先创建一个静态数组,数组的大小和下标都要声明,这里下标初始化为-1。 5 #define size 10 6 static int stack[size]; 7 static int top_element = -1; 2、第二步,我们要想...
  • 首先,有时用数组时,常把静态数组和动态相混淆,今天来区分一下:先写一下java中静态数组,一维数组的声明方式:type var[]; 或type[] var;声明数组时不能指定其长度(数组中元素的个数),Java中使用关键字new创建...
  • 静态数组和外部数组可以初始化问题书本上讲只有静态数组和外部数组可以初始化,但本人用下面程序调试时,却发现自动数组也可以初始化,不知道什么原因,望各位能给与指点.int main(void){int i,ch[5]={1,2,3,4,5};...
  • 前面我们学习的数组都是静态数组,其实在很多的时候,静态数组根本不能满足我们编程的实际需要,比方说我需要在程序运行过程中动态的向数组中添加 数据,这时我们的静态数组大小是固定的,显然就不能添加数据,要...
  • 不.从http://php.net/manual/en/language.oop5.static.php:Like any other PHP static variable, static properties may only beinitialized using a literal or ... expressions are not allowed.So while you ...
  • 详解java静态数组

    2021-08-13 13:54:39
    数组是一种线性表 顾名思义,数组就是数据组合在一起,是一个存储数据容器。其一般定义: 数组是具有相同数据类型元素的有序集合。 从定义可知 所有元素必须是相同数据类型。 那么可以推导数组也是一种数据类型,且...
  • 假设有这么一种情况:程序中定义了一个静态数组,然后将这个数组作为参数传递给某个函数,如何在该函数中确定数组长度呢? int arr[] = { 1, 2, 3, 4, 5 }; f(arr); // 如何在函数 f() 中确定 arr 的长度? C 语言...
  • } 注意: concat函数实现两个串的拼接生成一个新串,虽然使用静态数组方式可以实现,但是静态数组的特性无法扩容。所以有可能这两个函数拼接之后容量超了静态数组的容量。 所以实现concat这种类似拼接字符串的函数,...
  • 堆栈的静态数组实现

    2021-03-15 14:40:21
    package stack;... * Java中的堆栈:用静态数组或者动态链表结构实现,但需要维持堆栈后进先出与从顶端读取数据的两个原则 * */ /*用数组声明一个堆栈*/ class StackByArray { private int[] stack;.
  • 1-Delphi支持的数组类型有两种:静态数组和动态数组 静态数组——声明时就已经确定大小的数组类型; 动态数组——其大小在声明时不能确定的数组,其数组大小在使用时确定。 2-数组的声明及引用数组元素 1) 静态数组...
  • 你的大部分问题都得到了回答,但只是给出一个让我的生活更轻松的答案:定性地,非动态分配的数组的最大大小取决于您拥有的RAM量.它还取决于阵列的类型,例如一个int可能是4个字节,而double可能是8个字节(它们也是系统...
  • 构造函数(Construction) 创建空的列表 判空(Empty) 检查列表是否为空 插入(Insert) 在列表中增加一项 删除(Dete) 在列表中删除一项 遍历(Traverse) 按顺序访问列表或者列表的一部分 基于静态数组的...
  • 今天是2021年的第一天,大家新的一年也要好好学习Rust呀~在很多其他语言中,静态数组虽然是静态的,但是我们却可以“给它在运行时中指定一个动态的长度”。但在Rust中由于数组[T; N...
  • 容器:就是存储数据的"工具" 数组:(最基本的容器) StringBuffer:字符串缓冲区 ---->数据 ---->... 2)静态初始化 先说动态初始化: 给定了数组的长度,系统默认对元素进行初始化! 数据类型[]
  • //因为是静态数组,所以一开始就要定义最大长度, //并且一旦定义不能改变 typedef struct{ int data[MaxSize]; int length;//当前的长度,已经存了几个元素 }SqList; //初始化一个顺序表 void InitList...
  • Delphi的数组 大家都知道 有动态数组和静态数组 一.动态数组=不定长 array of byte 对其操作需要 setlength先分配 然后赋值 优点:不需要提前预先定义长度 方便扩展 缺点:性能对比静态稍差因为成员操作需要...
  • 一、静态数组 静态数组:定义时就已经在栈**上分配了空间大小,在运行时这个大小不能改变 数组(array)是一种数据格式,能够存储多个同类型的值。 一维数组 1、一维数组的声明: 一般声明:typeName arrayName...
  • 数组分类:1、从数组的下标分为索引数组、关联数组/* 索引数组,即通常情况下所说的数组 */var ary1 = [1,3,5,8];//按索引去取数组元素,从0开始(当然某些语言实现从1开始)//索引实际上就是序数,一个整型数字alert...
  • C语言 将二叉树转化为静态数组 (4页) 本资源提供全文预览,点击全文预览即可全文预览,如果喜欢文档就下载吧,查找使用更方便哦!9.9 积分//C语言,将动态二叉树转化为静态数组#include#include//建立二叉树struct ...
  • 事情是这样子滴,有一次我在代码评审的时候,发现有同事想使用运行时才能够获取到的值,去改变一个静态数组的元素个数,我当时就很诧异,因为我心里知道这样是不可行的,静态数组的元素个数在编译时就需要是固定不变...
  • 从寻址的角度来说,静态数组采用的是直接寻址,而动态数组都是两次寻址,这和动态数组本身实现是有关系的。静态数组的变量本身就是数组第一个元素的地址。动态数组的变量存放的是一根指向到申请空间的首址指针。 .....
  • 定义数组后,未初始化 ...//定义静态全局数组,未初始化数组成员 int array_glogal[LEN1]; //定义全局数组,但未初始化数组成员 int main() { char key = 6; switch(key) { case 6: { int i = 0; int arr...
  • 本文实例讲述了JAVA基于静态数组实现栈。分享给大家供大家参考,具体如下:1.栈的定义栈是一种“先进后出”的一种线性数据结构,有压栈出栈两种操作方式。如下图:2.栈的分类栈主要分为两类:静态栈动态栈【静态栈】...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 612,410
精华内容 244,964
关键字:

静态数组