Java数组

数组

一.数组的声明创建

public class HelloWord {
    public static void main(String[] args) {
        int[] nums1;//定义
        int nums2[];
        int sum=0;
        nums1=new int[8];//创建一个数组
        nums1[0]=9;//给数组元素中赋值
        for (int i=0;i<nums1.length;i++){
            sum+=nums1[i];
        }
        System.out.println(sum);
        System.out.println(nums1[1]);
    }
}

二.内存分析

java内存分析：

• 堆
  • 存放new的对象和数组；
  • 可以被所有线程共享，不会存放别的对象引用
• 栈
  • 存放基本变量类型（会包含这个基本类型的具体数值）
  • 引用对象的变量（会存放这个引用在堆里面的具体地址）
• 方法区
  • 可以被所有的线程共享
  • 包含了所有的class和static变量

三.数组的三种初始化

public class HelloWord {
    public static void main(String[] args) {
        //静态初始化：创建+赋值
        int[] a={1,2,3,4,5,6,7,8};
        //动态初始化：含默认初始化(一经分配空间，每个元素都被隐式初始化)
         int[] b=new int[8];
         b[0]=10;

    }
}

四.数组的四个基本特点

• 其长度是确定的，一经创建，大小不能改变；
• 元素必须是相同类型，不能出现混合类型；
• 元素可以是任何数据类型，包括基本类型和引用类型；
• 数组本身就是对象，数组元素相当于对象的成员变量；数组对象本身是在堆中；

五.数组的使用

public class HelloWord {
    public static void main(String[] args) {
      int[] arrays={1,2,3,4,5,6};
      //打印全部数组元素
      for (int i=0;i<arrays.length;i++)
      {
          System.out.println(arrays[i]);
      }
      //计算全部元素的和
        int sum=0;
      for (int i=0;i<arrays.length;i++)
      {
          sum+=arrays[i];
      }
        System.out.println(sum);
      //查找最大的元素
        int temp=arrays[0];
        for(int i=1;i<arrays.length;i++){
            if (temp<arrays[i]){
                temp=arrays[i];
            }
        }
        System.out.println(temp);
      //FOR-EACH循环
        for (int array:arrays) {
            System.out.println(array);
        }
        int[] test=new int[arrays.length];
        test=reverse(arrays);
    }
    //反转数组
    public static int[] reverse(int[] arrays){
        int[] result=new int[arrays.length];
        for (int i=0;i<arrays.length;i++){
            result[i]=arrays[arrays.length-i-1];
            System.out.println(result[i]);
        }
        return result;

    }
}

六.Arrays类

import java.util.Arrays;
public class HelloWord {
    public static void main(String[] args) {
        int[] a={54,3,7,8,4,345,90};
        //打印数组元素
        System.out.println(Arrays.toString(a));
        //排序数组元素(升序)
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
        //数组填充
        Arrays.fill(a,2,4,0);
        System.out.println(Arrays.toString(a));
    }
}

七.冒泡排序

import java.util.Arrays;
public class HelloWord {
    public static void main(String[] args) {
        int[] a={54,3,7,8,4,345,90};
        //临时变量
        int temp=0;
        boolean flag=false;//标志位减少比较
        //外层循环，判断要走多少次
        for(int i=0;i<a.length-1;i++){
            //内层循环，比较判断两个数
            for(int j=0;j<a.length-1-i;j++){
                if(a[j]>a[j+1]){
                    temp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;
                    flag=true;
                }
                if (flag==false){
                    break;
                }
            }
        }
        System.out.println(Arrays.toString(a));

    }
}

八.稀疏数组

public class HelloWord {
    public static void main(String[] args) {
        //创建一个数组
        int[][] a=new int[6][6];
        a[2][2]=1;
        a[3][1]=2;
        a[5][2]=3;
        //计算其非零值
        int sum=0;
        //输出数组
        for (int i = 0; i <a.length; i++) {
            for(int j=0;j<a[i].length;j++){
                if(a[i][j]!=0){
                    sum++;
                }
                System.out.print(a[i][j]+"	");
            }
            System.out.println();
        }
        //创建一个稀疏数组
        int[][] b=new int[sum+1][3];
        b[0][0]=a.length;
        b[0][1]=a[0].length;
        b[0][2]=sum;
        //计算非零值存放在稀疏数组的行数
        int count=0;
        for (int i=0;i<a.length;i++){
            for(int j=0;j<a[i].length;j++){
              if (a[i][j]!=0){
                  count++;
                  b[count][0]=i;
                  b[count][1]=j;
                  b[count][2]=a[i][j];
              }
            }
        }
        //输出稀疏数组
        for (int i = 0; i < b.length; i++) {
            for(int j=0;j<b[i].length;j++){
                System.out.print(b[i][j]+"	");
            }
            System.out.println();

        }
        //读取稀疏数组
        int[][] c=new int[b[0][0]][b[0][1]];
        for(int i=1;i<b.length;i++){
                c[b[i][0]][b[i][1]]=b[i][2];
        }
        //输出读取的数组
        for (int i = 0; i <c.length; i++) {
            for(int j=0;j<c[i].length;j++){
                System.out.print(c[i][j]+"	");
            }
            System.out.println();
        }
    }
}