精华内容
下载资源
问答
  • 如何使用Java构建一个动态数组

    千次阅读 2019-09-04 22:37:08
    数组基础 数组作为数据结构最大的优点...而在建立动态数组类前,我们首先要创建一个数组类。 这里我们假设要创建一个int类型的数组类。在开头先定义好我们这个类中有一个数组data[],以及数组中实际存放的元素数量...

    数组基础

    数组作为数据结构最大的优点在于可以快速查询,arr[2]。但由于数组的大小在开始创建时就被定义,因此如果存储的内容超出了数组容量,就无法在原先的数组中保存数据。这里就需要使用一个可以动态改变数组容量的动态数组来存放数组。而在建立动态数组类前,我们首先要创建一个数组类。

    这里我们假设要创建一个int类型的数组类。在开头先定义好我们这个类中有一个数组data[],以及数组中实际存放的元素数量size。初始化数组类时需要输入数组的容量capacity的值,如果没有输入则默认为10。

    public class Array {
        private int[] data;
        private int size;
    
        public Array(int capacity) {
            this.data = new int[capacity];
            size = 0;
        }
    
        public Array() {
            this(10);
        }
    }
    

    然后我们需要给该数组类添加增删改查四个基础功能。

    首先是加的功能,参数index是要添加的位置,即数组的索引,参数element是要添加进去的元素。类似于插入的过程使得整个数组在index往后的索引值都需要往后移一位。

    //添加指定索引index位置的元素data
    public void add(int index, int element) {
        if (size == data.length) {
            throw new IllegalArgumentException("Add failed, Array is full");
        }
        if (index > size || index < 0) {
            throw new IllegalArgumentException("Add failed, index is not under[0 - size]");
        }
        for (int i = size; i > index; i--) {
            data[i] = data[i - 1];
        }
        data[index] = element;
        size++;
    }
    

    我们可以通过上述的方法封装好在数组首部和尾部添加元素的方法。

    public void addFirst(int element) {
        add(0, element);
    }
    
    public void addLast(int element) {
        add(size, element);
    }
    

    删除的方法与增加的方法类似,只不过是后续的元素要往前移一位。

    //删除index位置的元素并返回该元素的值
        public int delete(int index) {
            if (index >= size || index < 0) {
                throw new IllegalArgumentException("delete failed, index is illegal");
            }
            int ret = data[index];
            for (int i = index; i < size; i++) {
                data[i] = data[i + 1];
            }
            size--;
            return ret;
        }
    
        public int deleteFirst() {
            return delete(0);
        }
    
        public int deleteLast() {
            return delete(size - 1);
        }
    

    查找和改变的方式比较简单。

    //寻找数组是否包含元素e,如果包含返回索引值,否则返回-1
    public int findx(int e) {
        for (int i = 0; i < size; i++) {
            if (data[i] == e) {
                return i;
            }
        }
        return -1;
    }
    
    //将索引上的值改变为e
    public void set(int index, int e) {
        if (index >= size || index < 0) {
            throw new IllegalArgumentException("set failed, index is illegal");
        }
        data[index] = e;
    }
    

    该数组类应该要有个输出,重写Object的toString方法

    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        res.append("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();
    }
    

    泛型

    由于数组不可能永远都是int类型,因此写一个泛型的数组类是必要的,我们可以通过它来创建各个类型的数组。

    但是需要注意的是,使用泛型创造的数据结构不可以放置基本数据类型(int, char, boolean, double…),只能放置它们的包装类(Int, Char, Boolean, Double…)。

    下面的代码是使用泛型创造的数组类:
    需要注意,泛型定义数组时不可以直接new一个泛型数组,而是要new Object[]后再整形成泛型

    public class Array<E> {
        private E[] data;
        private int size;
    
        public Array(int capacity) {
            this.data = (E[]) new Object[capacity];
            size = 0;
        }
    
        public Array() {
            this(10);
        }
    
        //添加指定索引index位置的元素data
        public void add(int index, E element) {
            if (size == data.length) {
                throw new IllegalArgumentException("Add failed, Array is full");
            }
            if (index > size || index < 0) {
                throw new IllegalArgumentException("Add failed, index is not under[0 - size]");
            }
            for (int i = size; i > index; i--) {
                data[i] = data[i - 1];
            }
            data[index] = element;
            size++;
        }
    
        public void addFirst(E element) {
            add(0, element);
        }
    
        public void addLast(E element) {
            add(size, element);
        }
    
        //删除index位置的元素并返回该元素的值
        public E delete(int index) {
            if (index >= size || index < 0) {
                throw new IllegalArgumentException("delete failed, index is illegal");
            }
            E ret = data[index];
            for (int i = index; i < size; i++) {
                data[i] = data[i + 1];
            }
            size--;
            return ret;
        }
    
        public E deleteFirst() {
            return delete(0);
        }
    
        public E deleteLast() {
            return delete(size - 1);
        }
    
        //寻找数组是否包含元素e,如果包含返回索引值,否则返回-1
        public int findx(E e) {
            for (int i = 0; i < size; i++) {
                if (data[i] == e) {
                    return i;
                }
            }
            return -1;
        }
    
        //将索引上的值改变为e
        public void set(int index, E e) {
            if (index >= size || index < 0) {
                throw new IllegalArgumentException("set failed, index is illegal");
            }
            data[index] = e;
        }
    
        @Override
        public String toString() {
            StringBuilder res = new StringBuilder();
            res.append("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();
        }
    }
    

    动态数组

    动态数组要实现的功能是在数组突破容量时扩大数组的容量,当数组实际存储的元素数远小于容量时缩小数组的容量。方法可以是:当数组到极限时,创建一个两倍于原数组容量的新数组,将原数组的内容复制到新数组中,并返回新数组;当数组的size小于等于1/4容量时,创建一个1/2容量的新数组,赋值进去并返回新数组。具体的代码操作只需要改变add和delete两个函数方法。

    public void add(int index, E element) {
        if (size == data.length) {
            renew(data.length * 2);
        }
        if (index > size || index < 0) {
            throw new IllegalArgumentException("Add failed, index is not under[0 - size]");
        }
        for (int i = size; i > index; i--) {
            data[i] = data[i - 1];
        }
        data[index] = element;
        size++;
    }
    public E delete(int index) {
        if (index >= size || index < 0) {
            throw new IllegalArgumentException("delete failed, index is illegal");
        }
        E ret = data[index];
        for (int i = index; i < size; i++) {
            data[i] = data[i + 1];
        }
        size--;
        if (size == data.length / 4 && data.length / 2 != 0) {
            renew(data.length/2);
        }
        return ret;
    }
    private void renew(int capacity) {
        E[] dataNew = (E[]) new Object[capacity];
        for (int i = 0; i < size; i++) {
            dataNew[i] = data[i];
        }
        data = dataNew;
    }
    

    代码测试

    增加元素观察是否能扩展数组容量,减少很多元素观察是否能缩小容量

    public class Main {
        public static void main(String[] args) {
            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.delete(2);
            System.out.println(arr);
    
            arr.delete(4);
            System.out.println(arr);
    
            arr.deleteFirst();
            System.out.println(arr);
    
            arr.deleteFirst();arr.deleteFirst();arr.deleteFirst();arr.deleteFirst();arr.deleteFirst();
            System.out.println(arr);
        }
    }
    
    展开全文
  • Java数组数组的声明与创建数组声明方式创建数组使用new来创建数组变量数组的长度数组的初始化静态初始化动态初始化默认的初始化内存分析 数组的声明与创建 数组声明方式 dataType[] arrayRefaVar;//首选 dataType ...

    数组的声明与创建

    数组声明方式

    dataType[] arrayRefaVar;//首选
    
    dataType arrayRefaVar[];
    

    创建数组

    使用new来创建数组变量

    dataType[] arrayRefaVar = new dataType[arraySize];
    

    数组的长度

    使用数组的length属性,每个数组都有一个length属性。
    如:获取数组名为array的长度

    int length = array.length
    

    数组的初始化

    静态初始化

    不指定数组长度,在声明的时候赋初值由系统自动声明长度

    int[] array=1,2,3,4,5;
    
    ObejcetType[] objects={new ObjectType(2),new ObjectType(2)};
    

    动态初始化

    int[] a = new int[2];
    a[0]=1;
    a[1]=2;
    

    默认的初始化

    数组是引用类型,他的元素类型相当于类的实例变量,数组一经分配空间,其中的每个元素也被按照实例变量同样的方式被隐式初始化

    展开全文
  • Java初学—数组初始化

    2020-06-07 14:59:33
    数组的概念:是种容器,可以同时存放多数据值 数组的特点: 1.数组种引用数据类型 2.数组当中的多数据,类型必须统一 3.数组长度在程序运行期间不可改变 代码练习: public class Demo01Array { public ...

    数组的概念:是一种容器,可以同时存放多个数据值

    数组的特点:

    1.数组是一种引用数据类型

    2.数组当中的多个数据,类型必须统一

    3.数组的长度在程序运行期间不可改变

    代码练习:

    public class Demo01Array {
        public static void main(String[] args){
            int score1 = 100;
            int score2 = 98 ;
            int score3 = 99 ;
            System.out.println(score3);//99
            score3 = 100;
            System.out.println(score3);//100
    
        }
    }
    

    数组的初始化:在内存当中创建一个数组,并且向其中赋予一些默认值

    两种常见的初始化:

    1.动态初始化(指定长度):在创建数组的时候,直接指定数组当中的数据元素个数

    2.静态初始化(指定内容):在创建数组的时候,不直接指定数据个数多少,而是直接将具体的数据内容进行指定。

    注意事项:

    1.虽然静态初始化没有直接告诉长度,但是根据大括号里面的元素的具体内容,也可以自动推算出长度。

    2.静态初始化标准格式可以拆分为两个步骤。

    3.动态初始化也可拆分成两个步骤

    4.静态初始化一旦使用省略格式,就不能拆分为两个步骤。

    使用建议:

    如果不确定数组当中的内容,使用动态初始化,否则,已经确定了具体内容,用静态初始化。

    动态初始化数组的格式
    
    数据类型[] 数组名称 = new 数据类型[数据长度];
    
    静态初始化的格式:
    数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,...};
    
    省略格式:
    数据类型[] 数组名称 = {元素1,元素2,...};
    
    

    解析含义:

    左侧数据类型,也就是数组当中保存的数据,全都是统一的什么类型

    左侧的中括号:代表我是一个数组

    左侧数组名称:给数组取一个名字

    右侧的new :代表创建数组的动作

    右侧数据类型:必须和左侧的数据类型保持一致

    右侧中括号的长度:也就是数组当中,到底可以保存多少个数据,是一个int数字
    代码练习:

    public class Demo01Array {
        public static void main(String[] args){
            //动态初始化
            int[] arrayA = new int[300];
    
            double[] arrayB = new double[10];
    
            String[] arrayC = new String[5];
    
        }
    }
    
    public class Demo02Array {
        public static void main(String[] args) {
            //静态初始化
            int[] arrayA = new int[]{5,15,25};
    
            String[] arrayB = new String[]{"Hello","world","java"};
        }
    }
    
    public class Demo03Array {
        public static void main(String[] args) {
            //省略格式的静态初始化
            int[] arrayA = {10,20,30};
    
            //静态初始化的标准格式,可以拆分为两个步骤
            int[] arrayB;
            arrayB = new int[]{11,21,31};
    
            //动态初始化也可以拆分为两个步骤
            int[] arrayC;
            arrayC = new int[5];
    
            //静态初始化的省略格式,不能拆分为两个步骤
    //        int [] arrayD;
    //        arrayD = {10,20,30};
        }
    }
    
    展开全文
  • Java 中有一个 Random 类,他可以在指定的取值范围内随机产生数字。 Random 类 要想使用 Random 类,第一步需要导入 java.util.Random 这个包。 import java.util.Random; 第二步需要创建 Random 对象。 Random ...

    Java数组之一维数值数组之随机数统计

    在 Java 中有一个 Random 类,他可以在指定的取值范围内随机产生数字。

    Random 类

    要想使用 Random 类,第一步需要导入 java.util.Random 这个包。
    import java.util.Random;
    第二步需要创建 Random 对象。
    Random random = new Random();

    创建完 Random 对象之后,我们就可以使用它提供的方法来创建随机数了。

    方法名方法说明
    nextDouble() 方法返回 0.0 至 1.0 之间的 double 类型值
    nextFloat() 方法返回的是 0.0 至 1.0 之间的 float 类型值
    nextInt(int n)方法返回的是 0(包括)至 n(不包括)之间的 int 值

    代码示例:

    public class RandomTest {
        public static void main(String[] args) {
            Random random = new Random();
                System.out.println(random.nextInt(10));
                System.out.println(random.nextFloat());
                System.out.println(random.nextDouble());
            }
    }
    

    第一次运行结果:

    4
    0.60541
    0.7046691676099207
    

    第二次运行结果:

    3
    0.055246472
    0.47445795351116005
    

    我们可以看到第一次运行结果和第二次运行的结果是不一样的。当我们想要第一次和第二次运行结果一致的话,可以在创建 Random 对象的时候传入一个 Long 类型的数字,这个数字叫随机种子。具有相同随机种子的 Random 对象生成的随机数是一样的。

    示例:

    public static void main(String[] args) {
            // 创建一个Random对象并传入随机种子
            Random random = new Random(10);
            System.out.println(random.nextInt(10));
            System.out.println(random.nextFloat());
            System.out.println(random.nextDouble());
    }
    

    第一次运行结果:

    3
    0.44563425
    0.2578027905957804
    

    第二次运行结果:

    3
    0.44563425
    0.2578027905957804
    

    例题:统计数组中每个随机数出现的次数

    具体要求如下:

    1.接收给定的数据(如:4 88,其中第一个数代表数组长度,第二个数代表随机数种子);
    2.创建数组并添加随机数(随机数介于 0-19 之间);
    3.输出随机数出现的次数(出现次数大于 0 才输出);
    4. 按随机数大小排序输出。

    注意:数字分隔符为空格。
    

    例:
    测试输入:

    20 9
    

    预期输出:

    4出现了:1 次
    6出现了:3 次
    8出现了:2 次
    9出现了:1 次
    11出现了:1 次
    13出现了:3 次
    15出现了:2 次
    16出现了:2 次
    17出现了:1 次
    18出现了:2 次
    19出现了:2 次
    
    import java.util.Random;
    import java.util.Scanner;
    
    
    public class RandomTest {
        public static void main(String[] args) {
            // 请在Begin-End间编写代码
            /********** Begin **********/
            // 接收给定数据
            Scanner input = new Scanner(System.in);
            int n = input.nextInt();
            int l = input.nextInt();
            // 创建Random对象,并设置随机种子
            Random random = new Random(l);
            // 定义数组添加数据
           int a[] = new int [n];
           for(int i=0;i<n;i++){
               a[i]=random.nextInt(20);
           }
            // 统计每个数出现的次数
            int b[]= new int [n];
            for(int i=0;i<n;i++){
                b[a[i]]++;
            }
            // 输出结果
            for(int i=0;i<20;i++){
                if(b[i]>0)
                    System.out.printf("%d出现了:%d 次\n",i,b[i]);
            }
            /********** End **********/
    
        }
    }
    
    展开全文
  • 就是做了一个方法 直接调用就好 private static Object[] splitAry(String[] ary, int subSize) { //用数组长度除以每个数据的内容数 能除尽就是商是数组个数,除不尽就是商+1个 int count = ary.length % ...
  • import java.util.InputMismatchException; import java.util.Scanner;... * 从键盘接收数据存放到数组中,并且对数组中的数据进行管理 * @author Administrator * */ public class DataManage { /** *...
  • java数组中删除元素或一个数组元素

    千次阅读 2020-03-13 17:55:47
    java数组中删除元素或一个数组元素删除数组中单个元素删除数组中多个元素(数组表示) 这里直接介绍两种情况: 1、删除数组中单个元素 2、删除数组中多个元素(数组表示) 删除数组中单个元素 1、 新建一个数组, 将...
  • 一个数组是相同数据类型的元素按一定顺序排列的集合。使用数组可以将同一类型的数据存储在连续的内存位置。数组中各元素的类型相同,通过下标的方式来访问数组中的元素,下标从0开始。 由此得...
  • Java基础知识面试题(2020最新版)

    万次阅读 多人点赞 2020-02-19 12:11:27
    文章目录Java概述何为编程什么是Javajdk1.5之后的三大版本JVM、JRE和JDK的关系什么是跨平台性?原理是什么Java语言有哪些特点什么是字节码?采用字节码的最大好处是什么什么是Java程序的主类?应用程序和小程序的...
  • 为了在程序中使用一个数组,必须声明一个引用该数组的变量,并指明整个变量可以引用的数组类型。声明一维数组的语法格式为: 数据类型数组名[]; //声明数组 或者 数据类型[]数组名; //声明数组 以上两种格式...
  • 数组创建三种方式 动态创建,声明数组,根据指定长度分配内存,但数组中元素值都为默认初始化值 int[ ] a=new int[10]; 声明数组,并分配内存,同时将其初始化 int[ ] b=new int[ ]{1,2,3,4,5}; int[ ] c={1,2,3} ...
  • 我们可能知道 js有个length函数,java也有啊length函数 ... //建立一个byte类型的数组长度为81 phone[i]!=0中phone[i]! //数组的第i的位置不等0 如: 代码如下 复制代码 byte[] phone =new by...
  • Java面试题大全(2020版)

    万次阅读 多人点赞 2019-11-26 11:59:06
    发现网上很多Java面试题都没有答案,所以花了...Java 基础 1. JDK 和 JRE 有什么区别? JDK:Java Development Kit 的简称,java 开发工具包,提供了 java 的开发环境和运行环境。 JRE:Java Runtime Environ...
  • java数组遍历的三种方式

    万次阅读 2020-11-08 02:36:36
    1.for循环遍历 通常遍历数组都是使用for循环来...java5之后,Java提供了种更简洁的循环:foreach循环,这种循环遍历数组和集合更加简洁。使用foreach循环遍历数组时,无须获得数组和集合长度,无须根据索引来访问数组
  • Java基础知识(字符串与数组

    千次阅读 2020-06-24 20:55:02
    5. 字符串与数组 5.1 字符串创建与存储的机制是什么 ...2.对于String s1=“abc”和String s2=“abc”,在JVM中存在一个字符串池,保存多个String对象,并可以被共享使用,s1和s2引用得是同一个常量池中的对
  • JAVA中的数组插入与删除指定元素

    万次阅读 多人点赞 2017-08-02 19:28:30
    今天学了Java数组,写了数组的插入和删除,本人小白,...给数组指定位置数组的插入 */ import java.util.*; public class ArrayInsert{ public static void main(String []args){ System.out.println(“请用键
  • 定义一个长度为 32 的数组,使用随机数(0~100)来初始化数组,然后按照每行 6 个进行输出。 public static void main(String[] args) { ///定义一个长度为 32 的数组,使用随机数(0~100)来初始化数组,然后按照...
  • java中的数组与动态数组

    千次阅读 2016-02-04 17:55:38
    java中的数组与动态数组 Java代码 int[] x1 = new int[100]; int[] x2; x2 = new int[100]; int[] x3 = new int[] { 1, 2, 3 }; int[][] x4; x4 = new int[2][]; x4...
  • java数组创建及输出

    千次阅读 2020-02-17 20:19:30
    数组: 是一种最简单的符合数据类型,它是有序数据的集合,数组中的每个元素具有相同的数据类型,可以用一个统一的数组名和不同的下标来,唯一确定数组中的元素。 特征: 数组可以是一维数组,二维数组或多维数组 ...
  • Java Script 数组

    2018-06-15 16:56:00
    数组:有许多变量的集合,它们的名称和数据类型都是一致的。 定义 操作(添加修改) ...数组元素:数组里面的每一个数组下标(索引):指明数组元素在数组中的位置(从0开始) 数组长度数组元素的个数 arr1...
  • 况且一个数组创建后,它的大小是无法改变的。 而链表可能是继数组之后第二种使用得最广泛的通用数据结构了。 这里主要来讨论并写一个单链表和双向链表。 顾名思义,单链表只能从表头到表尾的顺序,每个节点中保存了...
  • java数组的定义和使用

    万次阅读 多人点赞 2018-12-04 14:20:57
    Java数组属于引用类型,即数组一个对象。这里的数据类型不仅含八大基本数据类型,还包含引用数据类型,如数组里面可以存数组数组的作用? 在程序中常常需要使用数组,利用循环可以对数组中的数据进行批量...
  • Java创建数组的方法

    2020-12-18 08:14:36
    Java创建数组的方法大致有三种 说明:这里以int为数据类型,以arr为数组名来演示 、声明并赋值 int[] arr = {1,2,4, …}; 注意这里的花括号不是语句块,而且而且花括号后的分号也不能省,…不是元素意思是可以...
  • Java数组 逆序

    2020-08-08 18:57:22
    //新建一个数组等于上个数组长度 赋值上个数组 //遍历新的数组 //静态初始化命名数组arrayName = new type[]{element1,element2,element3,element4,} //动态初始化只指定数组长度,由系统为每个数组元素指定...
  • 2、数组一个引用数据类型,数组的变量只是一个引用,数组元素和数组变量在内存里是分开存放的。 (二)初始化 1、静态初始化:初始化时由程序员显示指定每个数组元素的初始值,由系统决定数组长度。 2、动态...
  • 本篇主要讲解的就是数组的创建和使用方法,以及Arrays类提供的操作数组的方法。 一、数组概述 数组是具有相同数据类型的一组数据的集合。...在java中,同样可以将数组看成一个对象,虽然基本数据类型...
  • Java数组拷贝——四种方法

    千次阅读 2019-03-22 21:36:53
    java语言中,Java数组的复制操作可以分为深度复制和浅度复制。 简单来说深度复制,可以将对象的值和对象的内容复制;...因为数组也是一个 Object 类,因此也可以使用数组对象的 clone() 方法来复制数组。 ...
  • 我们可以声明一个数组变量,如 numbers[100] 来代替直接声明 100 个独立变量 number0,number1,....,number99。这次我们来看Java 数组的声明、创建和初始化。 首先必须声明数组变量,才能在程序中...
  • 简述Java数组的基本属性及其用法

    千次阅读 2019-03-04 20:33:25
    1. 数组:属于引用类型,就是一个存放同类型变量数据的容器。(容器概念以后再补) 2. 数组初始化 第一种:数据类型[] 数组名 = new 数据类型[数据长度];(动态初始化过程) int[] arr = new int [5]; 第二种:...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 60,973
精华内容 24,389
关键字:

java建立一个指定长度的数组

java 订阅