JAVA——数组

数组：存储一组相同类型的一个容器（数据的组合）

什么是数组：

数组是一个变量，用来存储一组相同数据类型的数据

声明一个变量就是在内存空间划出一块合适的空间

声明一个数组就是在内存空间划出一串连续的空间

数组使用步骤：

1，声明数组：数组类型[]数组名；或者：数组类型 数组名[];

2，申请空间（向计算机申请内存）：new数据类型[数组的大小/长度]；

3，赋值：

4，使用数组

或者合并：

数据类型[] 数组名 = new 数据类型 [数组的长度]；

数据类型 []数组名 = {"值1"，"值2"……}；

数组基本要素：

        标识符：数组的名称，用于区分不同的数组

        数组元素：向数组中存放的数据

        元素下标：对数组元素进行编号，从0 开始，数组中的每个元素都可以通过下标来访问

        元素类型：数组元素的数据类型

        注意: 数组长度固定不变，避免数组越界

注意事项：

1，数组的下标从0开始；

2，数组的长度/数组的元素个数是：数组名.length；

3，数组的最后一个的下标是：（length-1）；

4，IDEA遍历数组的快捷写法：

        1，升序遍历：数组名.fori；

        2，倒叙遍历：数组名.forr；r==rerverse（颠倒）；

        3，foreach遍历：数组名.for 冒号之后是数组，之前是每一个元素，

如何使用数组：

//例如:定义一个存储分数的数组
//使用数组四步走:
        //第一步：声明数组
        int[] score;

        //第二步：分配空间
        score=new int[5];

        //第三步：赋值
        score[0]=80;

        //第四步：处理数组
        score[0]=score[0]*10;

声明数组：

声明数组 : 告诉计算机数据类型是什么

示例 : int [ ]   JavaScore ; //Java 成绩

语法 : 数据类型         数组名 [ ] ;

        数据类型 [ ]          数组名 ;

注意 : 声明数组时不能规定数组长度

分配空间:

分配空间 : 告诉计算机分配几个连续的空间

        JavaScore = new int [ 30 ];

语法 : 声明数组并分配空间

        数据类型 [ ] 数组名 = new 数据类型 [ 大小 ] ;

示例：

        int [] JavaScore = new int [ 30 ];

数组赋值：

赋值：向分配的空间里放入数据
    JavaScore[0] = 89; 
    JavaScore[1] = 79; 
    JavaScore[2] = 76; 
    ……
    太麻烦！能不能一起赋值？ 

方法1: 边声明边赋值 
    int[ ] JavaScore = {89, 79, 76}; 
    int[ ] JavaScore = new int[ ]{89, 79, 76}; 
注意：不能指定数组长度 

方法2：动态地从键盘录入信息并赋值 
    int[] JavaScore=new int[5]; 
    Scanner input = new Scanner(System.in); 
    for(int i = 0; i < JavaScore.length; i ++){ 
        score[i] = input.nextInt(); 
    }

处理数据:

对数据进行处理：计算5位学生的javaScore平均分 
方式一：
    int [ ] JavaScore = {60, 80, 90, 70, 85}; 
    double avg; 
    avg = (JavaScore[0] + JavaScore[1] + JavaScore[2] + JavaScore[3] + JavaScore[4])/5; 

方式二:
    int [ ] JavaScore = {60, 80, 90, 70, 85}; 
    int sum = 0; 
    double avg; 
    for(int i = 0; i < JavaScore.length; i++){ 
        sum = sum + JavaScore[i]; 
    }
    avg = sum / JavaScore.length; 

注释： 
    1:访问数组成员：使用“标识符[下标]” 
    2:数组的length属性 
    3:JavaScore[i]:访问成员

提问使用数组求10个学生的平均分:

数组升序排序:

题目：循环录入5位学员成绩，进行升序排列后输出结果
提示：
        使用java.util.Arrays类
        注意导包：java.util下的
        Arrays类的sort()方法：对数组进行升序排列
public class ScoreSort {
        public static void main(String[] args) {
                int[] scores = new int[5]; //成绩数组
                Scanner input = new Scanner(System.in);
                System.out.println("请输入5位学员的成绩：");
                //循环录入学生成绩并存储在数组中
                for(int i = 0; i < scores.length; i++){
                        scores[i] = input.nextInt();
                }
                //数组中的元素被重新排列
                Arrays.sort(scores);
                System.out.print("学员成绩按升序排列：");
                //循环输出数组中的信息
                for(int i = 0; i < scores.length; i++){
                        System.out.print(scores[i] + " ");
                }
        }
}

使用Arrays类的各种方法:

