数组

1. 数组概述

数组(array): 存储一个元素个数固定且元素类型相同的有序集

2. 数组的定义格式

• 格式一

  数据类型[] 变量名
  int[] array; -->推荐
  

• 格式二

  数据类型 变量名[]
  int array[];
  

3.数组的初始化

java中的数组必须先初始化才能使用

初始化: 就是为数组中的数据元素分配内存空间,并为每个数组元素赋值

• 静态初始化

  初始化时,指定每个数组元素的初始值,由系统决定数组长度
  
  格式: 数据类型[] 变量名 = new 数据类型[]{元素1,元素2,...};
  int[] array = new int[]{1,2,3};
  
  简化: 数据类型[] 变量名 = {元素1,元素2,...}
  int[] array = {1,2,3}
  
  适合一开始就能确定元素值的业务场景
  

• 动态初始化

  初始化时,只指定数组长度,由系统为数组分配初始值
  
  格式: 数据类型[] 变量名 = new 数据类型[数组长度]
  int[] array = new int[10]
  
  适合知道元素数量,不确定具体元素值的场景
  

4. 数组元素访问

• 数组变量的访问方式

  格式: 数组名
  

• 数组内部保存的数据的访问方式

  数组名[索引]
  
  索引: 数组中数据的编号方式
  作用: 用于访问数组中的数据,数据名[索引],等同于变联名,称为下标变量
  特征: ① 索引从0开始
       ⑤ 索引是连续的
       ③ 索引逐一增加,每次加一
  

5. 数组的常见操作

• 遍历

  什么是遍历?
  获取数组中的每一个元素
  
  获取数组长度(元素个数)
  格式: 数组名.length 
  array.length
  

  //数组遍历的通用格式
  for(int i=0;i<array.length;i++){
      array[i]//对每个元素进行操作
  }
  

• 获取最大值

  思路:
  1. 定义一个变量,用于保存最大值
  2. 取数组中的第一个元素,作为变量的初始值
  3. 与数组中剩余元素逐个比较,每次比较将最大值保存在变量中
  

  int max = array[0];
  for(int i = 1;i<array.length;i++){
      if(array[i]>max){
          max = array[i];
      }
      System.out.println("max:"+max);
  }
  

• 元素打乱

  什么是元素打乱?
  	把数组中的元素随机交换位置,每次运行都可能产生不一样的结果
  	
  获取元素中的随机索引
  	Random random = new Random();
  	int index = random.nextInt(array.length)
  

  Random random = new Random();
  for(int i=0;i<array.length;i++){
      int index = random.nextInt(array.length);
      
      int temp = array[i];
      array[i] = array[index];
      array[index] = temp;
  }
  System.out.println(Arrays.toString(array))
  

6. 数组使用的三个问题

• 指针越界

  访问了数组中不存在的索引对应的元素
  

• 空指针异常

  数组变量不在指向堆内存,还想继续访问数据
  

• 溢出

  操作系统会自动给每个进程分配一个最大栈空间2M
  操作系统会自动给每个进程分配一个最大堆空间4G
  如果数组过大,就会造成堆溢出
  

7. 二维数组概述

元素为一维数组的数组

8. 二位数组的定义格式

• 格式一

  数据类型[][] 变量名;
  int[][] array;  --->推荐
  

• 格式二

  数据类型 变量名[][];
  int array[][];
  

• 格式三

  数据类型[] 变量名[];
  int[] array[];
  

9. 二位数组初始化

• 静态初始化

  格式: 数据类型[][] 变量名 = new 数据类型[][]{元素1,元素2,元素3,...};
  int[][] array = new int[][]{{1,2,},{3,4}};
  
  简化: 数据类型[][] 变量名 = {{1,2},{3,4}} ;
  int[][] array = {{1,2},{3,4}};
  

• 动态初始化

  格式: 数据类型[][] 变量名 = new 数据类型[m][n];
  int[][] array = new int[2][2];
  

10. 二位数组的元素访问

• 获取二位数组

  数组名
  

• 获取一维数组

  数组名[索引]
  

• 获取每个二位数组的元素

  数组名[索引][索引]
  

