Java基础学习笔记（四）

Java数组

定义

要点：

• 用 [] 表示
• 相同类型的若干个数据
• 有序组合
• 每个元素可通过下标来访问
• 下标从0开始
• 元素为空时，int类型默认为0，String类型默认为null
• 长度不可变
• 数组对象本身是在堆中的

声明

1. dataType[] arrayRefVar;

   类型后加中括号，首选。dataType[] arrayRefVar = new dataType[arraySize]

2. dataType arrayRefVar[];

   变量后加中括号

初始化

• 静态初始化

  int[] a = {1,2,3};

  引用类：Man[] mans = {new Man(1,1),new Man(2,2)};

• 动态初始化

  int[] a = new int[2];

  a[0]=1;

  a[1]=2;

• 数组的默认初始化

  数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中每个元素也被按照实例变量同样的方式被隐式初始化，int类型默认为0，String类型默认为null

package com.okami.array;

public class ArrayDemo01 {
    public static void main(String[] args) {
        //1.申明一个数组
        int[] nums;
        //2.创建一个数组
        nums = new int[10];
        //1、2合并 int[] nums = new int[10]

        //3.给数组赋值
        nums[0]=1;
        nums[1]=2;

        int sum=0;

        //静态初始化：创建+赋值
        int[] a={1,2,3};

        //获得数组的长度：数组名.length
        for(int i=0;i<nums.length;i++){
            sum+=nums[i];
        }
        System.out.println("数组元素和："+sum);
        System.out.println(a[0]);
    }
}

内存

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

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

方法区：可以被所有线程共享，包含了所有的class和static变量

数组使用

• 普通for循环

• for-each循环（增强型for循环）

  int[] a={1,2,3,99,8};
  //没有下标，打印出每个元素
  for (int array : a) {
      System.out.println(array);
  }
  

• 数组做方法入参

  package com.okami.array;
  
  public class ArrayDemo01 {
      public static void main(String[] args) {
          int[] a={1,2,3,9,10};
          printArray(a);
      }
      
      //打印数组元素
      public static void printArray(int[] arrays){
          for (int i = 0; i < arrays.length; i++) {
              System.out.print(arrays[i]+" ");
          }
      }
  }
  

• 数组做返回值

  package com.okami.array;
  
  public class ArrayDemo01 {
      public static void main(String[] args) {
          int[] a = {1, 2, 3, 9, 10};
          int[] reverse=reverse(a);
          printArray(reverse);
      }
  
      //数组反转
      public static int[] reverse(int[] a){
          int[] result=new int[a.length];
          for(int i=0,j=a.length-1;i<a.length;i++,j--){
              result[j]=a[i];
          }
          return result;
      }
  
      //打印数组元素
      public static void printArray(int[] arrays){
          for (int i = 0; i < arrays.length; i++) {
              System.out.print(arrays[i]+" ");
          }
      }
  }
  

多维数组

• 二维数组

  int[][] array={{1,2},{3,4}};
  //array[0]={1,2}  一个对象
  //array[0][0]=1   
  

• 三维数组

  package com.okami.array;
  
  public class ArrayDemo02 {
      public static void main(String[] args) {
          int[][][] array={{{1,0},{2,0}},{{3,0},{4,0}}};
          //逐个元素打印
          for (int i=0;i<array.length;i++){
              for (int j=0;j<array[i].length;j++){
                  for (int k=0;k<array[i][j].length;k++){
                      System.out.print(array[i][j][k]+"  ");
                  }
              }
          }
      }
  }
  

Arrays类

冒泡排序

思路：

1. 两层循环，外层冒泡轮数，里层依次比较
2. 比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置
3. 每次比较都会产生一个最大（或最小）数字，下一轮则可以少一次排序
4. 依次循环，直到结束
5. 时间复杂度为O(n2)

package com.okami.array;

import java.util.Arrays;

public class ArrayDemo03 {
    public static void main(String[] args) {
        int[] a={99,67,234,2,44,2342,9,4,2};
        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;i++){
            boolean flag=false;//若数组已有序，则停止循环
            //内层循环
            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;
    }
}

稀疏数组

要点：

1. 当一个数组中大部分元素为同一值时，可以使用稀疏数组来压缩保存
2. 稀疏数组处理方式：
   • 记录数组的行数、列数、除同一值外其他元素的个数
   • 列出每个不同元素的位置与值

package com.okami.array;

public class ArrayDemo04 {
    public static void main(String[] args) {
        //1.创建二维数组，0：没有棋子，1：黑棋，2：白棋
        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();
        }

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

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

        array2[0][0]=array1.length;
        array2[0][1]=array1[0].length;
        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");
        }

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

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