包名命名规范

01PackageNameingNotations

  • 前面为域名倒着写，最后（contact）则体现不同的功能

数组的概述

  • 数组（Array），是多个相同数据类型按一定顺序排列的集合，并使用一个名字命名，通过编号的方式对这些数据进行统一管理。

数组的常见概念

  1. 数组名
  2. 标（或索引）
  3. 元素
  4. 数组的长度：元素的个数

特点

  1. 数组是有序排列的；
  2. 数组属于引用数据类型，但是数组的元素既可以是基本数据类型，也可以是引用数据类型；
  3. 创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是这块连续空间的首地址；
  4. 数组的长度一旦确定，就不能修改；
  5. 可以通过下标（或索引）的方式调用指定位置的元素，速度很快。

数组的分类

  1. 按照维数：一维数组、二维数组……
  2. 按照数组元素类型分类：基本数据类型元素的素组、引用数据类型元素的数组。

了解

数据结构

  1. 数据与数据之间的逻辑关系：集合、一对一、一对多、多对多

  2. 数据的存储结构：

    • 线性表：顺序表（比如：数组）、链表、栈、队列
    • 树形结构：二叉树
    • 图形结构：

算法

  1. 排序算法
  2. 搜（检索）索算法

一维数组的使用

一维数组的声明和初始化

  1. 声明：int[] ins;

  2. 静态初始化：数组的初始化和数组的赋值操作同时进行。

    • int ids = new int[]{1001,1002,1003,1004};

  3. 动态初始化：数组的初始化和数组的赋值操作分开进行

    • String[] names = new String[5];

  4. 错误写法

    • int[] arr1 = new int[];
    • int[5] arr2 = new int[5];
    • int [] arr3 = new int[3]{1,2,3};

  5. 总结：数组一旦初始化完成，其长度就确定了。

数组的基本操作

  1. 如何调用数组指定函数指定位置的函数

    • 通过索引（角标）的方式调用，索引（角标）从0开始，直到数组的长度-1结束

  2. 如何获取数组的长度

    • 属性：length
    • 使用：names.length

  3. 遍历数组

    • for(int i = 0; i < names.length; i++){}

数组元素的默认初始化值

  1. 数组元素是整形：0
  2. 数组元素浮点型：0.0
  3. 数组元素是char型：0（NUT）或’\u0000’（ASCII码为0的值）
  4. 数组元素是boolean型：false
  5. 数组元素是引用数据类型：null

数组的内存解析

  1. 栈（stack）：存放局部变量
  2. 堆（heap)：存放new出来的结构（对象数组）
  3. 方法区：常量池、静态域
  • 栈中的所有地址为Java虚拟机计算出来的哈希地址，并非真正的内存地址

多维数组的使用

二维数组

  1. 理解：对于二维数组的理解，可以看成是一维数组array1的元素而存在。从数组底层的运行机制来看，其实没有多维数组。
  2. 二维数组的使用
int[][] arr1 = new int[][]{{1, 2, 3}, {4, 5}, {6, 7, 8}};//静态初始化
String[][] arr2 = new String[3][2];//动态初始化1
String[][] arr3 = new String[3][];//动态初始化2
  • 错误情况
String[][] arr4 = new String[][4];
String[4][3] arr5 = new String[][];
int[][] arr6 = new int[4][3]{{1, 2, 3}, {4, 5}, {6, 7, 8}};
  • Tips：中括号（[]）的位置可以放在类名或者变量名后面；或者类名后面放一个，变量名后面放一个（二维数组）。
  • 类型推断：int[][] arr7 = {{1, 2, 3}, {4, 5}, {6, 7, 8}};//省略new int[][]

数组的基本操作

  1. 如何调用数组指定位置的函数

    • arry[i][j]; //第i行第j列的元素

  2. 如何获取数组长度

    • arr4.length;
    • arr4[0].length;

  3. 如何遍历数组

for(int i = 0; a <= arr4.length; i++){
    for(int j = 0; j <= arr4[i].length){
        //执行语句
    }
}

数组元素的默认初始化值

  1. 规定：二维数组分为外层数组的元素和内层数组的元素

    int[][] arr = new int[4][3];

  • 外层元素：arr[0]，arr[1]等；

  • 内层元素：arr[0][0]，arr[1][2]等；

  • 初始化方式一：int[][] arr = new int[4][3];

    • 外层元素的初始化值为：地址值
    • 内层元素的初始化值：与一维数组初始化情况相同

  • 初始化方式二：int[][] arr = new int[4][];

    • 外层元素的初始化值为：null
    • 内层元素的初始化值为：不能调用，否则报错

内存解析

