课时24—课时30 | Java 数组对象的创建和应用

1.数组的作用和类型

• 作用：存储相同数据类型的一组数据
• 对同类型数据进行集中管理，比如存储和遍历
• 数组的类型就是数组中存放数据的类型
• 要点
  —- 数组中的所有元素必须属于同一种类型
  —- 数组中所有元素在内存中连续存储
  —- 数组本身也是一种引用类型
  —- 数组名只是引用，指向堆中创建的数组对象，该对象保存一组其他引用或数值

---

2.声明、创建数组

• 声明：高速系统数据类型
  语法 数据类型[] 数组名
• 创建：为数组分配内存空间
• 声明并创建数组
  语法 数据类型[] 数组名=new 数据类型[length]
• 要点
  —- 数组中length是数组的容量，不是数据的数量
  —- []是访问数组元素的唯一方式
  —- 对象数组保存的是引用，基本类型数组直接保存基本类型的值，引用类型数组保存引用类型的地址
  —- 新声明的数组对象会自动初始化null，基本类型数组成员有各自的默认值（数值型为0，字符型为（char）0，布尔型为false）

---

3.初始化数组

• 边声明边赋值（静态初始化）：

int[] score={45,67,34};
int[] num=new int[]{14,22,34};

• 动态获取并赋值：

int[] score=new int[len];
Scanner input=new Scanner(System.in);
for(int i=0;i<len;i++){
     score[i]=input.nextInt();
}

---

4.常用数组查找算法

4.1 顺序查找法：逐一检查数组中的元素

/*计算字符的个数*/
import java.util.Scanner;
public class Main{
    public static void main(String[] args){
        Scanner scan=new Scanner(System.in);
        String all=scan.nextLine();
        String one=scan.nextLine();
        int num=0;
        char[] str=all.toCharArray();
        for(int i=0;i<str.length;i++){
            if(one.equalsIgnoreCase(String.valueOf(str[i])))
            num++;
        }
       System.out.println(num);
    }
}

/*找出数组中的最大值和最小值*/
public class Main{
     public static void main(String[] args){
          int[] array={10,22,21,2,54,209};
          int num=array[0];
          //find the min
          for(int i=1;i<array.length;i++){
              if(num>array[i]){
                    num=array[i];
              } 
          }
          System.out.prinln("min:"+num);

         //find the mun
          for(int i=1;i<array.length;i++){
              if(num<array[i]){
                    num=array[i];
              }
          }
          System.out.prinln("max:"+num)
     }

}

4.2 有序数组的二分查找法
需要设置start，end，middle“指针”

import java.util.Scanner;
public class Main{
    public static void main(String[] args){
        int[] array={0,1,2,3,4,5,6,7,8,9};
        System.out.println("Input a num:");
        Scanner scan=new Scanner(System.in);
        int i=scan.nextInt();
        int index=-1;//数组下标
        int start=0;//起始下标
        int end=array.length-1;//终止下标
        int middle;//中间下标
        while(start<=end){
               //确定中间下标
               middle=(start+end)/2;
               if(array[middle]==i){
                    index=middle+1;
                    System.out.println("The number location is "+index);
                    break;
               }else if(i<array[middle]){
                    end=middle-1;
               }else{
                    start=middle+1; 
               }
        }
if(index==-1)
System.out.println(i+" is not here!");
System.out.println("The number location is "+index);
    }
}

---

5.常用数组排序算法

5.1 冒泡排序法：
- 对每一对相邻元素作比较，前面的比后面的大，就交换位置。
- 从开始第一对到最后一对，最后的元素应该是最大的数
- 对最后一个元素以外的数组元素，重复上面的步骤，直到没有任何一堆数字需要比较
- 要点：
—- N个数要比较N-1轮——外层循环
—- 每一轮要比较N-1-i次——内层循环

