Java入门-----数组array（尚马day03）

使用了变量维护内存里面的一个数据。
int score = 90;
​
使用变量维护30个学生的成绩? 一个变量维护多个数据。
----> 容器  肯定有一个空间  多个数据存储在空间。  空间大小是固定的。
----> 数组。 
​
一种数据结构 一般作为底层维护某些类实现的功能。 List----> ArrayList
 
修改/查询： 性能最快  直接使用index进行操作
​
增加：空间是固定。 手动扩容。 
删除: 数据一般都是连贯的。 若删除，后面的元素循环遍历向前移动位置。 

1. 概念

数组 是一个容器。存储多个相同类型的数据。 空间大小固定。

数组也就是一个变量。 引用数据类型 默认值null 2块内存。(一块在堆 存储的是数据 一块是在栈内存 存储变量名称)

2. 一维数组[] 2.1 语法1

创建变量:
  [修饰符] 数据类型  变量名 = 数据;

数据类型[] 变量/数组名称/引用 = new 数据类型[length];// 初始化数组变量 开辟空间

开辟length个空间====> 数组中最多存储length个元素/数据   
length: 数组元素的个数

public static void main(String[] args) {
​
    //需求: 使用数组维护多个学生的成绩。
    //1.创建数组:  数据类型[]   变量/数组名称/引用  = new 数据类型[length];
    double[] scoreArray = new double[3]; // 初始化数组变量(已经占据内存)
    //length=30  数组的空间大小  或者说数组的元素个数
    //有默认值 元素类型的默认值
​
    //int num = 200;
    //System.out.println(num);
    //System.out.println(scoreArray);
    //System.out.println(scoreArray.toString());//[D@3ac3fd8b  16进制的hashcode值
​
    //在数组中  每个数据都有索引 index(0-(length-1))
    //访问数组元素:  数组名称[index]
​
    //---------------获得数组的每个元素数据---------------
    double firstData = scoreArray[0];
    System.out.println("第一个数据:" + firstData);
    System.out.println("第2个数据:" + scoreArray[1]);
    System.out.println("第3个数据:" + scoreArray[2]);
    //java.lang.ArrayIndexOutOfBoundsException  数组索引越界
    //System.out.println(scoreArray[3]);
​
    //----------------添加数组数据----------------
    System.out.println("-----------------------------");
    scoreArray[0] = 100;
    scoreArray[1] = 90;
    scoreArray[2] = 99;
    System.out.println("第一个数据:" + scoreArray[0]);
    System.out.println("第2个数据:" + scoreArray[1]);
    System.out.println("第3个数据:" + scoreArray[2]);
​
    //--------------修改数组元素-----------
    scoreArray[0] = 88;
    System.out.println("第一个数据:" + scoreArray[0]);
    System.out.println("第2个数据:" + scoreArray[1]);
    System.out.println("第3个数据:" + scoreArray[2]);
​
}

2.2 遍历数组元素

public static void main(String[] args) {
​
    int[] array = new int[5];
    array[0] = 100;
    array[1] = 200;
​
    //语法:  数组名称.length;
​
    System.out.println("获得数组的长度:" + array.length);
    //循环---> while  do...while  for
    //循环遍历数组的元素数据
    
    
​
    //普通for循环
    
​
    //新的遍历数组的方式: 增强for循环
    
    //弊端: 不能直接获得索引
    int count = 1;
    for (int a : array) {
        System.out.println("第" + count + "个数组元素是:" + a);
        count++;
    }
}

2.3 语法2

1. 声明数组
  数据类型[] 数组名；
2. 赋值
  数组名 = new 数据类型[length];

2.4 语法3

一般测试使用

数据类型[] 数组名称 = {数据1,数据2....数据n}；//静态初始化

2.5 语法4

1. 声明数组
  数据类型[] 数组名；
2. 赋值
  数组名 = new 数据类型[]{数据1,数据2....数据n};
​
int[] array1 =new int[] {1, 2, 3};
​
int[] array;
array = new int[]{1, 2, 3};

2.6 案例 1. 动态录入数据

使用数组实现: 动态录入学生的个数以及每个的成绩 求得学生成绩总分 打印每个学生的成绩。

public static void main(String[] args) {
    //动态录入学生的个数以及每个学生的成绩  求得学生成绩总分 打印每个学生的成绩。
    Scanner input = new Scanner(System.in);
    System.out.println("学生的个数:");
    int num = input.nextInt();
​
    double sum = 0;
    double[] scoreArray = new double[num];
    for (int i = 1; i <= num; i++) {
        System.out.println("请录入第" + (i) + "个学生的成绩:");
        double score = input.nextDouble();
        sum += score;
        //录入的每个成绩存储数组中
        scoreArray[i - 1] = score;
    }
​
    System.out.println("--------------------------");
​
    System.out.println("学生的总分:" + sum);
    //循环遍历打印
    int count = 1;
    for (double studentScore : scoreArray) {
        System.out.println("第" + (count++) + "个学生的成绩:" + studentScore);
    }
    input.close();
}