数组中涉及到的常见算法

  1. 数组元素的赋值（杨辉三角、回形书等）（面试常考）

  2. 求数值型数组中元素的最大值、最小值、平均数、总数等

    package com.dawnlee.arrayex;

    /**
     * 
     * @Description 求数值型数组中元素的最大值、最小值、平均数、总和等
     * @author DawnLee
     * @version 1.0
     * @data 2020-7-27        22:14:07
     *
     */
    public class NumArray {
        public static void main(String[] args) {
            int[] array = new int[10];
            int maxValue = 0;
            int minValue = 0;
            int avg = 0;
            int sum = 0;
            for(int i = 0;i < array.length;i++) {
                array[i] = (int)(Math.random() * (99 - 10 + 1) + 10);
                System.out.print(array[i] + " ");
                if(array[i] > maxValue) {
                    maxValue = array[i];
                }
                sum += array[i];
            }
            minValue = array[0];
            for(int i = 0;i < array.length;i++) {
                if(array[i] < minValue) {
                    minValue = array[i];
                }
            }
            avg = sum / array.length;
            System.out.println("\n最大值为：" + maxValue);
            System.out.println("最小值为：" + minValue);
            System.out.println("平均数为：" + avg);
            System.out.println("总和为：" + sum);
        }
    }

  3. 数组的复制、反转、查找（线性查找、二分法查找）（面试会考）

    • 复制：通过遍历元素的方式进行复制操作，赋值只能使得新数组值相同一块内存区域，修改其中一个，原数组就得一起改变，相当于Linux中的硬链接

    • 反转：通过中间变量实现反转

    • 查找

      • 线性查找
      String dest = "BB";
      boolean isFind = false;
      for(i = 0;i < arr.length;i++){
          if(dest.equals(arr[i])){
              System.out.println("找到了指定元素，位置为：" + i);
              isFind = true;
              break;
          }
      }
      if(isFind == false){
          System.out.println("没找到！");
      }
      • 二分法查找
      //所有要查找的数组必须有序
      int[] arr2 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
      int dest1 = -34;
      int head = 0;//初始首索引
      int end = arr2.length - 1;//初始末索引
      boolean isFind = false;
      while(head <= end){
          int mid = (head + end)/2;
          if(dest1 == arr2[mid]){
              System.out.println("找到了指定的元素，位置为：" + mid);
              isFind = true;
              break;
          }else if(arr2[mid] > dest1){
              end = mid - 1;
          }else{
              head = mid + 1;
          }
      }
      if(isFind == false){
          System.out.println("很遗憾，没有找到！" );
      }

  4. 数组元素的排序算法（面试最常考）

    • 排序：假设含有n个记录的序列为(R1, R2,…, Rn)，其相应的关键字序列为(K1, K2,…, Kn)。将这些记录重新排序为(Ri1, Ri2,…, Rin)，使得相应的关键字满足条件Ki1 <= Ki2 <=…<= Kin，这样的一种操作成为排序。

      • 通常来说，排序的目的是快速查找。

    • 衡量排序算法的优劣

      • 时间复杂度：分析关键字的比较次数和记录的移动次数。
      • 空间复杂度：分析排序算法中徐需要多少辅助内存。
      • 稳定性：若两个记录A和B的关键字值相等，但排序后A、B先后次序保持不变，则称这种排序算法是稳定的。

排序算法分类

  1. 内部排序：整个排序过程不需要借助外部存储器（如磁盘等），所有排序操作都在内存中完成。

  • 十大内部排序算法（和具体语言无关），前八种较常用。

    • 选择排序：

      ①直接选择排序；

      ②堆排序。

    • 交换排序

      ③冒泡排序

      • 介绍：冒泡排序的原理很简单，它重复地走访要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。
      • 排序思想：比较相邻的元素，如果第一个比第二个大（升序），就交换它们两个；对每一对相邻元素做同样的工作，从开始的第一对到结尾的最后一对，这步做完后，最后元素回事最大的数；针对所有的元素重复上述步骤，除了最后一个；持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较为止。
      package com.dawnlee.arrayex;
      /**
       * 
       * @Description 数组冒泡排序的实现
       * @author DawnLee
       * @version 1.0
       * @data 2020-7-28        14:24:38
       *
       */
      public class BubbleSort {
          public static void main(String[] args) {
              int[] arr = new int[] {43,32,76,-98,0,64,33,-21,32,99};
              for(int i = 0;i < arr.length - 1;i++) {
                  for(int j = 0;j < arr.length - 1 - i;j++) {
                      if(arr[j] > arr[j + 1]) {
                          int temp = arr[j];
                          arr[j] = arr[j + 1];
                          arr[j + 1] = temp;
                      }
                  }
              }
              for(int i = 0;i < arr.length;i++) {
                  System.out.print(arr[i] + " ");
              }
          }
      }

      ④快速排序

      • 介绍：快速排序通常明显比同为O（nlogn）的其他算法更快，因此常被采用，而且快排采用了分治法的思想，所以在很多笔试面试中经常看到快排的影子。快速排序（Quick Sort）由图灵奖获得者Tony Hoare发明，被列为20世纪十大算法之一，是迄今为止所有内排序算中速度最快的一种。快速排序的时间复杂度为O（nlog(n)）。
      • 排序思想：从数列种挑出一个元素，称为“基准”（pivot）；重新排序数列，所有元素比基准值小的放在基准值前面，比基准值大的放在基准值后面（相同的数可以到任一边）。在这个分区结束后，该基准就处于数列的中间位置。这个称为分区（partition）操作；递归地（recursive）把小于基准值的子数列和大于基准值的子数列排序；递归的最底部情形是数列的大小是0或1，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会结束，因为每次迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。

    • 插入排序

      ⑤直接插入排序

      ⑥折半插入排序

      ⑦Shell排序

    • ⑧归并排序

    • ⑨桶式排序

    • ⑩基数排序

  1. 外部排序：参与排序的数据非常多，数据量非常大，计算机无法把整个排序过程放在内存中完成，必须借助外部存储器（如磁盘等）。外部排序最常见的是多路归并排序。可以认为外部排序是由多个内部排序组成。

各种排序算法的比较

04SortComparsion

  1. 从平均时间而言：快速排序最佳，但在最坏的情况下，时间性能不如堆排序和归并排序。
  2. 从算法简单性看：由于直接选择排序、直接插入排序和冒泡排序的算法比较简单，将其认为是简单算法。对于Shell排序、堆排序、快速排序和归并排序算法，其算法比较复杂，认为是复杂排序。
  3. 从稳定性看：直接插入排序、冒泡排序和归并排序是稳定的；而直接选择排序、快速排序、Shell排序和堆排序是不稳定排序。
  4. 从待排序的记录数n的大小看：n较小时，宜采用简单排序；而n较大时，宜采用改进排序。

