Java复习day03

数组

一.数组的定义

---

1.数组的基本概念与内存

数组是指一组数据的集合,数组中的每个数据被称作元素,在数组中可以存放任意类型的元素,但同一个数组中存放的元素类型必须一致.数组可以分为一维数组和多维数组.

一维数组的定义主要有一下三种方式:

1.数组类型[] 数组名 = new 数组类型[数组长度];
int[] nums1 = new int[3];

2.数组类型[] 数组名 = new 数组类型[]{数组元素0,数组元素1,...}
int[] nums1 = new int[]{1,2,3,4};

3.数组类型[] 数组名 = {数组元素0,数组元素1,...};
int[] nums1 = {1,2,3,4,5};

---

2.数组中元素的赋值和访问

数组中每个元素都有一个索引(也可称为角标/下标),要想访问数组中的元素可以通过"数组名[下标]"的形式,如nums[1],ids[3].需要注意的是数组中的最小的索引是0,最大的索引是"数组的长度-1".

int[] nums = new int[3];
//给数组中第一个元素赋值
nums[0] = 1;
//访问第一个元素
System.out.println("数组中第一个元素为:"+nums[0]);

---

3.数组的特性:

第一种数组方式只定义数组的数据类型以及长度,并没有对元素进行赋值,此时内存中是默认值进行占位.

1. 不同数据类型元素在数组中的默认值

数据类型	默认初始化值
byte/short/int/long	0
float/double	0.0
char	一个空字符,即’\u0000’
boolean	false
引用数据类型	null,表示变量不引用任何对象

2. 数组一旦建立,长度是不能改变的
3. 每个位置只能存放一个值,多了会发生覆盖
4. 每个数组的索引范围都为"0~length-1",在访问时索引不能超过这个范围,否则会报下标越界异常

---

二.数组的常见操作

---

1.数组遍历

在操作数组时,经常需要一次访问数组中的每个元素,这种操作叫做数组的遍历.

int[] arr = {1,2,3,4,5};
for(int i = 0; i < arr.length;i++){
    System.out.println(arr[i]);
}

---

2.数组中最值

在操作数组时,经常需要获取当前数组中元素的最值.

int[] nums = {12,32,56,78,91,42,14,65};
        int max = 0;
        int min = 0;

        for (int i = 1 ; i < nums.length; i++) {
            max = nums[max] > nums[i] ? max : i;
            min = nums[min] < nums[i] ? min : i;
        }
        System.out.println("最小的数为:"+nums[max]);
        System.out.println("最大的数为:"+nums[min]);

---

3.元素的换位

我们现在想将数组倒序

int[] nums = {1,2,3,4,5};
int temp = nums.length/2;
for (int i = 0; i <= temp-1; i++) {
    int t;
    t = nums[i];
    nums[i] = nums[nums.length-1-i];
    nums[nums.length-1-i] = t;
}
for (int i = 0; i < nums.length; i++) {
    System.out.println(nums[i]);
}

---

4.数组的扩容

数组的长度一旦定义就不能改变,但是可以通过扩容来增加长度

int[] nums = {1,2,3};
int[] temp = new int[nums.length*2];

//将nums中元素复制到temp
for (int i = 0; i < nums.length; i++) {
    temp[i] = nums[i];
}

//将nums指向temp
nums = temp;

//需要扩容
nums[3] = 9;

for (int i = 0; i < nums.length; i++) {
    System.out.println(nums[i]);
}

---

5.数组的的排序及算法

(1)冒泡排序

冒泡排序是比较常见的一种排序方法,所谓冒泡,就是不断比较数组中相邻的两个元素,最小者向下浮,最大者向下沉,就像水中气泡上升一样,具体步骤如下;

1. 从第一个元素开始,将相邻两个元素依次进行比较,如果前一个元素比后一个元素大,则交换他们的位置.完成这一步后数组中最后一个元素一定是最大的.
2. 除了最后一个元素,将剩余的元素重新进行第一步,这样就把第二大的元素放在倒数第二位
3. 以此类推,直到没有元素需要比较为止.

具体代码如下:

int[] nums = {42,34,56,87,94,23,1274,894,13,46};
for (int i = 0; i < nums.length-1; i++) {
    for (int j = 0; j < nums.length-1-i; j++) {
        if (nums[j]>nums[j+1]) {
            int temp = nums[j];
            nums[j] = nums[j + 1];
            nums[j + 1] = temp;
        }
    }
}