11. 二维数组的常见操作

• 遍历

  for(int i=0;i<array.length;i++){
      for(int j=0;j<array[i].length;j++){
          System.out.print(array[i][j]+" ");
      }
      System.out.println();
  }
  // 外层循环得到一维数组
  // 内层循环得到每个二维数组的元素
  

• 元素打乱

  Random random = new Random();
  for(int i=0;i<array.length;i++){
      for(int j=0;j<array[i].length;j++)[
          int x = random.nextInt(array.length);
          int y = random.nextInt(array[x].length)
          
          int temp = array[i][j];
          array[i][j] = array[x][y];
          array[x][y] = temp;
      ]
  }
  

12.数组中的常见算法

1. 使用输入值初始化数组
public static void main(String[] args) {
    int[] ints = new int[5];
    Scanner input = new Scanner(System.in);
    System.out.println("Enter"+ints.length+"values:");
    for (int i = 0; i < ints.length; i++) {
        ints[i] = input.nextInt();
    }
    System.out.println(Arrays.toString(ints));
}

2. 使用随机数初始化数组
public static void main(String[] args) {
    int[] ints = new int[10];
    Random random = new Random();
    for (int i = 0; i < ints.length; i++) {
        ints[i] = random.nextInt(20);
    }
    System.out.println(Arrays.toString(ints));
}

3. 显示数组
public static void main(String[] args) {
    int[] ints ={1,2,3,4};
    for (int i = 0; i < ints.length; i++) {
        System.out.print(ints[i]+" ");
    }
}

4. 对所有元素求和
public static void main(String[] args) {
    int[] ints = {1,2,3,4};
    int sum = 0;
    for (int i = 0; i < ints.length; i++) {
        sum += ints[i];
    }
    System.out.println(sum);
}

5.找出最大元素
public static void main(String[] args) {
    int[] ints = {1,2,3,4,89,100};
    int max = 0;
    for (int i = 0; i < ints.length; i++) {
        if (ints[i]>max){
            max = ints[i];
        }
    }
    System.out.println(max);
}

6.找出最大元素的最小下标值
public static void main(String[] args) {
    int[] ints = {1,2,5,4,5,5,};
    int index = 0;
    int max = 0;
    for (int i = 0; i < ints.length; i++) {
       if (ints[i]>max){
           max = ints[i];
           index = i;
       }
    }
    System.out.println(index);
}

7.随机打乱
public static void main(String[] args) {
    int[] ints = {1,2,3,4,5,6,7,8,9,10};
    int temp = 0;
    Random random = new Random();
    for (int i = 0; i < ints.length; i++) {
        int j = random.nextInt(9);
        temp = ints[i];
        ints[i] = ints[j];
        ints[j] = temp;
    }
    System.out.println(Arrays.toString(ints));
}

8.移动元素(向左移动一个元素)
public static void main(String[] args) {
    int[] ints = {1,2,3,4,5};
    int temp = ints[0];
    for (int i = 1; i < ints.length; i++) {
        ints[i-1] = ints[i];
    }
    ints[ints.length-1] = temp;
    System.out.println(Arrays.toString(ints));
}

9.简化编码
public static void main(String[] args) {
    String[] strings = {"one","two","three","four","five","six","seven"};
    Scanner input = new Scanner(System.in);
    System.out.println("Enter a mother number(1 to 7):");
    int num = input.nextInt();
    System.out.println(strings[num-1]);
}

10.编写一个程序,找出所有大小项平均值的项的个数
public static void main(String[] args) {
    int[] ints = {1,2,3,4,5,6,7,8,9,10};
    int sum = 0;
    int temp = 0;
    for (int i = 0; i < ints.length; i++) {
        sum += ints[i];
    }
    int num = sum/ints.length;
    for (int i = 0; i < ints.length; i++) {
        if (ints[i]>num){
           temp++;
        }
    }
    System.out.println(temp);
}

13.数组的复制

1. 使用循环语句,逐个的复制数组中的元素
2. 使用System类中的静态方法arraycopy
3. 使用clone方法复制数组

