精华内容
下载资源
问答
  • 数组变量属引用类型,数组也可以看成是对象,数组中的每个元素相当于该对象的成员变量。 数组中的元素可以是任何数据类型,包括基本类型和引用类型。 2 一维数组的声明 一维数组的声明方式:type var[]或type[] var ...

    1 数组的概念

    • 数组可以看成是多个相同类型数据组合,对这些数据的统一管理。
    • 数组变量属引用类型,数组也可以看成是对象,数组中的每个元素相当于该对象的成员变量。
    • 数组中的元素可以是任何数据类型,包括基本类型和引用类型。

    2 一维数组的声明

    • 一维数组的声明方式:type var[]type[] var
        例如:int a1[];   int[] a2;
            double b[];
            Person[] p1; String s1[];
    • Java语言中声明数组时不能指定其长度(数组中元素的个数),例如:int a[5];//非法
    • Java中使用关键字new 创建数组对象,格式为:数组名 = new 数组元素的类型[数组元素的个数]
        public class Test {
            public static void main(String[] args){
                int[] s;
                s = new int[5];
                for (int i=0; i < 5;i++){
                    s[i] = i;
                }
            }
        }
    • 元素为引用数据类型的数组中的每一个元素都需要实例化。
      这里写图片描述

    3 一维数组的初始化

    • 动态初始化:数组定义与为数组元素分配空间和赋值的操作分开进行,先分配空间再赋值。
        public class Test {
            public static void main(String[] args){
                int[] a;
                a = new int[3];
                for (int i=0;i<3;i++){
                    a[i]=i;
                }
                Date[] day;
                day = new Date[3];
                for (int i=0;i<3;i++){
                    day[i]= new Date(2016,10,i+1);
                }
            }
        }
    
        class Date{
            int year;int month;int day;
            Date(int y,int m,int d){
                year = y; month = m; day = d;
            }
        }
    • 静态初始化:在定义数组的同时就为数组元素分配空间并赋值。
        public class Test {
            public static void main(String[] args){
                int[] a = {3,9,8};
                Date[] day = {new Date(2016,10,1),
                                     new Date(2016,10,2),new Date(2016,10,3)};
                }
            }
        }
    
        class Date{
            int year;int month;int day;
            Date(int y,int m,int d){
                year = y; month = m; day = d;
            }
        }

    4 数组元素的默认初始化
     数组是引用类型,它的元素相当于类的成员变量,因此数组分配空间后,每个元素也被按照成员变量的规则被隐式初始化。
     

        public class Test {
            public static void main(String[] args){
                int[] a = new int[5];
                Date[] days = new Date[3];
                System.out.println(a[3]);//0
                System.out.println(days[2]);//null
            }
        }
    
        class Date{
            int year;int month;int day;
            Date(int y,int m,int d){
                year = y; month = m; day = d;
            }
        }
    

     
    5 数组元素的引用

    • 定义并用运算符new为之分配空间后,才可以引用数组中的每个元素。
    • 每个数组都有一个**属性**length指明它的长度,例如a.length的值为数组a的长度(元素个数),不是方法,与String的length()做区别。

    选择排序(从小到大):遍历一次找出最小的数,放到起始位置

    int类型排序:

    public class NumSort{
        public static void main(String[] args){
            int[] a = new int[args.length];
            for (int i=0;i<args.length;i++){
                a[i]=Integer.parseInt(args[i]);
            }
            print(a);
            //selectSort(a);
            bubbleSort(a);      
            print(a);
        }
        //选择排序
        private static void selectSort(int[] a){
            int k,temp;
            for(int i=0;i<a.length;i++){
                k=i;
                for(int j=k+1;j<a.length;j++){
                    if (a[k]>a[j]){
                        k = j;
                    }
                }
                if (k!=i){
                    temp = a[i];
                    a[i] = a[k];
                    a[k] = temp;
                }
            }
        }
        //冒泡排序
        private static void bubbleSort(int[] a){
            int len=a.length;
            for(int i=len-1;i>=1;i--){
                for (int j=0;j<=i-1;j++){
                    if (a[j]>a[j+1]){
                        int temp=a[j];
                        a[j]=a[j+1];
                        a[j+1]=temp;
                    }
                }
            }
        }   
    
        private static void print(int[] a){
            for(int i=0;i<a.length;i++){
                System.out.print(a[i]+" ");
            }
            System.out.println();
        } 
    }

    运行结果:这里写图片描述

    引用对象的排序:

    public class TestDataSort{
        public static void main(String[] args){
            Date[] days = new Date[5];
            days[0] = new Date(2006,5,4);
            days[1] = new Date(2006,7,4);
            days[2] = new Date(2008,5,4);
            days[3] = new Date(2004,5,9);
            days[4] = new Date(2004,5,4);
    
            bubbleSort(days);
            //selectSort(days);
    
            for(int i=0;i<days.length;i++){
                //直接打印对象的引用会调用toString
                System.out.println(days[i]);
            }
        }
        //冒泡排序
        public static Date[] bubbleSort(Date[] a){
            int len = a.length;
            for (int i=len-1;i>=1;i--){
                for(int j=0;j<=i-1;j++){
                    //如果a[j]>a[j+1]
                    if (a[j].compare(a[j+1])>0){
                        Date temp = a[j];
                        a[j]=a[j+1];
                        a[j+1]=temp;
                    }
                }           
            }
            return a;
        }
        //选择排序
        public static Date[] selectSort(Date[] a){
            int k;
            Date temp;
            for (int i=0;i<a.length;i++){
                k=i;
                for (int j=k+1;j<a.length;j++){
                    if (a[k].compare(a[j])>0){
                        k=j;
                    }
                }
                if (k!=i){
                    temp=a[i];
                    a[i]=a[k];
                    a[k]=temp;
                }
            }
            return a;
        }
    }
    
    class Date{
        int year,month,day;
        Date(int y,int m,int d){
            year=y;
            month=m;
            day=d;
        }
        public int compare(Date date){
            return year > date.year ? 1
                        : year < date.year ? -1 
                        : month > date.month ? 1
                        : month < date.month ? -1
                        : day > date.day ? 1
                        : day < date.day ? -1:0;
        }
        //重写toString()
        public String toString(){
            return"Year:Month:Day --"+year+"-"+month+"-"+day;   
        }   
    }

    运行结果:这里写图片描述

    二分法: 找到12所在的位置

    public class TestSearch{
        public static void main(String[] args){
            //二分法一定要在排好序的前提下进行
            int a[] = {1,3,6,8,9,10,12,18,20,34};
            int i = 12;
            System.out.println(binarySearch(a,i));
        }
    
        public static int search(int[] a,int num){
            for (int i=0;i<a.length;i++){
                if(a[i] == num)
                    return i;
            }
            return -1;
        }
    
        public static int binarySearch(int[] a, int num){
            if (a.length == 0){
                return -1;          
            }
            int startPos =0;
            int endPos = a.length-1;
            int m=(startPos+endPos)/2;
            while (startPos<= endPos){
                if (num ==a[m]){
                    return m;
                }
                if (num > a[m]){
                    startPos = m+1;
                }
                if (num < a[m]){
                    endPos = m-1;
                }
                m = (startPos + endPos)/2;
            }
    
            return-1;
        }
    
    }

    6 二维数组
      二维数组可以看成以数组为元素的数组,例如:int [][] ={{1,2},{3,4,5,6},{7,8,9}};
      Java中多维数组的声明和初始化应按从高维到低维(从左到右)的顺序进行,例如: 

        int a[][] = new int[3][];
        a[0] = new int[2];
        a[1] = new int[4];
        a[2] = new int[3];
        int t1[][] = new int[][4];//非法

      这里写图片描述

      静态初始化:int A[][] = {{1,2},{2,3},{3,4,5}};

      动态初始化:   

        int a[][] = new int[3][5];
        int b[][] = new int[3][];
        b[0] = new int[2];
        b[1] = new int[3];
        b[2] = new int[5];

    例子程序:

    public class TestArray{
        public static void main(String[] args){
            int a[][]={{1,2},{3,4,5,6},{7,8,9}};
            for (int i=0;i<a.length;i++){
                for(int j=0;j<a[i].length;j++){
                    System.out.print("a["+i+"]["+j+"]=" +a[i][j]+" ");
                }
                System.out.println();
            }       
        }
    }

    运行结果:这里写图片描述

    String类型的二维数组:

    public class TestString{
        public static void main(String[] args){
            String[][] s = new String[3][];
            s[0] = new String[2];
            s[1] = new String[3];
            s[2] = new String[2];
            for (int i =0;i<s.length;i++){
                for(int j=0;j<s[i].length;j++){
                    s[i][j] =new String("我的位置是:"+i+","+j);
                }
            }
            for(int i=0;i<s.length;i++){
                for (int j=0;j<s[i].length;j++){
                    System.out.print(s[i][j]+" ");
                }
                System.out.println();
            }
        }
    }

    运行结果:这里写图片描述

      
      数组的拷贝:

    • 使用java.lang.System类的静态方法
    public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length);
    • 可以用于数组src从第srcPos项元素开始的length个元素拷贝到目标数组从destPos项开始的length个位置
    • 如果源数据数目超过目标数组边界会抛出IndexOutOfBoundsException异常。

    例子程序:

    public class TestArrayCopy{
        public static void main(String[] args){
            String[] s ={"Microsoft","IBM","Sun","Oracle","Apple"};
            String[] sBak = new String[6];
            System.arraycopy(s,0,sBak,0,s.length);
    
            for (int i=0;i<sBak.length;i++){
                System.out.print(sBak[i]+" ");
            }
    
            System.out.println();
            int[][] intArray = {{1,2},{1,2,3},{3,4}};
            int[][] intArrayBak = new int[3][];
            System.arraycopy(intArray,0,intArrayBak,0,intArray.length);
            intArrayBak[2][1] = 100;
            //虽然没有直接对intArray进行操作,但intArray[2][1]的值也会发生变化
            for(int i=0;i<intArray.length;i++){
                for(int j=0;j<intArray[i].length;j++){
                    System.out.print(intArray[i][j]+" ");
                }
                System.out.println();
            }
        }
    }

    运行结果:这里写图片描述

    展开全文
  • 通过赋初值定义二维数组的大小 第一种: 例如:int a[][3] = {{1, 2, 3}, {4, 5}, {6}, {8}}; 注意: 对于二维数组,省略只能省略第一个方括号中的常量表达式 如上的初赋值语句等同于: int a[4][3] = {{1...

    通过赋初值定义二维数组的大小

     

    第一种:

    例如:int a[][3] = {{1, 2, 3}, {4, 5}, {6}, {8}};

    注意:

           对于二维数组,省略只能省略第一个方括号中的常量表达式

    如上的初赋值语句等同于:

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

     

     

    第二种:int = c[][3] = {1, 2, 3, 4, 5};

           要计算第一个空的方括号中的值x:

         当花括号对中的个数能整除第二维的常量表达式时,整数的结果就是第一维的大小;否则,第一维的大小等于所得的结果加1。

    (即5/3 = 1 ……2, x = 1 +1 =2)

     

     

    二维数组和指针

    例如:int *p, a[3][4];

           //定义p为指针变量,a是含有12个元素的一维数组

    二维数组实际是一个一维数组,而每一个元素又是一个一维数组。

    如上述a,有三个元素a[0],a[1],a[2];而每个元素又是由四个整数元素组成的一维数组。

    通过a[0][0],a[0][1]引用,可以把a[0]看做一个整体,当做一个数组名。

    a[0]就是代表a[0][0]的地址。

    p = a[0]是合法的        p = a[0]+1 相当于&a[0][1]

     

    从基类型来看,a为具有4个整型元素的数组类型。

           注意:p = a;        //非法    p基类型只有4个字节,a基类型有4*4个字节

     

     

    二维数组取地址

           有变量i和j,它们的取值范围为0 <= I < 3 、0 <= j < 4

    那么a[i][j]的地址可以用以下五种表达形式:

    (1)&a[i][j]

    (2)a[i]+j

    (3)*(a+i)+j

    (4)&a[0][0]+4*i+j

    (5)a[0]+4*i+j

    展开全文
  • 1.数组指针:即指向数组的指针 ...2.通过指针引用数组元素的基本方法 (1)小标法:a[i]。 (2)指针法:* (a+i) 或 * (p+i) 或 p[i]。其中,a是数组名,p=a,p是指向数组元素的指针变量。 问:为什么*

    1.数组指针:即指向数组的指针
    那么, 如何声明一个数组指针呢?

    int (* p)[10]; /*括号是必须写的,不然就是指针数组;10是数组的大小*/

    拓展:有指针类型元素的数组称为指针数组。
    2.通过指针引用数组元素的基本方法
    (1)小标法:a[i]。
    (2)指针法:* (a+i) 或 * (p+i) 或 p[i]。其中,a是数组名,p=a,即p指向数组a首元素的地址。
    问:为什么* (a+i) 和* (p+i)是等价的,或者说是引用的同一个数组元素呢?
    答:在C语言中,数组名代表的是数组中首元素的地址。在程序编译时,a[i]是按*(a+i)处理的,即按数组元素的首地址加上相应位移量i找到新元素的地址。而p=a,即p是指向数组a的首元素的地址,因此是等价的。从这里可以看出,[ ]实际上是变地址运算符,即将a[i]按a+i计算地址,然后找此地址单元中的值。
    问:为什么p[i] 和* (p+i)是等价的,或者说是引用的同一个数组元素呢?
    答:C语言规定,当指针变量指向数字元素时,指针变量可以带下标。而在程序编译时,对此下标处理的方法是转换为地址,即对p[i] 处理成 (p+i)。同上,[ ]是变址运算符。
    3.利用指针引用数组元素
    (1)p++; *p;
    (2)*p++;等价于*(p++);因为++和*的优先级一样,故结合方向是从右向左。
    (3)*(p++);和*(++p);二者是有区别的。前者是先取*p的值,然后p加1;后者是先p加1,再取p的值。即如果p指向的是数组a元素a[0],则前者得到a[0]的值,后者得到a[1]的值。
    (4)++(*p);将p指向的元素的值加1。
    (5)如果p指向元素a[i],
    *(p--);先得到p指向的地址的元素a[i],然后p减1。
    *(++p);执行结果得到a[i+1],p加1。
    *(–p);执行结果得到a[i-1],p减1。

    4.利用指针输出数组元素

    int a[10];
    int * p;
    p = a;
    while(p<a+10)
    printf("%d",*p++);

    int a[10];
    int * p;
    p = a;
    while(p<a+10)
    {
       printf("%d",*p);
       p++;
    }

    int a[10];
    int * p;
    p = a;
    for(i=0;i<10;i++)
    printf("%d",*p++);

    int a[10];
    int * p;
    for(p=a;p<a+10;p++) /*比较专业的写法,代码简洁、高效*/
    printf("%d",*p);

    思考:下面代码能不能正确输出数组元素的值呢?

    int a[10];
    int * p;
    for(p=a;p<a+10;a++) 
    printf("%d",*a);

    答:是不行的。因为数组名a代表的是数组首元素的地址,是一个指针型常量,它的值在程序运行期间是不改变的,即a++是不变的。

    因此,结合动态分配数组,我们可以建立一个一维的数组指针:

    int (* array)[N]=(int *)malloc(N*sizeof(int));
    展开全文
  • 由于[]的优先级,下列先与[]结合,首先确定array为一个数组,然后&与int结合,所以array为一个数组,数组元素为int类型的引用,所以为引用数组。 int &array[]; 而下列中由于括号,array先与&结合,确定array为一...

    如何区分

    • 引用数组与数组引用
      由于[]的优先级,下列先与[]结合,首先确定array为一个数组,然后&与int结合,所以array为一个数组,数组元素为int类型的引用,所以为引用数组
      int &array[];
      而下列中由于括号,array先与&结合,确定array为一个引用,然后与[]结合,该引用指向一个数组,再然后,该数组的元素为int,所以为数组引用,即数组的引用。
      int (&array)[];

    • 指针数组与数组指针
      同样地,由于[]的高优先级,下列先与[]结合,首先确定p为一个数组,然后*与int结合,所以p为一个数组,数组元素为指向int的指针,所以为指针数组
      int *p[];
      下列,由于括号,p先与*结合,确定p为一指针,然后与[]结合,该指针指向一个数组,再然后,该数组的元素为int,所以为数组指针,即数组的指针。
      int (*p)[];

    介绍

    • 引用数组
      首先,可以明确的说明,引用的数组是不能当函数的参数的。再者要说明,这种方式是非法的。
      原因:从引用的本质而言,首先,引用必须被初始化,数组并不能被另一个数组初始化或被另一个数组赋值这是其一,并且其中的每一个引用,你没有办法给他全部初始化。其次,引用它不支持传统意义的复制,它不占用新的空间,并且,他没有意义,它可以用指针数组实现。
    • 数组引用
      数组引用必须将其维数传递,即[]中必须有常数,正确地传达信息,改变其元素,会导致数组发生变化。
    • 指针数组
      顾名思义,即数组中的每一个元素都为一指针。
    • 数组指针
      一个指向数组的指针,数组名即为一数组指针(有歧义,但作用相同),可以用指针访问数组。
    展开全文
  • //array首先向右结合,所以这个相当于 (int&)array[] array是个数组,其中的元素引用 //应该叫:引用数组 int &array[] //array首先和&结合,所以array是引用引用的对象是数组 //应该叫作数组引用 int (&...
  • 数组变量属引用类型,数组也可以看成是对象,数组中的每个元素相当于该对象的成员变量。  3. 数组中的元素可以是任何数据类型,包括基本类型和引用类型 二、一维数组的声明  1.一维数组的声明方式: type var[ ]...
  • C++数组引用引用数组

    万次阅读 2018-10-30 15:53:27
    )array[] array是个数组,其中的元素引用 //应该叫:引用数组 int &amp;array[] //array首先和&amp;结合,所以array是引用引用的对象是数组 //应该叫作数组引用 int (&amp;array...
  • 关于数组引用引用数组

    万次阅读 多人点赞 2018-04-27 23:58:36
    )array[] array是个数组,其中的元素引用 //应该叫:引用数组 int &amp;array[] //array首先和&amp;结合,所以array是引用引用的对象是数组 //应该叫作数组引用 int (&amp;array)[10] 二、引用...
  • 引用数组 数组引用 引用数组 数组引用
  • /** * 数组函数__回调处理 * 1.array_filter($arr, $callback):用回调过滤数组 * 2.array_walk(&amp;$arr, $callback($val,$key,...功能: 回调处理每个元素,仅返回结果为true的元素,默认仅值处理 * 2.参数: $a...
  • 关于数组引用引用数组

    千次阅读 2014-04-03 14:14:48
    一、大概区别 就像指针的数组和数组的指针一样...//array首先向右结合,所以这个相当于 (int&)array[] array是个数组,其中的元素引用 //应该叫:引用数组 int &array[] //array首先和&结合,所以arr
  • 使用指针访问数组元素

    万次阅读 2007-08-02 16:16:00
    C++语言中,指针和数组密切相关.... //ip points to ia[0]如果希望使指针指向数组中的另一个元素,则可使用下标操作符给某个元素定位,然后用取地址操作符&获取该元素的存储地址:ip=&ia[4]; //ip points to l
  • [C++]关于数组引用引用数组

    万次阅读 2015-10-26 12:25:17
    //array首先向右结合,所以这个相当于 (int&)array[] array是个数组,其中的元素引用 //应该叫:引用数组 int &array[] //array首先和&结合,所以array是引用引用的对象是数组 //应该叫作数组引用 int (&...
  • C语言数组引用

    2019-11-23 23:20:08
    数组元素的一般形式为:数组名[下标](下标从0开始) printf("%d\n",arr[5]) 数组名arr通常情况下代表数组元素的首地址 printf("%d\n",arr); //输出为1 数组名arr在两种情况表示整个数组(即不表示元素首地址...
  • #include&lt;iostream&gt;using namespace std;#include&lt;stdlib.h&gt;void main(){ int a[10] = { 1,2,3,4,5,6,7,8,9,...//一维数组引用 int i = 1; for (auto data : ra) { data += i; //i+...
  • //array首先向右结合,所以这个相当于 (int&)array[] array是个数组,其中的元素引用 //应该叫:引用数组 int &array[] //array首先和&结合,所以array是引用引用的对象是数组 //应该叫作数组引用 int (&...
  • 1.指针数组数组指针 引用数组 数组引用 int *a[10] ...指针数组 ...a指向一个含有10个元素数组 Int (&a)[10] 数组引用 a是一个数组引用 Int& a[10]...
  • 1.Eclipse 新建java project,在src 下新建package,再新建class 规范要求左括号 { 均下移 ...静态是指创建数组元素同时赋值,动态是指先创建数组,后赋值,如 //1.数组的静态初始化 String[] names; na...
  • 数组

    2018-10-03 20:20:32
    数组: 一维数组的声明方式: 例:int a1[]; 或 int[] a1; Java语言中声明数组时不...数组名 = new 数组元素的类型[数组元素的个数] 例: int s[]; s = new int[5]; 数组初始化: 1.动态初始化 数组定义与为数组元素...
  • 2 引用必须被初始化,因为引用是被引用对象的别名,那就要先要有被引用对象,比如一个人有一个绰号,那么引用相当于这个绰号,那么必须有一个绰号对应的人这个对象。一旦定义这个别名就不可以再作为别的变量名了。 ...
  • 利用指针访问二维数组元素

    千次阅读 2014-04-26 15:17:58
    1)二维数组a由若干个一维数组组成在C语言中定义的二维数组实际上是一个一维数组,这个一维数组的每一个...可用a[0][0]、a[0][1]等来引用a[0]中的每个元素,其它依次类推。C语言中,在函数体中或在函数外部定义的一维数
  • C++的一般引用及其数组引用

    千次阅读 2014-06-12 10:10:41
    引用就是某一变量(目标)的一个别名,对引用的操作与变量直接操作完全一样。 引用的声明方法:类型标识符 &引用名=目标变量名; 【例1】:int a; int &ra=a; //定义引用ra,它是变量a引用,即别名 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 32,361
精华内容 12,944
关键字:

对a数组元素的非法引用