(2)二分查找

		int[] nums = {1,3,5,7,9,11,24};
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您要查找的数字:");
        int target = sc.nextInt();

        //定义两个变量来确定查找范围
        int left = 0;
        int right = nums.length-1;

        //先判断是否在范围内
        if (target<nums[left] || target>nums[right] ){
            System.out.println("您输入的数字不在范围内!");
        }else{
            //定义一个变量来存放结果
            int result = -1;

            //左右边框不重合则继续
            while(left<=right){
                int mid = (left+right)/2;
                if (target == nums[mid]){
                    result = mid;
                    break;
                }else if (target < nums[mid]){
                    right = mid-1;
                }else if (target > nums[mid]){
                    left = mid+1;
                }
            }

            if (result>=0){
                System.out.println("您搜索的数字在数组中:"+nums[result]);
            }else{
                System.out.println("没有查到");
            }
        }

(3)两个数组合并

如果想将两个数组合并

1. 同时遍历两个数组,当前值进行比较,小的放入新数组
   

2. 放入后,数据继续遍历,指针后移

3. 重复上述操作

代码实现如下:

		int[] nums1 = {1,4,6,8,12,64,675};
        int[] nums2 = {3,5,7,36,46};
        int[] nums = new int[nums1.length+nums2.length];

        int index1,index2;
        index1 = index2 = 0;

        while (index1<nums1.length || index2< nums2.length){
            if (index1 == nums1.length){
                nums[index1+index2] = nums2[index2];
                index2++;
                continue;
            }else if (index2 == nums2.length){
                nums[index1+index2] = nums1[index1];
                index1++;
                continue;
            }

            if (nums1[index1] < nums2[index2]){
                nums[index1+index2] = nums1[index1];
                index1++;
            }else if (nums1[index1] > nums2[index2]){
                nums[index1+index2] = nums2[index2];
                index2++;
            }
        }

---

三.多维数组(以二维数组举例)

二维数组有很多种定义的方式

第一种方式,指定二维数组的长度以及每个数组的元素个数

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

上面的代码相当于定义了一个3 * 4的二维数组

第二种方式,只指定二维数组的长度,不确定每个数组的元素个数

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

第二种方式每个数组中每个元素的长度不确定

第三种方式,直接使用嵌套大括号"{}",对二维数组初始化赋值

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

上面的二维数组定义了三个元素,这三个元素都是数组分别为{1,2},{3,4,5,6},{7,8.9}

---

四.两个小项目

1.员工管理系统:可以不断的选择功能,一是查找员工,二是新增员工,三是查看所有工号,四是退出

		int f = 0;
        int[] nums = new int[3];
        nums[0] = 1001;
        nums[1] = 1002;
        int index = 2;
        Scanner sc = new Scanner(System.in);
        while (f != 3){
            System.out.println("欢迎来到人员管理中心,请选择您需要的服务");
            System.out.println("1.查找员工.2.新增员工.3.查看所有工号.4.退出");
            int n = sc.nextInt();
            //如果输入了1.进入查找员工功能
            if (n == 1){
                System.out.println("请输入您想要查询的工号:");
                int m = sc.nextInt();
                int flag = 0;
                for (int i = 0; i < index; i++) {
                    if (m == nums[i]){
                        System.out.println("您查找的工号为我公司员工.");
                        flag = 1;
                        break;
                    }
                }
                if (flag == 0) {
                    System.out.println("对不起,您查找的工号不为我公司员工.");
                }

            //如果输入了2,则进行添加工号功能
            }else if (n == 2){
                System.out.println("请输入您想要添加的工号");
                int s = sc.nextInt();
                if (index > nums.length-1){
                    int[] temp = new int[nums.length+5];


                    //将nums中元素复制到temp
                    for (int i = 0; i < nums.length; i++) {
                        temp[i] = nums[i];
                    }

                    //将nums指向temp
                    nums = temp;
                };
                nums[index] = s;
                index++;
                System.out.println("添加成功!");
            //如果输入了3,则进行查看所有工号功能
            }else if (n == 3){
                for (int i = 0; i < index; i++) {
                    System.out.println(nums[i]);
                }

            //如果输入了4,则退出
            }else if (n == 4){
                System.out.println("再见!欢迎下次使用!");
                break;
            }else{
                System.out.println("输入错误!请重新输入");
            }
        }

2.杨辉三角:输入数字可以选择打印多少行的杨辉三角

杨辉三角特性:

1. 每个数等于它上方两数之和。
2. 每行数字左右对称，由1开始逐渐变大。
3. 第n行的数字有n项。
4. 前n行共[(1+n)n]/2 个数。

        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您想打印几行的杨辉三角:");
        int n = sc.nextInt();
        int[][] nums = new int[n][];
        for (int i = 0; i < n; i++) {
            nums[i] = new int[i+1];
            nums[i][0] = nums[i][i] = 1;
        }

        for (int i = 2; i < n ; i++) {
            for (int j = 1; j < nums[i].length-1 ; j++) {
                nums[i][j] = nums[i-1][j] + nums[i-1][j-1];
            }
        }
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < nums[i].length; j++) {
                System.out.print(nums[i][j]);
                System.out.print(" ");
            }
            System.out.println();
        }