【JAVA基础】数组Array

第五章 数组Array

5.1 数组的定义

1， 存储相同数据类型的一组数据。相同数据类型（包括基本数据类型和引用数据类型）

2， 数组是引用数据类型

5.2 数组的作用

方便管理和维护一组数据。

5.3 数组的内存

1， 数组是连续的存储空间（连着的，所以方便管理）

2， 数组有下角标，从0开始（JAVA中的所有下角标都是从0开始的）

3， 基本数据类型临时变量，存储栈中，引用数据类型的数组存储在堆中

内存的区域： 栈（临时变量）

 int a = 10;
 a = 1;
 a = 5;//栈里的a被覆盖    

堆（引用类型）

 

常量池

方法区

静态区（static）

5.4 数组的生命和创建（重点）

5.4.1. 声明语法：

 数据类型 [] 数字名；     int[] a;
 数据类型 数组名 []；     double[]d;

小结：

1， 数据类型既可以是基本类型int，double也可以是引用类型String

2， 数组名第一方式同变量名

5.4.2. 创建语法（重点）

第一种

 数组名 = new int [ 数组大小 ];  
 //例如： 
 int[] a = new int[4];
 System.out.println()

小结：

1， 数组创建使用关键字 “new” 。

2， 数组大小必须给定，决定数组大小

3， 生命和创建的类型一致

4, a 是数组堆中的元素

5， a[ ] 获取对应的元素

6， 数组的元素是有类型的

7， 数组的长度(下标范围)：0 ~ ( 数组.length - 1 )

 

5.4.3.使用数组的元素

 数组名[下标] = 值；//赋值
 System.out,print(数组名[下标]);//获取    

数组的元素遍历（数组的迭代）：就是把数组都打出来。

 for( int i = 0 ; i < a.length ; i++ ){
     System.out.println(a[i]);
 }

增强for循环（JDK5+）（又称迭代器方式）

 for( 数据类型 迭代变量名 : 数组名 ){
     迭代变量;
 }

e.g.

 for( int m : a ){
     System.out.println(m + "\t");
 }

第二中语法规则：

 数据类型[] 数组名 = { 元素1 ， 元素2 ， 元素3 ...... }
 int[] a= { 1 , 2 , 3 ..... }

声明和创建必须在一起

第三种创建方式：

 数据类型[] 数据名 = new 数据类型[]{ 元素1， 元素2 ， 元素3，…… }；
 数据类型[] 数据名 = new 数据类型[]{ 元素1， 元素2 ， 元素3，…… }

注意：

[ ]里不要给大小，给就错误了

声明和创建可以分开写

总结：

1， 第一种适合：数组的大小已知，元素未知

2， 第二种适合： 数组元素固定，不改变

3， 第三种适合： 数据元素给定，还想要改变。

5.5 数组的高级应用

动态给数组赋值

数组求和

数组元素的平均值

最大值/最小值

计数

排序

查找

5.5.1 动态赋值

求和，平均值

 double[] score = new double[5];
         Scanner sc = new Scanner(System.in);
         
         double sum = 0;
         for (int i = 0; i < score.length; i++) {
             System.out.println(" input the score of student ");
             score[i] = sc.nextDouble();
             sum += score[i];
         }
         System.out.println("report :");
         for (int i = 0; i < 5; i++) {
             System.out.println("student: " + i + " get " + score[i]);
         }
 ​
         System.out.println("sum :" + sum + ". avg : " + (sum / score.length));

5.5.3 最大值和最小值

 public class TestUse2 {
     public static void main(String[] args) {
         System.out.println("请输入五个学生成绩:");
         Scanner sc = new Scanner(System.in);
 ​
         int[] score = new int[5];
         int max = 0, min = 999 , maxIndex = -1, minIndex = -1;
         for (int i = 0; i < score.length; i++) {
             
             score[i] = sc.nextInt();
             //每个人的分数和最高的比较，比max高，刷出最高分
             if(score[i] > max) {
                 max = score[i];
                 maxIndex = i;
             }
             if(score[i] < min) {
                 min = score[i];
                 minIndex = i;
             }
             
         }
         System.out.println(max + "," + min);
         System.out.println(maxIndex + 1  + "," + (minIndex + 1));
     }
 }
 ​