2. 数组比较

比较2个数组元素是否一致。

public static void main(String[] args) {
    //比较2个数组元素是否一致。 ==  equals
    int[] array1 = {1, 2, 3};
    int[] array2 = {0, 2, 3};
    //=赋值
    //基本数据类型 赋值的是数据
    //引用数据类型 赋值的是地址值
​
    //==: 比较的是什么？
    //局部变量:  基本数据类型 比较的是数据   引用数据类型 比较的是内存地址值
    //System.out.println(array1 == array2);//false
​
    //所有的引用数据类型都可以使用equals
    //System.out.println(array1.equals(array2));//false
​
    int length1 = array1.length;
    int length2 = array2.length;
    if (length1 != length2) {
        System.out.println("这2个数组的元素肯定是不一致的 false");
        return;
    }
​
    //比较相同索引下的2个数组数据是否一致
    //有1个数值不一样 就不用继续了
    for (int index = 0; index < length1; index++) {
        if (array1[index] != array2[index]) {
            System.out.println("这2个数组的元素肯定是不一致的 false");
            return;
        }
    }
    System.out.println("这2个数组的元素肯定是一致的  true");
}

3. 数组元素最值

求数组元素最值

public static void main(String[] args) {
​
    //动态录入学生的个数以及每个的成绩  求得学生成绩总分 打印每个学生的成绩。
    //最高分  最低分
​
    Scanner input = new Scanner(System.in);
    System.out.println("录入学生的个数：");
    int num = input.nextInt();
​
    int[] scoreArray = new int[num];
​
    int max = 0;
    int min = 0;
​
    //在录入成绩的这个地方  直接求最值
    for (int i = 1; i <= num; i++) {
        System.out.println("请录入第" + i + "个学生的成绩:");
        int score = input.nextInt();
        scoreArray[i - 1] = score;
        if (i == 1) {
            max = score;
            min = score;
            continue;
        }
        max = Math.max(max, score);
        min = Math.min(min, score);
    }
​
    //遍历数组元素
    
    
    //2个数据作比较----> 最大值与后面的元素做比较
​
​
    System.out.println("成绩最高分:" + max);
    System.out.println("成绩最低分:" + min);
​
}

4. 数组扩容

public static void main(String[] args) {
​
    //数组的元素是连贯的  空间一旦固定 无法改变数组的空间的
    //创建2个字符串数组： 将其中一个数组的所有的元素都赋值放入另外一个数组里面。
    //String: null
​
    String[] arr1 = new String[5];
    arr1[0] = "a";
    arr1[1] = "B";
    arr1[2] = "c";
​
    String[] arr2 = {"1", "2", "3"};
    //需要将arr2的所有的数据都存储到arr1里面
    //String数组里面 没有赋值的  当前元素都是null
    //核心: 找到第一个null值出现的位置
    int length = arr1.length;
    int index = 0;
    for (; index < length; index++) {
        if (arr1[index] == null) {
            break;
        }
    }
    //index:就是第一个null的值得索引位置  维护arr1里面有效的元素的个数  3
    //判断arr1的剩余空间是否足够
    int leftSpace = length - index;//arr1剩余空间
    int length2 = arr2.length;
    if (length2 > leftSpace) {
        //arr1空间不足的-----> 手动扩容----> new ---> 扩大的空间是我们自定义的
        String[] newArray = new String[index + length2];
        for (int i = 0; i < index; i++) {
            newArray[i] = arr1[i];
        }
        arr1 = newArray;
        
        // arr1 = Arrays.copyOf(arr1,index+length2);
    }
    for (String s : arr2) {
        arr1[index++] = s;
    }
​
    //数组的所有的数据: 遍历
    //Arrays java.util.Arrays  提供了很多操作数组元素的功能
    System.out.println(arr1);
    //将数组里面的元素转换成字符串进行打印输出
    System.out.println("arr1的元素:" + Arrays.toString(arr1));
}

5. 删除数组元素

public static void main(String[] args) {
​
    //数组元素是连贯的
    //数组的空间是固定的
    String[] array = {"a", "a", "aaaa", "dhh"};
    //删除数组里面的a  删除数据就是把指定的索引的内容变为类型的默认值即可
    //找到a元素的索引位置
​
    int length = array.length;
    for (int index = 0; index < length; index++) {
        if ("a".equals(array[index])) {
            //array[index] = null;//可以省略?
            //右边元素要循环向左移动位置
            for (int j = index; j < length - 1; j++) {
                array[j] = array[j + 1];
            }
            array[length - 1] = null;
            if ("a".equals(array[index])) {
                index--;
            }
        }
    }
​
    System.out.println("删除之后:" + Arrays.toString(array));
}

2.7 排序(了解)

数组的元素完全无序的。升序或者降序排列数组的元素。

1. 冒泡排序

l :将相邻的两个元素进行比较，最大的值放在右端。

