Java数组

数组的声明与创建

package Array;

public class ArrayDemon01 {
    //变量的类型     变量的名字    =   变量的值；
    //数组类型
    public static void main(String[] args) {
        int[] nums;          //1.声明一个数组     也可以int nums[];
        nums = new int[10];  //2.创建一个数组，这里边可以存放10个int类型的数字
        //3.给数组元素赋值
        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;
//获取数组长度：  arrays.length

        for (int i = 0; i < nums.length ; i++) {
            sum = sum + nums[i];
        }
        System.out.println("总和为"+sum);
    }
}

三种初始化及内存分析

内存分析

三种初始化

小结

数组特点

下标越界

数组的使用【重点理解】

• 普通的for循环

• For-Each循环

• 数组作方法入参

• 数组作返回值

  package Array;
  
  public class ArrayDemon04 {
      public static void main(String[] args) {
          int [] arrays = {1,2,3,4,5};
  
      /*    JDk1.5   没有下标
          for (int array : arrays){
              System.out.println(array);
          }                              */
                // printArray(arrays);
          int[] reverse = reverse(arrays);
          printArray(reverse);
      }
  
      //反转数组
      public static int[] reverse(int[] arrays){
          int[] result = new int[arrays.length];
  
          //反转的操作
          for (int i = 0,j = result.length-1; i < arrays.length ; i++,j--) {
              result[j] = arrays[i];
          }
          return result;
      }
      //打印数组元素
      public static void printArray(int[] arrays){
          for (int i = 0; i < arrays.length; i++) {
              System.out.print(arrays[i]+" ");
  
          }
      }
  }
  

多维数组

package Array;

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

        //【4】【2】
        /*
        1，2    array[0]
        2，3    array[1]
        3，4    array[2]
        4，5    array[3]
         */
        int[][] array = {{1, 2}, {2, 3}, {3, 4}, {4, 5}};

        System.out.println(array[0][0]);    // 1
        System.out.println(array[2][1]);    //4
        System.out.println(array.length);   //4，代表总的四个数组，外边
        System.out.println(array[0].length);//2,代表里边【0】中的两个数组，内部
    }

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

Arrays类详解

package Array;

import java.util.Arrays;

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

        int[] a = {1,2,23,485,5552,6621,25,789,};

        System.out.println(a);    //[I@1b6d3586
        //打印数组元素Arrays.toString
        //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));     //[1, 2, 0, 0, 485, 789, 5552, 6621],2，3的被填充
    }
   }

冒泡排序

package Array;

import java.util.Arrays;
//冒泡排序
//1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们交换他们的位置
//2.每一次比较，都会产生出一个最大，或者最小的数字
//3.下一轮检测可以少一次排序
//4.依次循环，直到结束!!
public class ArrayDemon07 {
    public static void main(String[] args) {
      int[]a ={1,4,5,8,85,79,23};
      int[] sort = sort(a); //调用完我们自己写的排序方法以后，返回到一个排序后的数组

        System.out.println(Arrays.toString(sort));
    }
    public static int[] sort(int[] array){
        //借助临时变量
        int temp = 0;

        //外层循环，判断我们这个要走多少次
        for (int i = 0; i < array.length-1 ; i++) {

            boolean flag = false;  //通过flag标识位减少没有意义的比较
            //内层循环，比较判断两个数，如果第一个数，比第二个数大，则交换位置
        for (int j = 0; j < array.length-1-i ; j++) {
                if(array[j+1]<array[j]){
                  temp = array[j];
                  array[j]=array[j+1];
                  array[j+1]=temp;
                  flag = true;
                }

            }
        if(flag=false){
            break;
        }
        }
        return array;
    }
}

稀疏数组

package Array;

public class ArrayDemon08 {
    //1.创建一个二维数组  11*11    0：没有棋子  1.黑棋  2.白棋
    public static void main(String[] args) {
        int[][]array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        //输出原始数组
        System.out.println("输出原始的数组");

        for (int[] ints : array1){
            for (int anInt : ints){
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        System.out.println("==============================");
        //转换为稀疏数组保存
        //获取有效值的个数
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j =0;j < 11;j++){
                if (array1[i][j]!=0){
                    sum++;
                }
            }

        }
        System.out.println("有效值的个数:"+sum);

        //创建一个稀疏数组的数组
        int[][] array2 = new int[sum+1][3];

        array2[0][0]  = 11;
        array2[0][1]  = 11;
        array2[0][2]  =sum;

        //遍历二维数组，将非零的值，存放到稀疏数组中
        int count = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0;j < array1[i].length;j++){
                if (array1[i][j]!=0){
                    count++;
                    array2[count][0]=i;
                    array2[count][1]=j;
                    array2[count][2]=array1[i][j];
                }
            }

        }
        //输出稀疏数组
        System.out.println("稀疏数组");

        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0]+"\t"
            +array2[i][1]+"\t"
            +array2[i][2]+"\t");
        }
        System.out.println("===============================");
        System.out.println("还原");
        //1.读取稀疏数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]];

        //2.给其中的元素还原它的值
        for(int i = 1;i< array2.length;i++){
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }
        //3.打印
        System.out.println("输出还原的数组");

        for (int[] ints : array3){
            for (int anInt : ints){
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }

}