六、数组和排序

一、数组得定义和使用

什么是数组？

        所谓数组，是有序的元素序列。 若将有限个类型相同的变量的集合命名，那么这个名称为数组名。组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。用于区分数组的各个元素的数字编号称为下标。

        在js中，数组没有数据类型限制,并且可以随意扩容。Java中的数组 就是 将相同数据类型的数据 进行存储的数据格式。并且存储到数组中的数据都会自动生成一个编号，称之为索引值或者下标。然后数组是通过操作索引值对数据进行存取。索引值从0开始。并且java中的数组是定容，统一数据类型的。

        java数组的特点

• java数组是一种引用数据类型
• java数组中的数据类型必须统一
• java数组是定长的（长度一旦确定就不能变化）
• 数组的重新赋值，只能通过标准格式，不能使用简化格式赋值
• 初始化数组时如果没有直接赋值，那么数组中元素的默认值  整数: 0 浮点数: 0.0 字符:'\u0000' 布尔型:false 引用类型:null
• 因为数组是定长的，如果想扩容只能创建一个新的数组。  Arrays.copyOf(原始数组，长度)

        数组的定义

•  定义有容量的数组数据类型[] 数组变量 = new 数据类型[数组容量];
•  定义有初始化数据的数组.后面的中括号中不能写长度数据类型[] 数组变量 = new 数据类型[]{数据1,数据2...};
•  直接赋值创建(静态创建)，定义和赋值必须写在一起数据类型[] 数组变量 = {数据1,数据2...};

public static void main(String[] args) {

/*

数据类型 变量名 = 数据;

数据类型[] 数组变量名 = new 数据类型[长度];

*/

int num = 10; // 普通变量

int[] numAry = new int[10]; // 数组对象

// java中的数组创建

// 方式一: 定义数组变量，并创建特定长度的数组空间

// 没有赋值，有默认值: int 0,String null,char '0',boolean false

int[] numAry = new int[5];

System.out.println(numAry); // 输出数组再内存地址

/*System.out.println(numAry[0]);

System.out.println(numAry[1]);

System.out.println(numAry[2]);

System.out.println(numAry[3]);

String[] nameAry = new String[3];

//System.out.println(nameAry);

System.out.println(nameAry[0]);

System.out.println(nameAry[1]);

System.out.println(nameAry[2]);

//System.out.println(nameAry[3]);*/

//Array(数组)Index(索引)OutOf(超出)Bounds(边界)Exception(异常)

// 方式二: 定义数组变量，并使用new的方式进行数据初始化

// 后面的中括号，一定不能写长度

int[] numAry2 = new int[]{200,100,300}; // 根据个数创建数组空间，并赋值

/*System.out.println(numAry2.length); // length:数组长度

System.out.println(numAry2[0]);

System.out.println(numAry2[1]);

System.out.println(numAry2[2]);*/

// 方式三: 定义变量，用静态方式直接进行初始化

// 这种方式必须再声明变量的同时进行赋值。不能先声明变量，再赋值

int[] numAry3 ={12,34,11,39};

// 循环

for (int i=0;i<numAry3.length;i++){

System.out.println(numAry3[i]);

}

}

         数组的使用

数据类型[] 数组变量 = new 数据类型[数组容量];

// 通过数组变量+下标 为数组元素赋值。数组的最大下标只能取到"数组容量-1"

数组变量[下标1] = 数据1;

数组变量[下标2] = 数据2

数组变量[数组容量-1] = 数据n;

// 通过数组变量+下标 访问数组元素

System.out.println(数组变量[下标])

public class Test2 {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

// 定义长度为5的整形数组,输入5个分数,并遍历输出

int[] scoreAry = new int[5];

//scoreAry[0] =234;

//scoreAry[1] = 456;

for (int i=0;i<scoreAry.length;i++){

System.out.println("请输入第"+(i+1)+"个学生的分数:");

int s = sc.nextInt(); // 接收整数

// 将分数存入数组中

scoreAry[i] = s;

}

System.out.println("==================");

// for+索引 遍历

for (int i=0;i<scoreAry.length;i++){

System.out.println(scoreAry[i]);

}

System.out.println("==================");

// for each 遍历

for(int t : scoreAry){

System.out.println(t);

}

}

}

注意: 当数组下标超出数组边界的时候，会报出ArrayIndexOutOfBoundsException 

        数组的遍历

方式一：for+索引

int[] scoreAry = new int[5];
// for+索引 遍历
for (int i=0;i<scoreAry.length;i++){
    System.out.println(scoreAry[i]);
}

 方式二: for each 遍历

int[] scoreAry = new int[5];
// for each 遍历
for(int t : scoreAry){
    System.out.println(t);
}

        数组的操作

求数组最大值，最小值，最大值下标，最小值下标
 

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

// 定义长度为5的整形数组,输入5个分数,并遍历输出

int[] scoreAry = new int[5];

//scoreAry[0] =234;

//scoreAry[1] = 456;

for (int i=0;i<scoreAry.length;i++){

System.out.println("请输入第"+(i+1)+"个学生的分数:");

int s = sc.nextInt(); // 接收整数

// 将分数存入数组中

scoreAry[i] = s;

}

System.out.println("==================");

// for+索引 遍历

for (int i=0;i<scoreAry.length;i++){

System.out.println(scoreAry[i]);

}

System.out.println("==================");

// for in 遍历

for(int t : scoreAry){

System.out.println(t);

}

}

 