排序算法的选择

  1. 若n较小（如n≤50），可采用直接插入或直接选择排序。

    • 当记录规模较小时，直接插入排序较好，否则因为直接选择移动的记录数少于直接插入，应选直接选择排序为宜。

  3. 若文件初始状态基本有序（正序），则应选用直接插入、冒泡或随机的快速排序为宜。

  4. 若n较大，则应采用时间复杂度为O（nlgn）的排序方法：快速排序、堆排序或归并排序。

算法五大特征

输入(Input) 有0个或多个输入数据，这些输入必须有清楚的描述和定义
输出(Output) 至少有1个或多个输出结果，不可以没有输出结果
有穷性(有限性，Finiteness) 算法在有限的步骤之后会自动结束而不会无限循环，并且每一个步骤可以在可接受的时间内完成
确定性(明确性，Definiteness) 算法中的每一步都有明确的含义，不会出现二义性
可行性(有效性，Effectiveness) 算法每一步都是清楚且可行的，能让用户用纸和笔计算出答案
  • 说明：满足确定性的算法也成为了确定性算法。现在人们也关注更广泛的概念，例如考虑各种非确定性的算法，如并行算法、概率算法等。另外，人们也关注并不要求终止的计算描述，这种描述有时被称为过程（procedure）。

Arrays工具类的使用

  1. java.util.Arrays类即为操作数组的工具类，它包含了用来操作数组（比如排序和搜索）的各种方法。
1 boolean equals(int[] a,int[] b) 判断两个数组是否相等
2 String toString(int[] a) 输出数组信息
3 void fill(int[] a,int val) 将指定值填充到数组之中
4 void sort(int[] a) 对数组进行排序
5 int binarySearch(int[] a,int key) 对排序后的数组进行二分法检索指定的值 
package com.dawnlee.arrayex;

import java.util.Arrays;
/**
 * 
 * @Description java.util.Arrays：操作数组的共工具类，里面定义了很多操作数组的方法
 * @author DawnLee
 * @version 1.0
 * @data 2020-7-28        16:56:11
 *
 */
public class ArraysTest {
    public static void main(String[] args) {
        //1.boolean equals(int[] a,int[] b):判断两个数组是否相等
        int[] arr1 =  new int[] {1,2,3,4};
        int[] arr2 =  new int[] {1,3,2,4};
        boolean isEquals = Arrays.equals(arr1,arr2);
        System.out.println(isEquals);

        //2.String toString(int[] a):输出数组信息
        System.out.println(Arrays.toString(arr1));

        //3.void fill(int[] a,int val):将指定的值填充到数组中
        Arrays.fill(arr1,10);
        System.out.println(Arrays.toString(arr1));

        //4.void sort(int[] a):对数组进行排序
        Arrays.sort(arr2);
        System.out.println(Arrays.toString(arr2));

        //5.int binarySearch(int[] a,int key):对排序后的数组进行二分法检索指定的值
        int[] arr3 = new int[] {-98,-34,2,34,54,66,79,105,210,333};
        int index = Arrays.binarySearch(arr3, 333);
        if(index >= 0) {
            System.out.println(index);
        }else {
            System.out.println("未找到");
        }
    }                
}
  • 运行结果

05RunResult01

数组中常见的一异常

package com.dawnlee.arrayex;
/**
 * 
 * @Description 说明数组中的常见异常
 * @author DawnLee
 * @version 1.0
 * @data 2020-7-28        17:27:15
 *1.数组角标越界的异常:ArrayIndexOutOfBoundsException
 *
 *2.空指针异常:NullPointerException
 */
public class ArrayException {
    public static void main(String[] args) {
        //数组角标越界的异常
//                int[] arr = new int[] {1,2,3,4,5};
//                for(int i = 0;i <= arr.length;i++) {
//                        System.out.print(arr[i] + " ");
//                }
//                System.out.println(arr[-2]);

        //空指针异常
        //情况一:
//                int[] arr1 = new int[] {1,2,3};
//                arr1 = null;
//                System.out.println(arr1[0]);

        //情况二:
//                int[][] arr2 = new int[4][];
//                System.out.println(arr2[0][0]);

        //情况三:
//                String[] arr3 = new String[] {"AA","BB","CC"};
//                arr3[0] = null;
//                System.out.println(arr3[0].toString());
    }
}

  1. 数组角标越界异常：ArrayIndexOutOfBoundsException

    • 情况一
    int[] arr = new int[] {1,2,3,4,5};
    for(int i = 0;i <= arr.length;i++) {
        System.out.print(arr[i] + " ");
    }

    06IndexRunResult1

    • 情况二
    System.out.println(arr[-2]);

06IndexRunResult2

  1. 空指针异常
  • 情况一
int[] arr1 = new int[] {1,2,3};
arr1 = null;
System.out.println(arr1[0]);

07NullRunResult1

  • 情况二
int[][] arr2 = new int[4][];
System.out.println(arr2[0][0]);

07NullRunResult2

  • 情况三
String[] arr3 = new String[] {"AA","BB","CC"};
arr3[0] = null;
System.out.println(arr3[0].toString());

07NullRunResult3

章节练习题

简答题

  1. Java能动态分配数组吗？

    答：可以。int i = 12; int[] myInt = new int[i];

  2. 我怎么知道数组的长度？

    答：.length属性获取。

  3. 数组有没有length()这个方法? String有没有length()这个方法？

    答：数组没有length()这个方法，只有length的属性；String有length()这个方法。

  4. Java中的任何数据类型都可以使用System.out.pritln方法显示。

    • 对于基本数据类型而言，输出的往往是变量的值；
    • 对于像数组这一类复杂的数据类型，输出的是其堆空间中存储位置的hashCode值。

  5. 操作二维数组的注意点。

    • 操作二位数组不应使用常数来控制维数，具体方法是array.length表示行数，array[row].length老表示row行的列数。这样当数组行数和列数不相等时，代码可以自动调整为正确的值。