public class BubbleSort {
     public static void main(String[] args){
          int[] array={20,19,23,54,22,31,39};
          //sort
          int len=array.length-1;
          //length个数，要比较length-1轮
          for(int i=0;i<len;i++){
              //每一轮比较的次数是length-1-i次
              for(int j=0;j<len-i;j++){
                   if(array[j+1]<array[j]){
                        int temp=array[j];
                        array[j]=array[j+1];
                        array[j+1]=temp;
                   }
              }
          }
          for(int i=0;i<=len;i++){
              System.out.print(array[i]+",");
          }
     }
}

5.2 选择排序法
- 在未排序序列中找到最小元素，放在序列的起始位置
- 再从剩余的未排序元素中继续寻找最小元素，放在已排序序列的末尾
- 以此类推，直到所有元素均排序完毕
- 要点：
—- N个数要比较N-1轮——外层循环
—- 每一轮要从第i+1个元素查找到最后一个元素——内层循环
—- 需要设置一个minIndex存放第i个最小元素

public class SelectSort {
     public static void main(String[] args){
          int[] array={23,19,42,22,20,52,43};
          int minIndex=0;//保存最小元素值的下标
          int len=array.length-1;

          for(int i=0;i<len;i++){
              minIndex=i;
              //查找最小元素的下标
              for(int j=i+1;j<len+1;j++){
                   if(array[minIndex]>array[j]){
                        minIndex=j;//保存最小元素的下标
                   }
              }
              //如果第i个最小的元素位置发生变化，需要互换
              if(i!=minIndex){
                   int temp=array[i];
                   array[i]=array[minIndex];
                   array[minIndex]=temp;
              }
          }
          for(int i=0;i<len+1;i++){
              System.out.print(array[i]+",");
          }
     }
}

5.3 插入排序法

-对于未排序的数据，在已排序的序列中从后向前扫描，找到相应位置并插入。
-从后向前扫描的过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间
方法一
-要点：
—- N个数要比较N-1轮，插入元素从第二个元素开始到最后一个元素结束——外层循环
—- 每一轮要从第i-1个元素比较到第一个元素——内层循环
—- 比较的过程中需要与前面比自己大的元素互换

public class InsertSort2 {
     public static void main(String[] args){
          int[] array={10,23,4,29,32,14,53,31};
          for(int i=1;i<array.length;i++){
            for(int j=i;j>0;j--){
              if(array[j]<array[j-1]){
                   int temp=array[j];
                   array[j]=array[j-1];
                   array[j-1]=temp;
              }
            }
        }
          for(int i=0;i<array.length;i++){
              System.out.print(array[i]+",");
     }
     }
}

方法二
- 要点：
—- 需要提前把要插入的元素值存起来。
—- 把前面的元素逐个后移，直到找到要插入的位置。
—- 最后把存起来的数据放在要插入的位置。

public class InsertSort {
     public static void main(String[] args){
          int[] array={10,23,4,29,32,14,53,31};
          for(int i=1;i<array.length;i++){
            int temp=array[i];//把要插入的数存起来
            int j=i;//把下标存起来
            //把要插入的位置挪出来
            while(j>0&&temp<array[j-1]){
              array[j]=array[j-1];
              j--;
            }
            array[j]=temp;
        }
          for(int i=0;i<array.length;i++){
              System.out.print(array[i]+",");
          }
     }
}

---

6.Arrays类的用法

binarySearch() 二分查找
sort() 排序
equals() 比较数组
copyOf() 复制
copyOfRange() 按范围复制
fill() 填充
toString()返回指定数组内容的字符串表示形式。

---

7.二维数组

7.1 声明与创建：
- 二维数组可以看成以数组为元素的数组
- 从高维到低维的顺序声明和初始化
- 第一维的大小姐定了二维数组对象的大小
7.1 初始化
- 静态初始化

int[][] arr={{1,2},{3,4,5},{6,7}}

-动态初始化

String[][] arrStr;//声明
arrStr=new String[3][];//创建

//高维初始化
arrStr[0]=new String[2];
arrStr[1]=new String[3];
arrStr[2]=new String[3];

//低维初始化
arrStr[0][0]=new String("abc000");