public static void main(String[] args) {

// 定义数组，存储5个分数，求最高分，最低分，最高分位置，最低分位置

int[] scores = {67,34,88,29,5,87,120,33,58,90};

// 定义最大值位置

int maxPos = 0;

// 定义最小值位置

int minPos = 0;

for (int i = 1; i < scores.length; i++) {

// 比较对应位置上的数据

if(scores[i]>scores[maxPos]){

// 记录数据的位置

maxPos = i;

}

if(scores[i]<scores[minPos]){

minPos = i;

}

}

System.out.println("最大值:"+scores[maxPos]+" 最大值位置:"+maxPos );

System.out.println("最小值:"+scores[minPos]+" 最小值位置:"+minPos );

}

二、数组排序

        冒泡排序

public static void main(String[] args) {
    // N元数组冒泡序，两两相比小前移，外层循环从1始，内层循环减i去
    // 冒泡排序:
    // 1.比较 2.换位
    int[] numAry = {20,12,33,8,4,1,200,34,98};
    // 外层控制轮数
    for(int i=1;i<numAry.length;i++){
        // 内层控制比较过程(次数)
        for(int j=0;j<numAry.length-i;j++) {
            //核心
            // 比较 
           if (numAry[j] > numAry[j + 1]) {
                // 换位
                int temp = numAry[j];
                numAry[j] = numAry[j + 1];
                numAry[j + 1] = temp;
            }
        }
    }
    for(int n :numAry){
        System.out.println(n);
    }
}

         选择排序

选择: 每轮排序都选择数据最小的那个元素（下标），与本轮排位第一的元素换位

public static void main(String[] args) {
    int[] numAry = {1,12,33,8,4,200,34,20,98};
    //k=1       k=5
    // 控制轮数,记录本轮第一个元素的位置
    for (int i=0;i<numAry.length-1;i++){
        int k=i; // 记录最小值的位置
        for(int j=i+1;j<numAry.length;j++){
            // 通过比较，记录最小值的位置
            // 如果k上的值，比j上的值大
            if(numAry[k]>numAry[j]){
                // 就要把j的值赋值给k。k总是指向最小值
                k = j;
            }
        }
        // 找到本轮最小值的位置
        System.out.println("K:"+k);
        // 如果最小值的位置，和排位第一的位置不同，则换位
        if(k!=i){
            int temp = numAry[i];
            numAry[i] = numAry[k];
            numAry[k] = temp;
        }
    }
    // 循环输出
    for (int n :numAry){
        System.out.println(n);
    }
}

三、二维数组

public static void main(String[] args) {
    // 存储一排学生的位置
    String[] names1 = {"张三","李四","王五"};
    // 存储一个班级的学生
    String[][] names2= new String[][] {
            //0      1     2
            {"张三","李四","王五"},
  // 0
            {"赵六","孙琪","王高"},
  // 1
            {"高达","悟空","唐僧"}
   // 2
    };
    // 创建二维数组: [行][列]
    String[][] names3 = new String[3][5];
    for (int i = 0; i < names2.length; i++) {
        System.out.println("第"+(i+1)+"排:");
        for (int j=0;j<names2[i].length;j++){
            System.out.print(names2[i][j]+" ");
        }
        System.out.println();
    }
    /*System.out.println(names2[0][0]);
    System.out.println(names2[0][1]);
    System.out.println(names2[0][2]);
    System.out.println(names2[1][0]);
    System.out.println(names2[1][1]);
*/
}

四、对象数组

        对象数组创建和遍历

public static void main(String[] args) {
    // 定义对象数组
    //int[] nums;
 // 整形数组
    //String[] strs;
 // 字符串数组
    //Student[] stus;
 // 学生数组,每个元素空间，必须存储学生对象
    Student[] stus = new Student[10];
    // 在数组第一个位置存储一个学生
    Student s1 = new Student("张三","男",20);
    //System.out.println(s1.name+" "+s1.sex);
    //System.out.println(s1);
    stus[0] = s1;
    stus[1] = new Student("李四","女",18);
    stus[2] = new Student("王五","女",18);
    stus[3] = new Student("赵六","女",18);
    stus[4] = new Student("孙琪","女",18);
    // 遍历学生对象
    for (int i=0;i<stus.length;i++){
        if(stus[i]!=null) {
            Student x =  stus[i];
            System.out.println(x.name+" "+x.sex+" "+x.age);
            //System.out.println(stus[i].name + " " + stus[i].sex + " " + stus[i].age);
        }
    }
}

         对象数组的排序

public class Test2 {
    public static void main(String[] args) {
        Student[] stus = new Student[3];
        stus[0]=new Student("张三","男",20);
        stus[1]=new Student("李四","男",19);
        stus[2]=new Student("王五","男",25);
        for (Student s: stus){
            s.show();
        }
        System.out.println("===================="); 
       // 冒泡排序
        for(int i=1;i<stus.length;i++){
            for(int j=0;j<stus.length-i;j++){
                // 前面的学生和后面学生的年龄相比
                if(stus[j].age>stus[j+1].age){
                    // 年龄大的学生，向后移动 
                   Student temp = stus[j];
                    stus[j]=stus[j+1];
                    stus[j+1]=temp;
                }
            }
        }
        for (Student s: stus){
            s.show();
        }
    }
}

五、Arrays工具类的使用

// 定义数组
int[] nums = {20,30,40,12,17};
// 排序Arrays.sort(nums);for (int n : nums){
    System.out.println(n);}// 字符串String res =  Arrays.toString(nums);
System.out.println(res);
// 扩展数组（重点内容，是后面ArrayList集合扩容的核心方法）
int[] my = Arrays.copyOf(nums,20);
System.out.println(Arrays.toString(my));