最高分重复问题：

 for (int i = 0; i < score.length; i++) {
             if(max == score[i]) {
                 System.out.println("最高分：" + (i + 1));
             }
     }

5.5.4 计数问题

数组内部统计个数

统计不及格的学生人数：

 ​

5.5.5 数组排序

排序方式：

冒泡排序，选择排序，插入排序，归并排序，堆排序……

5.5.5.1 冒泡排序：（下沉法）

将数组的元素 挨着的 两两比较，交换，大的向下沉，小的上浮，直到最大的沉到最下面，完成一次冒泡，后续的将元素按照此原来的一次完成。

n个数字 冒 n-1次泡 4 3 2 1

 

e.g.

     int[] a = { 1,2,3,4 };
         int t = 0;
         for ( int i = 1 ; i < a.length ; i ++ ) {
             for( int j = 0 ; j < a.length-i ; j++ ) {
                 if( a[j] < a[j+1] ) {
                     t = a[i];
                     a[i]=a[j];
                     a[j]=t;
                 }
             }
         }
 System.out.println( Arrays.toString(a) );
 //输出结果： [4, 3, 2, 1]

5.5.5.2 选择排序

将数组的某个位置上的元素与其他位置元素比较，进行交换，a[0]和a[1]a[2]a[3],每次确定一个位置。

 

JAVA中的数组的API

导包：

Arrays java.util.Arrays JAVA 工具包

String是唯一不用导包的类

专门处理数组：数组的帮助类。该类中定义很多操作数组的方法：排序/查找、输出数组、交换元素……

排序方法：sort()

用法：

 Arrays.sort(数组名);//自动升序

打印方法：toString()

 Arrays.toString(数组名);//打印数组成串

5.5.6 数组元素查找

线性查找，二分查找（折半查找）

线性查找：将目标元素和数组当中的每一个元素依次比较，

当发现有相同，结果为：查找到，

当循环全部执行结束后，依然没有找到，结果为：没有。

 int [] a = {12,45,66,34,12,7,34,12,45,45,78,45};
         Scanner sc = new Scanner(System.in);
         System.out.println("请输入要查找的元素:");
         int target = sc.nextInt();
         boolean flag = true;
         for (int i = 0; i < a.length; i++) {
             if(target == a[i]) {
                 System.out.println("找到该元素");
                 flag = false;
                 break;
             }
         }
         if(flag) {
             System.out.println("没有该元素");
         }

二分查找（折半查找）：

先保证数组先排序，取中间位置上的元素和目标，

目标>中间元素，中间位置就会变成开始位置

目标<中间元素，中间位置成为查找j

结束位置，目标就是中间位置，直接找到。

e.g.

 public class TestFind2 {
     public static void main(String[] args) {    
         int [] a = {12,45,66,34,12,7,34,12,45,45,78,45};
         Scanner sc = new Scanner(System.in);
         System.out.println("请输入要查找的元素:");
         int target = sc.nextInt();
         boolean flag = true;
         int s = 0, e = a.length - 1, m;
         while(s <= e) {
             m = (s + e) / 2;
             if(a[m] == target) {
                 System.out.println("找到了");
                 flag = false;
                 break;
             }else if(a[m] < target) {
                 s = m + 1;
             }else {
                 e = m - 1;
             }
         }
         
         if(flag) {
             System.out.println("没有该元素");
         }
     }
 }

查找API

 int index = Arrays.binarySearch(a,target);
 System.out.println(index);//输出值为下标。

 public class TestFind3 {
     public static void main(String[] args) {    
         int [] a = {12,45,66,34,12,7,34,12,45,45,78,45};
         Scanner sc = new Scanner(System.in);
         System.out.println("请输入要查找的元素:");
         int target = sc.nextInt();
         
         Arrays.sort(a);
         //第一个参数数组 第二个参数是目标
         int index = Arrays.binarySearch(a, target);
         if(index >= 0) {
             System.out.println("包含");
         }else {
             System.out.println("不包含");
         }
     }
 }