精华内容
下载资源
问答
  • Java中数组定义使用(一)

    万次阅读 多人点赞 2018-09-01 00:05:13
    如果说现在要求你定义100个整型变量,那么如果按照之前的做法,可能现在定义的的结构如下: int i1, i2, i3, ... i100; 但是这儿时候如果按照此类方式定义就会非常麻烦,...

    数组的基本概念

    如果说现在要求你定义100个整型变量,那么如果按照之前的做法,可能现在定义的的结构如下:

    int i1, i2, i3, ... i100;
    

    但是这个时候如果按照此类方式定义就会非常麻烦,因为这些变量彼此之间没有任何的关联,也就是说如果现在突然再有一个要求,要求你输出这100个变量的内容,意味着你要编写System.out.println()语句100次。

    其实所谓的数组指的就是一组相关类型的变量集合,并且这些变量可以按照统一的方式进行操作。数组本身属于引用数据类型,那么既然是引用数据类型,这里面实际又会牵扯到内存分配,而数组的定义语法有如下两类。

    • 数组动态初始化:
      • 声明并开辟数组:
        • 数据类型 [] 数组名称 = new 数据类型[长度];
        • 数据类型 [] 数组名称 = new 数据类型[长度];
      • 分布进行数组空间开辟(实例化)
        | Tables | Are |
        | ------------- |:-------------?
        | 声明数组: | 数组类型 数组名称[] = null; | | | 数组类型 [] 数组名称 =null; | | 开辟数组空间: | 数组名称 =new` 数组类型[长度]; |

    那么当数组开辟空间之后,就可以采用如下的方式的操作:

    • 数组的访问通过索引完成,即:“数组名称[索引]”,但是需要注意的是,数组的索引从0开始,所以索引的范围就是0 ~ 数组长度-1,例如开辟了3个空间的数组,所以可以使用的索引是:0,1,2,如果此时访问的时候超过了数组的索引范围,会产生java.lang.ArrayIndexOutOfBoundsException 异常信息;
    • 当我们数组采用动态初始化开辟空间后,数组里面的每一个元素都是该数组对应数据类型的默认值;
    • 数组本身是一个有序的集合操作,所以对于数组的内容操作往往会采用循环的模式完成,数组是一个有限的数据集合,所以应该使用 for 循环。
    • Java 中提供有一种动态取得数组长度的方式:数组名称.length;

    范例: 定义一个int型数组

    public class ArrayDemo {
    	public static void main(String args[]) {
    		int data[] = new int[3]; /*开辟了一个长度为3的数组*/
    		data[0] = 10; // 第一个元素
    		data[1] = 20; // 第二个元素
    		data[2] = 30; // 第三个元素
    		for(int x = 0; x < data.length; x++) {
    			System.out.println(data[x]); //通过循环控制索引
    		}
    	}
    }
    

    数组本身除了声明并开辟空间之外还有另外一种开辟模式。

    范例: 采用分步的模式开辟数组空间

    public class ArrayDemo {
    	public static void main(String args[]) {
    		int data[] = null; 
    		data = new int[3]; /*开辟了一个长度为3的数组*/
    		data[0] = 10; // 第一个元素
    		data[1] = 20; // 第二个元素
    		data[2] = 30; // 第三个元素
    		for(int x = 0; x < data.length; x++) {
    			System.out.println(data[x]); //通过循环控制索引
    		}
    	}
    }
    

    但是千万要记住,数组属于引用数据类型,所以在数组使用之前一定要开辟控件(实例化),如果使用了没有开辟空间的数组,则一定会出现 NullPointerException 异常信息:

    public class ArrayDemo {
    	public static void main(String args[]) {
    		int data[] = null; 
    		System.out.println(data[x]);
    	}
    }
    

    这一原则和之前讲解的对象是完全相同的。

    数组在开发之中一定会使用,但是像上面的操作很少。在以后的实际开发之中,会更多的使用数组概念,而直接使用,99%情况下都只是做一个 for 循环输出。

    数组引用传递

    既然数组属于引用数据类型,那么也一定可以发生引用传递。在这之前首先来研究一下数组的空间开辟。

    范例: 观察一道程序

    public class ArrayDemo {
    	public static void main(String args[]) {
    		int data[] = null;
    		data = new int[3]; //开辟一个长度为3的数组
    		data[0] = 10;
    		data[1] = 20;
    		data[2] = 30;
    	}
    }
    

    新建数组变量

    那么既然说到了引用数据类型了,就一定可以发生引用传递,而现在的引用传递的本质也一定是:同一块堆内存空间可以被不同的栈内存所指向。

    范例: 定义一个程序

    public class ArrayDemo {
    	public static void main(String args[]) {
    		int data[] = null;
    		data = new int[3]; //开辟一个长度为3的数组
    		int temp[] = null; //声明对象
    		data[0] = 10;
    		data[1] = 20;
    		data[2] = 30;
    		temp = data;  //int temp[] = data;
    		temp[0] = 99;
    		for(int i = 0; i < temp.length; i++) {
    			System.out.println(data[i]);
    		}
    	}
    }
    

    这里写图片描述

    引用传递分析都是一个套路。同一块堆内存被不同的栈内存所指向。

    数组静态初始化

    在之前所进行的数组定义都有一个明显特点:数组先开辟内存空间,而后再使用索引进行内容的设置,实际上这种做法都叫做动态初始化,而如果希望数组在定义的时候可以同时出现设置内容,那么就可以采用静态初始化完成。

    数组的静态初始化一共分为以下两种类型:

    Tables Are
    简化格式: 数据类型 数组名称 = {值, 值,…}
    完整格式: 数据类型 数组名称 = new 数据类型[] {值, 值,…}

    范例: 采用静态初始化定义数组

    public class ArrayDemo {
    	public static void main(String args[]) {
    		int data[] = {1, 2, 4, 545, 11, 32, 13131, 4444};
    		for(int i = 0; i < data.length; i++) {
    			System.out.println(data[i]);
    		}
    	}
    }
    

    在开发之中,对于静态数组的初始化强烈建议使用完整语法模式,这样可以轻松地使用匿名数组这一概念。

    public class ArrayDemo {
    	public static void main(String args[]) {
    		System.out.println(new int[] {1, 2, 4, 545, 11, 32, 13131, 4444}.length);
    	}
    }
    

    以后使用静态方式定义数组的时候一定要写上完整格式。

    数组最大的缺陷:长度固定。

    二维数组

    在之前所使用的数组发现只需要一个索引就可以进行访问,那么这样的数组实际上非常像一个数据行的概念。

    索引 0 1 2 3 4 5 6 7 8
    内容 12 23 44 56 90 445 49 99 1010

    现在痛过一个索引就可以取得唯一的一个记录。所以这样的数组可以简单理解为一维数组,而二维数组本质上指的是行列集合,也如果要确定某一个数据需要行索引和列索引来进行定位。

    索引 0 1 2 3 4 5 6 7 8
    0 12 23 44 56 90 445 49 99 1010
    1 2 3 41 56 9 45 49 99 10

    如果要想确定一个数据则数据使用的结构是“数组名称[行索引][列索引]”,所以这样的结构就是一个表的结构。

    那么对二维数组的定义有两种声明形式:

    • 数组的动态初始化:数据类型 对象数组[][] = new 数据类型[行个数][列个数];
    • 数组的静态初始化:数据类型 对象数组[][] = new 数据类型[行个数][列个数]{{值, 值,…}, {值, 值,…},…};

    数组的数组就是二维数组。

    范例: 定义一个二维数组

    public class ArrayDemo {
    	public static void main(String args[]) {
    		//此时的数组并不是一个等列数组
    		int data[][] = new int[][] {
    			{1, 2, 3}, {4, 5}, {6, 7, 8, 9}};
    		//如果在进行输出的时候一定要使用双重循环,
    		//外部的循环控制输出的行数,而内部的循环控制输出列数
    		for(int i = 0; i < data.length; i++) {
    			for(int j = 0; j < data[i].length; j++) {
    				System.out.print("data[" + i + "][" + j + "]=" + data[i][j] + "、");
    			}
    			System.out.println();
    		}
    	}
    }
    

    由于输出麻烦,所以可以忽略了,在进行开发之中,出现二位数组的几率并不高。

    展开全文
  • 一维数组和二维数组定义及用法

    万次阅读 2018-06-08 19:03:01
    一维数组定义 类型说明符 数组名 [常量表达式]; 此说明:常量表达式必须是常量和常量符号。...数组必须先定义在使用,可以通过引用数组元素方式使用数组中的元素,如arr[0]就是访问的数组的第...

    一维数组的定义

    类型说明符  数组名 [常量表达式];

    在此说明:常量表达式必须是常量和常量符号。常量表达式定义了数组的长度。在宏定义中#define定义一个符号常量,则这个符号常量可以用来声明数组的个数

    #define n=9

    .....

    int arr[n];

     

    一维数组的引用

    数组必须先定义在使用,可以通过引用数组元素方式使用该数组中的元素,如arr[0]就是访问的数组的第一个元素。

    一维数组初始化的方式有三种

    1.完全初始化

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

    2.部分初始化,没有赋值的元素默认值为0

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

    因为这个数组有留个元素,前三个分别赋值为1,2,3,后边没赋值他们就为0。

     

    3.不指定数组长度,系统会根据元素个数定义数组的长度。

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

    注意事项:

    1.数组名不能和其他变量名相同如下:

    int a;

    int a[];

    2.[]里面一定为常量表达式,常量表达式可以是整型常量,整形符号常量和整形常量表达式

     

    3.避免数组越界。数组元素个数不能超过给定的值。

     

    4.给数组赋值只能逐个赋值,不能整体赋值。

     

    二维数组的定义

    类型说明符  数组名 [常量表达式1] [常量表达式2];

            int arr[n][m];//定义了一个n行m列的数组

    二维数组的引用

    与一维数组引用的方式一样都是通过引用数组下标的方式引用的。如arr[0][0],arr[0][1]

     

    二维数组初始化方法

    1.安行连续赋值,即将所有的数据写在一个大括号内,按照元素排列顺序对元素赋值。

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

    2.给所有元素赋初值时,可以省略行标,但列标一定不能省略。

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

    3.按行分段赋值,可以分行给数组元素赋值

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

     

    4.也可以直接对元素赋值

           int a[2][2]

              a[0][0] = 1;

              a[0][1] = 2;

     

     

    字符数组的定义

    char   数组名 [常量表达式];

                 char arr[5];

     

    字符数组的引用

    与其他数组引用方式相同,也是通过下标访问的。如arr[0]='a';\

     

    字符数组的初始化:

    1.逐个把字符赋给字符数组

    char arr[5] = {'a','b','c','d','e'};

     

    2.如果在定义字符数组长度时进行初始化,可以省略数组长度

    char arr[] = {'a','b','c','d','e'};

     

    3.利用字符串给字符数组赋值。

    char arr[] = {"hello"};

    或者将{}去掉

    char arr[5] = "hello";

     

    注意字符数组的结束标志为'\0'。

    字符数组的输入输出方式

    1."%c",实现的是单个字符的输入和输出

    int main(void)

    {

            char arr[] = { 'a', 'b', 'c', 'd', 'e' };

            int i = 0;

            int sz = sizeof(arr) / sizeof(arr[0]);

            for (i = 0; i < sz; i++)

            {

                   printf("%c ", arr[i]);

            }

            system("pause");

            return 0;

    }

    2."%s",实现的是字符串的输入和输出。

     

    int main(void)

    {

            char arr[] = "hello";

            int i = 0;

            printf("%s ", arr);

            system("pause");

            return 0;

    }

     

     

     

     

     

     

     

     

    展开全文
  • java数组定义使用

    万次阅读 2012-11-04 17:41:20
    java数组定义使用 3.1数组 数组是一组相关数据的集合,数组按照使用可以分为一维数组、二维数组、多维数组 有点: 不使用数组定义100个整形变量:int1,int2,int3;;;;;; 使用数组定义 int i[100] ...
    java数组定义及使用

    3.1数组

    数组是一组相关数据的集合,数组按照使用可以分为一维数组、二维数组、多维数组

    有点:
    不使用数组定义100个整形变量:int1,int2,int3;;;;;;
    使用数组定义 int i[100]


    数组定义:int i[100],只是一个伪代码,只能表示含义的。


    3.2一维数组

    可以存放上千万个数据,并且这些数据的类型是完全是相同的。

    要使用java的数组,必须经过两个步骤:(1)声明数组,(2)分配内容给该数组,这两个步骤的语法如下:



    声明形式一:

    ◇声明一维数组: 数据类型 数组名[] = null;
    ◇分配内存给数组:数组名 = 买受人数据类型[长度]

    声明形式二:
    ◇声明一维数组: 数据类型[]  数组名  = null;

    public class ArrayDemo01{
        public static void main(String args[]){
            int score[] = null;    //声明数组
            score = new int[3];    //为数组开辟空间
        }
    }


    变量的命名规则: 第一个单词的首字母小写,之后的每个单词的首字母大写:studentName;

    详细解释:

    "
    栈堆
    int score[] = null ;  ->null 表示引用数据类型的默认值
    int score[];   此时score尚未指向具体的空间,所以score内容未知,无法直接使用。
    为数组开辟空间
    score = new int[3];
    栈内存
    堆内存
    "

    验证只开辟空间却不赋值时数组默认值是多少?

    public class ArrayDemo01{
        public static void main(String args[]){
            int score[] = null;    //声明数组
            score = new int[3];    //为数组开辟空间
            System.out.println("score[0] = " + score[0]);
            System.out.println("score[1] = " + score[1]);
            System.out.println("score[2] = " + score[2]);
        }
    }


    错误显示:

    public class ArrayDemo01{
        public static void main(String args[]){
            int score[] = null;    //声明数组
            System.out.println("score[0] = " + score[0]);
            System.out.println("score[1] = " + score[1]);
            System.out.println("score[2] = " + score[2]);
        }
    }




    如果删除score = new int[3];时显示结果将如下:
    Exception int thread "main"  java.lang.NullPointerException
        at ArrayDemo01.main<ArrayDemo01.java:5>


    一个堆内存可以被多个栈内存空间使用。

    下面使用一个步骤一次性完成:
    即:
    声明数组的同时分配内存空间

    数据类型 数组名[] = new 数据类型[个数]

    int score[] = new int[10];

    数组中元素的表示方法:

    想要访问数组里的元素,可以利用索引来完成。
    数组的访问也可通过循环方式进行操作中,循环操作的时候只需要改变期索引[下标]即可。

    public class ArrayDemo01{
        public static void main(String args[]){
            int score[] = null;    //声明数组
            score = new int[3];    //为数组开辟空间
            System.out.println("score[0] = " + score[0]);
            System.out.println("score[1] = " + score[1]);
            System.out.println("score[2] = " + score[2]);
            for(int x=0;x<3;x++){
                System.out.println("score["+x+"] = " + score[x]);    
            }
        }
    }




    访问注意:


    假设程序中取出的内容超过了这个下标,如"score[3]",则的程序运行的时候会出现以下的错误提示:
    java.lang.ArrayIndexOutOfBoundsException:3

    public class ArrayDemo01{
        public static void main(String args[]){
            int score[] = null;    //声明数组
            score = new int[3];    //为数组开辟空间
            System.out.println("score[0] = " + score[0]);
            System.out.println("score[1] = " + score[1]);
            System.out.println("score[2] = " + score[2]);
            for(int x=0;x<3;x++){
                System.out.println("score["+x+"] = " + score[x]);    
            }
            System.out.println("score[3] = " + score[3]);
        }
    }



    Excepiton  in thread "main"  java.lang.ArrayIndexOutOf BoundException : 3
            at ArrayDemo01.main<ArrayDemo01.java:11>



    数组索引超出绑定,就是表示数组越界。


    数组中默认的内容都是0,也可以通过下标的方式为数组中的内容赋值。


    public class ArrayDemo02{
        public static void main(String args[]){
            int score[] = null;    //声明数组
            score = new int[3];    //为数组开辟空间
    
            for(int x=0;x<3;x++){     //为每个元素赋值
                score[x] = x*2+1;   //每一个值都是奇数
            }
    
            for(int x=0;x<3;x++){
                System.out.println("score["+x+"] = " + score[x]);    
            }
        }
    }





    取得数组的长度
    可以使用“数组名称.length”来完成操作。


    public class ArrayDemo03{
        public static void main(String args[]){
            int score[] = null;
            score = new int[3];
            System.out.println("数组长度为:" + score.length);    
        }
    
    }




    3.3数组的静态初始化

    之前所看到的数组,所采用的方式都是动态初始化,即:所有的内容在数组声明的时候并不具体的制定,而都是以默认值的形式以出现。
    静态初始化就是指在数组定义之后,直接制定好期内容。




    操作格式:
    数据类型 数组名[] = {初值0,初值1,....,初值n}

    public class ArrayDemo04{
        public static void main(String args[]){
            int score[] = {91,92,93,94,95,96};        //使用静态初始化的方式初始数组。
            for(int x=0;x<score.length;x++){        //循环输出
                System.out.println("score["+x+"] = " + score[x]);
            }
        }
    }



    3.4观察两道范例:
    3.4.1求出最大和最小值:

    给出一个数组求出最大值和最小值

    public class ArrayDemo05{
        public static void main(String args[]){
            int score[] = {67,89,87,69,90,100,75,90};  //静态初始化数组
            int max = 0;
            int min = 0;
            max = main = score[0] ;                   //把第一个元素的内容赋值给max和min
            for(int x = 0;x<score.length;x++){        //循环求出最大值和最小值
                if(score[x]>max){
                    max = score[x];
                }
                if(score[x]<min){
                
                    min = score[x];
                }
            }
            System.out.println("最高成绩:" + max);
            System.out.println("最低成绩:" + min);
        }
    }



    3.4.2排序

    在数组中,排序是一个比较常见的算法。
    通过一个简单的范例,来了解排序的基本操作。

    public class ArrayDemo06{
        public static void main(String args[]){
            int score[] = {67,89,87,69,90,100,75,90};
            for(int i=0;i<score.length;i++){
                for(int j=0;j<score.length;j++){
                    if(score[i]<score[j]){            //交换位置,这里关系到到底是从大到小还是从小到大!
                        int temp = score[i];            //中间变量
                        score[i] = score[j];
                        score[j] = temp;
                    }
                }
            }
            for(int j=0;j<score.length;j++){            //循环输出
                System.out.print(score[j]+"\t");
            }
        }
    }



    为了让大家可以更好的观察到每次的执行,下面在每次排序的时候都输出原始内容。



    public class ArrayDemo07{
        public static void main(String args[]){
            int score[] = {67,89,87,69,90,100,75,90};
            for(int i=0;i<score.length;i++){
                for(int j=0;j<score.length;j++){
                    if(score[i]<score[j]){            //交换位置,这里关系到到底是从大到小还是从小到大!
                        int temp = score[i];            //中间变量
                        score[i] = score[j];
                        score[j] = temp;
                    }
                }
                System.out.println("第" + i +"次排序的结果:\t");
                for(int j=0;j<score.length;j++){
                    System.out.print(score[j]+"\t");
                }
                System.out.println("");
            }
            for(int i=0;i<score.length;i++){            //循环输出
                System.out.print(score[i]+"\t");
            }
        }
    }



    冒泡排序,自己观察运行的过程,来分析代码是如何操作的.

    3.5二维数组


    二维数组的声明方式和一维数组类似,内存的分配也是一样是用new这个关键字。
    其声明与分配内存的格式如下所示:
    1.动太初始化:
    数据类型 数组名[][]
    数组名 = new 数据类型[行的个数][列的个数];
    2.声明加初始化
    数据类型  数组名[][] = new 数据类型[行的个数][列的个数]
    3.二维数组静态初始化
    数据类型 数组名[][] = {{第0行初值},{第0行初值},.....{第n行初值}}


    如:
    int score[][] = null;        //生命
    score = new int[3][4];    //分配空间

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


    public  class ArrayDemo08{
        public static void main(String args[]){
            int score[][] = new int[4][3];                //声明并实例化二维数组
    
            score[0][1] = 30;
            score[1][1] = 30;
            score[2][2] = 30;
            score[3][1] = 30;
            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();                    //换行
            }
        }
    }





    public class ArrayDemo09{
        public static void main(String args[]){
            int score[][] = {{67,61},{78,61,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.println(score[i][j] + "\t");
                }
                System.out.println("");
            }
        }
    }




    3.6多维数组

    三维数组的声明为int score[][][],而四维数组为int  score[][][][].....,以此类推


    public class ArrayDemo10{
        public static void main(String args[]){
            int score[][] = {
            {
                {5,1},{6,7}
            },
            {
                {9,4},{8,3}
            }
            };            //静态初始化完成,每行的数组元素个数不一样
        
            for(int i=0;i<score.length;i++){
                for(int j=0;j<score[i].length;j++){
                    for(int k=0;k<score[i][j].length;k++){
                    System.out.println("score[" + i + "]["+ j +"]["+ k +"] = " + score[i][j][k] + "\t");
                    }
                }
                System.out.println("");
            }
        }
    }


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

    千次阅读 多人点赞 2019-10-04 22:17:30
    文章目录1、什么是容器2、什么是数组3、数组的三种定义定义方式一定义方式二定义方式三数组定义格式详解:4、数组的访问5、什么是内存5.1 Java虚拟机的内存划分5.2 数组内存中的存储5.2.1 一个数组内存图5.2.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

    展开全文
  • 一维数组定义: //动态初始化 int []a;... //a,b这种定义方式必须在使用前给a,b声明长度,否则编译会出问题: //(The local variable a may not have been initialized)。 //静态初始化 ...
  • go语言结构体数组定义 介绍 (Introduction) Building abstractions around concrete details is the greatest tool that a programming language can give to a developer. Structs allow Go developers to describe...
  • 数组定义使用

    千次阅读 2018-01-14 19:24:33
    使用数组定义100个整形变量:int i1;int i2;int i3 使用数组定义 int i[100]; 数组定义:int i[100];只是一个伪代码,只是表示含义的 一维数组 一维数组可以存放上千万个数据,并且这些数据的
  • JQ数组操作(定义一个数组,给数组赋值)

    万次阅读 多人点赞 2016-07-14 13:36:33
    JQ数组操作(定义一个数组,给数组赋值)1、JS定义一个数组:(1)、var select=[]; (2)、var select=new Array();2、JS给一个数组赋值:(1)、select.push(); 具体详解: js中添加数组用push.示例如下: var arr = []; ...
  • js多维数组和hash数组定义使用

    千次阅读 2014-03-27 18:27:36
    多维数组定义 定义数组数组对象用来单独的变量名中存储一系列的值。使用关键词 new 来创建数组对象。 一维数组定义 var myArray=new Array('a','b','c'); 或 var myArray = []; 二维数组及多维数组...
  • java定义对象数组及其使用

    千次阅读 2019-10-06 18:19:29
    定义一个student类,主类中定义一个student数组stu[10];需要对每个对象stu[i]都new Student(); public class Student { int number; } public class Example4_21 { public static void main(String[] args){ ...
  • 使用malloc动态定义数组

    千次阅读 2016-03-29 19:30:25
     因为要求int array[n]括号里的n必须为常量,于是天真的认为在定义n的时候写上一个const int n就可以解决问题了,经过尝试失败。  上网一搜,有很多方法,比如使用结构,使用链表等。  下面给出一种简单的方法,...
  • 通常情况下定义数组都是顶一个什么类型的数组然后下标或者脚标就是从0开始++++int array[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};但是用0-N这种整形数字做下标可读性非常不高,如果这个数组里保存的数据比较复杂,...
  • oracle数组定义使用

    万次阅读 2013-07-04 11:00:09
    定义固定长度的一维数组 type type_array is varray(10) of varchar2(20);1、varray(10)表示定义长度为10的数组 2、varchar2(20)表示数组为字符型,且元素字符串长度不超过20 定义可变长度的一维数组 type type_...
  • 数组定义使用

    千次阅读 2018-07-26 16:00:15
    一、基本概念 数组指的就是一组相关变量的集合。例如:如果现在要想定义100个整型变量,如果按照传统的思路: int i1,i2,……i100,一共写100个变量。...数组定义语法如下: · 声明并开辟数组:数据类型...
  • java中的数组定义使用

    千次阅读 2016-05-07 09:15:44
    使用数组定义100个整形变量:int i1;int i2;int i3 使用数组定义 int i[100]; 数组定义:int i[100];只是一个伪代码,只是表示含义的 一维数组 一维数组可以存放上千万个数据,并且这些数据的类型是完
  • C语言数组定义使用

    千次阅读 2020-08-27 01:55:38
    C语言数组定义使用 数组定义使用 2.从语义上说:数据的组合 code array.c #include<stdio,h> //数组作为函数的参数时被转换为指针 void display_arry(int arr[10]) { for(int i=0;i<sizeof...
  • 数组的三种定义方式

    万次阅读 多人点赞 2017-12-25 16:16:58
    1.数组定义 用于存储同一类型数据的集合,其实数组就是一个容器。 连续的存储单元 2.数组的好处 自动给数组中的元素从零开始编号。自动给下标,从零开始0-1-2-3-…… 3.书写格式 元素类型[] 数组名 = new...
  • JAVA中一维数组和二维数组定义

    万次阅读 多人点赞 2008-12-30 15:28:00
    java中数组被看成是一个对象在定义数组时,有两种定义方法:int[] a 和...总的原则:任何对象被调用之前必须先被初始化!1 一维数组定义 //定义包含三个元素的一维数组 //方法1,new对象,然后再初始化每个元
  • Java中数组定义使用

    万次阅读 多人点赞 2018-06-02 00:40:03
    如果希望保存一组有相同类型的数,可以使用数组。...与C、C++不同,Java在定义数组时并不为数组元素分配内存空间,因此[]中无需指定数组元素的个数,也就是数组长度。所以我们需要分配内存空间,才能访问数组中的...
  • Android中定义数组使用

    万次阅读 2013-01-18 16:38:21
    Android学习中如何定义使用数组呢,请看下面的代码! 黑色 | Black 蓝色 | Blue 棕色 | Brown 绿色 | Green 灰色 | Grey 粉色 | Pink 紫色 | Purple 红色 | Red
  • Java数组定义使用

    千次阅读 多人点赞 2019-06-01 21:05:53
    一。java数组定义: ...type 为Java中的任意数据类型,包括基本类型和组合类型,arrayName为数组名,必须是一个合法的标识符,[ ] 指明该变量是一个数组类型变量。例如: int demoArray[]; int[] demoArray...
  • 定义数组1、定义一维数组data_group = []2、定义二维数组(1)定义三个数组使用时Data_groups[0][0],第一个数组第一个元素data_groups = [[]]*3这个一般不是我们想要的,运行结果如下,任意一...
  • java数组定义使用

    万次阅读 多人点赞 2018-12-04 14:20:57
    程序中常常需要使用数组,利用循环可以对数组中的数据进行批量操作,大大提高了效率,十分方便。 如何使用数组数组的声明方式: 1.数据类型 [] 数组名称 eg:int [] a; 2数据类型 数组名称...
  • Java--二维数组定义使用

    千次阅读 2017-02-14 18:55:17
    二维数组概述  二维数组格式例子:  int[][] arr = new int[3][2];  二维数组表示格式:  数据类型 数组名[][] = new 数据类型[m][n];  数据类型[] 数组名[] = new 数据类型[m][n];  int[] x,y[]; x是一维...
  • js中数组定义使用

    千次阅读 2018-03-31 23:54:13
    java 中,数组定义为一组相同类型的变量的集合。而js中,一个数组可以存放任意类型的数据。创建数组有两种类型方式:1. 使用new字段 通过 new 实例化一个数组,又分为3种方式: var arr = new Array();//...
  • 数组数组定义数组的注意事项

    千次阅读 多人点赞 2018-08-05 23:37:42
    2. 数组当中的多个数据,类型必须统一 3. 数组的长度程序运行期间不可改变 数组的初始化:内存当中创建一个数组,并且向其中赋予一些默认值。 两种常见的初始化方式: 1. 动态初始化(指定长度) 2. 静态初始...
  • 动态数组定义使用

    千次阅读 2018-07-04 10:20:32
    #include &lt;iostream&gt; #include &lt;vector&gt; //必要头文件 ... //定义动态数组 int main() { for(int i = 1;i &lt;= 200;i ++) a.push_back(i); //类似队列的数组元素插入...
  • 结构体数组定义

    千次阅读 2018-08-07 22:06:32
     结构体数组定义:具有相同结构体类型的结构体变量组成的数组  定义结构体数组的方法和定义结构体变量的方法类似。 eg: #include&lt;stdio.h&gt; #include&lt;string.h&gt; #define N 10 ...
  • 百度结果中很多写的都不是很清晰,可变长数组定义好后,如果使用此做个记录: 定义: type id_array is table of number(15) index by binary_integer; acb_ids id_array; 这个定义方式适用package,如果是...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,761,944
精华内容 704,777
关键字:

任何数组在使用前必须先定义