编程题

  1. 显示输出

    String[] stringArray = new String[3]; // 各元素的值默认为null
    for (int i = 0; i < stringArray.length; i++) { // 对各元素进行初始化，但没有赋值。
        stringArray[i] = new String();
        System.out.println(stringArray[i]);
    }

    答：空（有别于null）。

  2. 面试题目：创建一个长度为6的int型数组，要求取值为1-30，同时元素值各不相同。

    package top.triabin.chapter02;
    /**
     * 
     * @Description 面试题目：创建一个长度为6的int型数组，要求取值为1-30，同时元素值各不相同。
     * @author DawnLee
     * @version 1.0
     * @data 2020-9-8    17:10:29
     *
     */
    public class CreateArrays {
        public static void main(String[] args) {
            int[] array = new int[6];
            int count = 0;
            while(count < 6) {
                int ele = (int)(Math.random() * (30 - 1 + 1) + 1);
                boolean isEqual = false;
                for(int i = 0;i < count;i++) {
                    if(array[i] == ele) {
                        isEqual = true;
                    }
                }
                if(isEqual) {
                    continue;
                }else {
                    array[count++] = ele;
                }
            }
            for(int i = 0;i < array.length;i++) {
                System.out.print(array[i] + " ");
            }
        }
    }

  3. 回形数格式方阵的实现：从键盘输入1个整数（1~20），以该数字为矩阵的大小，把1，2，3，…… n*n的数字按照顺时针螺旋的形式填入其中。例如输入数字2，则程序2输出：

    1 2

    4 3

    输入数字3，则程序输出：

    1 2 3

    8 9 4

    7 6 5

    输入数字4， 则程序输出：

    1 2 3 4

    12 13 14 5

    11 16 15 6

    10 9 8 7

    • 方法一：
    package top.trabin.chapter03;
    import java.util.Scanner;
    /**
     * 
     * @Description 回形数格式方阵的实现：从键盘输入1个整数（1~20），以该数字为矩阵的大小，
     *     把1，2，3，…… n*n的数字按照顺时针螺旋的形式填入其中。
     * @author DawnLee
     * @version 1.0
     * @data 2020-9-8    21:26:59
     *
     */
    public class CliNumber03 {
        public static void main(String[] args) {
            Scanner scan = new Scanner(System.in);
            System.out.print("矩阵大小(1~20)：");
            int len = scan.nextInt();
            int[][] mat = new int[len][len];
            int s = len * len;
            
            //k = 1:向右，k = 2:向下，k = 3:向左，k = 4:向上
            int k = 1;
            int i = 0,j = 0;
            for(int m = 1;m <= s;m++) {
                if(k == 1) {
                    if(j < len && mat[i][j] == 0) {
                        mat[i][j++] = m;
                    }else {
                        k = 2;
                        i++;
                        j--;
                        m--;
                    }
                }else if(k == 2) {
                    if(i < len && mat[i][j] == 0) {
                        mat[i++][j] = m;
                    }else {
                        k = 3;
                        i--;
                        j--;
                        m--;
                    }
                }else if(k == 3) {
                    if(j >= 0 && mat[i][j] == 0) {
                        mat[i][j--] = m;
                    }else {
                        k = 4;
                        i--;
                        j++;
                        m--;
                    }
                }else if(k == 4) {
                    if(i >= 0 && mat[i][j] == 0) {
                        mat[i--][j] = m;
                    }else {
                        k = 1;
                        i++;
                        j++;
                        m--;
                    }
                }
            }
            
            //显示
            for(int m = 0;m < mat.length;m++) {
                for(int n = 0;n < mat[m].length;n++) {
                    System.out.print(mat[m][n] + " ");
                }
                System.out.println();
            }
            scan.close();
        }
    }
    • 方法二：
    package top.trabin.chapter03;
    import java.util.Scanner;
    /**
     * 
     * @Description 第3题方法二
     * @author DawnLee
     * @version 1.0
     * @data 2020-9-13    12:53:16
     *
     */
    public class CliNumber0302 {
        public static void main(String[] args) {
            Scanner scan = new Scanner(System.in);
            System.out.print("矩阵大小(1~20)：");
            int len = scan.nextInt();
            int[][] mat = new int[len][len];
            scan.close();
            
            int count = 0;//元素个数
            int maxX = len - 1;//x轴最大下标
            int maxY = len - 1;//y轴最大下标
            int minX = 0;//x轴最小下标
            int minY = 0;//y轴最小下标
            
            while(minX <= maxX) {
                for(int x = minX;x <= maxX;x++) {
                    mat[minY][x] = ++count;
                }
                minY++;
                for(int y = minY;y <= maxY;y++) {
                    mat[y][maxX] = ++count;
                }
                maxX--;
                for(int x = maxX;x >= minX;x--) {
                    mat[maxY][x] = ++count;
                }
                maxY--;
                for(int y = maxY;y >= minY;y--) {
                    mat[y][minX] = ++count;
                }
                minX++;
            }
            
            for(int i = 0;i < mat.length;i++) {
                for(int j = 0;j < mat[i].length;j++) {
                    System.out.print(mat[i][j] + " ");
                }
                System.out.println();
            }
        }
    }

  4. 下面数组定义正确的有：

    A.String strs[] = { ‘a’ ‘b’ ‘c’};

    B.String[] strs = {“a”, “b”, “c”};

    C.String[] strs = new String{“a” ”b” ”c”};

    D.String strs[] = new String[]{“a”, “b”, “c”};

    E.String[] strs = new String[3]{“a”, “b”, “c”};

    答案：B、D。

  5. 写出结果：

    class Demo{
        public static void main(String[] args){
            String foo="blue"; 
            boolean[] bar=new boolean[2]; 
            if(bar[0]){
                        foo="green";
            }
            System.out.println(foo);
        }
    }

    答：输出：blue

  6. 下面哪个数组定义是错误的？对错误的答案加上单行注释，写出错误原因。

    A、float[]=new float[3]; //错误，没有变量名

    B、 float f2[]=new float[];//未指定数组长度

    C、 float[] f1=new float[3];//

    D、boolean[] b={“true”,”false”,”true”};//布尔型数组元素不能是字符串

    E、 double f4[]={1,3,5}; //错误

    F、int f5[]=new int[3]{2,3,4}; //动态赋值与静态赋值混用

    G、float f4[]={1.2F,3.0,5.4};//float型数组中放入了double型元素

  7. Arrays工具类的使用。

    练习：

    ①从键盘输入本组学员的成绩，放到数组中；

    ②用for循环显示所有学员的成绩；

    ③排序：从低到高；

    ④查找是否有正好60分的，如果有，返回位置；

    ⑤复制成绩最低三名构成新数组；

    ⑥用工具类打印成绩最低三名成绩。

    package top.trabin.chapter03;
    import java.util.Arrays;
    import java.util.Scanner;
    /**
     * 
     * @Description Arrays工具类的使用。
            练习：
            ① 从键盘输入本组学员的成绩，放到数组中；
            ② 用for循环显示所有学员的成绩；
            ③ 排序：从低到高；
            ④ 查找是否有正好60分的，如果有，返回位置；
            ⑤ 复制成绩最低三名构成新数组；
            ⑥ 用工具类打印成绩最低三名成绩。
     * @author DawnLee
     * @version 1.0
     * @data 2020-9-13    20:37:21
     *
     */
    public class ArraysTools07 {
        public static void main(String[] args) {
            Scanner scan = new Scanner(System.in);
            int[] scores = new int[10];
            System.out.println("请依次输入成绩：");
            for(int i = 0;i < scores.length;i++) {
                System.out.print("学生" + (i + 1) + "：");
                scores[i] = scan.nextInt();
            }
            scan.close();
            
            System.out.println("for循环显示：");
            for(int i = 0;i < scores.length;i++) {
                System.out.print(scores[i] + " ");
            }
            System.out.println("\n");
            
            Arrays.sort(scores);
            System.out.println("排序后：\n" + Arrays.toString(scores));
            System.out.println();
            
            int index = Arrays.binarySearch(scores, 60);
            if(index >= 0) {
                System.out.println("找到了，位置为：" + index);
            }else {
                System.out.println("没有成绩为正好60分的。");
            }
            System.out.println();
            
            int[] low = new int[3];
            low[0] = scores[0];
            low[1] = scores[1];
            low[2] = scores[2];
            System.out.println("最低3名成绩：" + Arrays.toString(low));
        }
    }

  8. 数组赋值练习2

    创建一个char类型的36个元素的数组，前26个元素放置’A’-‘Z’，后10个元素放置’1’-‘9’。使用for循环访问所有元素并打印出来。

    • 提示：char类型数据运算，’A’+1 –> ‘B’，’0’+1 –> ‘1’
    package top.trabin.chapter03;
    /**
     * 
     * @Description 创建一个char类型的36个元素的数组，前26个元素放置'A'-'Z'，后10个元素放置'1'-'9'。
     *     使用for循环访问所有元素并打印出来。
     *     提示：char类型数据运算，'A'+1 --> 'B'，'0'+1 --> '1'
     * @author DawnLee
     * @version 1.0
     * @data 2020-9-13    21:11:18
     *
     */
    public class CharTest {
        public static void main(String[] args) {
            char[] charArr = new char[36];
            charArr[0] = 'A';
            charArr[26] = '0';
            for(int i = 1;i < 26;i++) {
                charArr[i] = (char) ('A' + i);
            }
            for(int i = 27;i < 36;i++) {
                charArr[i] = (char)('0' + (i - 26));
            }
            for(int i = 0;i < charArr.length;i++) {
                System.out.print(charArr[i] + " ");
            }
        }
    }
    • 运行结果

  9. 一维数组a[]，用Java代码将数组元素顺序颠倒。

    package top.trabin.chapter03;

    import java.util.Arrays;

    /**
     * 
     * @Description 一维数组a[]，用Java代码将数组元素顺序颠倒。
     * @author DawnLee
     * @version 1.0
     * @data 2020-9-13    21:44:03
     *
     */
    public class ReverseArr {
        public static void main(String[] args) {
            int[] a = new int[] {1,2,3,4,5,6,7,8};
            System.out.println("原数组：" + Arrays.toString(a));
            for(int i = 0;i < (a.length / 2);i++) {
                int temp = a[i];
                a[i] = a[a.length - i - 1];
                a[a.length - i - 1] = temp;
            }
            System.out.println("颠倒后：" + Arrays.toString(a));
        }
    }
    • 运行结果

  10. 任意输入一个人输入年龄就可以判断出他是哪个年龄段的人。

    年龄 0-9 10-19 20-29 30-39 40-49 50-59 60-69 70-79 80-89 90-99
    年龄段 儿童 少年 青少年 青年 壮年 中年 中老年 老年 老老年 老老老年 
    package top.trabin.chapter03;
    import java.util.Scanner;
    /**
     * 
     * @Description 任意输入一个人输入年龄就可以判断出他是哪个年龄段的人。
     * @author DawnLee
     * @version 1.0
     * @data 2020-9-27    10:27:16
     *
     */
    public class AgeGroup {
        public static void main(String[] args) {
            Scanner scan = new Scanner(System.in);
            System.out.print("请输入年龄：");
            int age = scan.nextInt();
            scan.close();
            int level = (int)(age / 10);
            switch(level) {
            case(0):
                System.out.println("年龄段：儿童");
                break;
            case(1):
                System.out.println("年龄段：少年");
                break;
            case(2):
                System.out.println("年龄段：青少年");
                break;
            case(3):
                System.out.println("年龄段：青年");
                break;
            case(4):
                System.out.println("年龄段：壮年");
                break;
            case(5):
                System.out.println("年龄段：中年");
                break;
            case(6):
                System.out.println("年龄段：中老年");
                break;
            case(7):
                System.out.println("年龄段：老年");
                break;
            case(8):
                System.out.println("年龄段：老老年");
                break;
            case(9):
                System.out.println("年龄段：老老老年");
                break;
            default:
                System.out.println("错误：年龄超出范围(0~99)！");
            }
        }
    }

  11. 用数组求出斐波那契数列的前20项值。

    package top.trabin.chapter03;

    import java.util.Arrays;

    /**
     * 
     * @Description 用数组求出斐波那契数列的前20项值。
     * @author DawnLee
     * @version 1.0
     * @data 2020-9-27    10:45:04
     *
     */
    public class Fibonacci {
        public static void main(String[] args) {
            int[] fibo = new int[20];
            fibo[0] = 0;
            fibo[1] = 1;
            for(int i = 2;i < fibo.length;i++) {
                fibo[i] = fibo[i - 1] + fibo[i - 2];
            }
            System.out.println(Arrays.toString(fibo));
        }
    }
    • 运行结果

  12. 对10个整数进行从小到大的顺序排序。

    package top.trabin.chapter03;

    import java.util.Arrays;
    import java.util.Calendar;

    /**
     * 
     * @Description 对10个整数进行从小到大的顺序排序。
     * @author DawnLee
     * @version 1.0
     * @data 2020-9-27    10:52:27
     *
     */
    public class Sort {
        public static void main(String[] args) {
            int[] arr = new int[] {5,2,9,3,8,4,0,1,6,7};
            Sort sort = new Sort();
            //冒泡排序
            double start = Calendar.getInstance().getTimeInMillis();
            System.out.println("冒泡排序后：" + Arrays.toString(sort.bubbleSort(arr)));
            double end = Calendar.getInstance().getTimeInMillis();
            System.out.println("耗时：" + (end - start));
            System.out.println();
            
            //快速排序
            start = Calendar.getInstance().getTimeInMillis();
            System.out.println("快速排序后：" + Arrays.toString(sort.quickSort(arr)));
            end = Calendar.getInstance().getTimeInMillis();
            System.out.println("耗时：" + (end - start));
            
            //原序列
            System.out.println();
            System.out.println("原序列：" + Arrays.toString(arr));
        }
        
        public int[] bubbleSort(int[] array) {
            int[] a = new int[array.length];
            for(int i = 0;i < a.length;i++) {
                a[i] = array[i];
            }
            for(int i = 0;i < a.length - 1;i++) {
                for(int j = 0;j < a.length - 1 - i;j++) {
                    if(a[j] > a[j + 1]) {
                        int temp = a[j];
                        a[j] = a[j + 1];
                        a[j + 1] = temp;
                    }
                }
            }
            return a;
        }
        public int[] quickSort(int[] array) {
            int[] a = new int[array.length];
            for(int i = 0;i < a.length;i++) {
                a[i] = array[i];
            }
            Arrays.sort(a);
            return a;
        }
    }
    • 运行结果

  13. 求一个3*3对角线元素之和。

    提示：利用双重for循环控制输入二维数组，再将a[i][i]累加后输出。

    package top.trabin.chapter03;
    import java.util.Scanner;
    /**
     * 
     * @Description 求一个3*3对角线元素之和。
     * @author DawnLee
     * @version 1.0
     * @data 2020-9-27    11:55:02
     *
     */
    public class SumDia {
        public static void main(String[] args) {
            Scanner scan = new Scanner(System.in);
            System.out.print("数组大小：");
            int len = scan.nextInt();
            int[][] arr = new int[len][len];
            System.out.println("请分别输入数组元素：");
            for(int i = 0;i < arr.length;i++) {
                for(int j = 0;j < arr[i].length;j++) {
                    arr[i][j] = scan.nextInt();
                }
            }
            scan.close();
            SumDia sumD = new SumDia();
            sumD.show(arr);
            System.out.println("对角线元素之和为：" + sumD.sumDia(arr));
        }
        
        public void show(int[][] array) {
            System.out.println("数组：");
            for(int i = 0;i < array.length;i++) {
                for(int j = 0;j < array[i].length;j++) {
                    System.out.print(array[i][j] + " ");
                }
                System.out.println();
            }
        }
        public int sumDia(int[][] array) {
            int sum = 0;
            for(int i = 0;i < array.length;i++) {
                for(int j = 0;j < array[i].length;j++) {
                    //正对角
                    if(i == j) {
                        sum += array[i][j];
                    }
                }
                //反对角
                sum += array[i][array.length - 1 - i];
            }
            if(array.length % 2 != 0) {
                sum = sum - array[(int)(array.length / 2)][(int)(array.length / 2)];
            }
            return sum;
        }
    }
    • 运行结果

  14. 利用随机数生成一个整数数组，数组中有10个元素，每个元素的值都在1-30之间，且要求各个数值不能相同。打印该数组。

    package top.trabin.chapter03;

    import java.util.Arrays;

    /**
     * 
     * @Description 利用随机数生成一个整数数组，数组中有10个元素，每个元素的值都在1-30之间，
     *     且要求各个数值不能相同。打印该数组。
     * @author DawnLee
     * @version 1.0
     * @data 2020-9-27    13:59:09
     *
     */
    public class RandomArrays {
        public static void main(String[] args) {
            int[] ranArr = new int[10];
            for(int i = 0;i < ranArr.length;i++) {
                int ele = (int)(Math.random() * (30 - 1 + 1) + 1);
                if(new RandomArrays().isExist(ranArr, ele)) {
                    i -= 1;
                }else {
                    ranArr[i] = ele;
                }
            }
            System.out.println(Arrays.toString(ranArr));
        }
        
        public boolean isExist(int[] array,int key) {
            boolean isExisted = false;
            for(int i = 0;i < array.length;i++) {
                if(array[i] == key) {
                    isExisted = true;
                }
            }
            return isExisted;
        }
    }
    • 运行结果

  15. 输入数组，最大的与第一个元素交换，最小的与最后一个元素交换，输出数组。 

    package top.trabin.chapter03;
    import java.util.Arrays;
    /**
     * 
     * @Description 输入数组，最大的与第一个元素交换，最小的与最后一个元素交换，输出数组。 
     * @author DawnLee
     * @version 1.0
     * @data 2020-9-27    14:38:10
     *
     */
    public class ArraysExchange {
        public static void main(String[] args) {
            int max;
            int min;
            int[] arr = new int[] {20, 18, 5, 29, 15, 26, 3, 27, 8, 11};
            max = min = arr[0];
            for(int i = 0;i < arr.length;i++) {
                if(arr[i] > max) {
                    max = arr[i];
                }
                if(arr[i] < min) {
                    min = arr[i];
                }
            }
            System.out.println("原数列：" + Arrays.toString(arr));
            System.out.println();
            
            //最大值与第一个元素交换
            int maxIndex = new ArraysExchange().search(arr,max);
            int maxTemp = arr[0];
            arr[0] = arr[maxIndex];
            arr[maxIndex] = maxTemp;
            
            //最小值与最后一个元素交换
            int minIndex = new ArraysExchange().search(arr,min);
            int minTemp = arr[arr.length - 1];
            arr[arr.length - 1] = arr[minIndex];
            arr[minIndex] = minTemp;
            System.out.println("交换后：" + Arrays.toString(arr));
        }
        
        public int search(int[] array,int key) {
            for(int i = 0;i < array.length;i++) {
                if(array[i] == key) {
                    return i;
                }
            }
            return -1;
        }
    }
    • 运行结果

  16. 有n个整数，使其前面各数顺序向后移m个位置，最后m个数变成最前面的m个数。

    package top.trabin.chapter03;
    import java.util.Scanner;
    import java.util.Arrays;
    /**
     * 
     * @Description 有n个整数，使其前面各数顺序向后移m个位置，最后m个数变成最前面的m个数。
     * @author DawnLee
     * @version 1.0
     * @data 2020-9-28    16:52:20
     *
     */
    public class MoveEle {
        public static void main(String[] args) {
            Scanner scan = new Scanner(System.in);
            int[] arr = new int[] {19, 17, 2, 11, 29, 26, 20, 6, 16, 4};
            System.out.println("n = " + arr.length);
            System.out.print("m = ");
            int m = scan.nextInt();
            scan.close();
            
            System.out.println("原数组：" + Arrays.toString(arr));
            for(int i = 0;i < m;i++) {
                int temp = arr[arr.length - 1];
                for(int j = arr.length - 1;j > 0;j--) {
                    arr[j] = arr[j - 1];
                }
                arr[0] = temp;
            }
            System.out.println("移位后：" + Arrays.toString(arr));
        }
    }
    • 运行结果

  17. 定义一个4行4列的二维数组，逐个从键盘输入值，然后将第1行和第4行的数据进行交换，将第2行和第3行的数据进行交换。

    package top.trabin.chapter03;
    import java.util.*;
    /**
     * 
     * @Description 定义一个4行4列的二维数组，逐个从键盘输入值，然后将第1行和第4行的数据进行交换，
     *     将第2行和第3行的数据进行交换。
     * @author DawnLee
     * @version 1.0
     * @data 2020-9-28    20:49:59
     *
     */
    public class ExchangeRow {
        public static void main(String[] args) {
            Scanner scan = new Scanner(System.in);
            System.out.print("数组大小 n = ");
            int n = scan.nextInt();
            int[][] arr = new int[n][n];
            System.out.println("分别输入数组元素：");
            for(int i = 0;i < arr.length;i++) {
                for(int j = 0;j < arr[i].length;j++) {
                    System.out.print("arr[" + i + "][" + j + "] = ");
                    arr[i][j] = scan.nextInt();
                }
            }
            scan.close();
            System.out.println("交换前：\n");
            new ExchangeRow().showArr(arr);
            for(int i = 0;i < (int)(arr.length / 2);i++){
                for(int j = 0;j < arr[i].length;j++) {
                    int temp = arr[i][j];
                    arr[i][j] = arr[arr.length - 1 - i][j];
                    arr[arr.length - 1 - i][j] = temp;
                }
            }
            System.out.println("交换后：");
            new ExchangeRow().showArr(arr);
        }
        public void showArr(int[][] arrays) {
            for(int i = 0;i < arrays.length;i++) {
                System.out.println(Arrays.toString(arrays[i]));
            }
        }
    }
    • 运行结果

  18. 定义一个3行4列的二维数组，逐个从键盘输入值，编写程序将四周的数据清0。

    package top.trabin.chapter03;
    import java.util.*;
    /**
     * 
     * @Description 定义一个3行4列的二维数组，逐个从键盘输入值，编写程序将四周的数据清0。
     * @author DawnLee
     * @version 1.0
     * @data 2020-9-28    21:20:51
     *
     */
    public class ClearAround {
        public static void main(String[] args) {
            Scanner scan = new Scanner(System.in);
            System.out.print("行数：");
            int row = scan.nextInt();
            System.out.print("列数：");
            int clu = scan.nextInt();
            int[][] arr = new int[row][clu];
            
            System.out.println("依次输入数组元素：");
            for(int i = 0;i < arr.length;i++) {
                for(int j = 0;j < arr[i].length;j++) {
                    System.out.print("a[" + i + "][" + j + "] = ");
                    arr[i][j] = scan.nextInt();
                }
            }
            scan.close();
            System.out.println("原数组：");
            new ClearAround().showArr(arr);
            
            for(int i = 0;i < arr.length;i++) {
                for(int j = 0;j < arr[i].length;j++) {
                    if(i == 0 || i == (arr.length - 1) || j == 0 || j == (arr[i].length - 1)) {
                        arr[i][j] = 0;
                    }
                }
            }
            System.out.println("四周清零后：");
            new ClearAround().showArr(arr);
        }
        public void showArr(int[][] arrays) {
            for(int i = 0;i < arrays.length;i++) {
                System.out.println(Arrays.toString(arrays[i]));
            }
        }
    }
    • 运行结果

  19. 定义一个3行4列的二维数组，逐个从键盘输入值，将左下三角的值清0。

    package top.trabin.chapter03;
    import java.util.*;
    /**
     * 
     * @Description 定义一个3行4列的二维数组，逐个从键盘输入值，将左下三角的值清0。
     * @author DawnLee
     * @version 1.0
     * @data 2020-9-28    21:54:51
     *
     */
    public class ClearDLTriangle {
        public static void main(String[] args) {
            Scanner scan = new Scanner(System.in);
            System.out.print("行数：");
            int row = scan.nextInt();
            System.out.print("列数：");
            int clu = scan.nextInt();
            int[][] arr = new int[row][clu];
            
            System.out.println("依次输入数组元素：");
            for(int i = 0;i < arr.length;i++) {
                for(int j = 0;j < arr[i].length;j++) {
                    System.out.print("a[" + i + "][" + j + "] = ");
                    arr[i][j] = scan.nextInt();
                }
            }
            scan.close();
            System.out.println("原数组：");
            new ClearDLTriangle().showArr(arr);
            
            for(int i = arr.length/2;i < arr.length;i++) {
                for(int j = 0;j < i;j++) {
                    arr[i][j] = 0;
                }
            }
            System.out.println("左下三角清零后：");
            new ClearDLTriangle().showArr(arr);
        }
        public void showArr(int[][] arrays) {
            for(int i = 0;i < arrays.length;i++) {
                System.out.println(Arrays.toString(arrays[i]));
            }
        }
    }
    • 运行结果

  20. 定义一个4行4列的二维数组，逐个从键盘输入值，将对角线的值清0。

    package top.trabin.chapter03;
    import java.util.*;
    /**
     * 
     * @Description 定义一个4行4列的二维数组，逐个从键盘输入值，将对角线的值清0。
     * @author DawnLee
     * @version 1.0
     * @data 2020-9-28    22:00:34
     *
     */
    public class ClearDia {
        public static void main(String[] args) {
            Scanner scan = new Scanner(System.in);
            System.out.print("数组大小 n = ");
            int n = scan.nextInt();
            int[][] arr = new int[n][n];
            
            System.out.println("依次输入数组元素：");
            for(int i = 0;i < arr.length;i++) {
                for(int j = 0;j < arr[i].length;j++) {
                    System.out.print("a[" + i + "][" + j + "] = ");
                    arr[i][j] = scan.nextInt();
                }
            }
            scan.close();
            System.out.println("原数组：");
            new ClearDia().showArr(arr);
            
            for(int i = 0;i < arr.length;i++) {
                arr[i][i] = 0;
                arr[i][arr[i].length - 1 - i] = 0;
            }
            System.out.println("对角线清零后：");
            new ClearDia().showArr(arr);
        }
        public void showArr(int[][] arrays) {
            for(int i = 0;i < arrays.length;i++) {
                System.out.println(Arrays.toString(arrays[i]));
            }
        }
    }
    • 运行结果

  21. 定义一个N*N二维数组，从键盘上输入值，找出每行中最大值组成一个一维数组并输出。

    package top.trabin.chapter03;
    import java.util.*;
    /**
     * 
     * @Description 定义一个N*N二维数组，从键盘上输入值，找出每行中最大值组成一个一维数组并输出。
     * @author DawnLee
     * @version 1.0
     * @data 2020-9-28    22:13:47
     *
     */
    public class MaxArray {
        public static void main(String[] args) {
            Scanner scan = new Scanner(System.in);
            System.out.print("数组大小 n = ");
            int n = scan.nextInt();
            int[][] arr = new int[n][n];
            System.out.println("依次输入数组元素：");
            for(int i = 0;i < arr.length;i++) {
                for(int j = 0;j < arr[i].length;j++) {
                    System.out.print("a[" + i + "][" + j + "] = ");
                    arr[i][j] = scan.nextInt();
                }
            }
            scan.close();
            System.out.println("原数组：");
            new ClearDia().showArr(arr);
            
            int[] max = new int[n];
            for(int i = 0;i < arr.length;i++) {
                int maxValue = arr[i][0];
                for(int j = 0;j < arr[i].length;j++) {
                    if(maxValue < arr[i][j]) {
                        maxValue = arr[i][j];
                    }
                }
                max[i] = maxValue;
            }
            System.out.println("每行最大值数组：" + Arrays.toString(max));
        }
        public void showArr(int[][] arrays) {
            for(int i = 0;i < arrays.length;i++) {
                System.out.println(Arrays.toString(arrays[i]));
            }
        }
    }
    • 运行结果