Java基础4__数组

数组的定义

1. 数组是相同类型数据的有序集合.
2. 数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。
3. 其中,每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问它们.

数组声明创建

1.首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法:

dataType[] arrayRefVar; // 首选的方法
或
dataType arrayRefVar[]; // 效果相同，但不是首选方法

2.Java语言使用new操作符来创建数组，语法如下:

dataType[] arrayRefVar = new dataType[arraySize] ;

3.数组的元素是通过索引访问的,数组索引从0开始。

public class ArrayDemo01 {
    //变量类型   变量名称 = 变量值
    //数组类型   数据名称  数组值
    public static void main(String[] args) {
        int[] nums;//声明一个数组
         nums=new int[5];//创建一个数组
        //给给数组中的元素赋值
        nums[0]=1;
        nums[1]=2;
        nums[2]=3;
        nums[3]=4;
        nums[4]=5;
        System.out.println(nums[5]);
        //计算数组所有元素的和
        int sum=0;
        for (int i=0;i<nums.length;i++){
            sum=sum+nums[i];
        }
        System.out.println("总和为："+sum);
    }
}
//arrays . length获取数组的长度

内存分析

 

堆（数组创建）

• 存放new的对象和数组
• 可以被所有线程共享，不会存放别的对象引用

栈（数组声明）

• 存放基本变量类型（包含这个基本类型的具体数值）
• 引用对象的变量（会存放这个引用在堆里面的具体地址）

方法区

• 可以被所有线程共享
• 包含了所有的class和static变量

数组三种初始化

• 静态初始化：int[] a = {1,2,3,4};相当于int[] b = new int[]{1,2,3,4}
• 动态初始化：int[] a = new int[1]; int[0] = 1
• 默认初始化：int[] a = new int[1]
• 动态初始化包含静态初始化。

数组使用

1.普通的For循环

public class ArraryDemo04 {
    public static void main(String[] args) {
        //遍历打印数组中的元素
        int [] a={1,2,3,4,5};
        for (int i=0;i<a.length;i++){
            System.out.println(a[i]);
        }
        //求数组中元素的和
        int sum=0;
        for (int i=0;i<a.length;i++){
            sum+=a[i];
        }
        System.out.println("sum="+sum);
        //查找最大元素
        int max=a[0];
        for (int i=1;i<a.length;i++){
            if (a[i]>max){
                max=a[i];
            }
        }
        System.out.println("max="+max);
    }
}

2.For-Each循环

public class ArraryDemo05 {
    public static void main(String[] args) {
        int [] arrays={1,2,3,4,5};
//        for (int array:arrays){
//            System.out.println(array);
//        }
       // printArray(arrays);
      int [] reverse  =reverse(arrays);
      printArray(reverse);
   }
   //反转数组
    public static int[] reverse(int[] arrays){
        int [] rssult=new int[arrays.length];
        //反转的操作
        for (int i=0,j=rssult.length-1;i<arrays.length;i++,j--){
            rssult[j]=arrays[i];
        }
        return rssult;
    }

    //打印数组元素
    public static void printArray(int[] arrays){
        for (int i=0;i<arrays.length;i++){
            System.out.print(arrays[i]+" ");
        }
    }
}

多维数组

多维数组可以看做是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组

int a [][] = new int[2][5];//二维数组

以下就是一个3行2列的数组，可遍历取出里面的元素

public class ArrayDemo06 {
    public static void main(String[] args) {

        int [] [] array={{1,2},{4,5},{5,6}};
//        System.out.println(array[0][0]);
        for (int i=0;i <array.length;i++){
            for(int j=0;j<array[i].length;j++){
                System.out.println(array[i][j]);
            }
        }
    }
}

 Arrays类

mport java.util.Arrays;

public class ArraryDemo07 {
    public static void main(String[] args) {
        int [] a={1,453,21,43,46665,9090};
//        System.out.println(a);
        //打印数组中的元素
       System.out.println(Arrays.toString(a));
//        printArray(a);/
        Arrays.sort(a);
        System.out.println(Arrays.toString(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.print(a[i]+"]");
            }else {
                System.out.print(a[i]+", ");
            }

        }
    }
}

冒泡排序

import java.util.Arrays;

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

    /*冒泡排序
    1.比较数组中相邻的两个数，如果第一个数比第二个数大，就交换两个数的位置；
    2.每一次比较都会产生一个最大的数或一个最小的数
    3.下一次排序则会减少一次排序
    4.依次循环知道结束
     */

    public static  int[] sort(int[]  array){
        //定义一个变量
        boolean flag=false;
        //定义临时变量
        int  temp=0;
        //数组的循环次数
        for (int i=0;i<array.length-1;i++){
            //比较两个数大小，如果后一个比前一个数大就交换位置；
            for (int j=0;j<array.length-1-i;j++){
              if(array[j]>array[j+1]){
                  temp=array[j+1];
                  array[j+1]=array[j];
                  array[j]=temp;
                  flag=true;
              }
            }
            if(flag==true){
                break;
            }
        }
        return array;
    }

}

稀疏数组

package ShuZu;
 
public class XiShuShuZu {
    public static void main(String[] args) {
        //创建一个二维数组 11*11  0：没有棋子  1：黑棋  2：白棋
        int [][] a = new int[11][11];
        a[1][2] = 1;
        a[2][3] = 1;
        //输出原始的数组
        System.out.println("输出原始数组");
        for (int [] ints : a ) {
            for (int anInt : ints){
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
            //转化为稀疏数组储存。
            //获取有效值的个数。
            int sum = 0;
            for (int i = 0; i < 11; i++) {
                for (int j = 0; j < 11; j++) {
                    if(a[i][j]!=0){
                        sum++;
                    }
                }
            }
            System.out.println("有效值的个数："+sum);
            //2.创建一个稀疏数组
            int[][] a2 = new int[sum+1][3];
            a2[0][0] = 11;
            a2[0][1] = 11;
            a2[0][2] = sum;
            //遍历二维数组，将非0的值，存放到稀疏数组中。
            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++;
                        a2[count][0]=i;
                        a2[count][1]=j;
                        a2[count][2]=a[i][j];
                    }
                }
            }
            //输出稀疏数组
            System.out.println("稀疏数组：");
            for(int i = 0; i < a2.length;i++){
                System.out.println(a2[i][0]+"\t"+a2[i][1]+"\t"+a2[i][2]+"\t");
            }
            System.out.println("=========================");
            System.out.println("还原");
            //1.读取稀疏数组
            int[][] a3 = new int[a2[0][0]][a2[0][1]];
            //2.给其中的元素还原她的值。
            for (int i = 1; i < a2.length; i++) {   //从一开始
                a3[a2[i][0]][a2[i][1]] = a2[i][2];
            }
            //打印
            System.out.println("输出还原的数组");
            for (int [] ints : a3 ) {
                for (int anInt : ints){
                    System.out.print(anInt+"\t");
                }
                System.out.println();
            }
    }
}