精华内容
下载资源
问答
  • Java数组索引超出界限异常
    2021-02-28 10:15:02

    System.out.print("Enter an integer: ");

    Scanner sc = new Scanner(System.in);

    int x = sc.nextInt();

    int lArray = x - 2;

    int[] newArray = new int[lArray];

    System.out.println("Let's display all possible integers...");

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

    newArray[i] = i + 2;

    System.out.print(newArray[i] + " ");

    }

    我最近刚刚开始使用Java,但我确信如果我用另一种语言编写类似的代码,我会遇到同样的问题.这是一个应用程序的摘录,它列出了用户输入之前的所有素数.

    将x-2用作lArray的定义的原因是因为数组的长度将是从2到数字{2,3,4,5 …… x}的所有整数.

    我注意到了这条线

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

    如果我将i< = newArray更改为i< newArray,代码正常运行.但是,如果x是素数,则省略用户的输入x,这是一个问题.

    更多相关内容
  • 说明:修改了b的的引用地址,当第二次添加数据时候,b就报错,非法索引 ``` public static void main(String[] args) { int[] a = {1,2,3,4}; int[] b = new int[10]; System.out.println("b长度:"+b....
  • 3:数组长度 */ 静态初始化 格式:数据类型[] 变量名 = new 数据类型[]{数据1,数据2} 简化格式:数据类型 [] 变量名 = {数据1,数据2} int[] arr = {1,2,3}; 数组的元素访问 使用索引

    数组的初始化

    动态初始化

    int[] arr = new int[3]
    /*
    	左边:
    		int:数组中元素的类型。
    		[]:说明这是一个数组。
    		arr:数组名称。
    	右边
    		new:申请内存空间
    		int:说明数组中元素的类型
    		[]:说面这是一个数组
    		3:数组的长度
    */
    

    静态初始化

    • 格式:数据类型[] 变量名 = new 数据类型[]{数据1,数据2}
    • 简化格式:数据类型 [] 变量名 = {数据1,数据2}
    int[] arr = {123};
    

    数组的元素访问

    使用索引进行访问

    int[] arr = new int[3]
    int[] arr = new int[3];
    arr[0] = 100;
    arr[2] = 1000;
    System.out.println(arr[0]);
    
    展开全文
  • Java-数组引用总结

    2022-03-31 08:05:17
    Java-数组引用总结

    数组和引用总结



    一、数组的基本用法

    1.什么是数组

    数组本质上就是让我们能“批量”创建相同类型的变量。

    注意:在Java中,数组中包含的变量必须是相同类型

    2.一维数组的创建

    基本语法:

    // 动态初始化
    数据类型[] 数组名称 = new 数据类型 [] { 初始化数据 };
    int[] arr = new int[]{1, 2, 3};
    // 静态初始化
    数据类型[] 数组名称 = { 初始化数据 };
    int[] arr = {1, 2, 3};
    
    注意: 静态初始化的时候, 数组元素个数和初始化数据的格式是一致的.
    

    3.二维数组的创建

    基本语法:

    数据类型[][] 数组名称 = new 数据类型 [行数][列数] { 初始化数据 };
    int[][] arr = {
    {1, 2, 3, 4},
    {5, 6, 7, 8},
    {9, 10, 11, 12}
    };
    for (int row = 0; row < arr.length; row++) {
        for (int col = 0; col < arr[row].length; col++) {
             System.out.printf("%d\t", arr[row][col]);
        }
        System.out.println("");
    }
    // 执行结果
    1 2 3 4
    5 6 7 8
    9 10 11 12
    

    4.数组的使用

    4.1获取长度 & 访问元素

    int[] arr = {1, 2, 3};
    // 获取数组长度
    System.out.println("length: " + arr.length); // 执行结果: 3
    // 访问数组中的元素
    System.out.println(arr[1]); // 执行结果: 2
    System.out.println(arr[0]); // 执行结果: 1
    arr[2] = 100;
    System.out.println(arr[2]); // 执行结果: 100
    

    注意事项

    1. 使用 arr.length 能够获取到数组的长度. . 这个操作为成员访问操作符. 后面在面向对象中会经常用到.
    2. 使用[ ] 按下标取数组元素. 需要注意, 下标从 0 开始计数
    3. 使用 [ ] 操作既能读取数据, 也能修改数据.
    4. 下标访问操作不能超出有效范围 [0, length - 1] , 如果超出有效范围, 会出现下标越界异常

    C中数组下标越界和Java中的区别

    C:未定义行为
    Java:行为是确定的

    4.2遍历数组

    所谓 “遍历” 是指将数组中的所有元素都访问一遍, 不重不漏. 通常需要搭配循环语句.

    int[] arr = {1, 2, 3};
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
    }
    // 执行结果
    1
    2
    3
    

    4.3使用 for-each 遍历数组

    int[] arr = {1, 2, 3};
    for (int x : arr) {
        System.out.println(x);
    }
    // 执行结果
    1
    2
    3
    

    5.数组的相关练习

    5.1数组转字符串

    Java 中提供了 java.util.Arrays 包, 其中包含了一些操作数组的常用方法

    import java.util.Arrays
    int[] arr = {1,2,3,4,5,6};
    String newArr = Arrays.toString(arr);
    System.out.println(newArr);
    // 执行结果
    [1, 2, 3, 4, 5, 6]
    

    自己实现:

    import java.util.Arrays;
    
    public class Test1 {
        public static void main(String[] args) {
            int[] arr = {1,2,3,4,5,6};
            String result = arrToString(arr);
            System.out.println(result);
        }
        public static String arrToString(int[] arr) {
            String result = "[";
        //判定一下当前元素是否为最后一个,如果是,就不加逗号
            for (int i = 0;i <= arr.length - 1;i++) {
                result += arr[i];
                if (i != arr.length - 1) {
                    result += ", ";
                } else {
                    result += "";
                }
            }
            result += "]";
            return result;
        }
    
    }
    

    5.2数组拷贝

    import java.util.Arrays;
    
    public class Test2 {
        public static void main(String[] args) {
            int[] arr = {1,2,3,4,5,6};
            //数组拷贝
    //        int[] arr2 = copyArray(arr);
            int[] arr2 = Arrays.copyOf(arr,arr.length);
            arr[0] = 10;
            System.out.println(arr2[0]);
        }
    
        public static int[] copyArray(int[] arr) {
            //首要操作,创建一个新的数组;
            int[] result = new int[arr.length];
            for (int i = 0;i <= arr.length - 1;i++) {
                result[i] = arr[i];
            }
            return result;
        }
    }
    
    

    5.3找数组中的最大元素

    public class Test3 {
        public static void main(String[] args) {
            //寻找数组中的最大元素
            int[] arr = {5, 7, 3, 8, 9, 1, 10};
            int result = max(arr);
            System.out.println(result);
        }
    
        //打擂台的方法,谁大谁留在台上,否则就下去
        public static int max(int[] arr) {
            int result = arr[0];
            for (int i = 0;i <= arr.length-1;i++) {
                if (arr[i] > result) {
                    result = arr[i];
                }
            }
            return result;
        }
    }
    
    

    5.4求数组中元素的平均值

    public class Test4 {
        public static void main(String[] args) {
            //求数组平均值
            int[] arr = {9,3,4,5,1,8,6,10};
            double result = avg(arr);
            System.out.println(result);
        }
    
        public static double avg(int[] arr) {
            int sum = 0;
            for (int x : arr) {
                sum += x;
            }
            return (double)sum / arr.length;
        }
    }
    
    

    5.5查找数组中指定元素(顺序查找)

    
    代码在5.6二分查找中,未拆开
    

    5.6查找数组中指定元素(二分查找)

    public class Test5 {
        public static void main(String[] args) {
            //“查找”有两种风格
            //1.给定位置,查找值
            //2.给定值,查找位置(数组下标)
            //查找数组元素的位置
            //int[] arr = {8,5,6,9,3,7,1};
            //int pos = search(arr,3);
            //System.out.println(pos);
    
            //二分查找
            //二分查找必须应用于有序数组
            int[] arr = {2,3,4,5,7,13};
            int pos = binarySearch(arr,5);
            System.out.println(pos);
        }
    
        //直接去整个数组的中间元素,用中间元素和待查找元素进行对比
        public static int binarySearch(int[] arr, int toSearch) {
            int left = 0;
            int right = arr.length - 1;
            while (left <= right) {
                int mid = (left + right) / 2;
                if (toSearch < arr[mid]) {
                    //左侧区间查找,淘汰掉右侧区间
                    right = mid - 1;
                } else if (toSearch > arr[mid]) {
                    //右侧区间查找,淘汰掉左侧区间
                    left = mid + 1;
                } else {
                    //相等
                    return mid;
                }
            }
            return -1;
        }
    
        public static int search(int[] arr, int toSearch) {
            for (int i = 0;i <= arr.length - 1;i++) {
                if (arr[i] == toSearch) {
                    return i;
                }
            }
            //返回-1表示没找到
            return -1;
        }
    }
    

    5.7检查数组的有序性

    public class Test6 {
        public static void main(String[] args) {
            //验证数组的有序性
            int[] arr = {2,3,4,5,6,7};
            System.out.println(isSorted(arr));
        }
    
        //按照升序来比较
        //依次比较数组中的两个相邻元素,如果所有的相邻元素之间都是有序的话,
        //就认为整个数组是有序的
        //只要找到一个反例,就是无序的
        public static boolean isSorted(int[] arr) {
            for (int i = 0; i < arr.length - 1;i++) {
                if (arr[i] > arr[i+1]) {
                    return false;
                }
            }
            return true;
        }
    }
    
    

    5.8数组排序(冒泡排序)

    import java.util.Arrays;
    
    public class Test7 {
        public static void main(String[] args) {
            //冒泡排序(升序来算)
            //一趟比较下来,就可以将最大的元素放到最后,或将最小的元素放到最前
            int[] arr = {9,5,2,7,3,6};
            bubbleSort(arr);
            //Java标准库中提供了一个现成的排序算法Array.sort()
            //Arrays.sort(arr);
            System.out.println(Arrays.toString(arr));
        }
    
        //这个代码,可以直接在方法内部修改数组的内容
        //也可以创建新数组,以返回值的方式返回新数组
        //数组这样的类型,在方法内部做出修改,也能影响到实参的内容
        public static void bubbleSort(int[] arr) {
            //如果从前往后遍历进行比较交换,就把最大元素放到最后
            //如果从后往前遍历进行比较交换,就把最小元素放到最前
            //[0,bound)已排序区间
            //[bound,length)待排序区间
            for (int bound = 0;bound < arr.length;bound++) {
                for (int cur = 0;cur < arr.length - bound - 1;cur++) {
                    if (arr[cur] > arr[cur + 1]) {
                        int tmp = arr[cur];
                        arr[cur] = arr[cur + 1];
                        arr[cur + 1] = tmp;
                    }
                }
            }
        }
    }
    
    

    5.9数组逆序

    import java.util.Arrays;
    
    public class Test8 {
        public static void main(String[] args) {
            int[] arr = {9,5,2,7,3,6,10};
            //数组逆序
            reverse(arr);
            System.out.println(Arrays.toString(arr));
        }
        public static void reverse(int[] arr) {
            int left = 0;
            int right = arr.length - 1;
            while (left < right) {
                int tmp = arr[right];
                arr[right] = arr[left];
                arr[left] = tmp;
                left++;
                right--;
            }
        }
    }
    
    

    5.10数组数字排列

    import java.util.Arrays;
    
    public class Test9 {
        public static void main(String[] args) {
            int[] arr = {9,4,2,7,3,6,10};
            //对数组进行重新排列
            //排列之后偶数在前,奇数在后
            //从前往后排列,找到一个奇数
            //再从后往前,找到一个偶数
            //交换这两元素,直到两个下标重合
            transform(arr);
            System.out.println(Arrays.toString(arr));
        }
    
        public static void transform(int[] arr) {
            int left = 0;
            int right = arr.length - 1;
            while (left < right) {
                while (left < right && arr[left] % 2 == 0) {
                    left++;
                }
                while (left < right && arr[right] % 2 != 0) {
                    right--;
                }
                if (left < right) {
                    int tmp = arr[right];
                    arr[right] = arr[left];
                    arr[left] = tmp;
                }
            }
        }
    }
    
    

    二、引用

    1.什么是引用

    String s = "Hello World"; // 这里的 s 的类型是 String 类型的引用;该引用指向了一个String 类型的对象。
    int[] a = { 1, 2, 3, 4, 5 }; // 这里的 a 的类型是 int[] 类型的引用;该引用指向了一个元素类型是 int 的数组类型对象。
    

    引用其实通俗的讲也就是别名。

    注意:
    1.一个对象可以拥有多个别名;
    2.一个引用只能对应到一个对象

    2.引用的规则

    注1:
    (1)只有引用指向对象;没有对象指向引用;也没有引用指向引用;更没有对象指向对象;
    (2)对象可以被多个引用指向;
    (3)操作引用,其实操作的是引用指向的对象;
    (4)一个对象至少得有一个引用指向,如果一个引用都没有了,说明这个对象无法在代码中被使用了,此时这个对象就会被垃圾回收器当成垃圾从而回收并释放内存空间;

    注2:
    “=”赋值操作的是引用的指向,对对象本身并无影响;

    注3:
    (1)引用是一种数据类型,用来指向对象;
    (2)对引用进行大部分操作实际上都是操作的该引用指向的对象;
    (3)当多个引用指向同一个对象时,通过哪个引用修改了对象,其他引用都可以看到对象;
    (4)当一个引用不指向对象时,要求访问其指向的对象,就会遇到NullPointerException;

    注3:
    (1)引用和对象都是一种数据组织形式,所以都是存放在内存中的;
    (2)对象一定保存在堆上,但引用则不一定;
    (3)引用是一类只能用来指向对象的数据类型;
    (4)引用可以指向对象,也可以不指向对象;
    (5)解引用操作就是通过引用找到对象;
    (6)Java中无法直接接触到对象,都是通过引用接触到对象;
    (7)对一个空的引用做到解引用操作,会出现NullPointerException;
    (8)JVM为了便于管理,将其管理的内存人为划分为6个区域:
    ①PC区;②虚拟机栈;③本地方法栈;④堆;⑤方法区;⑥运行时常量池;

    注4:
    (1)空指针表示指针中存的地址对应的内存是一个非法内存;
    (2)空引用表示该引用里面的所持有的地址对应的对象,是一个非法的对象;

    注5:
    (1)null和0号地址,不一定直接相关;
    (2)null存的地址,不一定是0;
    (3)不能针对null这样的引用进行“解引用”,指的就是不能够访问这个对象的成员;

    注6:
    (1)Build:编译错误; 编译一次
    (2)Exception:运行错误; 运行可能是N次

    注7:
    (1)使用null可以表示一个非法值;
    (2)null不能赋值给内置类型,只能赋值给引用类型
    eg:不能赋值为int,可以赋值给Integer。

    展开全文
  • 这时就只能改变数组里的数值而不能改变它的长度了.Java是一门面向对象编程语言,不仅吸收了C++语言的各种优点,还摒弃了C++里难以理解的多继承、指针等概念,因此Java语言具有功能强大和简单易用两个特征。Java语言...

    7ab9c958ed5e4a59d04c4b84f2f920d9.png

    MYYA

    定义时当然可以:例如 int[] a;但是要把它初始化成为一个真正意义上的数组就必须设定长度: int [] a = new int[10]; 这时就只能改变数组里的数值而不能改变它的长度了.Java是一门面向对象编程语言,不仅吸收了C++语言的各种优点,还摒弃了C++里难以理解的多继承、指针等概念,因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表,极好地实现了面向对象理论,允许程序员以优雅的思维方式进行复杂的编程。扩展资料:1.简单性。Java看起来设计得很像C++,但是为了使语言小和容易熟悉,设计者们把C++语言中许多可用的特征去掉了,这些特征是一般程序员很少使用的。例如,Java不支持go to语句,代之以提供break和continue语句以及异常处理。Java还剔除了C++的操作符过载(overload)和多继承特征,并且不使用主文件,免去了预处理程序。因为Java没有结构,数组和串都是对象,所以不需要指针。Java能够自动处理对象的引用和间接引用,实现自动的无用单元收集,使用户不必为存储管理问题烦恼,能更多的时间和精力花在研发上。2.面向对象。Java是一个面向对象的语言。对程序员来说,这意味着要注意应中的数据和操纵数据的方法(method),而不是严格地用过程来思考。在一个面向对象的系统中,类(class)是数据和操作数据的方法的集合。数据和方法一起描述对象(object)的状态和行为。每一对象是其状态和行为的封装。类是按一定体系和层次安排的,使得子类可以从超类继承行为。在这个类层次体系中有一个根类,它是具有一般行为的类。Java程序是用类来组织的。Java还包括一个类的扩展集合,分别组成各种程序包(Package),用户可以在自己的程序中使用。例如,Java提供产生图形用户接口部件的类(java.awt包),这里awt是抽象窗口工具集(abstract windowing toolkit)的缩写,处理输入输出的类(java.io包)和支持网络功能的类(java.net包)。3.分布性。Java设计成支持在网络上应用,它是分布式语言。Java既支持各种层次的网络连接,又以Socket类支持可靠的流(stream)网络连接,所以用户可以产生分布式的客户机和服务器。网络变成软件应用的分布运载工具。Java程序只要编写一次,就可到处运行。

    展开全文
  • java数组长度可变

    2021-03-16 00:26:24
    Java数组练习题(带答案)_IT... 2) 数组复制时,"......Java 数组练习题(带答案) 一 填空题 1) 数组的元素通过 下标 来访问,数组 Array 的长度为 Array、length 。 2) 数组复制时,=将一个数组引用 传递给另........
  • Java数组的创建及引用

    2021-12-12 16:46:25
    文章目录数组的概念数组的创建和引用数组的声明数组的创建数组元素的初始化数组的引用多维数组二维数组的声明二维数组的创建二维数组初始化二维数组的引用 数组的概念 数组是由同类型的数据元素构成的一种数据结构...
  • 前言 Java中可以创建一个长度为0的数组。 见如下代码: ...当数组为null的时候,也就是数组引用并没有指向堆中的空间,Java虚拟机并没有为这个数组分配一段空间。 如下形式: int[] a = null;//数
  • 为什么如此获取 Java 数组长度

    万次阅读 2018-02-01 15:41:15
    public class Test { public static void main(String[] args) { int[] arr = new int[5]; System.out.println(arr.length); System.out.println("Hello".length());...为什么获取数组的...
  • 为什么使用length获取Java数组长度

    万次阅读 多人点赞 2016-05-13 12:28:10
    记得vamcily 曾问我:“为什么获取数组长度用.length(成员变量的形式),而获取String的长度用.length()(成员方法的形式)?”   我当时一听,觉得问得很有道理。做同样一件事情,为什么采用两种风格迥异的...
  • Java中,数组变量为null与数组长度为0的区别 转自https://blog.csdn.net/fyfcauc/article/details/37930193 有如下两个变量定义: 1 int[] zero = new int[0]; 2 int[] n = null; 解释: 在Java中,允许有长度为0...
  • java数组长度为0和数组为null

    千次阅读 2017-04-20 19:38:38
    //zero引用一个长度为0的数组对象为null的数组,不能求数组长度,且求解时会出现空指针异常NullPointerException。int[] zero = null; //数组类型的空引用,不指向任何对象假设一个方法返回一个数组: 如果它返回...
  • Java数组声明创建赋值长度

    千次阅读 2021-01-01 17:43:54
    Java数组数组的声明与创建数组声明方式创建数组使用new来创建数组变量数组长度数组的初始化静态初始化动态初始化默认的初始化内存分析 数组的声明与创建 数组声明方式 dataType[] arrayRefaVar;//首选 dataType ...
  • 数组是一种引用类型,其长度在程序运行期间不可以改变 初始化 动态初始化(指定长度): 格式: 数据类型[] 数组名称 =new 数据类型[数据长度]; 左右俩侧数据类型必须相同。int[] str = new int[10]; short[] str2...
  • java二维数组的初始化及使用其长度

    千次阅读 2021-02-26 16:56:19
    Java语言中,由于把二维数组看作是数组数组数组空间不是连续分配的,所以不要求二维数组每一维的大小相同。2.动态初始化1) 直接为每一维分配空间,格式如下:arrayName = new type[arrayLength1][arrayLength2];...
  • 从零开始学java(数组)

    2021-02-25 19:58:58
    简单理解数组java中的数组要求一个数组内只能存储一种数据类型,因为java是面向对象的所以我们之前说到了面向对象的多态性,所以这里的类型引用可以是父类,实例的子类。(即:水果类作为引用,苹果实例...
  • Java之路:数组引用传递

    万次阅读 多人点赞 2018-12-04 12:08:22
    一、引用 int[] a = new int[10]; int[] b; b = a; 让数组b直接指向数组a(即b = a;...所以,在Java语言中, b = a(a和b都是引用名)的含义就是将a起个别名&amp;quot;b&amp;quot;。 之后,a和b其...
  • Java数组的使用

    千次阅读 2021-02-27 15:48:26
    1.声明数组1.1声明一维数组声明一维数组有下列两种格式:数组的元素类型 数组名字[ ];数组的元素类型[ ] 数组名字1.2声明二维数组声明二维数组有下列...Java数组声明注意以下两点内容:1.数组的元素类型可以是Java中...
  • (无论使用哪种类型的数组数组标识符其实只是一个引用,指向在堆中创建的一个真实对象 Int[] A =new int[10];new 一下就是实例化了,开辟了内存空间,基本数据类型的元素会被赋初始值,数组建立后长度不能改变,...
  • 常用 Object类Java Object数组引用讨论Java数组的本质是一个Java类,它是通过new语句来实例化,但是这个new语句却不会实例化数组中的对象。对于基本类型的数组,在new语句创建数组实例时,会为该数组分配指定长度的...
  • Java动态数组是一种可以任意伸缩数组长度的对象,在Java中比较常用的是ArrayList,ArrayList是javaAPI中自带的java.util.ArrayList。下面介绍一下ArrayList作为Java动态数组的用法。1.语法:add()是添加一个新的元素...
  • 使用Java定义数组

    千次阅读 多人点赞 2021-12-03 16:34:07
    一维数组和二维数组的定义及使用
  • 详解java静态数组

    2021-08-13 13:54:39
    数组是一种线性表 顾名思义,数组就是数据组合在一起,是一个存储数据容器。其一般定义: 数组是具有相同数据类型元素的有序集合。 从定义可知 所有元素必须是相同数据类型。 那么可以推导数组也是一种数据类型,且...
  • Java数组

    2022-03-24 18:52:18
    Java数组01 1.数组的定义 数组是相同类型数据的有序集合。 数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。 其中,每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问它们。 二....
  • Java数组的特性

    2021-02-12 21:14:46
    数组是基本上所有语言都会有的一种数据类型,它表示一组相同类型的数据的集合,具有固定的长度,并且在内存中占据连续的空间。在C,C++等语言中,数组的定义简洁清晰,而在java中确有一些会让人迷惑的特性。本文就...
  • 清空Java数组的最佳方法 - java

    千次阅读 2021-03-22 16:14:09
    设定长度:data = new MyClass[1];添加数据:data[0] = new MyClass();现在我需要清除数组。做这个的最好方式是什么?将null分配给该数组可以吗?data=null;参考方案您是否希望数组仍然存在但其中什么也没有?重新...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 193,885
精华内容 77,554
关键字:

java引用数组长度

java 订阅