java数组及Arrays类中常用方法与内存分析

java数组

数组：相同类型数据的有序集合

数组的长度是固定的，一旦被创建就不可以改变
数组中不允许出现其他类型的数据
数组中的元素类型可以是任意数据类型，包括引用类型
数组可以看做是对象，数组中的每个元素相当于该对象的成员变量
java中对象是在堆中的，数组对象本身是在堆中的

数组要先声明才能在程序中使用

数据类型[] 数组名; //java推荐使用该种 (可联想到javamain方法中的String[] args)

例：int[] nums;

数据类型数组名[]; //该种为C、C++形式

例: int nums[];

声明后的数组用new来创建：

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

例：nums=new int[10];

也可以声明创建一步进行:

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

例: int[] nums=new int[10];

package com.yuanyu.study;

public class ArrayDemo01 {
    public static void main(String[] args) {
        int[] nums =new int[10];
        
        nums[0]=1;
        nums[1]=2;
        nums[2]=3;
        nums[3]=4;
        nums[4]=5;
        nums[5]=6;
        nums[6]=7;
        nums[7]=8;
        nums[8]=9;
        nums[9]=10;

        int sum=0;
        for (int i=0;i


数组三种初始化


静态初始化
package com.yuanyu.study;

public class ArrayDemo01 {
    public static void main(String[] args) {
        int[] a={1,2,3}; //静态初始化:创建+赋值
        System.out.println(a[0]);
    }
}





动态初始化
package com.yuanyu.study;

public class ArrayDemo01 {
    public static void main(String[] args) {
        int[] b=new int[2]; //动态初始化:包含默认初始化
        b[0]=2;
        b[1]=8;
        System.out.println(b[1]);
    }
}





数组默认初始化
package com.yuanyu.study;

public class ArrayDemo01 {
    public static void main(String[] args) {
        int[] b=new int[5]; //动态初始化:包含默认初始化
        System.out.println(b[1]);
    }
}


数组是引用类型，它的元素相当于类的实例变量，数组一被分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。


数组与循环结合
package com.yuanyu.study;

public class ArrayDemo01 {
    public static void main(String[] args) {
        int sum=0;
        int max=0;
        int[] a={1,2,3,4,5};
        //遍历数组每个元素
        for (int i = 0; i < a.length; i++) {
            sum+=a[i];
            System.out.println(a[i]);
            
//            for (int x:a){ //加强for循环适合遍历数组每个元素,无下标
//                System.out.println(x);
//            }

            if (a[i]>max){
                max=a[i];
            }
        }
        System.out.println("====================");
        //计算所有元素总和
        System.out.println("数组元组总和sum="+sum);
        System.out.println("====================");
        //查找数组中的最大元素
        System.out.println("数组最大元素为"+max);
    }
}



数组作为参数：
package com.yuanyu.study;

public class ArrayDemo02 {
    public static void main(String[] args) {
        int a[]={1,2,3,4,5};
        printArray(a);
    }

    public static void printArray(int[] x){
        for (int i = 0; i < x.length; i++) {
            System.out.println(x[i]);
        }
    }
}


数组作为返回值：
package com.yuanyu.study;

public class ArrayDemo02 {
    public static void main(String[] args) {
        int a[]={1,2,3,4,5};
        printArray(reverseArray(a));
    }

    public static void printArray(int[] x){ //打印数组
        for (int i = 0; i < x.length; i++) {
            System.out.println(x[i]);
        }
    }

    public static int[]  reverseArray(int[] y){ //数组反转
        int[] result=new int[y.length];
        for (int i = 0,j=y.length-1;i < y.length;i++,j--) {
                result[i]=y[j];
        }
        return result;
    }
}



多维数组
package com.yuanyu.study;

public class ArrayDemo01 {
    public static void main(String[] args) {
        int[][] a={{1,2},{2,3},{3,4},{4,5}}; //定义了一个四行两列的数组；
     /*[4,2]
        1,2
        2,3
        3,4
        4,5
         */
        System.out.println(a[2][1]); //4
        System.out.println(a.length); //4
        System.out.println(a[0].length); //2
        System.out.println("==============================");
        
        for (int i=0;i


Arrays类中的常用方法
package com.yuanyu.study;

public class Demo07 {
    public static void main(String[] args) {
        int[] a={15,2,9,4,10,1};
        System.out.println(a); 
    }
}


直接打印数组：（打印的是数组的hashcode）
[I@1b6d3586
package com.yuanyu.study;

import java.util.Arrays;

public class Demo07 {
    public static void main(String[] args) {
        int[] a={15,2,9,4,10,1};
        System.out.println(Arrays.toString(a));
    }
}


Arrays类中提供了打印数组的方法：toString()
[15, 2, 9, 4, 10, 1]
java类中的方法都是人写出来的，可以自己写也可以直接调用，自己写的“toString()”：
package com.yuanyu.study;

public class Demo07 {
    public static void main(String[] args) {
        int[] a={15,2,9,4,10,1};
        printArray(a);
    }

    public static void printArray(int[] a){
        for (int i = 0; i < a.length; i++) {
            if (i==0){
                System.out.print("[");
            }
            if (i==a.length-1){
                System.out.println(a[a.length-1]+"]");
            }
            else {
                System.out.print(a[i]+", ");
            }
        }
    }
}


打印结果：[15,2,9,4,10,1]
点开toString原码


数组排序:Arrays类提供sort（升序）方法进行数组的排序
package com.yuanyu.study;

import java.util.Arrays;

public class Demo07 {
    public static void main(String[] args) {
        int[] a={15,2,9,4,10,1};
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
    }
}


[1, 2, 4, 9, 10, 15]
数组赋值：Arrays类提供fill方法给数组整体（或部分）赋值
package com.yuanyu.study;

import java.util.Arrays;

public class Demo07 {
    public static void main(String[] args) {
        int[] a={15,2,9,4,10,1};
        System.out.println(Arrays.toString(a));
        //Arrays.fill(a,0); //将数组中的每个元素用0去覆盖
        Arrays.fill(a,2,4,0);//数组中的[2,4)元素被0覆盖，其他不变
        System.out.println(Arrays.toString(a));
    }
}


[15, 2, 9, 4, 10, 1]
[0, 0, 0, 0, 0, 0]
[15, 2, 0, 0, 10, 1]
常用方法还有equals比较数组，binarySearch对排序好的数组进行二分查找等
Arrays类中的方法都是static修饰的，使用时可以直接使用类名进行调用，
java内存分析

堆：存放new对象和数组，可被所有线程共享
栈：存放基本变量类型，引用对象的变量
方法区：包含了所有class和static变量，可被所有线程共享

java数组及Arrays类中常用方法与内存分析

java数组

数组三种初始化

数组与循环结合

多维数组

Arrays类中的常用方法

java内存分析

相关

标签