注意: 不能使用使用赋值语句复制数组,如list1 = list2,它是将list2的引用值复制给了list1,
list1和list2都将指向list2引用的数组,而list1引用的数组将被垃圾回收

1. 使用循环
public static void main(String[] args) {
    int[] ints = {1,2,3,4,5};
    int[] ints2 = new int[ints.length];
    for (int i = 0; i < ints.length; i++) {
        ints2[i] = ints[i];
    }
    System.out.println(Arrays.toString(ints2));
}
2. 使用方法arraycopy
语法: arraycopy(sourceArray, srcPos, targetArray, tarPos, length)
sourceArray: 原数组
targetArray: 目标数组
srcPos: 原数组的复制起始位置
tarPos: 目标数组的复制起始位置
length: 复制的长度

public static void main(String[] args) {
    int[] ints = {1,2,3,4,5};
    int[] ints2 = new int[ints.length];
    System.arraycopy(ints, 0, ints2, 0, ints.length);
    System.out.println(Arrays.toString(ints2));
}

14.可变长参数列表

当不确定方法中能传递进来多少参数的时候,可以使用可变长参数列表

格式: 参数类型...参数名

java将可变长参数列表当做数组处理

注意: 可变长参数列表必须是最后一个参数

public static void main(String[] args) {
    int i = searchMax(1, 2, 3, 4);
    System.out.println(i);
}
public static int searchMax(int ...nums){
    int max = 0;
    for (int i = 0; i < nums.length; i++) {
        if (nums[i]>max){
            max = nums[i];
        }
    }
    return max;
}

15. 数组的查找

• 线性查找

  //返回一个索引
  public static void main(String[] args) {
      int[] ints = {1,2,3,4,5};
      int i = searchNum(ints, 1);
      System.out.println(i);
  }
  public static int searchNum(int[] nums,int key){
      int index = 0;
      for (int i = 0; i < nums.length; i++) {
          if (nums[i] ==key){
              index = i;
          }
      }
      return index;
  }
  //返回索引数组
  public static void main(String[] args) {
      int[] ints = {1,2,3,4,5,1,1};
      int[] i = searchNum(ints, 1);
      System.out.println(Arrays.toString(i));
  }
  public static int[] searchNum(int[] nums,int key){
      int temp = 0;
      for (int i = 0; i < nums.length; i++) {
          if (nums[i] ==key){
              temp++;
          }
      }
      int[] ints = new int[temp];
      int j = 0;
      for (int i = 0; i < nums.length; i++) {
          if (nums[i] ==key){
              ints[j] = i;
              j++;
          }
      }
      return ints;
  }
  

• 二分查找

  public static void main(String[] args) {
      int[] ints = {1,2,3,4,5,6,7,8,9};
      System.out.println(searchIndex(ints, 5));
  }
  public static int searchIndex(int[] ints,int key) {
      int max = ints.length-1;
      int min = 0;
      while (max > min) {
          int temp = (max + min) / 2;
          if(key > ints[temp]) {
              min = temp + 1;
          }else if(key == ints[temp]){
              return temp;
          }else{
              max = temp -1;
          }
      }
      return -1;
  }
  

16. Arrays类

这个类中包含一些常用的对数组操作的静态方法

• 排序

  Arrays.sort(elementType[])
  	可以对byte short int long char double float Object类型的数据进行排序,没有返回值
  Arrays.sort(elementType[],num1,num2)
  	对数组中索引从num1到num2的元素进行排序
  Arrays.parallelSort(Object[])
  	和sort类似
  

• 数组是否相等

  Array.equals(list1,list2);
  相等则返回true
  不相等返回false
  

• 填充

  Arrays.fill(list1,num)
  	将num填充到list1中
  Arrays.fill(list1,num1,num2,num3)
  	将num3填充在list1[num1]到list1[num2-1]之间
  	
  注意: 填充是使目标值替换掉原始值
  

• 打印

  Arrays.toString(list[])
  
  返回值为数组元素的字符表达
  

17. 数组在方法中的传递

数组在方法中不管是作为参数传入,还是作为返回值返回,传递的都是数组的引用
在数组作为参数传入的时候,可能会出现这种形式:
	new int[]{1,2,3}
	称为匿名数组