zoukankan      html  css  js  c++  java
  • Java——数组的定义与使用

    数组的定义与使用

    1.数组的基本概念

    (1)数组的动态初始化:

         数组首先先开辟内存空间,而后再使用索引进行内容的设置,这种定义数组的方式称为动态初始化

         数组是引用数据类型,存在有内存分配问题。在使用前一定要开辟空间(实例化),否则就会产生NullPoninterException

    数组的动态初始化(声明并开辟数组)

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

    数组的分步初始化:

    数据类型[ ] 数组名 = null;

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

    当数组开辟空间之后,就可以采用如下方式对数组进行操作:

    1.数组可以通过索引完成,即“数组名[索引]”;

     注意:数组索引从0开始,所以索引的范围为:0——(数组长度-1)如果访问的值超过数组长度,会产生    “java.lang.ArrayIndexOutOfBoundsException”异常。

    2.当数组动态初始化开辟空间后,数组中每个元素都是该数据类型的默认值。

    3.数组是一个有序的集合操作,所以对于数组的内容操作往往采用循环操作(for循环)。

    4.Java中可采用 数组名.length 来获取数组长度。

    public class Test7 {

    public static void main(String[] args){

    int[] demon = new int[4];//开辟一个长度为10的整型数组

    System.out.println(demon.length);//求数组的长度

    demon[0] = 0;//数组的第一个元素

           demon[1] = 1;

    demon[2] = 2;

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

    System.out.print(" ");

    System.out.print(demon[i]);//打印数组的元素

    }

    }

    }

    运次结果:10

     0 1 2 0

    (2)数组的动态初始化:

         数组在定义的同时可以设置内容,则称为数组的静态初始化。

    数据类型[] 数组名 = {值1……}

    数据类型[] 数组名 = new 数据类型[] {值……}(推荐使用)

    public class Test7 {

    //数组静态初始化简化格式

    public static void main(String[] args){

    int[] demon1 ={2,3,5,6,9,11};

    System.out.println(demon1.length);

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

    System.out.println(demon1[i]);

    }

    }

    }

    运行结果:6

    2

    3

    5

    6

    9

    public class Test7 {

    //数组静态初始化完成格式**推荐使用

    public static void main(String[] args){

    System.out.println(new int[]{1,2,3,4,5}.length);//匿名数组

    }

    }

    运行结果:5

    2.数组的引用传递

      数组作为引用数据类型,也一定存在引用传递。

    public class Test7 {

    public static void main(String[] args) {

    int[] demon = null ;

    demon = new int[4] ;

    demon[0] = 0 ; // 数组第一个元素

    demon[1] = 1 ; // 数组第二个元素

    demon[2] = 2 ; // 数组第三个元素

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

    System.out.println(demon[i]) ; // 通过循环控制索引下标更改

    }

    }

    }

      通过上述例子,我们来探讨内存分配的问题:

     


    引用传递空间:同一块堆内存可被多个栈内存所指向。如下例:内存分析见下。

    public class Test7 {

    public static void main(String[] args) {

    int[] demon = new int[4] ;

    int[] temp = null;

    System.out.println(demon.length);

    demon[0] = 0 ; // 数组第一个元素

    demon[1] = 1 ; // 数组第二个元素

    demon[2] = 2 ; // 数组第三个元素

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

    System.out.println(demon[i]) ; // 通过循环控制索引下标更改

    }

    temp = demon;

    temp[0] = 20;

    System.out.println(demon[0]);

    }

    }

     

    运行结果:4

    0

    1

    2

    0

    20

     

    内存分析图:

     

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

    3.二维数组

    二维数组(数组的数组):二维数组本质上指的就是一个行列的集合。换言之,如果要获得一个数据,既需要行索引,也需要列索引。

    要获取二维数组中的元素:数组名[行索引][列索引]

    二维数组的初始化:

    动态初始化:

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

    静态初始化:

       数据类型[][] 数组名 = new 数据类型[][]{{值……},……{值……}}

    public class Test7 {

    //二维数组

       //数组并不是等列数组

    public static void main(String[] args){

    int[][] demon3 = new int[][]{{1,3},{5,7,9},{2,4}};

    //打印二维数组要使用双重循环

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

    for(int j =0;j<demon3[i].length;j++){

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

    }

    }

      }

    }


    4.数组和方法的互操作

    数组是引用数据类型,所有引用数据类型都可以为其设置多个栈内存所指向;所以在进行对数组的操作时,可以通过其他方式处理。

    (1)方法接收数组

    (2)方法返回数组

    (3)方法修改数组

    public class Test7 {

    //数组与方法的互操作

    public static void main(String[] args){

    int[] demon = receive();

    changeDouble(demon);

    printArray(demon);//等价于 int[] temp =demon;

    }

    //方法接收数组组

    public static int[] receive(){

    return new int[]{1,27,18,21};//匿名数组

    }

    //方法返回数组

    public static void printArray(int[] temp){

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

    System.out.println(temp[i]);

    }

    }

    //方法改变数组

    public static void changeDouble(int[] arr){

    for(int j = 0;j<arr.length;j++){

    arr[j] *=2;//每个数组元素扩大两倍

    }

    }

    }

    运行结果:2

    54

    36

    42

    内存分析图如下:


    5.Java对数组的支持

    1.对数组进行排序:

        只要是基本数据类型的数组,sort方法都可以进行排序处理(升序处理)。

        数组排序 java.util.Arrays.sort(数组名称)

    package test;

    public class Test7 {

    //java对数组的支持

    public  static void main(String[] args){

    int[] demon5 = new int[]{20,8,4,92,1};

    char[] demon6 = new char[]{'c','D','a','g','A'};

    java.util.Arrays.sort(demon5);//对整型数组排序

    java.util.Arrays.sort(demon6);//对字符型数组排序

    printArray(demon5);

    printArray(demon6);

    }

    public static void printArray(int[] temp){

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

    System.out.print(temp[i]);

    System.out.print(" ");

    }

    }

    public static void printArray(char[] temp){

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

    System.out.print(temp[i]);

    System.out.print(" ");

    }

    }

    }

    运行结果:1 4 8 20 92 A D a c g

     

    2.实现数组的拷贝:

    数组拷贝:指的是将一个数组的部分内容替换掉另一个数组的部分内容(必须是连续的)。

    System.arraycopy(源数组名称,源数组开始点,目标数组名称,目标数组开始点,拷贝长度)

    public class Test7 {

    //实现数组的拷贝

    //实现将demon22-4个元素拷贝至demon16-8个元素位置处

    public static void main(String[] args){

    int[] demon1 = new int[]{1,2,3,4,5,6,7,8,9};

    int[] demon2 = new int[]{9,8,7,6,5,4,3,2,1};

    System.arraycopy(demon2,1,demon1,5,3);

    printArray(demon1);

    }

    public static void printArray(int[] temp){

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

    System.out.print(temp[i]);

    System.out.print(" ");

    }

    }

    }

    6.数组案例

    给出以下数组,要求可以统计出该数组的最大值、最小值、平均值、总和。

    0

    1

    2

    3

    4

    5

    6

    7

    8

    1

    4

    3

    4

    55

    77

    6

    9

    8

    (1)简单的实现方法实现

    public class Test7 {

           

           public static void main(String[] args){

    int[] demon = new int[]{1,4,3,4,55,77,6,9,8};

    int max = demon[0];

    int min = demon[0];

    int sum = demon[0];

    double avg = 0.0;

    for(int i = 1;i< demon.length;i++){

    sum += demon[i];

    if(demon[i] > max){

    max = demon[i];

    }

    if(demon[i] < min){

    min = demon[i];

    }

    }

    System.out.println("max= "+max);

    System.out.println("min= "+min);

    System.out.println("sum= "+sum);

    System.out.println("avg= "+(1.0*sum/demon.length));

    }

    }

    运行结果:

    max= 77

    min= 1

    sum= 167

    avg= 18.555555555555557

    由上述代码可以看出:主函数中代码量大,代码比较凌乱;主方法相当于客户端调用,代码应越简单越越好。

    (2)使用方法与数组互操作实现

    //数组排序(数组与方法互操作)

    public class Test7 {

           public static void main(String[] args){

    int[] demon = new int[]{1,4,3,4,55,77,6,9,8};

    maxValue(demon);

    minValue(demon);

    sumAndAvg(demon);

    }

    //求最大值

    public static void maxValue(int[] temp){

    int max = temp[0];

    for(int i = 1;i < temp.length;i++){

    if(temp[i] > max){

    max = temp[i];

    }

    }

    System.out.println("max= "+max);

    }

    //求最小值

    public static void minValue(int[] temp){

    int min = temp[0];

    for(int i = 1;i < temp.length;i++){

    if(temp[i] < min){

    min = temp[i];

    }

    }

    System.out.println("min= "+min);

    }

    //求平均值和总和

    public static void sumAndAvg(int[] temp){

    int sum = temp[0] ;

    for(int i = 1;i < temp.length;i++){

    sum += temp[i];

    }

    double avg = 1.0*sum/temp.length;

    System.out.println("sum= "+sum);

    System.out.println("avg= "+avg);

    }

    }

    运行结果:

    max= 77

    min= 1

    sum= 167

    avg= 18.555555555555557

    使用如上方式使得逻辑比较清晰,主函数中代码量减少。

    7.对象数组

    可以看出前面所定义的都是基本数组,对象数组往往是以引用数据类型为主的定义;对象数组中保存的内容要比普通类型多;如:接口、类。

    (1)对象数组的动态初始化

    类名称[ ] 对象数组名 =  new 类名称[长度]

    //对象数组的动态初始化

    class Person{

    private String name;

    private int age;

    public Person(String name, int age){//构造方法

    this.name = name;

    this.age = age;

    }

    public void getPrint(){

    System.out.println("姓名: "+this.name+" 年龄: "+this.age);

    }

    }

    public class Test7 {

    public static void main(String[] args){

    Person[] per = new Person[3];

    per[0] = new Person("张三",16);

    per[1] = new Person("李四",18);

    per[2] = new Person("王五",20);

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

    per[i].getPrint();

    }

    }

    }

    运行结果:

    姓名: 张三 年龄: 16

    姓名: 李四 年龄: 18

    姓名: 王五 年龄: 20

    (2)对象数组的静态初始化

    类名称[ ] 对象数组名 =  new 类名称[]{new 类名称()…… }

    class Person{

    private String name;

    private int age;

    public Person(String name, int age){//构造方法

    this.name = name;

    this.age = age;

    }

    public void getPrint(){

    System.out.println("姓名: "+this.name+" 年龄: "+this.age);

    }

    }

    //静态初始化

    public class Test7 {

    public static void main(String[] args){

    Person[] per = new Person[]{

        new Person("张三",16),

    new Person("李四",18),

    new Person("王五",20)};

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

    per[i].getPrint();

    }

    }

    }

    运行结果:

    姓名: 张三 年龄: 16

    姓名: 李四 年龄: 18

    姓名: 王五 年龄: 20


    运行结果:1 3 5 7 9 2 4

  • 相关阅读:
    怎么在ubuntu上运行php代码?
    html5中的meta标签
    怎么写jquery插件
    InnoDB和Foreign KEY Constraints
    Hadoop 管理工具HUE配置-filebrowser配置
    Ubuntu 14.10 下Hadoop HttpFS 配置
    Hadoop 管理工具HUE配置-Yarn Resource Manager HA配置
    Hadoop 管理工具HUE配置
    Spark 在Hadoop HA下配置HistoryServer问题
    Ubuntu 14.10 下安装Synergy,不同电脑之间公用一套键盘鼠标
  • 原文地址:https://www.cnblogs.com/edda/p/12602113.html
Copyright © 2011-2022 走看看