精华内容
下载资源
问答
  • Java动态数组大小?
    千次阅读
    2021-02-26 13:58:13

    在java数组中,长度是固定的。

    可以使用列表保存值并调用toArray方法如果需要,请参见以下示例:import java.util.List;import java.util.ArrayList;import java.util.Random;public class A  {

    public static void main( String [] args ) {

    // dynamically hold the instances

    List list = new ArrayList();

    // fill it with a random number between 0 and 100

    int elements = new Random().nextInt(100);

    for( int i = 0 ; i 

    list.add( new xClass() );

    }

    // convert it to array

    xClass [] array = list.toArray( new xClass[ list.size() ] );

    System.out.println( "size of array = " + array.length );

    }}class xClass {}

    更多相关内容
  • 主要介绍了Java动态数组添加数据的方法,结合实例形式详细分析了Java动态数组的创建、添加、查找、打印等相关操作技巧,需要的朋友可以参考下
  • Java动态数组

    万次阅读 多人点赞 2018-07-18 10:38:44
    1.Java动态数组的用法详解  Java动态数组是一种可以任意伸缩数组长度的对象,在Java中比较常用的是ArrayList,ArrayList是javaAPI中自带的java.util.ArrayList。下面介绍一下ArrayList作为Java动态数组的用法。 ...

    1.Java动态数组的用法详解

         Java动态数组是一种可以任意伸缩数组长度的对象,在Java中比较常用的是ArrayList,ArrayList是javaAPI中自带的java.util.ArrayList。下面介绍一下ArrayList作为Java动态数组的用法。

     语法:add()是添加一个新的元素,remove()删除一个元素,size()获得ArrayList的长度。ArrayList的下标是从0开始。

    import java.util.ArrayList;
     
    public class JavaArrayList {
    	public static void main(String[] args) {
    		// Java动态数组的初始化
    		ArrayList al = new ArrayList();
    		// 向Java动态数组中添加数据
    		al.add("a");
    		al.add("b");
    		al.add("c");
    		// 输出Java动态数组
    		for (int i = 0; i < al.size(); i++) {
    			String alEach = (String) al.get(i);
    			System.out.println(alEach);
    		}
    		// 删除数组中的某个元素,删除第二个元素
    		al.remove(1);
    		// 修改Java动态数组,把新的元素放到第二个位置
    		al.add(1, "2");
    		// //输出Java动态数组
    		for (int i = 0; i < al.size(); i++) {
    			String alEach = (String) al.get(i);
    			System.out.println(alEach);
    		}
    	}
    }
    

    2.动态数组实现(ArrayList原理)

    2.1 什么是数组

            同类数据元素的集合,在计算机中以连续的地址存储,编译时确定长度,无法改变。

    2.2 什么是动态数组

           数据结构中顺序表的物理实现,同类数据元素的集合,在计算机中以连续的地址存储,大小在创建时决定,但是可以改变。

    2.3 为什么使用动态数组

           支持随机访问,查询速度快。但是插入和删除都需要移动元素,比起链表开销较大。如:java集合类中的ArrayList Vector等

    2.4 动态数组实现代码(ArrayList原理)

    /**
     * 顺序表的实现
     * @author chengh
     * @param 
     */
    public class ArrayList<E> {
        private Object[] data = null; // data: 用来保存此线性表数据的数组
        private int capacity; // capacity: 线性表的容量
        private int current; // current: 当前数据的下标
        /**
         * 初始化为声明大小,则设置为10。
         */
        ArrayList() {
            this(10);
        }
        /**
         * 初始化线性表,声明保存数据的数组大小。
         * @param initialSize 顺序表的初始化大小
         */
        ArrayList(int initialSize) {
            if (initialSize >= 0) {
                this.capacity = initialSize;
                data = new Object[initialSize];
                current = 0;
            } else {
                throw new RuntimeException("初始化大小不能小于0:" + initialSize);
            }
        }
        /**
         * 在线性表的末尾添加元素,添加之前确认线性表是否已满
         * @param e 待加入的元素
         * @return
         */
        public boolean AddElement(E e) {
            ensureCapacity();
            data[current] = e;
            ++current;
            return true;
        }
        /**
         * 检查存储数据的数组容量,如果数组已经满,则扩充容量;否则不操作。
         */
        private void ensureCapacity() {
            int index;
            if (current == capacity) {
                capacity *= 2;
                Object[] newData = new Object[capacity];
                for(index = 0; index < current; ++index) {
                    newData[index] = data[index];
                }
                data = newData;
            }
        }
        /**
         * 返回下标为index的元素
         * @param index 欲取得元素的下标
         * @return
         */
        public E get(int index) {
            validateIndex(index);
            return (E) data[index];
        }
        /**
         * 
         * @param index 待插入的位置
         * @param e 待插入的元素
         * @return
         */
        public boolean set(int index, E e) {
            validateIndex(index);
            data[index] = e;
            return true;
        }
        /**
         * 验证下标值是否合法,非法时抛出异常
         * @param index 待验证的下标值
         */
        private void validateIndex(int index) {
            if (index < 0 || index > current) {
                throw new RuntimeException("无效的下标:" + index);
            }
        }
        /**
         * 返回当前顺序表的大小
         * @return
         */
        public int size() {
            return current;
        }
        /**
         * 在指定位置插入指定元素
         * @param index 待插入的位置
         * @param e 待插入的元素
         * @return
         */
        public boolean insert(int index, E e) {
            validateIndex(index);
            ensureCapacity();
            for (int temp = current; temp > index; --temp) {
                data[temp] = data[temp - 1];
            }
            data[index] = e;
            return true;
        }
        /**
         * 删除下标为index元素
         * @param index 待删除元素的下标
         * @return
         */
        public boolean delete(int index) {
            validateIndex(index);
            for ( ; index < current - 1; ++index) {
                data[index] = data[index + 1];
            }
            data[current - 1] = null;
            --current;
            return true;
        }
        @Override
        public String toString() {
            String str = "[ ";
            for (Object o : data) {
                if (o != null) {
                    str += o + " ";
                }
            }
            str += "]";
            return str;
        }
    } 

     

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

    千次阅读 2019-06-16 16:21:55
    前言: 基于java提供的静态数组,自定义实现的动态数组 ... * @Description 基于java数组进行二次封装 * @Author lilei * @Date 16/06/2019 11:09 * @Version 1.0 **/ public class Array<E> { private E...

    前言:
    基于Java提供的静态数组,自定义实现的动态数组
    代码如下:

    /**
     * @ClassName Array
     * @Description  基于java数组进行二次封装
     * @Author lilei
     * @Date 16/06/2019 11:09
     * @Version 1.0
     **/
    
    public class Array<E> {
    
        private E[] data;
        private int size;
    
        public Array(int capacity){
            data = (E[]) new Object[capacity];
            size = 0;
        }
    
        public Array(){
            this(10);
        }
    
        public int getCapacity() {
            return data.length;
        }
    
    
        public int getSize() {
            return size;
        }
    
        // 判断是否为空
        public boolean isEmpty(){
            return size == 0;
        }
    
        // 增加一个元素
        public void addLast(E e){
            if (size == data.length)
                resize(2 * data.length);
            data[size++] = e;
        }
    
        //指定索引增加元素
        public void add(int index, E e){
            if (index < 0 || index > size){
                throw new IllegalArgumentException("Add failed. Require index >= 0 and index < size.");
            }
    
            if (size == data.length){
                resize(2 * data.length);
            }
    
            if (size == data.length/2)
                resize(data.length/2);
    
            for (int i = size -1; i >= index ; i--) {
                data[i + 1] = data[i];
            }
            data[index] = e;
            size++;
        }
    
        private void resize(int newCapacity) {
            E[] newData = (E[])new Object[newCapacity];
            for (int i = 0; i < size; i++) {
                newData[i] = data[i];
            }
            data = newData;
        }
    
        // 在数组开头增加元素
        public void addFirst(E e){
            add(0, e);
        }
    
        // 获得指定索引元素
        public E get(int index){
            if (index < 0 || index >= size)
                throw new IllegalArgumentException("Get failed. Index is illegal");
            return data[index];
        }
    
        // 查找数组中是否有元素e
        public boolean contains(E e){
            for (int i = 0; i < size; i++) {
                if (data[i].equals(e))
                    return true;
            }
            return false;
        }
    
        // 查找元素e所在索引
        public int find(E e){
            for (int i = 0; i < size; i++) {
                if (data[i].equals(e))
                    return i;
            }
            return -1;
        }
    
        // 从数组中删除index位置的元素, 返回删除的元素
        public E remove(int index){
            if (index < 0 || index >= size)
                throw new IllegalArgumentException("Set failed. Index is illegal");
            E ret = data[index];
            for (int i = index +1 ; i < size ; i++)
                data[i-1] = data[i];
            size--;
            data[size] = null; // loitering objects != memory leak
            return ret;
        }
    
        // 从数组中删除第一个元素, 返回删除的元素
        public E removeFirst(){
            return remove(0);
        }
    
        // 从数组中删除最后一个元素
        public E removeLast(){
            return remove(size-1);
        }
    
        // 删除指定元素
        public void removeElement(E e){
            int index = find(e);
            if (index != -1)
                remove(index);
        }
    
        // 修改指定索引元素
        public void set(int index, E e){
            if (index < 0 || index >= size)
                throw new IllegalArgumentException("Set failed. Index is illegal");
            data[index] = e;
        }
    
        @Override
        public String toString(){
            StringBuilder res = new StringBuilder();
            res.append(String.format("Array: size = %d, capacity = %d\n", size, data.length));
            res.append('[');
            for (int i = 0; i < size; i++) {
                res.append(data[i]);
                if (i != size -1)
                    res.append(", ");
            }
            res.append(']');
            return res.toString();
        }
    
    }
    
    
    展开全文
  • 使用Java动态数组的实现

    万次阅读 2018-05-13 14:23:08
    使用Java中的数组int[] arr=new int[10]; for(int i=0;i&lt;arr.length;i++) arr[i]=i; int[] scores =new int[]{100,99,66}; for (int i=0;i&lt;scores.length;i++) System.out.println(scores[i]); for...

    使用Java中的数组

    int[] arr=new int[10];
    for(int i=0;i<arr.length;i++)
        arr[i]=i;
    int[] scores =new int[]{100,99,66};
    for (int i=0;i<scores.length;i++)
        System.out.println(scores[i]);
    for(int score:scores)
        System.out.println(score);
    scores[0]=98;
    for(int score:scores)
        System.out.println(score);


    自己实现的动态数据

    public class Array<E> {
        private E[] data;
        private int size;
    
        /**
         *构造函数,传入数组的容量capacity构造Array
         */
        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;
        }
    
        // 向所有元素后添加一个新元素,O(1)
        public void addLast(E e){
    //        if(size==data.length)
    //            throw new IllegalArgumentException("AddLast failed!");
    //        data[size]=e;
    //        size++;
         add(size,e);
        }
    
        // 在所有元素前添加一个新元素,O(1)
        public void addFirst(E e){
            add(0, e);
        }
    
        //在第index个位置插入一个新元素e,O(n/2)=O(n)
        public void add(int index,E e) {
            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索引位置的元素,O(1)
        public E get(int index){
            if(index<0 || index>=size)
                throw new IllegalArgumentException("Get failed.Index is illegal.");
            return data[index];
        }
    
        //修改index索引位置的元素为e,O(1)
        void set(int index,E e){
            if(index<0 || index>=size)
                throw new IllegalArgumentException("Set failed.Index is illegal.");
            data[index]=e;
        }
    
        //查找数组中是否有元素e,O(n)
        public boolean contains(E e){
            for (int i =0 ; i<size;i++){
                if(data[i].equals(e))
                    return true;
            }
            return false;
        }
    
        // 查找数组中元素e所在的索引,如果不存在元素e,则返回-1,O(n)
        public int find(E e){
            for (int i =0 ; i<size;i++){
                if(data[i].equals(e))
                    return i;
            }
            return -1;
        }
    
        // 从数组中删除index位置的元素, 返回删除的元素,O(n)
        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--;
            data[size]=null;//loitering objects != memory leak
    
            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);
        }
    
        @Override
        public String toString(){
            StringBuilder res=new StringBuilder();
            res.append(String.format("Array: size = %d , capacity = %d\n", size, data.length));
            res.append('[');
            for(int i =0;i<size;i++){
                res.append(data[i]);
                if(i!=size-1)
                    res.append(",");
            }
            res.append(']');
            return res.toString();
        }
    
        // 将数组空间的容量变成newCapacity大小
        private void resize(int newCapacity){
            E[] newData=(E[])new Object[newCapacity];
            for(int i=0;i<size;i++)
                newData[i]=data[i];
            data=newData;
        }
    
    }
    

    验证自己实现的动态数组

    public class Main {
        public static void main(String[] args) {
    
    //        int[] arr=new int[10];
    //        for(int i=0;i<arr.length;i++)
    //            arr[i]=i;
    //        int[] scores =new int[]{100,99,66};
    //        for (int i=0;i<scores.length;i++)
    //            System.out.println(scores[i]);
    //        for(int score:scores)
    //            System.out.println(score);
    //        scores[0]=98;
    //        for(int score:scores)
    //            System.out.println(score);
    
    
               Array<Integer> arr=new Array<>();
               for (int i=0;i<10;i++)
                   arr.addLast(i);
               System.out.println(arr);
    
               arr.add(1,100);
               System.out.println(arr);
    
               arr.addFirst(-1);
               System.out.println(arr);
    
               arr.remove(2);
               System.out.println(arr);
    
               arr.removeElement(4);
            System.out.println(arr);
    
            arr.removeFirst();
            System.out.println(arr);
    
        }
    }

    自己定义一个Student类,来验证刚才实现的动态数组

    public class Student {
    
        private String name;
        private int score;
    
        public Student(String studentname,int studentScore){
            name =studentname;
            score=studentScore;
        }
    
        @Override
        public String toString(){
            return String.format("Student(name: %s,score: %d)",name,score);
        }
    
        public static void main(String[] args) {
            Array<Student> arr=new Array<>();
            arr.addLast(new Student("Alice",100));
            arr.addLast(new Student("Bob",66));
            arr.addLast(new Student("David",88));
            System.out.println(arr);
        }
    }
    

    展开全文
  • Java实现动态数组

    千次阅读 2021-03-05 14:41:44
    动态数组Java实现思路:底层用一个固定长度的数组element来保存数据,每插入一个元素之前先判断一下size+1是否大于底层数组element的长度,如果大于,那么将生成一个大于原来数组长度两倍的数组,然后将原有数据...
  • java有静态数组动态数组 静态初始化 int[] a = {1,2,3}; 动态初始化 int[] a = new int[10] a[0]=1; a[1]=2; 区别: 1,数组创建时间不同,静态的是一定义出来就创建了,动态的则是定义时不创建,使用时才创建,...
  • 关于java动态数组你都了解多少呢?那么具体的来说java当中应该怎样使用动态数组呢?下面来看一下代码详例吧。首先我们要搞清楚,java动态数组是一种能够任意伸缩数组长度的对象,在java当中,我们经常使用的就是...
  • 动态数组java实现

    千次阅读 2021-02-12 10:06:58
    动态数组相对于一般数组的优势是可以灵活地添加或删除元素。而一般数组则受限于固定的内存空间。只能有限的添加元素动态数组(Dynamic Array)接口设计◼ int size(); // 元素的数量◼ boolean isEmpty(); // 是否为空...
  • Java静态数组动态数组的定义方式

    千次阅读 2020-04-21 18:38:57
    数组的定义方式 ...//数组的定义和初始化同时完成,使用动态初始化语法 int[] prices = new int[5]; 补充: //初始化数组时元素的类型是定义数组时元素类型的子类 Object[] books = new String[4]; ...
  • Java自定义动态数组

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

    千次阅读 2021-03-14 10:42:22
    java动态创建数组JAVA中,有时候需要根据条件来生成批处理sqls语句等,需要动态生成数组。方法:List list=new ArrayList();if(true){list.add("insert.....");list.add("update....");}else{list.add("insert.......
  • 展开全部java中的数组一旦被定义长e5a48de588b662616964757a686964616f31333337393533度是不允许修改长度的,如果题主希望实现类似的功能可以采用ArrayList。ArrayList的底层结构就是数组。当ArrayList实例化时会...
  • 主要介绍了Java封装数组动态数组实现方法,结合实例形式详细分析了java动态数组的实现原理、操作步骤与相关注意事项,需要的朋友可以参考下
  • Java动态数组的用法详解

    万次阅读 2014-04-27 21:34:03
    Java动态数组是一种可以任意伸缩数组长度的对象,在Java中比较常用的是ArrayList,ArrayList是javaAPI中自带的java.util.ArrayList。下面介绍一下ArrayList作为Java动态数组的用法。  1.语法:add()是添加一个新...
  • java怎样实现动态数组

    千次阅读 2020-11-08 13:20:21
    在学习Tomcat源码时看到很多地方都用到了动态数组的设计,而不是直接使用集合。这种方法很值得我们学习借鉴,所以在此单独拿出来学习讨论。 比如其中向容器Server增加service的方法如下(其中与本文讨论无关的代码已...
  • JAVA动态申请数组

    千次阅读 2019-10-30 19:58:20
    JAVA动态申请数组 1.java中就只能用new来申请内存。相对C++有个好处是省了delete操作。 2.java中区分可变类与不可变类,这两种申请动态内存的方式不同。 3.java中静态数组定义时与申请动态内存一致。 不可变类(int,...
  • Java实现自定义动态数组

    千次阅读 2020-09-04 22:41:44
    Java实现自定义动态数组 数组基础回顾 1、数组是一种常见的数据结构,用来存储同一类型值的集合 2、数组就是存储数据长度固定的容器,保证多个数据的数据类型要一致 3、数组是一种顺序存储的线性表,所有元素的内存...
  • 使用Java中ArrayList创建动态数组 代码及解释如下: //用户向数组内输入并且最后将输入的数组遍历出来 使用动态数组ArrayList public static void shuru(){ //单独写了个方法存放动态数组,这里不用管 //创建...
  • Java动态数组初始化

    千次阅读 2019-03-19 18:19:07
    先展示思维导图: 这是一个二数组的遍历图。... * 动态数组初始化 * */ public class Arrary { public static void main(String[] args) { // 二维动态数组并遍历 int[][] arr = new int[3][3]; arr[...
  • Java动态二维数组 怎么动态定义

    千次阅读 2021-02-12 14:22:56
    展开全部有两种实现方法:可以用e68a843231313335323631343130323136353331333337623534List数组来实现可以用map来实现方法一:用map来实现比如要创建一个1行、3列的数组,实现方法如下:public static void main...
  • java 中 String 数组怎么动态赋值

    千次阅读 2021-02-12 15:18:17
    展开全部首先明确一下数组的初始62616964757a686964616fe4b893e5b19e31333337626264化://静态初始化inta[]={1,2,3};//动态初始化inta[];a=newint[3];...JAVA是强类型,数组类型一旦声明,就不能更改...
  • java动态数组的应用

    2009-08-27 15:35:20
    java动态数组java动态数组java动态数组java动态数组java动态数组java动态数组java动态数组java动态数组java动态数组java动态数组
  • 输入客户的姓名,客户的人数不定。待输入完成后,请打印出客户的名单,并定义一个方法查询客户是否...import java.util.Arrays; import java.util.Scanner; public class CustomBiz { public String[] custom; pu
  • JAVA数组实现动态数组——顺序表

    千次阅读 2018-07-07 18:14:55
    JAVA中,有一个封装好的API——ArrayList,就是一个动态数组,在C++中有一个vector也是动态数组。我们可以直接拿过来使用。但是有时我们可能需要自己定制一个动态数组,以便更好地解决我们的问题。今天,我们...
  • 如何使用Java构建一个动态数组

    千次阅读 2019-09-04 22:37:08
    这里就需要使用一个可以动态改变数组容量的动态数组来存放数组。而在建立动态数组类前,我们首先要创建一个数组类。 这里我们假设要创建一个int类型的数组类。在开头先定义好我们这个类中有一个数组data[],以及数组...
  • java实现动态数组,数组与字符串

    千次阅读 2019-07-12 20:52:01
    Java学习笔记(3) 1.String类 String-用于表述字符串,代码中被双引号引用的就叫字符串 注意: 1.值是存储在被final修饰的char数组中 2.String被final修饰 String的使用: 1.构造方法String str=new String(“字符...
  • Java——ArrayList(动态数组)介绍

    千次阅读 2021-10-31 10:45:43
    本章节对ArrayList进行个简要的介绍,前面也写过一篇博客记录自己模拟实现ArrayList的情况。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,799,498
精华内容 719,799
关键字:

java动态数组

java 订阅
友情链接: qbln619.rar