数组和排序

本是古典何须时尚 2023-10-03 19:01 31阅读 0赞

## **一、数组的定义和使用** ##

**什么是数组？**

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

在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);
     
    }
     
    }
     
    }

## 一、数组得定义和使用 ##

**什么是数组？**

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

**java数组的特点**

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

**数组的定义**

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

1.  `public static void main(String[] args) {`
2.  
3.  `/*`
4.  
5.  `数据类型 变量名 = 数据;`
6.  
7.  `数据类型[] 数组变量名 = new 数据类型[长度];`
8.  
9.  `*/`
10. 
11. `int num = 10; // 普通变量`
12. 
13. `int[] numAry = new int[10]; // 数组对象`
14. 
15. `// java中的数组创建`
16. 
17. `// 方式一: 定义数组变量，并创建特定长度的数组空间`
18. 
19. `// 没有赋值，有默认值: int 0,String null,char '0',boolean false`
20. 
21. `int[] numAry = new int[5];`
22. 
23. `System.out.println(numAry); // 输出数组再内存地址`
24. 
25. `/*System.out.println(numAry[0]);`
26. 
27. `System.out.println(numAry[1]);`
28. 
29. `System.out.println(numAry[2]);`
30. 
31. `System.out.println(numAry[3]);`
32. 
33. `String[] nameAry = new String[3];`
34. 
35. `//System.out.println(nameAry);`
36. 
37. `System.out.println(nameAry[0]);`
38. 
39. `System.out.println(nameAry[1]);`
40. 
41. `System.out.println(nameAry[2]);`
42. 
43. `//System.out.println(nameAry[3]);*/`
44. 
45. `//Array(数组)Index(索引)OutOf(超出)Bounds(边界)Exception(异常)`
46. 
47. `// 方式二: 定义数组变量，并使用new的方式进行数据初始化`
48. 
49. `// 后面的中括号，一定不能写长度`
50. 
51. `int[] numAry2 = new int[]{200,100,300}; // 根据个数创建数组空间，并赋值`
52. 
53. `/*System.out.println(numAry2.length); // length:数组长度`
54. 
55. `System.out.println(numAry2[0]);`
56. 
57. `System.out.println(numAry2[1]);`
58. 
59. `System.out.println(numAry2[2]);*/`
60. 
61. `// 方式三: 定义变量，用静态方式直接进行初始化`
62. 
63. `// 这种方式必须再声明变量的同时进行赋值。不能先声明变量，再赋值`
64. 
65. `int[] numAry3 ={12,34,11,39};`
66. 
67. `// 循环`
68. 
69. `for (int i=0;i<numAry3.length;i++){`
70. 
71. `System.out.println(numAry3[i]);`
72. 
73. `}`
74. 
75. `}`

**数组的使用**

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

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

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

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

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

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

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

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

![214e0a4f08eb4976a9462d4b4327d772.png][]

**数组的遍历**

**方式一：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) {
        // 存储一排学生的位置
        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工具类的使用 ##

![118a876df56548f3ae8b5b9990908416.png][]

![537319fc351b4e548a6113db2c04b6aa.png][]

[214e0a4f08eb4976a9462d4b4327d772.png]: https://img-blog.csdnimg.cn/214e0a4f08eb4976a9462d4b4327d772.png
[118a876df56548f3ae8b5b9990908416.png]: https://img-blog.csdnimg.cn/118a876df56548f3ae8b5b9990908416.png
[537319fc351b4e548a6113db2c04b6aa.png]: https://img-blog.csdnimg.cn/537319fc351b4e548a6113db2c04b6aa.png