public class Arrays_Study {
        public static void main(String[] args) {
                //返回值：boolean 方法名称:equals(array1,array2)
                //作用：比较数组array1和array2是否相等
                System.out.println("---------equals(array1,array2)方法:----------");
                int[] arr1={10,50,90,80,60};
                int[] arr2={10,50,90,80,60};
                int[] arr3={20,40,90};
                //判断arr1与arr2的长度及元素是否相等
                System.out.println(Arrays.equals(arr1,arr2));
                //判断arr1与arr3的长度及元素是否相等
                System.out.println(Arrays.equals(arr1,arr3));

                //方法名称： sort(array)
                //作用：对数组array的元素进行升序排列
                System.out.println("\n---------sort(array)方法:----------");
                int[] JavaScores ={90,50,100,60,30,70};
                //对数组进行升序排列
                Arrays.sort(JavaScores);
                System.out.println("Java成绩升序排列后：");
                for (int i = 0; i <JavaScores.length ; i++) {
                        System.out.print(JavaScores[i]+"\t");
                }

                System.out.println();
                //返回值：String 方法名称：toString(array)
                //作用:将数组array转换成一个字符串
                System.out.println("\n---------toString(array)方法:----------");
                int[] SqlScores = {70,80,50,40,60,20};
                //对数组进行升序排列
                Arrays.sort(SqlScores);
                //将SqlScores数组转换为字符串并输出
                System.out.println(Arrays.toString(SqlScores));

                //方法名称：fill(array,val)
                //作用：把数组array所有元素都赋值为value
                System.out.println("\n---------fill(array,val)方法:----------");
                int[] HtmlScores = {70,50,90,40,30,100};
                Arrays.fill(HtmlScores,60);
                //将HtmlScores数组转换为字符串并输出
                System.out.println(Arrays.toString(HtmlScores));

                //方法名称：copyOf(array,length)
                //作用：把数组array复制成一个长度为length的新数组，返回类型与复制的数组一致
                System.out.println("\n---------copyOf(array,length)方法:----------");
                int[] arr11={10,90,80,70,60};
                int[] arr22=Arrays.copyOf(arr11,6);
                System.out.println(Arrays.toString(arr22));
                int[] arr33=Arrays.copyOf(arr11,3);
                System.out.println(Arrays.toString(arr33));
                //将arr11复制成长度为5的新数组arr44
                int[] arr44=Arrays.copyOf(arr11,5);
                System.out.println(Arrays.toString(arr44));

                //返回值：int 方法名称：binarySearch(array, val)
                //作用：查询值val在数组array中的下标
                //（要求数组中元素已经按升序排列，如果没有找到，则返回一个负整数）
                System.out.println("\n---------binarySearch(array, val)方法:----------");
                int[] MathScores ={60,70,40,20,80,100};
                Arrays.sort(MathScores);
                int index = Arrays.binarySearch(MathScores,99);
                System.out.println(index);
                int indexTwo = Arrays.binarySearch(MathScores,20);
                System.out.println(indexTwo);
        }
}

求数组最大值：

题目:从键盘输入五位学生的成绩，求考试成绩最高分
示例：
        public static void main(String[] args) {
                Scanner input = new Scanner(System.in);
                //定义存储5个学生的成绩数组
                int[] scores = new int[5];
                //记录最大值
                int max = 0;
                System.out.println("请输入5位学员的成绩：")
                for(int i = 0; i < scores.length; i++){
                        scores[i] = input.nextInt();
                }
                //假设第一个元素为最大的成绩
                max = scores[0];
                //从第一个成绩开始比较
                for(int i = 1; i < scores.length; i++){
                        //循环判断
                        if(scores[i] > max){
                                max = scores[i];
                        }
                }
                System.out.println("考试成绩最高分为：" + max);
}

数组插入数据：

public static void main(String[] args){ 
    int[] list = new int[6]; 
    list[0] = 99; 
    list[1] = 85; list[2] = 82; 
    list[3] = 63; list[4] = 60; 
    //将最后一个元素空出 
    //保存新增成绩将插入的位置 
    int index = list.length; 
    System.out.println(index); 
    System.out.println("请输入新增成绩： "); 
    Scanner input = new Scanner(System.in); 
    int num = input.nextInt(); 
    //找到新元素的要插入的位置 
    for(int i = 0; i < list.length; i++){ 
        if(num > list[i]){ 
            index = i; 
            break; 
        } 
    }
    //元素后移 
    for(int j = list.length-1; j > index; j--){ 
        list[j] = list[j-1]; 
    }
    list[index] = num; 
    System.out.println("插入成绩的下标是："+index); 
    System.out.println("插入后的成绩信息是： "); 
    for (int k = 0; k < list.length; k++) { 
        System.out.print(list[k] + "\t"); 
    } 
}

数组降序排序:

实现思路： 
    1:先使用arrays类的sort方法进行升序排列 
    2:再使用for循环降序排列 
    int[] numbers = {9,41,52,1,8,90,60}; 
    Arrays.sort(numbers); 

    //从最后一个下标的输入开始 小于第一个下标 递减 
    for (int i = numbers.length-1; i >=0 ; i--) { 
        System.out.println(numbers[i]); 
    }

二维数组：

语法：
    <数据类型> [ ][ ] 数组名; 或者 <数据类型> 数组名 [ ][ ]; 
示例：
    int [ ][ ] scores; //定义二维数组 
    scores=new int[5][50]; //分配内存空间 
    或者
    int [ ][ ] scores = new int[5][50]; 

    注意：定义二维数组时，要定义最大维数 
         二维数组本质上仍是一个一维数组，只是它的每个元素又是一个一维数组

二维数组例图：int[][] s =new int[3] [5];

二维数组定义:

定义并赋值 
    写法一
        int[][] scores=new int[][]{ { 90, 85, 92, 78, 54 }, { 76, 63,80 }, { 87 }}; 
    写法二
        int scores[][] = {{ 90, 85, 92, 78, 54 }, { 76, 63,80 }, { 87 } }; 
    写法三
        int[][] scores ={{4},{5,78,18,13,78},{45,788}};