精华内容
下载资源
问答
  • 数组扩容
    2021-05-21 16:18:18

    用数组模拟栈

    数组是固定大小的,不能改变长度,要想达到数组扩容的目的,就只能把当前数组复制到一个更长长度的数组中;

    使用Arrays.copyOf()方法

    源码如下:

    public static short[] copyOf(short[] original, int newLength) {

    short[] copy = new short[newLength];

    System.arraycopy(original, 0, copy, 0,

    Math.min(original.length, newLength));

    return copy;

    }

    可以看出,内部调用了System.arraycopy()方法。

    下面是用数组实现一个栈的代码:

    class MinStack {

    /** initialize your data structure here. */

    int[] stack ;//数组

    int defaultSize = 2;//默认大小

    int realNumber;//存在的数量

    public MinStack() {

    this.stack = new int[defaultSize];

    }

    public void push(int x) {

    if(realNumber == stack.length){

    stack = Arrays.copyOf(stack,stack.length+defaultSize);

    }

    stack[realNumber++] = x;

    }

    public void pop() {

    if(realNumber > 0){

    realNumber--;

    }

    }

    public int top() {

    return stack[realNumber-1];

    }

    public int getMin() {

    int min = stack[0];

    for(int i = 0;i < realNumber;i++){

    if(min > stack[i]){

    min = stack[i];

    }

    }

    return min;

    }

    }

    更多相关内容
  • Java中数组扩容方式

    2021-12-17 11:30:05
    package FirstJava; public class array{ public static void main(String[] args) { ... //扩容步骤1:创建比原数组更大的数组 int [] newArray = new int [ oldArray.length *2]; //扩容步骤2,将原...

    package FirstJava;

    public class array{
        public static void main(String[] args) {

            //原数组
            int [] oldArray = new int []{11,22,33,44};

            //扩容步骤1:创建比原数组更大的数组
            int [] newArray = new int [ oldArray.length *2];

            //扩容步骤2,将原数组的元素,依次复制到新数组中
            //写个循环,将old下标的值赋给new里
            for(int i = 0;i < oldArray.length ; i++){
                newArray[i]=oldArray[i];
            }

            //遍历访问
            for(int i = 0;i < newArray.length; i++){
                System.out.print(newArray[i]);
            }
            System.out.println();
        }
    }


    package FirstJava;

    public class array {
        public static void main(String[] args) {

            //原数组
            int [] oldArray = new int []{11,22,33,44,55};

            //扩容步骤1:创建比原数组更大的新数组
            int [] newArray = new int [ oldArray.length * 2 ];

            //扩容步骤2:将原数组的元素,依次复制到新数组中
            System.arraycopy(oldArray,0,newArray,0,oldArray.length);

            //遍历访问
            for(int i = 0 ; i <= newArray.length ; i++) {
                System.out.println(newArray[i] + "\t");
            }
                System.out.println();
        }
    }

    //第三种方法
    package FirstJava;

    //引入包
    import java.util.Arrays;

    public class array {
        public static void main(String[] args) {

            int [] oldArray = new int []{11,22,33,44,55};

            int [] newArray = Arrays.copyOf(oldArray,oldArray.length * 2);

            //遍历访问

            for(int i = 0 ; i <=5 ; i++) {
                System.out.println(newArray[i]);
            }
        }
    }

    展开全文
  • Java数组扩容实例代码

    2021-02-26 13:15:22
    在写程序的过程中,我们常常会碰见数组空间...用C语言实现太难了吧,需要调用memcpy函数要一个一个偏,但是在java中就不用那么麻烦了,有种叫数组扩容方式,轻松实现。来看看代码:public class HelloWorld {public...

    在写程序的过程中,我们常常会碰见数组空间不够用的情况,比如我已经初始化了一个数组int []a = {1,2,3,4,5,6,7,8,9,10} ;这时,我想往数组下标3的位置插入一个元素,该怎么做?用C语言实现太难了吧,需要调用memcpy函数要一个一个偏,但是在java中就不用那么麻烦了,有种叫数组的扩容方式,轻松实现。来看看代码:

    public class HelloWorld {

    public static void main(String[] args){

    // Scanner s = new Scanner(System.in);

    // System.out.println("请输入一个数字");

    // int num = s.nextInt();

    //这个数组下标只能到9

    int []a = {1,2,3,4,5,6,7,8,9,10};

    //先扩容

    int []b = Getarray(a,3,100);

    Demoe.PrintArray(b);

    }

    //案例:有一个数组已经初始化完毕,现向其下标3插入一个元素100

    public static int[] Getarray(int []a , int index , int num){

    int src_array_length = a.length ;

    int []b = new int[src_array_length+1] ;

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

    b[i] = a[i] ;

    }

    a = b ; //如果还想使用a,使得a指向b

    //接下来从最后一个元素开始,将最后一个元素的前面一个元素拷贝到最后一个

    //以此类推

    for(int i = a.length - 1 ; i > index ; i--){

    a[i] = a[i-1];

    }

    //别忘了,将要插入的元素插入到对应的数组坐标

    a[index] = num ;

    return a ;

    }

    }

    也可以使用java中的库函数来实现

    import java.util.Arrays;

    public class HelloWorld {

    public static void main(String[] args){

    // Scanner s = new Scanner(System.in);

    // System.out.println("请输入一个数字");

    // int num = s.nextInt();

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

    int []b = new int[a.length] ;

    //1、源数组

    //2、源数组的哪个位置开始

    //3、目标数组

    //4、目标数组的哪个位置开始存放

    //5、拷贝几个

    //System.arraycopy(a, 0, b, 0, a.length);

    //Demoe.PrintArray(b);

    //扩容--->扩容了一倍

    //a = Arrays.copyOf(a, 2*a.length) ;

    //Demoe.PrintArray(a);

    a = insertArray(a , 3 , 100) ;

    //打印数组

    System.out.println(Arrays.toString(a));

    }

    //写一个函数,向整数数组的任意pos位置插入一个元素value

    public static int[] insertArray(int []a , int pos , int value){

    if(pos < 0 || pos > a.length + 1) //索引下标不对,直接返回源数组

    return a ;

    //放入一个元素,先扩容,后复制

    a = Arrays.copyOf(a, a.length+1) ;

    for(int i = a.length - 1 ; i > pos ; i--){

    a[i] = a[i-1] ; //后移动

    }

    a[pos] = value ;

    return a ;

    }

    }

    运行结果:

    [1, 2, 3, 100, 4, 5]

    总结

    以上就是本文关于Java数组扩容实例代码的全部内容,希望对大家有所帮助。如有不足之处,欢迎留言指出。感谢朋友们对本站的支持!

    展开全文
  • 5.数组动态扩容

    2021-01-30 00:56:45
    5.数组动态扩容 试题: 设置一个类, 命名为 MyList 类中包含属性:Object[] element 方法有如下几个: 1. 增加方法 add : 可以向数组属性中依次存储 Object,数组内容存满时,需实现动态扩容(详解在下面)...

    5.数组动态扩容

    试题:

    • 设置一个类, 命名为 MyList
    • 类中包含属性:Object[] element
    • 方法有如下几个:
      • 1. 增加方法 add : 可以向数组属性中依次存储 Object,数组内容存满时,需实现动态扩容(详解在下面)。
      • 2. 删除方法 remove :可以根据数据或下标,从数组属性中删除Object 数据,删除后,数组后续元素需前移。
      • 3. 查询方法 get :方法传入下标,返回数组中指定下标的数据。当前存储数据量 size:获取当前存储的有效数据长度
      • 动态扩容详解:无需真正增加原数组的容量,只用将原内容复制到新的大数组,然后让原数组名称重新等于大数组即可。由于原数组数据在堆中,失去引用会被 GC 自动回收。
    package demo9;
    import java.util.Objects;
    
    //Person类
    public class MyListPerson {
        String name;
    
        public MyListPerson(String name) { this.name = name;}
    
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            MyListPerson that = (MyListPerson) o;
            return Objects.equals(name, that.name);
        }
    
        @Override
        public int hashCode() {
            return Objects.hash(name);
        }
    
        @Override
        public String toString() {
            return "MyListPerson{" +
                    "name='" + name + '\'' +
                    '}';
        }
    
    
    public class MyList {
        private Object[] element=new Object[2];
        private int size=0;//数组有效数据长度
    
        static {
            System.out.println("原始数组长度为2");
        }
    
        public void add(Object o){
            if (size==element.length){ //数组内容存满,进行扩容
                System.out.println("数组已存入"+size+"个元素,"
                                  +"数组内容存满了,进行翻倍扩容可存储"+size*2+"个元素");
                Object[] element1 = new Object[size*2]; //新数组
                System.arraycopy(element,0,element1,0,size);//数组复制
                element=element1;//element指向扩容后的数组
                add(o);
            }else{
                element[size++]=o;
                System.out.println("元素添加完成");
            }
        }
    
        public void remove(Object o){
            int i;
            for (i = 0; i < size; i++) {
                if (element[i].equals(o)){ //找到要删除的元素
                    for (int j=i+1;j<size;j++){//后续元素前移
                        element[j-1]=element[j];
                    }
                    size--;
                    System.out.println("元素已被删除");
                    break;
                }
            }
            if (i==size){
                System.out.println("数组中不存在该元素");
            }
        }
    
        public void get(int index){
            System.out.println("获取数组下标为"+index+"的元素是"+ element[index]);
        }
    
        public void showAll(){
            System.out.print("当前数组:");
            for (int i = 0; i < size; i++) {
                System.out.print(element[i]+",");
            }
            System.out.println();
        }
    }
    
    
    package demo9;
    public class MyListMain {
        public static void main(String[] args) {
            MyList myList = new MyList();
    
            MyListPerson p1 = new MyListPerson("张三");
            MyListPerson p2 = new MyListPerson("李四");
            MyListPerson p3 = new MyListPerson("王五");
    
            myList.add(p1);
            myList.add(p2);
            myList.add(p3);
            myList.showAll();
    
            myList.get(2);
    
            myList.remove(p2);
            myList.showAll();
        }
    }

    展开全文
  • Java中实现数组动态扩容的两种方法java中初始化一个数组需要定义数组的容量,而在我们使用数组时往往会遇到数组容量不够的情况,此时我们就需要通过动态扩容的方式来来根据需求扩大数组的容量。我们可以通过两种方法...
  • 关于一维数组扩容: 在java开发中,数组长度一旦确定,不可改变。 那么数组满了怎么办?数组满了,需要扩容。 java中对数组扩容是: 先建立一个大容量数组,然后将小容量数组中的数据一个一个拷贝到大数组当中...
  • 我就废话不多说了,大家还是直接看代码吧~public static T[] dilatationArray(T[] datas,int newlen) {/...//生成一个新数组,并copy原值到新数组return Arrays.copyOf(datas, newlen);}package testpro;import java...
  • JAVA 数组动态扩容的方法

    万次阅读 2018-03-02 23:09:49
    有两种方法可以实现数组容量扩容:public class Demo1 { static int []array=new int [20]; public static void main(String[] args){ array=addLengthArray(array); for(int i = 0;i&...
  • 学习笔记:java数组扩容方法

    千次阅读 2021-12-15 14:50:52
    1.新旧替换,使用一个新的容量更大的数组来接收旧的数组中的数据 1.1 遍历数组进行值的交换 //旧数组 int[] a = {1,2,3,4,5}; //新数组 int[] b = new int[a.length*2]; //将旧数组的值遍历传给...
  • 数组扩容与缩减

    2021-07-26 22:26:44
    = = = = 数组扩容与缩减= = = = 一、扩容基本思想 1、定义一个新数组,其类型与原来数组一致 2、新数组容量比原数组 大1; 3、把原数组的值遍历赋值给新数组 4、把要添加的数赋值在新数组的最后一个位置 5、把新...
  • 之前我们讲了JAVA语言数组的概念和简单应用,但是我们痛死也发现一...接下来就向大家介绍下JAVA语言的数组扩容吧。其实,我们在学习数组的时候,就学到数组和数组之间是可以互相赋值的,那我们利用这个原理就可以来...
  • 数组扩容(俩种方法)

    千次阅读 2021-07-03 10:03:58
    数组扩容—扩大/小数组容器的容量(长度)—数组复制实现----数组定义完成之后长度无法改变。 数组的复制(原数组,拷贝的起始下标,目标数组,粘贴的起始下标,复制的元素个数) System.arraycopy(arr1,0,arr2,0,arr1....
  • 1. resize()方法主要用于对数组进行初始化 或 扩容。 2. 初始化:HashMap底层数组初始化采用延时机制,被推迟到put()方法中,但主要还调用resize()方法来完成。HashMap底层数组初始化两种情况,创建HashMap对象时:...
  • 1)Java数组对象的大小是固定不变的,数组对象是不可扩容的。利用数组复制方法可以变通的实现数组扩容。System.arraycopy()可以复制数组。Arrays.copyOf()可以简便的创建数组副本。创建数组副本的同时将数组长度增加...
  • Java 数组扩容

    2021-05-29 15:32:24
    // 数组扩容数组一旦被创建不可被改变 // 若要扩容则需要新建数组 Scanner scanner = new Scanner(System.in); System.out.println("数据扩容:"); System.out.println("请先输入五个数字"); int[] num = ...
  • 数组长度存储数据长度不够时,我们不能直接在原数组进行容量扩容。 因此我们需要进行动态扩容:新建立一个新数组,扩充一个能够存储我们需要的数据的长度,最好超过它。然后将原数组的数据复制给新数组,然后再将...
  • 从今天开始,每周周四写一点算法/数据结构相关的内容...动态数组允许使用者随时扩容数组,因此即使使用者不能确定数组将要容纳的元素个数,只需在动态数组容量不足时及时扩容,就可以正常使用数组。 3. 框架 下面给...
  • C++动态数组扩容

    2021-08-01 16:52:24
    C++数组扩容类 #include<iostream> #include<string> using namespace std; class Myarray { int maxval = 3;//自定义空间上限 //不推荐写法:int *arr = new int[maxval];这会导致,在拷贝构造时, /...
  • 扩容机制其实就是新开辟一个新的空数组,新的数组容量要比原先数组要大,然后通过遍历将原先数组的元素赋给新的数组中,最后再将原先数组的引用指向新的数组,原先数组会因为没有引用就会被垃圾处理机制当成垃圾...
  • 因为数组是在内存中连续的一段存储空间,所以数组一旦被创建,空间就固定...Java数组扩容的原理1)Java数组对象的大小是固定不变的,数组对象是不可扩容的。2)利用数组复制方法可以变通的实现数组扩容。3)System.arra...
  • 数组 数组(Array)是一种线性表的数据结构,是一组连续的存储空间(区别于链表,不连续)用来存储相同类型的数据。 连续的内存空间 数组在内存中的存储方式是一组给定长度的连续的空间。 连续的空间才使得数组可以...
  • //数组扩容 public static void main(String[] args) { int[] arr = new int[8]; for(int i = 0; i <arr.length; i++) { arr[i] = (int) (Math.random() * 20); } //遍历 for(int temp : ...
  • java 数组扩容的方法

    万次阅读 多人点赞 2018-04-29 23:10:41
    java 拓展数组长度的方法前言数组是我们编程常用到的一种最简单的数据结构,操作简单,功能强大。但是也是一个缺点,就是一旦创建了数组,就不能改变它的大小。如果申请一个超大的内存空间,又容易造成空间浪费,那...
  • 实现数组扩容的方式 for循环 System.arraycopy Arrays.copyOf 方法一 for循环 /** * 方法一:使用for循环 */ public static int[] enlarge1(){ int[] a = {1,2,3,4,5}; int[] b = new int[10]; // 将数组 a 的元素赋...
  • java中的两种数组扩容方式 1.System类中的arrayCopy方法 2.Arrays类中的copyOf方法 来看看第一种方法 int[] n = new int[]{2,5,8}; int[] y = new int[n.length+1]; System.arraycopy(n,0,y,0,n.length); System.out...
  • 静态空间管理: 优化1:动态空间管理思路: 优化2:在原数组上固定大小扩容: 优化3:容量加倍扩容

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 79,247
精华内容 31,698
关键字:

数组容量扩容