流程: N个数字要排序完成，总共进行N-1趟排序，每i趟的排序次数为(N-i)次，所以可以用双重循环语句，外层控制循环多少趟，内层控制每一趟的循环次数。

 int[] array = {89, 100, 0, 78};
length = array.length;
一共要经过3轮排序
​
第一轮:
   指针指向第一个元素89  89余与100比较  89<100  不交换
   指针指向第2个元素100  100与0比较  100>0   交换位置  89 0 100 78
   指针指向第3个元素100  100与78    100>78  交换位置   89 0 78 100
       
       
 第2轮:  
   指针指向第一个元素89  89与0  交换位置  0  89  78  100
   指针指向第2个元素89   89与78  交换位置  0  78 89 100
       
 第3轮: 
   指针指向第一个元素0   不交换  0  78 89 100
       
//代码实现
       for(int i=1;iarray[j+1]){
                   int temp = array[j];
                   array[j] = array[j+1];
                   array[j+1] = temp;
               }
           }
​
       }          

2. 选择排序

交换次数少于冒泡。

从第一个元素开始，分别与后面的元素相比较，找到最小的元素与第一个元素交换位置；从第二个元素开始，分别与后面的元素相比较，找到剩余元素中最小的元素，与第二个元素交换；重复上述步骤，直到所有的元素都排成由小到大为止

当前元素与最小元素交换。

 int[] array = {89, 100, 0, 78};
length = array.length;
一共要经过3轮排序
第一轮:
  指针指向第一个元素: 89  min=89
      89与100比  89<100  最小值还是89
      89与0比较  89>0    最小值为0
      0与78比较  0<78     最小值还是0
  0与89交换位置    0  100  89  78     
      
第2轮:
  指针指向第2个元素100   min=100
  100 与89   min=89
  89与78      min=78 
  78与100交换    0 78 89 100
      
第3轮:
 指针指向第3个元素89   
   89与100  min=89
     
  89与89交换(当前元素与最小值元素正好一致)
  
  
     for(int i=0;iarray[j]){
                 min = array[j];
                 minIndex = j;
             }
         }
         
         //交换位置
         if(i!=minIndex){
             int temp = array[i];
             array[i] = min;
             array[minIndex] = temp; 
         }
        
     }     
    

3. 插入排序

将指针指向某个(第二个)元素，假设该元素左侧的元素全部有序，将该元素抽取出来，然后按照从右往左的顺序分别与其左边的元素比较，遇到比其大的元素便将元素右移，直到找到比该元素小的元素或者找到最左面发现其左侧的元素都比它大，停止.

此时会出现一个空位，将该元素放入到空位中，此时该元素左侧的元素都比它小，右侧的元素都比它大；

指针向后移动一位，重复上述过程。每操作一轮，左侧有序元素都增加一个，右侧无序元素都减少一个。

int[] array = {89, 100, 0, 78};
第一轮:
  指针指向第2个元素:100    89，_,0,78
  100与89比较  不需要右移 
  当前元素填补空位:  89  100 0  78
      
第2轮:   
   指针指向第3个元素  0      89  100 _  78
   0与100 100右移   89  _ 100 78
   0与89比较 89右移  _  89 100 78
       
   当前元素填补空位:   0  89 100  78
       
第3轮:  
   指针指向第4个元素  78
       0 78 89 100
 
       
       for(int i=1;i=0 && array[leftIndex]>temp){
               //左边元素向右移动
               array[leftIndex+1] = array[leftIndex];
               leftIndex--;
           }
               
           //当前元素填补空位
          array[leftIndex+1]  = temp;
          
       }     
​
       
       

3. Arrays

jdk开发工具包里面提供了一个工具类 主要是操作数组元素。封装了很多功能 直接使用即可。

在java.util包里面 因此要在java文件中使用Arrays功能 需要提前导包

常用功能如下：

Arrays.toString(数组名称); // 将数组转换成字符串操作

Arrays.copyOf(原数组名称, 新数组的长度);// length>=0 1.1 扩容 1.2 截断

Arrays.sort(数组名) ; // 默认对数组元素进行升序排列

4. 高维数组(忘记)

二维数组。（）

二维数组的数据是一维数组。其实真实的数据还是在一维数组中。

4.1 语法

1. 语法1
数据类型[][] 变量名/数组名 =  new  数据类型[m][n];//初始化二维数组变量
​
m: 数组的length。 规定二维数组的length，空间大小  元素个数
n: 一维数组的元素个数 一维数组的length
​
​
2. 语法2
 数据类型[][] 变量名/数组名 =  new  数据类型[m][];
​
​
3. 语法3
  数据类型[][] 变量名/数组名 = {}；//初始化
  
4.语法4
数据类型[][] 变量名/数组名  =  new 数据类型[][]{}；

4.2 案例

需求:
  使用二维数组实现  动态录入班级个数  以及每个班级的学生个数  动态录入每个学生的名称
  
  
  打印输出 每个班级每个学生的姓名。
  
​
​