Java数组——一维二维数组的声明及引用以及数组元素的引用

最新推荐文章于 2024-01-29 20:36:16 发布
最新推荐文章于 2024-01-29 20:36:16 发布
阅读量1.4k 收藏 4
点赞数
分类专栏： java学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CherrieZhang/article/details/52950062
版权

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();
        }
    }
}

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

CherrieZhang
关注
专栏目录
JAVA——二维数组遍历二维数组的三种方法
weixin_61638178的博客
07-13 5739
java二维数组遍历的三种方法
JAVA 数组———二维数组的案例
q2643336977的博客
04-03 504
//a 第一种定义格式: // int[][] arr = new int[3][4]; arr里面包含3个数组 每个数组里面有四个元素 //上面的代码相当于定义了一个3*4的二维数组，即二维数组的长度为3，二维数组中的每个元素又是一个长度为4的数组 //b 第二种定义格式 //int[][] arr = new int[3][]; //int...
java操作数组（一维数组、二维数组的声明和遍历）
qq_52395816的博客
04-21 474
java操作数组（一维数组、二维数组的声明和遍历） 1.一维数组 三种声明数组的方法和四种遍历数组的方法 public static void main(String[] args) { //静态初始化 int [] a = {2,8,5,3,4,7,5,2,1}; int [] b = new int [] {2,8,5,3,4,7,5,2,1}; //动态初始化 int [] c = new int[6]; c[0]=0;c[1]=1;c[2]=2;c[3]=3;c[4]=4
java二维数组
pailchen的博客
06-04 513
关于Java中的二维数组[实例]： [java] view plaincopy public class Lesson{       public static void main(String [] args){                  //二维数组的声明方式：           //数据类型 [][] 数组名称 = new
Java中一维数组和二维数组的详解
路宇的博客
05-16 3611
一、数组的概述： 数组的理解：数组(Array),是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一的管理。 数组的相关概念。 2.1.数组名 2.2.元素 2.3.角标，下标，索引 2.4.数组的长度，元素的个数 数组的特点： 3.1.数组是有序排列的 3.2.数组属于引用数据类型的变量，数组的元素即可以是基本数据类型的变量，也可以是引用数据类型的变量。 3.3.创建数组对象会在内存中开辟一整块连续的空间 3.4.数组的长度一旦确定，就不能修改
java 数组元素是引用_Java学习之旅基础知识篇：数组及引用类型内存分配
weixin_39951396的博客
02-17 229
在上一篇中，我们已经了解了数组，它是一种引用类型，本篇将详细介绍数组的内存分配等知识点。数组用来存储同一种数据类型的数据，一旦初始化完成，即所占的空间就已固定下来，即使某个元素被清空，但其所在空间仍然保留，因此数组长度将不能被改变。当仅定义一个数组变量(int[] numbers)时，该变量还未指向任何有效的内存，因此不能指定数组的长度，只有对数组进行初始化(为数组元素分配内存空间)后才可以使用。...
java二维数组元素的引用_二维数组指针表示，C语言指针引用二维数组详解
weixin_39979516的博客
02-26 285
指针变量可以指向一维数组中的元素，当然也就可以指向二维数组中的元素。但是在概念和使用方法上，二维数组的指针比一维数组的指针要复杂一些。要理解指针和二维数组的关系首先要记住一句话：二维数组就是一维数组，这句话该怎么理解呢？假如有一个二维数组：int a[3][4] = {{1, 3, 5, 7}, {9, 11, 13, 15}, {17, 19, 21, 23}};其中，a 是二维数组名。a 数组...
javascript从入门到跑路—–小文的js学习笔记（10）——数组（一维数组、二维数组以及三维数组）和冒泡排序
01-08
一、一维数组 两种创建数组的语法： 1、构造函数的形式: new Array()  2、创建字面量的形式: [ ] 那么下面我们来分别举个栗子： 第一种创建数组的方法举例 栗2： 用创建字面量的形式： 补充： 获
《剑指Offer》系列一——二维数组中的查找
12-21
在编程领域，二维数组是一种常见的数据结构，尤其在处理矩阵或表格类问题时十分常见。《剑指Offer》是一本著名的编程面试准备书籍，其中涵盖了各种算法和数据结构的实战题目。本篇讨论的是该书中的第一道题目，即...
java二维数组元素的引用,Java一一Arrays工具类与二维数组
weixin_39862669的博客
03-21 377
Arrays工具类使用帮助文档:1.61.8作用：主要用于对数组进行排序，查找，填充，比较等的操作Arrays工具类存在于java.util包下，所以使用的第一步就是导包：import java.util.Arrays;注意1：如果在同一个Java文件中同时使用Scanner和Arrays，则可以向如下方式导包：import java.util.Scanner;import java.util.A...
Java中的一维数组和二维数组-学习笔记
Rock N' Roll Forever
05-08 1646
目录 数组的定义 数组的内存结构 数组操作常见问题 数组的常见操作 二维数组 数组练习题 数组的定义 数组的概念：同一种类型数据的集合。其实数组就是一个容器。 数组的好处：可以自动给数组中的元素从0开始编号，方便操作这些元素。 定义数组的格式： 元素类型[] 数组名= new 元素类型[元素个数或数组长度]; 例如：int [] arr = new int[3]; //定义一个可以存储3个整数的容器 还有另外一种格式： 元素类型[] 数组名= new 元素类型[...
java学习笔记10——怎么使用二维数组中的一列或者一行
NLP与推荐算法
09-27 4092
人生艰难啊。 当我想直接取出二维数组中一行或者一列时，我发现不可能，百了很久。使用其中一行可以直接用Arrays中的方法。 甚至Arrays都不需要，想要哪一行直接索引就好了。 我总是习惯于将简单的东西复杂化。 float [][]a={{1,2},{3,4},{5,6}}; float []a1=a[2]; 问了好几个群都不用直接用二维数组的其中一列，我知道for，但你不觉得f...
java学习初探八之数组一维数组、二维数组
LK2013的博客
09-03 679
1.数组 （1）数组是一种引用类型。 （2）数组是一种简单的数据结构，线性的结构。 （3）数组是一个容器，可以用来存储其他元素。 数组是可以存储任意数据类型的元素。 （4）数组分为：一维数组、二维数组、三维数组、多维数组。 （5）数组中存储的元素类型是统一的。 （6）数组长度不可改变，数组一旦创建，长度是不可改变的，固定的。 数组优点：查找效率高。因为数组中的存储元素的类型是统一的，
3_2、Java基本语法之一维数组与二维数组的使用
xiaosuxueJava的博客
10-16 349
Java基本语法之一维数组与二维数组的使用
[Java]一维二维数组的理解，定义与调用
weixin_44581452的博客
08-04 557
一维数组 1.定义（类型名[] 数组名 = new 类型名[数组长度]） public class Hee { public static void main(String[] args){ int[] arr = new int[5];//这里定义了一个长度为5的一维数组 } } 2.调用（数组名[索引]） import java.util.Scanner; public class...
java 2 维数组_Java 二维数组 方法
weixin_36277197的博客
02-12 352
二维数组定义第一种：int[][] arr = new int[3][4];第二种：int[][] arr = new int[3][];(了解即可)第三种：int[][] arr = {{1,2},{3,4,5,6},{7,8,9}};访问int[][] arrt = new int[3][4];System.out.println(arrt[0][1]);System.out.println(...
Java中数组的定义方式
DDDDeng_的博客
11-05 316
Java中数组的定义方式 一维数组 方法一 int[] arr1 = new int[3]; // 给定数组长度，数值默认为0，长度必须给定 ints[0] = 1; ints[1] = 2; ints[2] = 3; 方法二 int[] arr2 = new int[]{1,2,3}; // 创建数组时赋值 方法三 int[] arr3 = {1,2,3}; // 直接赋值，不使用new关键字 二维数组 动态初始化 // 三种形式,第一种为常用 // m为行数，n为列数，其中n可
C语言学习日记—— 一维数组的定义和引用
最新发布
qq_61802519的博客
01-29 781
将数组与循环结合起来，可以有效地处理大批量的数据，大大提高了工作效率，十分方便。本篇介绍在C语言中怎样定义和使用一维数组。
【Java基础】数组应用及源码分析
Java 技术专栏，从入门到精通，熟悉企业级开发
07-07 480
数组对于每一门编程语言来说都是重要的数据结构之一，当然不同语言对数组的实现及处理也不尽相同。 Java 语言中提供的数组是用来存储固定大小的同类型元素。 你可以声明一个数组变量，如 numbers[100] 来代替直接声明 100 个独立变量 number0，number1，....，number99。 本教程将为大家介绍 Java 数组的声明、创建和初始化，并给出其对应的代码。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值