精华内容
下载资源
问答
  • Java动态数组扩展问题

    2020-10-15 09:50:12
    这项技术称为动态数组扩展(dynamic array expansion),当程序运行时,动态数组扩展使我们能分配任意大小数组,使数组扩大或缩小。以输入个字符串为例进行介绍。 方法一: 用一个整型变量innumber记录当前输

    假设我们需要读取数的序列,为了处理这些数,将它们存储在数组中。数组的基本属性需要我们声明数组的大小,以便编译器能分配正确的内存数量。同时,我们必须在第一次访问数组之前声明数组的大小。如果我们不知道数组的具体大小,那么对数组的大小很难做出合理的选择。如果数组初始大小太小,如何扩大数组。这项技术称为动态数组扩展(dynamic array expansion),当程序运行时,动态数组扩展使我们能分配任意大小的数组,使数组扩大或缩小。以输入个字符串为例进行介绍。
    方法一:
    用一个整型变量innumber记录当前输入的字符串数目,字符串数组arr存储输入的字符串,当innumber等于数组大小时,对arr大小进行扩展,这里采用扩展两倍的方式,即扩展后的数组大小等于arr大小的两倍,如果扩展规模太小的话,随着arr数组大小N的增加,付出的代价是很昂贵的,因为每次扩展都伴随着数组元素的搬运。
    数组扩展函数resize里面有一个min函数,这个min函数的作用是为了最后过滤掉数组arr后面的null元素。

        public static String[] getString() {
            String[] arr = new String[5];
            Scanner cin = new Scanner(System.in);
            int innumber = 0;
            while (cin.hasNextLine()) {
                String thisStr = cin.nextLine();
                if (thisStr.equals(""))
                    break;
                if (innumber == arr.length)
                    arr = resize(arr, innumber * 2);
                arr[innumber++] = thisStr;
            }
            return resize(arr, innumber);
        }
    
        public static String[] resize(String[] prearr, int size) {
            String arr[] = new String[size];
            int minsize = Math.min(size, prearr.length);
            for (int i = 0; i < minsize; i++) {
                arr[i] = prearr[i];
            }
            return arr;
        }
    

    方法二:
    另外,在java中我们还可以使用更为简便的ArraList来动态扩展数组

        public static ArrayList<String> getString2() {
            ArrayList<String> arr = new ArrayList<String>();
            Scanner cin = new Scanner(System.in);
            while (cin.hasNextLine()) {
                String thisStr = cin.nextLine();
                if (thisStr.equals(""))
                    break;
                arr.add(thisStr);
            }
            return arr;
        }
    
    展开全文
  • java学习笔记数组

    2016-05-11 18:04:23
    数组:一组相关变量的集合,按照数组的使用可分为一维数组、二维数组 ...// int 整形数组 int,数组名attr, new 动态开辟 int[6],数组大小为6,里面存放6个元素,下标0-5。实例public class Test {

    数组:一组相关变量的集合,按照数组的使用可分为一维数组、二维数组
    定义:int [ ] attr。
    使用java数组分为两步,声明数组和分配内存给该数组。
    int [ ] attr=new int [6];// int 整形数组 int,数组名attr, new 动态开辟 int[6],数组大小为6,里面存放6个元素,下标0-5。

    实例

    public class Test {
            public static void main(String[] args) {
              int attr[]=null;//声明数组
              attr=new int[5];//开辟空间,大小为5
         }
    }

    数据类型是数组元素的类型,常见的数据类型有整形,浮点型,字符型。
    数组名用来同一该数据类型元素的名称,命名规则与变量相同。
    数组声明后该数组名保存在栈内存里
    new出来的对象(数组)存在堆内存中。
    在数组操作中,栈内存里保存的是数组名,只开辟了栈内存数组是无法使用的,同时堆内存空间是可以同时被多个栈内存空间指向的,好不如人可以有多个称呼,人就相当于堆内存,称呼就相当于栈内存。

    堆内存每一个局部变量都有一个默认的初始值,根据类型不同,初始值也不同,例如int型的是0;float型的是0.0f\0.0,boolean型的是false。堆内存中的垃圾系统会不定时自定垃圾回收。

    数组的访问
    想要访问数组中的元素可以利用索引来访问,如int[0]代表以一个元素,以此类推。

    数组的初始化可以使通过静态初始化和动态初始化,所谓的静态初始化是指在数组声明后直接为数组指定具体内容,动态初始化时通过new出来的。

    length表示数组的长度。

    求出数组中的最大值和最小值

    package SString;
    
    public class Arraytest {
    
        public static void main(String[] args) {
            int num[]={32,25,12,51,25};
            int max=0;
            int min=0;
    
            min=max=num[0];
            for(int i=0;i<num.length;i++){
                if(num[i]>max){
                    max=num[i];
                }
                if(num[i]<min){
                    min=num[i];
                }
            }
            System.out.println("max:"+max);
            System.out.println("min:"+min);
        }
    }
    

    用冒泡法进行排序

    public class attrr {
        /**
         * @param args
         */
          public static void main(String[] args) {
              int []  nums = {216,25,58,654,545};
    
              for(int i=0;i<nums.length-1;i++){//外层循环,控制比较的轮数
                  for(int j=0;j<nums.length-1-i;j++){//内层循环,控制每轮比较的次数
                      if(nums[j]<nums[j+1]){//相邻的两元素进行比较,满足条件交换位置
                          int temp=nums[j];
                          nums[j]=nums[j+1];
                          nums[j+1]=temp;
                      }
              }
            }
              for(int i=0;i<nums.length;i++){
                  System.out.print(nums[i]+" ");
              }
          }
    }
    
    展开全文
  • java实现智能数组

    2014-04-06 22:06:27
    现在请你来写一个智能数组类 SmartArray,它能够根据需要动态分配空间。 实际上,它只不过是在其它位置分配新的数组,然后把旧的数据拷贝过去。 请提供数组访问方法: int get(int idx); // 返回...
    题目:
    java提供的数组有个特点: 当数组元素的个数确定后,就不能再追加元素了。

    也就是说,数组的大小在创建的时候就固定了。

    现在请你来写一个智能数组类 SmartArray,它能够根据需要动态地分配空间

    实际上,它只不过是在其它位置分配新的数组,然后把旧的数据拷贝过去。

    请提供数组访问方法:

    int get(int idx); // 返回指定位置的元素值

    void set(int idx, int value); // 对指定的下标元素设置新值。当然,如果下标超出了原来数组的大小,则自动分配新的空间。

    代码:
    class SmartArray
    {
    	private int capacity; // 程序实际存储数据的数组大小
    	private int size;  // 用户视角的数组大小
    	private int[] data;  //工作数组
    	
    	public SmartArray()
    	{
    		capacity = 16;
    		size = 0;
    		data = new int[capacity];
    	}
    	
    	public int get(int idx)
    	{
    		return data[idx];
    	}
    	
    	public void set(int idx, int value)
    	{
    		if(idx >= capacity){ // 重新分配,拷贝就数据
    			if(idx >= capacity* 2) 
    				capacity = idx+1;
    			else
    				capacity = capacity * 2;
    				
    			int[] dd = new int[capacity];
    			for(int i=0; i<size; i++){
    				dd[i] = data[i];
    			}
    			data = dd; //指向新数据,丢掉老数组
    		}
    		
    		data[idx] = value;
    		if(idx+1>size) size = idx+1;
    	}
    	
    	public int length() { return size; }
    }
    
    public class MyA
    {
    	public static void main(String[] args)
    	{
    		SmartArray a = new SmartArray();
    		a.set(2,22);
    		a.set(3,33);
    		a.set(9,99);
    		a.set(15,1515);
    		
    		for(int i=0; i<a.length(); i++){
    			System.out.println(i + ": " + a.get(i));
    		}
    	}
    }


    展开全文
  • 在计算机科学中,动态数组/ 可扩展数组/ 可调整数组/ 动态表/ 可变数组/ 数组列表 是一种随机...动态数组动态分配数组不同 动态数组可能使用固定大小数组作为后端。 例子: ArrayList List = new A...

    动态数组:基础

    • 在计算机科学中,动态数组/ 可扩展数组/ 可调整数组/ 动态表/ 可变数组/ 数组列表 是一种随机存取可变大小列表数据结构,允许添加删除元素。它提供许多现代主流编程语言的标准库。

    • ArrayList类

      • ArrayList类实现了List接口,由ArrayList类实现的List集合采用数组结构保存对象
      • 数组结构的优点是便于对集合进行快速随机访问,如果经常需要根据索引位置访问集合中的对象,使用由ArrayList类实现的List集合的效率较好
      • 数组结构的缺点是向指定索引位置插入对象和删除指定索引位置对象的速度较慢,如果经常需要向List集合的指定索引位置插入对象,或者是删除List集合的指定索引位置的对象,使用由ArrayList类实现的List集合的效率较低,并且插入或删除对象的索引位置越小效率越低,原因是当向指定的索引位置插入对象时,会同时将指定索引位置及之后的所有对象相应的向后移动一位。当删除指定索引位置的对象时,会同时将指定索引位置之后的所有对象相应的向前移动一位。如果在指定的索引位置之后有大量的对象,将严重影响对集合的操作效率
    • 动态数组克服了静态数组的限制,静态数组具有需要在分配时指定的固定容量

    • ??动态数组与动态分配的数组不同

    • 构造器
      ArrayList提供了三个构造器:

      • public ArrayList();
        默认的构造器,将会以默认(16)的大小来初始化内部的数组
      • public ArrayList(Collection实现类对象);
        初始化时,将一个Collection接口的实现类对象填入ArrayList中。
      • public ArrayList(int);
        指定的大小来初始化内部的数组
    • 泛型类数组ArrayList类指定存放对象类型,需要将类型标注在尖括号内。以下语句将声明和构造一个存放Employee类型对象的数组列表:

      ArrayList<Employee> arrEmp=new ArrayList<Employee>();
      

      从Java 7以后,可以省去后面的类型参数

      ArrayList<Employee> arrEmp=new ArrayList<>();
      



    动态数组:方法

    • 按索引查值

      arrayList.get(index)
      
    • 增加元素

      arrayList.Add(object)
      
    • 按索引移除 RemoveAt(index)

      arrayList.RemoveAt(5);//将第6个元素移除 
      
    • 按索引移除 remove(index)

      arrayList.remove(5);//将第6个元素移除 
      
    • 移除指定元素 remove(element)

      arrayList.remvoe("A");//将字符`A`移除
      

      Q: 然而,如何移除指定的整数,而不与“按索引移除”混淆?

    • 按索引改值 set(index, element)

      arrayList.set(2, "F");
      
    • 查询元素总数

      int elementTotal = arrayList.size(); 
      
      • 必须是.size(),若是.size则会报错size in ArrayList has private access
    • ?? Count属性和Capacity属性

      • Count属性是目前ArrayList包含的元素的数量,这个属性是只读的。
      • Capacity属性是目前ArrayList能够包含的最大数量,可以手动设置这个属性,但是当设置为小于Count值的时候会引发一个异常。



    动态数组:效率

    • ArrayList是Array的复杂版本
      ArrayList内部封装了一个Object类型的数组,从一般的意义来说,它和数组没有本质的差别,甚至于ArrayList的许多方法,如Index、IndexOf、Contains、Sort等都是在内部数组的基础上直接调用Array的对应方法。

    • 内部的Object类型的影响
      对于一般的引用类型来说,这部分的影响不是很大,但是对于值类型来说,往ArrayList里面添加和修改元素,都会引起装箱和拆箱的操作,频繁的操作可能会影响一部分效率。
      但是恰恰对于大多数人,多数的应用都是使用值类型的数组。
      消除这个影响是没有办法的,除非你不用它,否则就要承担一部分的效率损失,不过这部分的损失不会很大。

    • 数组扩容
      这是对ArrayList效率影响比较大的一个因素。
      每当执行Add、AddRange、Insert、InsertRange等添加元素的方法,都会检查内部数组的容量是否不够了,如果是,它就会以当前容量的两倍来重新构建一个数组,将旧元素Copy到新数组中,然后丢弃旧数组,在这个临界点的扩容操作,应该来说是比较影响效率的。

      例1:比如,一个可能有200个元素的数据动态添加到一个以默认16个元素大小创建的ArrayList中,将会经过:
      162222 = 256
      四次的扩容才会满足最终的要求,那么如果一开始就以:
      ArrayList List = new ArrayList( 210 );
      的方式创建ArrayList,不仅会减少4次数组创建和Copy的操作,还会减少内存使用。

      例2:预计有30个元素而创建了一个ArrayList:
      ArrayList List = new ArrayList(30);
      在执行过程中,加入了31个元素,那么数组会扩充到60个元素的大小,而这时候不会有新的元素再增加进来,而且有没有调用TrimSize方法,那么就有1次扩容的操作,并且浪费了29个元素大小的空间。如果这时候,用:
      ArrayList List = new ArrayList(40);
      那么一切都解决了。
      所以说,正确的预估可能的元素,并且在适当的时候调用TrimSize方法是提高ArrayList使用效率的重要途径。

    • 频繁的调用IndexOf、Contains等方法(Sort、BinarySearch等方法经过优化,不在此列)引起的效率损失

      首先,我们要明确一点,ArrayList是动态数组,它不包括通过Key或者Value快速访问的算法,所以实际上调用IndexOf、Contains等方法是执行的简单的循环来查找元素,所以频繁的调用此类方法并不比你自己写循环并且稍作优化来的,如果有这方面的要求,建议使用Hashtable或SortedList等键值对的集合。

    展开全文
  • 如何实现动态分配? 说白了其实就是数组大小由外部输入,然后在动态生成数组。 因此在添加元素时需要判断数组是否已经满员了,所以类中需要一个记录了数组大小的标记,这里记为font 我以下的代码写了一个Array的父类...
  • C++动态分配二维数组

    2016-04-04 23:11:18
    动态分配就是在运行的时候进行内存的分配,在C++中,可以在栈上分配数组,这种情况下,必须指定数组的长度,长度不能是变量,必须是常量或者常量表达式(其原因在于静态分配在编译时需要知道数组的长度,而变量在...
  • JAVA数据结构--ArrayList动态数组 ...在计算机科学中,动态数组,可扩展数组,可调整数组,动态表,可变数组或数组列表是一种随机...动态数组动态分配数组不同,数组数组分配时大小固定的数组...
  • 读线性表有感一维数组可以是静态分配的,也可以是静态分配的动态分配并不是链式存储,同样是属于顺序存储结构,其物理结构没有发生变化,依然是随机存储方式,只是分配的空间大小可以在运行时决定 联想到了java中的...
  • JAVA 数组

    2021-01-07 11:54:17
    语法: 数据类型[] 数组名称 = new int[数组大小(容量)]; 动态初始化 int[] a =new int[10];//数组大小为10 叫a 静态初始化 int[] a = new int[]{1,2,3};//自动分配空间 大小为3 int[] b = {1,2,3};//可以简化为...
  • Java语言中,由于把二维数组看作是数组数组数组空间不是连续分配的,所以不要求二维数组每一维的大小相同。   2.动态初始化 1) 直接为每一维分配空间,格式如下: arrayName = new type[arrayLength1]...
  • java数组

    2021-01-02 09:37:24
    在声明的时候只给数组指定大小,那么分配的空间就会根据类型自动初始化,如int为0,对象为null。 如: int[] arr = new int[3]; 三:动态初始化 在声明的时候只给数组指定大小,随后指定每个对象具体的值 如: //3、...
  • 动态数组

    2019-09-16 21:48:24
    说到动态数组,我们可能会想到在java数组的概念,那么何为数组呢?数组就是系统给分配的内存,通俗的说就是容器,但是是一种数据类型的集合,存储的数据是同一种类型。那么有哪些特点呢?1.每个存储空间大小一致且...
  • Java 数组

    2012-08-01 22:27:20
    缺点:数组对象大小被固定,在其生命周期不可改变,而使用ArrayList动态分配,这种弹性需要开销,效率会比较低。 数组的标志符其实只是个引用,指向在堆中创建的一个真实对象,这个数组的对象以保存指向其他...
  • 在结构体类中使用数组有几种方式,可以使用静态指定大小的方式也可以通过使用 ArrayLengthMaker 进行动态分配数组大小既可以在类中定义,也可以在定义对象后通过对象进行指定。 静态指定方法 如下所
  • 数组的初始化 Java中要使用数组,必须要先经过初始化。所谓初始化,就是为每个数组元素分配内存空间...动态初始化:在初始化数组时,仅指定数组大小(长度),由系统为每个数组元素分配默认值。 数组元素的类型是基
  • Java数组详解

    2019-07-18 11:06:43
    数组(其长度不可修改) 一维数组 1.声明一维数组的(常用)...A. 使用new指定数组大小动态初始化 ) 其格式;type[]array=new int[size]; 在A的基础上,单独为数组元素赋值(通过下标)为动态初始化 B. 使用new...
  • 当然不可以,形象的说你有200个空间,你现在分配了100个空间,...数组空间是静态分配的,就是初始化的时候就分配好了的,你如果需要修改就要使用链表之类的动态分配空间的类,学过数据结构应该都知道链表的使用。...
  • 自定义动态数组

    2013-05-31 11:54:10
    现在要求定义一个数组(Array),里面定义了一个整型数组,但是此整型数组属于动态分配大小, 即:所以大小由程序指定,并在此基础上实现以下的两个子类。  *反转类:可以将数组的内容反转排列  *排序类:可以对...
  • java内置了管理大量同类型数据的容器,数组。数组的声明方式如下:int[] a = new ...数组的大小可以在创建时确定(C/C++的数组大小是决不允许这样确定的,较早的标准甚至连const整数都没法用,只能使用枚举)。 使用数
  • java 第一回 数组讲解

    2011-08-29 23:33:46
    数组 在 Java 代码中数组是动态创建的对象。一个数组可以包含若干个同类型的变量。...在声明时指定数组大小是非法的。方括号可以作为类型的一部分出现在声明的开始处,也可以作为数组标识符的一部分: ...
  • java 数组初始化

    2014-07-12 20:25:07
    Java语言的数组必须经过初始化才能够使用。所谓初始化就是为元素分配内存空间,并为每个数组元素指定初始值。 数组的初始化方式有以下两种: 静态初始化:指在定义数组变量的同时指定数组元素。 int [] arr =...
  • Java数组初始化

    2014-06-03 21:34:30
    Java语言的数组必须经过初始化才能够使用。所谓初始化就是为元素分配内存空间,并为每个数组元素指定初始值。 数组的初始化方式有以下两种: 静态初始化:指在定义数组变量的同时指定数组元素。 int [] arr =...
  • Java——数组(概念理解+应用举例)

    千次阅读 2020-06-04 13:24:12
    数组是一种数据结构,系统为数组分配的存储空间是连续的、指定长度的、且大小固定不变的,用来存储一组大小固定并且类型相同的数据。 这些数据可以通过索引进行访问,数组的下标索引是从 0 开始,其取值范围必需是:...
  • 动态初始化,给出数组大小,由系统给每个数组元素一个初始值,例如:int [] arr = new int [3]; 初始化数组时会在堆内存中分配一个不会变化的数组内存地址,以后访问数组元素,要先找到堆内存中的数组地址,再查找...
  • Java数组的基本讲解

    2019-07-21 06:50:48
    由于Java数组涵盖的内容比较多,这里从个人...何为静态,就是说Java数组在初始化的时候必须确定在内存中分配的空间的大小。 具体实现方式就是在初始化数组的时候(注意不是声明数组的时候,这两个概念别搞混了)指...

空空如也

空空如也

1 2 3 4 5 ... 10
收藏数 200
精华内容 80
关键字:

java动态分配数组大小

java 订阅