精华内容
下载资源
问答
  • java数组遍历 删除remove。需要的朋友可以过来参考下,希望对大家有所帮助
  • 主要介绍了Java数组中的元素删除并实现向前移的代码的相关资料,需要的朋友可以参考下
  • WORD格式 专业资料整理 . 一 填空题 1) 数组的元素通过 下标 来访问数组 Array的长度为 Array.length 2) 数组复制时"="将一...5) Java数组的下标的数据类型是 整型 6) 数组最小的下标是 0 7) arraycopy)的最后一个参
  • 主要介绍了Java数组传递及可变参数操作,结合实例形式详细分析了java数组参数传递与可变参数相关使用技巧,需要的朋友可以参考下
  • 韩顺平_Java数组.ppt

    2013-08-15 11:26:21
    找了好久才找到的,跟大家分享一下,里面有韩老师java从入门到精通教程中数组那章的ppt
  • Java数组元素求和

    千次阅读 2019-10-18 18:46:31
    今天给大家解析,Java数组元素求和的过程 一听到求和我们应该首先想到,要运用到**+=** public class Qiuhe { public static void main(String[] args) { //定义一个静态初始化 int[] arr = {1, 2, 3, 4, 5, 6, 7...

    今天给大家解析,Java中数组元素求和的过程
    一听到求和我们应该首先想到,要运用到**+=**

    public class Qiuhe {

    public static void main(String[] args) {
    
        //定义一个静态初始化
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        
        //再定义一个数据用来接收最后的和
        int sum = 0;
        //for循环遍历每个数组中的元素
        for (int x = 0; x < arr.length; x++) {
            //+=运算符求出结果
            sum += x;
        }
        //打印最终结果
        System.out.println(sum);
       }
     }
    

    这个代码,我要记住遍历集合中每个数组,与最后求和,最为重要

    展开全文
  • Java数组

    千次阅读 多人点赞 2018-07-28 09:59:47
    Java 语言中提供的数组是用来存储固定大小的同类型元素。 数组中的元素可以是任何数据类型,包括基本数据类型和引用数据类型。 数组属引用类型,数组型数据是对象(object),数组中的每个元素相当于该对象的成员...

    数组介绍

    Java 语言中提供的数组是用来存储固定大小的同类型元素。

    数组中的元素可以是任何数据类型,包括基本数据类型和引用数据类型。

    数组属引用类型,数组型数据是对象(object),数组中的每个元素相当于该对象的成员变量。

    数组是多个相同类型数据的组合,实现对这些数据的统一管理。一个数组实际上就是一连串的变量,数组按照使用可以分为一维数组、二维数组、多维数组。

     

    要使用Java的数组,必须经过两个步骤:

    1)声明数组变量

    2)创建数组:分配内存给这个数组

     

    声明数组

    首先必须声明数组变量,才能在程序中使用数组。下面是声明数组变量的语法:

    元素类型[] 数组名;  // 建议使用的方式
    元素类型 数组名[];  // 效果相同,这种风格类似 C/C++ 语言 

    “数组名”是用来统一这组相同数据类型的元素的名称,建议使用有意义的名称为数组命名。

    int[] score = null;  // 推荐方式,null表示引用数据类型的默认值
    // int socre[] = null;  // 非推荐方式
    

     

    为数组开辟空间

    数组声明后实际上是在栈内存中保存了此数组的名称,接下来便是要在堆内存中配置数组所需的内存,其中“元素的个数”(数组的长度)是告诉编译器,所声明的数组要存放多少个元素,而“new”则是命令编译器根据括号里的长度开辟空间。

    数组名 = new 元素类型[元素的个数];

    我们为上面声明的socre数组开辟空间:

    score = new int[3];

    数组操作中,在栈内存中保存的永远是数组的名称,只开辟了栈内存空间数组是永远无法使用的,必须有指向的堆内存才可以使用,要想开辟新的堆内存则必须使用new关键字,之后只是将此堆内存的使用权交给了对应的栈内存空间,而且一个堆内存空间可以同时被多个栈内存空间指向,即:一个人可以有多个名字,人就相当于堆内存,名字就相当于栈内存。

     

    数组的动态初始化

    声明数组的同时分配内存:

    元素类型 数组名[] = new 元素类型[元素的个数];

    下面我们声明一个元素个数为10的整型数组score,同时开辟一块内存空间供其使用:

    int[] score = new int[10];

    在Java中,由于整数数据类型所占用的空间为4个bytes,而整型数组score可保存的元素有10个,所以上例中占用的内存共有4 * 10 = 40个字节。

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

    public class ArrayTest {
        public static void main(String[] args) {
             // 对各元素进行初始化,但没有赋值。
            String[] stringArray = new String[3]; // 各元素的值默认为String类型的初始值null
            // 数组没有length()这个方法,有length的属性。
            for (int i = 0; i < stringArray.length; i++) {
                System.out.println(stringArray[i]);  // null null null
            }
        }
    }

     

    数组中元素的表示方法

    想要访问数组里的元素,可以利用索引来完成。Java的数组索引编号由0开始,以一个的score[10]的整形数组为例,score[0]代表第1个元素,score[1]代表第2个元素,score[9]为数组中第10个元素(也就是最后一个元素)。

    程序中可以发现,对于数组的访问采用“数组名称[下标]”的方式,之前一共开辟了三个空间大小的数组,所以下标的取值是0~2,假设程序中取出的内容超过了这个下标,如“score[3]”,则程序运行的时候会出现数组下标越界的错误提示:java.lang.ArrayIndexOutOfBoundsException。

     

    为数组中的元素赋值并进行输出:

    public class Test {
        public static void main(String[] args) {
            int score[] = null; // 【1】声明数组,但未开辟堆内存
            score = new int[3]; // 【2】为数组开辟堆内存空间,大小为3
            for (int x = 0; x < score.length; x++) { // 数组的长度可以用“数组名.length”
                score[x] = x * 2 + 1 ; // 为每一个元素赋值
            } // 【3】开辟堆内存空间结束
            for (int x = 0; x < 3; x++) { // 使用循环依次输出数组中的全部内容
                System.out.println("score[" + x + "] = " + score[x]);
            }
        }
    }

    我们对以上代码进行内存分析,【1】【2】【3】处分别对应下面这三张图:

     

    数组的静态初始化

    数组的内容分为动态初始化和静态初始化两种,前面所讲解的全部代码是采用先声明数组之后为数组中的每个内容赋值的方式完成的。那么也可以通过数组静态初始化在数组声明时就为数组元素分配空间并赋值。

    元素类型 数组名 = {元素1,元素2...};
    元素类型 数组名 = new 元素类型[]{元素1,元素2...};

    数组的元素是通过索引访问的。数组索引从 0 开始,所以索引值从 0 到数组长度-1。

     

    处理数组

    数组的元素类型和数组的大小都是确定的,所以当处理数组元素时候,我们通常使用基本循环,尤其是for循环。JDK 1.5 引进了一种新的循环类型,被称为 foreach 循环或者加强型循环,它能在不使用下标的情况下遍历数组。

    public class TestArray {
       public static void main(String[] args) {
          double[] arr = {1.5, 2.5, 3.5, 3.5, 5.5};
          // 打印所有数组元素
          for (double element: arr) {
             System.out.println(element);
          }
       }
    }

    数组和前面讲到的八种基本数据类型一样也是一种数据类型,只不过它和后面要讲到的类、接口一样都是引用类型。既然是数据类型,那么就可以作为方法的参数类型(比如main方法的 string[] args)、方法的返回值类型使用,这个我们在方法篇再举例说明。

     

    多维数组

    多维数组可以看成是数组的数组,比如二维数组就是一个特殊的一维数组,其每一个元素都是一个一维数组。我们以二维数组为例看一下多维数组的初始化:

    二维数组的动态初始化:直接为每一维分配空间

    元素类型 变量名 = new 元素类型[行数][列数];

    声明整型数组score,同时为其开辟一块内存空间:

    int[][] score = new int[4][3];

    整型数据score可保存的元素有4*3 = 12个,而在Java中,int数据类型所占用的空间为4个字节,因此该整型数组占用的内存共为4*12 = 48个字节。

    public class Test {
        public static void main(String[] args) {
            int score[][] = new int[4][3]; // 声明并实例化二维数组
            score[0][1] = 30 ; // 为数组中的部分内容赋值
            score[1][0] = 31 ; // 为数组中的部分内容赋值
            score[2][2] = 32 ; // 为数组中的部分内容赋值
            score[3][1] = 33 ; // 为数组中的部分内容赋值
            score[1][1] = 30 ; // 为数组中的部分内容赋值
            for (int i = 0; i < score.length; i++) { // 外层循环行
                for(int j=0;j<score[i].length;j++){// 内层循环列
                    System.out.print(score[i][j] + "\t");
                }
                System.out.println("") ; // 换行
            }
        }
    }
    

    执行结果如下:

    0	30	0	
    31	30	0	
    0	0	32	
    0	33	0	

     

    二维数组的静态初始化:

    元素类型 变量名 = {{元素A1,元素A2...}, {元素B1,元素B2}...};

    例如

    int score[][] = {{ 67, 61 }, { 78, 89, 83 }, { 99, 100, 98, 66, 95 }};

    一般来讲,操作二维数组不应使用常数来控制维数。具体方法是array.length表示行数,array[row].length来表示row行的列数。这样当数组行数和列数不相等时,代码可以自动调整为正确的值。

    public class Test {
        public static void main(String[] args) {
            // 静态初始化一个二维数组,每行的数组元素个数不一样
            int[][] score = {{ 67, 61 }, { 78, 89, 83 }, { 99, 100, 98, 66, 95 }};
            for (int i = 0; i < score.length; i++) { // 外层循环输出行
                for (int j = 0; j < score[i].length; j++) {// 内存循环输出列
                    System.out.print(score[i][j] + "\t");// 输出每一个元素
                }
                System.out.println(""); // 换行
            }
        }
    }
    

    执行结果如下:

    67	61	
    78	89	83	
    99	100	98	66	95

     

    操作数组的工具类:Arrays

    java.util.Arrays类包含了用来操作数组(比如排序和搜索)的各种方法,它提供的所有这些方法都是静态的。

    Arrays拥有一组static方法:

    序号方法和说明
    1public static int binarySearch(Object[] a, Object key)
    用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中,则返回搜索键的索引;否则返回 (-(插入点) - 1)。
    2public static boolean equals(long[] a, long[] a2)
    如果两个指定的 long 型数组彼此相等,则返回 true。如果两个数组包含相同数量的元素,并且两个数组中的所有相应元素对都是相等的,则认为这两个数组是相等的。换句话说,如果两个数组以相同顺序包含相同的元素,则两个数组是相等的。同样的方法适用于所有的其他基本数据类型(Byte,short,Int等)。
    3public static void fill(int[] a, int val)
    将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型(Byte,short,Int等)。
    4public static void sort(Object[] a)
    对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型(Byte,short,Int等)。
    public class Test {
        public static void main(String[] args) {
            int array[] = { 2, 5, 8, 3, 1, 4, 9, 6, 7 }; // 声明一个整型数组
            System.out.println("Object的toString:"array.toString()); //Object的toString()方法
            Arrays.sort(array);  // 数组排序
            System.out.println("排序后的数组: " + Arrays.toString(array)) ; 
            int point = Arrays.binarySearch(array, 3) ; // 检索数据位置
            System.out.println("元素‘3’的位置在:" + point) ;
            Arrays.fill(array, 6) ; // 填充数组
            System.out.print("数组填充:" + Arrays.toString(array)) ;
        }
    }

    执行结果:

    Object的toString:[I@7852e922
    排序后的数组: [1, 2, 3, 4, 5, 6, 7, 8, 9]
    元素‘3’的位置在:2
    数组填充:[6, 6, 6, 6, 6, 6, 6, 6, 6]

    System.arraycopy()array的复制。    

    使用System.arraycopy()方法进行数组拷贝,可以提高性能。

    public class Test {
        public static void main(String[] args) {
            int[] a = { 3, 5, 6, 12, 45 }; // 声明一个整型数组a
            int[] b = { 23, 12, 4, 53, 2}; // 声明一个整型数组b
            System.arraycopy(a, 1, b, 2, 2);
            System.out.println("数组a: " + Arrays.toString(a));
            System.out.println("数组b: " + Arrays.toString(b));
        }
    }

    执行结果:

    数组a: [3, 5, 6, 12, 45]
    数组b: [23, 12, 5, 6, 2]

     

     

     

    展开全文
  • java数组删除数组元素_如何在Java中删除数组元素

    万次阅读 多人点赞 2020-07-20 15:04:52
    java数组删除数组元素When we create an array in Java, we specify its data type and size. This is used by JVM to allocates the necessary memory for array elements. There are no specific methods to ...

    java数组删除数组元素

    When we create an array in Java, we specify its data type and size. This is used by JVM to allocates the necessary memory for array elements. There are no specific methods to remove elements from the array.

    在Java中创建数组时,我们指定其数据类型和大小。 JVM使用它为数组元素分配必要的内存。 没有从数组中删除元素的特定方法。

    1.使用for循环从数组中删除一个元素 (1. Removing an element from Array using for loop)

    This method requires the creation of a new array. We can use for loop to populate the new array without the element we want to remove.

    此方法需要创建一个新的数组。 我们可以使用for循环来填充新数组,而无需删除想要删除的元素。

    
    package com.journaldev.java;
    
    import java.util.Arrays;
    
    public class Main {
    
        public static void main(String[] args) {
            int[] arr = new int[]{1,2,3,4,5};
            int[] arr_new = new int[arr.length-1];
            int j=3;
            for(int i=0, k=0;i<arr.length;i++){
                if(i!=j){
                    arr_new[k]=arr[i];
                    k++;
                }
            }
            System.out.println("Before deletion :" + Arrays.toString(arr));
            System.out.println("After deletion :" + Arrays.toString(arr_new));
    
        }
    }
    
    Arr Delete

    The code removes the element at index 3. This method simply copies all the elements except the one at index 3 to a new array.

    代码将删除索引3处的元素。此方法将索引3处的元素以外的所有元素简单地复制到新数组中。

    2.按其值删除数组元素 (2. Deleting an array element by its value )

    Unlike the previous case, this code will delete the element based on its value. This will not work with duplicates since the size of the array after deletion has to be known.

    与前一种情况不同,此代码将根据其值删除该元素。 这不适用于重复项,因为必须知道删除后阵列的大小。

    
    package com.journaldev.java;
    import java.util.Arrays;
    
    public class Main {
    
        public static void main(String[] args) {
            int[] arr = new int[]{1,2,3,4,5};
            int[] arr_new = new int[arr.length-1];
            int j=3;
            for(int i=0, k=0;i<arr.length;i++){
                if(arr[i]!=j){
                    arr_new[k]=arr[i];
                    k++;
                }
            }
            System.out.println("Before deletion :" + Arrays.toString(arr));
            System.out.println("After deletion :" + Arrays.toString(arr_new));
    
        }
    }
    
    Arr Delete based on value

    The only difference between this and the previous case is arr[i]!=j in the if condition in place of i!=j.

    这种情况与前一种情况之间的唯一区别是在if条件下代替i!=j arr[i]!=j i!=j

    3.当数组包含重复项时,通过其值删除元素 (3. Deleting element by its value when the array contains duplicates )

    Performing deletion based on the value in case of duplicates requires using ArrayList. Since ArrayList doesn’t require the size to be now in advance, it allows us to expand dynamically.

    在重复的情况下,根据值执行删除操作需要使用ArrayList。 由于ArrayList不需要现在预先指定大小,因此它允许我们动态扩展。

    
    package com.journaldev.java;
    
    import java.util.ArrayList;
    import java.util.Arrays;
    
    public class Main {
    
        public static void main(String[] args) {
            int[] arr = new int[]{1,3,3,4,5};
            ArrayList<Integer> arr_new = new ArrayList<>();
            int j=3;
            for(int i=0;i<arr.length;i++){
                if(arr[i]!=j){
                    arr_new.add(arr[i]);
    
                }
            }
            System.out.println("Before deletion :" + Arrays.toString(arr));
            System.out.println("After deletion :" +arr_new);
    
        }
    }
    
    array-deletion-duplicates

    4.移位相同数组中的元素 (4. Shifting elements in the same array)

    This method involves shifting the elements in the same array. Shifting of elements replaces the element to be deleted by the element at the next index.

    此方法涉及移动同一阵列中的元素。 元素的移动将替换下一个索引处要删除的元素。

    
    package com.journaldev.java;
    import java.util.Arrays;
    public class Main {
    
        public static void main(String[] args) {
            int[] arr = new int[]{1,3,3,4,5};
            int j=3;
            System.out.println("Before deletion :" + Arrays.toString(arr));
            int count =0;
            for(int i = 0; i < arr.length; i++){
                if(arr[i] == j){
                    count++;
    
                    // shifting elements
                    for(int k = i; k < arr.length - 1; k++){
                        arr[k] = arr[k+1];
                    }
                    i--;
                   // break;
                }
            }
    
            System.out.print("After Deletion :" );
            for(int i = 0; i < arr.length-count; i++){
                System.out.print(" " + arr[i]);
            }
            System.out.println();
            System.out.println("Whole array :" + Arrays.toString(arr));
    
        }
    }
    

    Count variable indicates the number of elements deleted. This variable is essential to keep a track of index till which the array should be printed. This method takes care of duplicates as well.

    Count变量指示删除的元素数。 该变量对于跟踪要打印数组的索引至关重要。 此方法也处理重复项。

    Shifting Elements In Array

    5.从ArrayList中删除元素 (5. Deleting elements from ArrayList)

    ArrayList is backed by arrays. The deletion of an element in the ArrayList is straight forward. It requires one simple call to an inbuilt function.

    ArrayList由数组支持。 直接删除ArrayList中的元素。 它仅需简单调用一个内置函数。

    
    package com.journaldev.java;
    import java.util.ArrayList;
    import java.util.Arrays;
    public class Main {
    
        public static void main(String[] args) {
            int[] arr = new int[]{1,3,3,4,5};
            ArrayList<Integer> arr_new = new ArrayList<Integer>();
            for (int i : arr)
            {
                arr_new.add(i);
            }
            arr_new.remove(3);
            System.out.println("Before deletion :" + Arrays.toString(arr));
            System.out.println("After Deletion:" + arr_new);
        }
    }
    

    A call to the remove(i) function removes the element at index i. Deletion in ArrayLists is relatively easier as compared to Arrays.

    调用remove(i)函数将删除索引i处的元素。 与Arrays相比,ArrayLists中的删除相对容易。

    ArrayList Deletion

    结论 (Conclusion)

    We saw some examples of deleting elements in an array using different methods. The difference between the deletion of an element in an Array and an ArrayList is clearly evident. If deletion is to be performed again and again then ArrayList should be used to benefit from its inbuilt functions. Same is the case with the addition of elements to an array. ArrayList due to its dynamic nature provides easier and less cumbersome ways to alter an array.

    我们看到了一些使用不同方法删除数组中元素的示例。 删除Array中的元素和ArrayList之间的区别很明显。 如果要一次又一次地执行删除操作,则应使用ArrayList来受益于其内置功能。 将元素添加到数组的情况也是如此。 ArrayList由于其动态特性而提供了更轻松,更省力的方式来更改数组。

    翻译自: https://www.journaldev.com/42212/java-remove-array-elements

    java数组删除数组元素

    展开全文
  • java数组定义、使用、以及数组内存分析详解

    千次阅读 多人点赞 2019-10-04 22:17:30
    旨在全面性了解java数组。 文章目录1、什么是容器2、什么是数组3、数组的三种定义定义方式一定义方式二定义方式三数组定义格式详解:4、数组的访问5、什么是内存5.1 Java虚拟机的内存划分5.2 数组在内存中的存储...

    前言

    本文主要是从容器概念到数组概念再到数组的三种定义以及各种情况的数组内存分析,以及一些数组常用的遍历以及反转、取最大值等操作。旨在全面性了解java数组。

    1、什么是容器

    在讲数组之前,很有必要来谈谈容器的概念 所谓容器就是将多个数据存储到一起,每个数据称为该容器的元素。

    生活中的容器:水杯,衣柜,教室

    2、什么是数组

    所谓数组就是存储数据长度固定容器,保证多个数据的数据类型一致

    3、数组的三种定义

    下面主要讲解下数组的三种定义方式。

    定义方式一

    数据类型[] 数组名字 = new 数据类型 [长度] ;

    举例: 定义可以存储3个整数的数组容器,代码如: int[] arr = new int[3]

    定义方式二

    数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3...};

    举例: 定义存储1,2,3,4,5整数的数组容器。 int[] arr = new int[]{1,2,3,4,5};

    定义方式三

    数据类型[] 数组名 = {元素1,元素2,元素3...};

    举例: 定义存储1,2,3,4,5整数的数组容器 int[] arr = {1,2,3,4,5};

    数组定义格式详解:

    数组存储的数据类型: 创建的数组容器可以存储什么数据类型。
    [] : 表示数组。
    数组名字:为定义的数组起个变量名,满足标识符规范,可以使用名字操作数组
    new:关键字,创建数组使用的关键字。
    数组存储的数据类型: 创建的数组容器可以存储什么数据类型。
    [长度]:数组的长度,表示数组容器中可以存储多少个元素。
    注意:数组有定长特性,长度一旦指定,不可更改。 和水杯道理相同,买了一个2升的水杯,总容量就是2升,不能多也不能少。

    4、数组的访问

    索引:从0开始,索引 (index)可以访问到数组中的元素。

    格式数组名[索引]

    数组长度属性: 数组长度是固定的,由于索引从0开始,所以数组的最大索引值为数组名.length-1

    public static void main(String[] args) { 
    int[] arr = new int[]{1,2,3,4,5}; 
    //打印数组的属性,输出结果是5 
    System.out.println(arr.length); 
    }
    

    5、什么是内存

    在讲数组的原理内存前,必须了解的一个叫内存的概念。

    内存是计算机中的重要原件,临时存储区域,作用是运行程序。我们编写的程序是存放在硬盘中的,在硬盘中的程 序是不会运行的,必须放进内存中才能运行,运行完毕后会清空内存。 Java虚拟机要运行程序,必须要对内存进行空间的分配和管理。

    5.1 Java虚拟机的内存划分

    为了提高运算效率,就对空间进行了不同区域的划分,因为每一片区域都有特定的处理数据方式和内存管理方式。
    在这里插入图片描述

    5.2 数组在内存中的存储

    5.2.1 一个数组内存图
    public static void main(String[] args) { 
    	int[] arr = new int[3]; 
    	System.out.println(arr);//[I@5f150435 
    	}
    

    以上方法执行,输出的结果是[I@5f150435,这个是什么呢?是数组在内存中的地址。new出来的内容,都是在堆内存中存储的,而方法中的变量arr保存的是数组的地址。

    输出arr[0],就会输出arr保存的内存地址中数组中0索引上的元素,如没有具体确定值,则是类型的默认值!比如:

     String[] arr=new String[3];
       System.out.println(arr);     //  [Ljava.lang.String;@1b6d3586
       System.out.println(arr[0]);  //  null
       
     int[] arrInt=new int[3];
       System.out.println(arrInt);    // [I@1b6d3586
       System.out.println(arrInt[0]); // 0
    

    在这里插入图片描述

    5.2.2两个数组内存图
     public static void main(String[] args) { 
    	 int[] arr = new int[3]; 
    	 int[] arr2 = new int[2]; 
    	 System.out.println(arr); 
    	 System.out.println(arr2); 
     }
    

    在这里插入图片描述

    5.2.3 两个变量指向一个数组
     public static void main(String[] args) { 
    	 // 定义数组,存储3个元素 
    	 int[] arr = new int[3]; 
    	 //数组索引进行赋值 
    	 arr[0] = 5; 
    	 arr[1] = 6; 
    	 arr[2] = 7; 
    	 //输出3个索引上的元素值 
    	 System.out.println(arr[0]);
    	 System.out.println(arr[1]); 
    	 System.out.println(arr[2]); 
    	 //定义数组变量arr2,将arr的地址赋值给arr2 
    	 int[] arr2 = arr; 
    	 arr2[1] = 9; 
    	 System.out.println(arr[1]); 
     }
    

    在这里插入图片描述

    6、数组常见的异常

    数组常见的异常主要有数组越界异常以及空指针异常,这是非常基础的,就不多做介绍了,这里主要分析下空指针异常在内存的情况
    在这里插入图片描述

    7、 数组遍历【重点】

    所谓数组遍历 就是将数组中的每个元素分别获取出来,就是遍历。遍历数组非常重要!!!

     public static void main(String[] args) { 
    	 int[] arr = { 1, 2, 3, 4, 5 }; 
    	 System.out.println(arr[0]); 
    	 System.out.println(arr[1]); 
    	 System.out.println(arr[2]); 
    	 System.out.println(arr[3]); 
    	 System.out.println(arr[4]); 
    	 } 
    

    以上代码是可以将数组中每个元素全部遍历出来,但是如果数组元素非常多,我把这种方式叫做傻瓜式遍历,这种傻瓜式写法肯定不行,因此我们需要改 造成循环的写法。数组的索引是 0lenght-1 ,可以作为循环的条件出现。如下

     public static void main(String[] args) { 
    	 int[] arr = { 1, 2, 3, 4, 5 }; 
    	 for (int i = 0; i < arr.length; i++) {
    	 System.out.println(arr[i])
    	    } 
    	  } 
    

    8、数组获取最大值元素

    实现思路:
    定义变量,保存数组0索引上的元素
    遍历数组,获取出数组中的每个元素
    将遍历到的元素和保存数组0索引上值的变量进行比较
    如果数组元素的值大于了变量的值,变量记录住新的值
    数组循环遍历结束,变量保存的就是数组中的最大值

    真香警告大家小心点,别被第一个和第二个婆娘给迷住了
    在这里插入图片描述
    代码如下:

    public static void main(String[] args) { 
    	int[] arr = { 5, 15, 2000, 10000, 100, 4000 }; 
    	//定义变量,保存数组中0索引的元素 
    	int max = arr[0]; 
    	//遍历数组,取出每个元素 
    	for (int i = 0; i < arr.length; i++) { 
    	//遍历到的元素和变量max比较 
    	//如果数组元素大于max 
    	if (arr[i] > max) { 
    	//max记录住大值 
    	max = arr[i]; 
        } 
      }
    System.out.println("数组最大值是: " + max);
    } 
    

    9、 数组反转

    所谓反转就是把数组元素位置颠倒过来

    实现思想:数组最远端的元素互换位置
    实现反转,就需要将数组最远端元素位置交换
    定义两个变量,保存数组的最小索引和最大索引
    两个索引上的元素交换位置 最小索引++,最大索引–,再次交换位置
    最小索引超过了最大索引,数组反转操作结束

    在这里插入图片描述

    具体代码如下

    public static void main(String[] args) { 
    	int[] arr = { 1, 2, 3, 4, 5 }; 
    	/*循环中定义变量min=0最小索引 
    	max=arr.length‐1最大索引 
    	min++,max‐‐ */ 
    	for (int min = 0, max = arr.length ‐ 1; min <= max; min++, max‐‐){
    	//利用第三方变量完成数组中的元素交换 
    	int temp = arr[min]; 
    	arr[min] = arr[max]; 
    	arr[max] = temp;
    	 }
    	// 反转后,遍历数组 
    	for (int i = 0; i < arr.length; i++) {
    	 System.out.println(arr[i])
    	 } 
     } 
    

    10、数组作为方法参数和返回值

    首先明确一点:数组作为方法的返回值,返回的是数组的内存地址

    public static void main(String[] args) {
    	 //调用方法,接收数组的返回值 
    	 //接收到的是数组的内存地址 
    	 int[] arr = getArray(); 
    	 for (int i = 0; i < arr.length; i++) { 
    	 System.out.println(arr[i])
    	    } 
    	 }
    	 /* 创建方法,返回值是数组类型创建方法,返回值是数组类型 
    	 return返回数组的地址 */
    	 public static int[] getArray() { 
    	 int[] arr = { 1, 3, 5, 7, 9 };
    	  //返回数组的地址,返回到调用者
         return arr; 
       }
    

    在这里插入图片描述

    11、方法的参数类型区别

    方法的参数为基本类型时,传递的是数据值. 方法的参数为引用类型时,传递的是地址值.

    分析下列程序代码,计算输出结果。

     public static void main(String[] args) { 
    	 int a = 1; int b = 2; 
    	 System.out.println(a); 
    	 System.out.println(b); 
    	 change(a, b); 
    	 System.out.println(a); 
    	 System.out.println(b); 
    	 }
    	 public static void change(int a, int b) { 
    	 a = a + b; b = b + a; 
     } 
    
    1. 分析下列程序代码,计算输出结果。
    public static void main(String[] args) { 
    	int[] arr = {1,3,5}; 
    	System.out.println(arr[0]); 
    	change(arr); 
    	System.out.println(arr[0]); 
    }
    	
    	public static void change(int[] arr) {
    	arr[0] = 200; 
       }
    

    总结: 方法的参数为基本类型时,传递的是数据值. 方法的参数为引用类型时,传递的是地址值.

    相信各位同学已经将上面的代码copy到eclipse或者idea中运行了,是不是结果很意外?而且对下面的总结不是很理解?这位童靴,我估计你可能是忽略了这一点:数组是引用类型,数组本身元素类型没有影响的,就像数组元素全是int,数组依旧是引用类型,哈哈,小白同学真可爱 中枪了咩,中枪的话点个赞呗支持支持下,关注楼主,楼主带你学java,关注楼主不迷路hhhhh

    展开全文
  • java 数组中插入元素How to add elements to an array in java? We know that java array size is fixed, so we can’t add elements to an Array. We have to provide size of the array when we initialize array ...
  • Java数组的定义方式有哪几种

    千次阅读 2019-09-09 17:30:27
    今天动力节点java培训机构小编为大家分享Java数组的定义方式有哪几种,希望通过此文,大家能够熟知java数组的定义方式,下面就是小编一起看看Java数组的定义方式有哪几种呢? Java数组定义方式一  动态方式...
  • java的自带类库中有求和的方法吗?为啥没有搜索到此方法了,如果有希望告诉我
  • 本篇文章主要介绍了Java实现数组反转翻转的方法实例,详细的介绍了3种实现方法,有兴趣的可以了解一下。
  • 主要介绍了java检查数组是否有重复元素的方法,涉及java针对数组元素的操作技巧,具有一定参考借鉴价值,需要的朋友可以参考下
  • Java 数组的输入输出

    万次阅读 多人点赞 2017-03-02 12:01:01
    Java中要对控制台进行输入操作的话要调用Scanner类,定义一个扫描的对象,例://要导入java.util.Scanner; Scanner scanner = new Scanner(System.in);这样便打开了输入流,接下来定义数组:int[] n = new int[4];//...
  • java 数组的合并

    2010-06-18 16:44:23
    java 数组的合并 java 数组的合并 java 数组的合并
  • java数组的存储方式

    千次阅读 2020-07-25 09:48:09
    java数组在内存中的存储方式 数组的引用存在栈中,而数组中的元素都存储在堆中。数组作为一种容器,它在堆中所被分配的是一段连续的空间。用来存放元素,这段连续的空间每一个空间都有下标,下标是连续的对应的! ...
  • JAVA数组实现学生成绩统计

    千次阅读 多人点赞 2019-09-28 17:29:36
    数组实现学生成绩统计 二、项目描述 1.项目简介: 由用户输入学生人数与名字,并定义当前学期课程数与课程名,并分别录入每位学生每门课程成绩,系统显示输入每位学生每门课程成绩,并显示学生的总分与平均分。 2....
  • 如何优雅地打印Java数组

    万次阅读 多人点赞 2019-12-26 12:54:43
    在逛 Stack Overflow 的时候,发现了一些访问量像‎安第斯山一样高的问题,比如说这个:打印 Java 数组最优雅的方式是什么?访问量足足有 220W+,想不到啊,这么简单的问题竟然有这么多程序员被困扰过。 来回顾一下...
  • JAVA数组去重方法

    千次阅读 2020-09-14 19:50:20
    记录JAVA数组去重方法 1利用Set的特性去重复 Set set = new HasSet(); for (int x=0 ; x<arr.length ; x++){ set.add(arr[x]); } 最后set里面的值就是arr数组去重后的所有元素,但是set中数据是无序的,...
  • java数组中删除元素或一个数组元素

    千次阅读 2020-03-13 17:55:47
    java数组中删除元素或一个数组元素删除数组中单个元素删除数组中多个元素(数组表示) 这里直接介绍两种情况: 1、删除数组中单个元素 2、删除数组中多个元素(数组表示) 删除数组中单个元素 1、 新建一个数组, 将...
  • Java 数组的复制

    千次阅读 2020-07-02 15:34:28
    1、数组复制:Arrays.copyOf(原数组,新数组的长度); 注意: 该方法是创建新数组然后将原数组的值复制到新数组的过程。 如果新数组的长度小于原数组的长度,则复制到原数组该长度的位置; 如果新数组的长度大于原...
  • Java 数组元素的删除

    万次阅读 多人点赞 2019-05-28 10:17:15
    Java数组的长度固定,因此无法直接删除数组中的元素。 通过创建新的数组,将保留的原数组中的元素赋值到新数组来实现原数组元素的删除。同理,可以实现数组添加元素。 package package1; import java.util....
  • java 数组求和计算

    2010-06-18 16:44:52
    java 数组求和计算 java 数组求和计算 java 数组求和计算
  • Java数组的定义及常用方法

    万次阅读 2021-01-23 16:14:24
    数组:一组相同类型的数据集合,长度固定 方式1: 先声明数组(定义数组):尚未开辟内存空间 再创建数组:在内存中,根据数组长度,开辟一块"连续"的内存空间,并完成初始化(默认值) 数据类型 默认值 整数 0 ...
  • JAVA数组复制、截取

    千次阅读 2020-06-28 19:56:32
    将指定数组original,从下标from开始复制,复制到下标to,返回一个新的数组T[] 示例: File[] fileArray = file.listFiles(); File[] newFileArray = Arrays.copyOfRange(fileArray, 0, 10); ...
  • JAVA数组的3种赋值方式

    万次阅读 2021-02-23 17:41:02
    基本数据类型数组的3种赋值方式 第一种赋值方式 int[] arr = {1,2,3}; 第二种赋值方式 int[] arr2 = new int[]{1,2,3}; 第三种赋值方式 int[] arr3 = new int[3]; arr3[0] = 1; arr3[1] = 2; arr3[2] = 3;
  • Java数组之一维数值数组之成绩统计

    千次阅读 2020-11-26 17:35:01
    Java数组之一维数值数组Java数组之一维数值数组之成绩统计一维数组声明一维数值数组变量创建一维数值数组一维数组初始化一维数组元素的使用一维数组长度成绩统计 Java数组之一维数值数组之成绩统计 一维数组 数组...
  • JAVA数组值传递问题

    千次阅读 2019-05-12 15:01:43
    有关java的问题” main方法是static修饰的,说明直接使用Hello类调用即可. 在底层是JVM通过Hello.main(new String[]{}); main方法的String数组参数,其实是暴露给程序运行者的,用于给程序传递一个数据信息. ...
  • JAVA 数组分割为多个数组

    万次阅读 2019-07-02 13:06:12
    * 分隔数组 根据段数分段 <多出部分在最后一个数组> * * @param data 被分隔的数组 * @param segments 需要分隔的段数 * @return */ public List<List<T>> subListBySegment(List<...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,557,433
精华内容 622,973
关键字:

java数组

java 订阅