JAVA基础：数组 （习题笔记）

猫爪笔记2024-11-07 6:08

一，编码题

1，数组查找操作：定义一个长度为10 的一维字符串数组，在每一个元素存放一个单词；然后运行时从命令行输入一个单词，程序判断数组是否包含有这个单词，包含这个单词就打印出"Yes"，不包含就打印出"No"。

java 复制代码 
import java.util.*;

public class PanTi {

    public static void main(String[] args) {
        String[] strArr = new String[10];
        strArr[0] = "java";
        strArr[1] = "html";
        strArr[2] = "sql";
        strArr[3] = "android";
        strArr[4] = "javascript";
        strArr[5] = "ruby";
        strArr[6] = "c";
        strArr[7] = "c++";
        strArr[8] = ".net";
        strArr[9] = "ios";
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入需要查找的计算机编程语言:");
        String inputStr = scanner.next();
        boolean flag = false;
        for (String string : strArr) {
            if (string.equals(inputStr)) {
                flag = true;
            }
        }
        if (flag) {
            System.out.println("YES");
        } else {
            System.out.println("NO");
        }
    }

}

2，获取数组最大值和最小值操作：利用Java的Math类的random()方法，编写函数得到0到n之间的随机数，n是参数。并找出产生50个这样的随机数中最大的、最小的数，并统计其中>=60的有多少个。

提示：使用 int num=(int)(n*Math.random());获取随机数

java 复制代码 
import java.util.*;

public class PanTi {

    public static void main(String[] args) {
        //创建一个长度为50的，每个元素在0-100之间的数组
        int[] arr = getArray(100);
        //遍历数组
        printArr(arr);
        //获取最大值和最小值
        int min = getMin(arr);
        int max = getMax(arr);
        System.out.println("数组中最大值：" + max + "\t数组中最小值：" + min);
        //统计其中大于等于60的元素个数
        int count = count(arr,60);
        System.out.println("数组中大于或等于60的数有:" + count + " 个");
    }
    //遍历数组
    private static void printArr(int[] arr) {
        System.out.println("输出数组元素");
        for(int i=0;i<arr.length;i++){
            if(i%10 ==0){
                System.out.println();
            }
            System.out.print(arr[i]+"\t");
        }
    }
    //获取数组最大值
    private static int getMax(int[] arr) {
        int max = arr[0];
        for(int i=1;i<arr.length;i++){
            if(max<arr[i]){
                max = arr[i];
            }
        }
        return max;
    }
    //获取数组最小值
    private static int getMin(int[] arr) {
        int min = arr[0];
        for(int i=0;i<arr.length;i++){
            if(min>arr[i]){
                min = arr[i];
            }
        }
        return min;
    }
    // 创建数组 并且初始化50个数据
    public static int[] getArray(int n) {
        int arr[] = new int[50];
        for (int i = 0; i < 50; i++) {
            arr[i] = (int) (n * Math.random());
        }
        return arr;
    }
    // 统计数组中大于等于60的数量的方法 思路：使用一个int值计数
    public static int count(int[] arr,int elem) {
        int count = 0;
        for (int i : arr) {
            if (i >= elem) {
                count++;
            }
        }
        return count;
    }
}

3，数组逆序操作：定义长度为10的数组，将数组元素对调，并输出对调前后的结果。

思路：把0索引和arr.length-1的元素交换，把1索引和arr.length-2的元素交换.....

只要交换到arr.length/2的时候即可。

java 复制代码 
import java.util.*;

public class PanTi {


    public static void main(String[] args) {
        //定义一个数组，并进行静态初始化。
        int[] arr = {12, 98, 50, 34, 76, 87, 90, 34, 67, 80};
        //逆序前
        System.out.println("逆序前：");
        printArr(arr);
        //逆序后
        System.out.println("逆序后：");
        reverseArr(arr);
        printArr(arr);
    }

    public static void reverseArr(int[] arr) {
        for (int x = 0; x < arr.length / 2; x++) {
            int temp = arr[x];
            arr[x] = arr[arr.length - 1 - x];
            arr[arr.length - 1 - x] = temp;
        }
    }

    //遍历数组
    public static void printArr(int[] arr) {
        System.out.print("[");
        for (int x = 0; x < arr.length; x++) {
            if (x == arr.length - 1) { //这是最后一个元素
                System.out.println(arr[x] + "]");
            } else {
                System.out.print(arr[x] + ", ");
            }
        }
    }


}

4，合并数组操作：现有如下一个数组： int oldArr[]={1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5} 要求将以上数组中值为0的项去掉，将不为0的值存入一个新的数组，生成的新数组为： int newArr [] ={1,3,4,5,6,6,5,4,7,6,7,5}

思路： 确定出不为0的个数，这样可以开辟新数组；从旧的数组之中，取出内容，并将其赋给新开辟的数组。

java 复制代码 
import java.util.*;

public class PanTi {


    public static void main(String[] args) {
        int oldArr[] = {1, 3, 4, 5, 0, 0, 6, 6, 0, 5, 4, 7, 6, 7, 0, 5};
        int newArr[] = selectArr(oldArr);
        for (int i : newArr) {
            System.out.print(i + " ");
        }
    }

    // 去掉数组中值为0的元素的方法
    public static int[] selectArr(int[] arr) {
        // 1.计算数组中元素不为0的个数
        int count = 0;
        for (int i : arr) {
            if (i != 0) {
                count++;
            }
        }
        // 2.创建一个新数组,长度为count
        int newArr[] = new int[count];
        // 3.复制不为0的元素到新数组中
        int size = 0;
        for (int i : arr) {
            if (i != 0) {
                newArr[size++] = i;
            }
        }
        return newArr;


    }


}

++5，二分法查找操作：使用二分法查找有序数组中元素。找到返回索引，不存在输出-1。++

分析：二分法查找的前提是数组有序。

假如有一组数为3，12，24，36，55，68，75，88要查给定的值24.可设三个变量front，mid，end分别指向数据的上界，中间和下界，mid=（front+end）/2.

  1. 开始令front=0（指向3），end=7（指向88），则mid=3（指向36）。因为mid>x，故应在前半段中查找。

  2. 令新的end=mid-1=2，而front=0不变，则新的mid=1。此时x>mid，故确定应在后半段中查找。

  3. 令新的front=mid+1=2，而end=2不变，则新mid=2，此时a[mid]=x，查找成功。

  4. 如要查找的数不是数列中的数，例如x=25，当第三次判断时，x>a[mid]，按以上规律，令front=mid+1，即front=3，出现front>end的情况，表示查找不成功。

java 复制代码 
import java.util.*;

public class PanTi {


    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        System.out.println(searchLoop(array, 9));
    }

    /**
     * 循环二分查找，返回第一次出现该值的位置
     *
     * @param array     已排序的数组
     * @param findValue 需要找的值
     * @return 值在数组中的位置，从0开始。找不到返回-1
     */
    public static int searchLoop(int[] array, int findValue) {
        // 如果数组为空，直接返回-1，即查找失败
        if (array == null) {
            return -1;
        }
        // 起始位置
        int start = 0;
        // 结束位置
        int end = array.length - 1;
        while (start <= end) {
            // 中间位置
            int middle = (start + end) / 2;
            // 中值
            int middleValue = array[middle];
            if (findValue == middleValue) {
                // 等于中值直接返回
                return middle;
            } else if (findValue < middleValue) {
                // 小于中值时在中值前面找
                end = middle - 1;
            } else {
                // 大于中值在中值后面找
                start = middle + 1;
            }
        }
        // 返回-1，即查找失败
        return -1;


    }


}

6，二维数组遍历求和操作：用二重循环求出二维数组b所有元素的和：

int[][] b={{11},{21,22},{31,32,33}}

java 复制代码 
import java.util.*;

public class PanTi {


    public static void main(String[] args) {
        int sum = 0;
        int[][] b = {{11}, {21, 22}, {31, 32, 33}};
        for (int i = 0; i < b.length; i++) {
            for (int j = 0; j < b[i].length; j++) {
                sum += b[i][j];
            }
        }
        System.out.println(sum);
    }


}

可选题

1，生成一百个随机数，放入数组，然后排序输出。

java 复制代码 
import java.util.*;

public class PanTi {


    public static void main(String[] args) {
        //1.生成100个随机数的数组
        int[] arr = createArr();
        //2.从小到大排序
        arr = sortArr(arr);
        //3.打印
        printArr(arr);
    }

    //生成100个随机数的方法
    public static int[] createArr() {
        int[] arr = new int[100];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) (100 * Math.random());
        }
        return arr;
    }

    //对数组进行排序的方法
    public static int[] sortArr(int arr[]) {
        int temp;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j <= i; j++) {
                if (arr[i] < arr[j]) {
                    temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        return arr;
    }

    //数组遍历输出打印的方法
    public static void printArr(int[] arr) {
        for (int i : arr) {
            System.out.print(i + "\t");
        }
    }


}

2，题目：输入某年某月某日，判断这一天是这一年的第几天？

分析：以3月5日为例，先把前两个月的加起来，然后再加上5天即本年第几天，特殊情况，闰年且输入月份大于3需考虑多加一天。可定义数组存储1-12月各月天数。

java 复制代码 
import java.util.*;

public class PanTi {


    public static void main(String[] args) {
        Scanner scanner1 = new Scanner(System.in);
        System.out.print("输出今年是第几年");
        int year = scanner1.nextInt();
        System.out.print("输出本月是第几月");
        int month = scanner1.nextInt();
        System.out.print("输出今天是第几日");
        int day = scanner1.nextInt();
        int daynum = 0; // 天数
        //一年365天
        int[] month1 = new int[]{31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
        //闰年366天
        if (year % 400 == 0 && year % 100 != 0 || year % 100 == 0) {
            month1 = new int[]{31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; // 闰年里的每个月的天数
        }
        //判断这一天是第几天
        for (int index = 1; index <= month; index++) {
            if (index == 1) {
                daynum = day;
            } else {
                daynum += month1[index - 2];
            }
        }
        System.out.println("这一天是这一年的第" + daynum + "天！");

    }


}

3， 数组A：1，7，9，11，13，15，17，19；数组b：2，4，6，8，10 ； 两个数组合并为数组c，按升序排列。 要求：使用Arrays类的方法快速实现。

java 复制代码 
import java.util.*;

public class PanTi {


    public static void main(String[] args) {
        int data1[] = new int[]{1, 7, 9, 11, 13, 17, 19};
        int data2[] = new int[]{2, 4, 6, 8, 10};
        int newArr[] = concat(data1, data2);
        print(newArr);
        Arrays.sort(newArr);
        print(newArr);
    }

    public static int[] concat(int src1[], int src2[]) {
        int len = src1.length + src2.length; // 新数组的大小
        int arr[] = new int[len]; // 新数组
//		int count = 0;
//		for (int i : src1) {
//			arr[count++] = i;
//		}
//		for (int i : src2) {
//			arr[count++] = i;
//		}
        // 还可以通过系统的方法拷贝数组
        System.arraycopy(src1, 0, arr, 0, src1.length); // 拷贝第一个数组
        System.arraycopy(src2, 0, arr, src1.length, src2.length); //拷贝第二个数组
        return arr;
    }

    public static void print(int[] temp) {
        for (int x = 0; x < temp.length; x++) {
            System.out.print(temp[x] + "、");
        }
        System.out.println();

    }


}

二，简答题

1，数组的特点。

  • ‌有序性‌：数组中的元素按照一定的顺序排列。
  • ‌类型一致性‌：数组中的所有元素必须是相同的数据类型。
  • ‌连续存储‌：数组中的元素在内存中连续存储，这使得访问数组元素时效率较高。
  • ‌索引访问 ‌：每个元素通过数组名和它在数组中的位置索引来访问，例如，array表示数组中的第一个元素。

2，数组的优缺点

优点:

  1. ‌快速访问 ‌：‌数组按照索引查询元素的速度非常快，因为元素在内存中是连续存储的。
  2. ‌大量数据存储‌：数组适合存储大量数据，因为它可以快速访问和遍历。
  3. ‌随机访问‌：数组支持随机访问元素，只要知道元素的索引，就可以直接访问。
  4. ‌简单易用‌：数组的定义和使用非常简单，语法直观。
  5. ‌高效查找‌：利用二分查找等算法，数组可以高效地查找元素。

缺点:

  1. ‌大小固定‌：数组的大小一旦确定，就不能改变，不适合动态存储。
  2. ‌类型单一‌：数组只能存储一种类型的数据。
  3. ‌插入和删除效率低‌：由于元素连续存储，插入和删除元素会导致大量元素移动，影响效率。
  4. ‌内存浪费‌：如果数组中存储的元素少于其声明的大小，会导致内存浪费。
  5. ‌容易溢出‌：如果访问超出数组边界的元素，可能会导致程序错误或异常。

3，冒泡排序的算法。

定义：

冒泡排序是一种简单的排序算法，其基本思想是通过重复遍历待排序的数列，比较相邻元素的大小，如果它们的顺序错误则交换它们的位置。这个过程会重复进行，直到没有需要交换的元素为止。

冒泡排序的基本步骤：

  1. ‌初始化‌：设定一个标志位（通常是布尔值），用于优化算法（可选）。

  2. ‌遍历数列‌：从数列的第一个元素开始，到倒数第二个元素结束。

  3. ‌比较和交换‌：比较相邻的两个元素，如果前一个元素比后一个元素大（对于升序排序），则交换它们的位置。

  4. ‌优化‌：如果在一次完整的遍历中没有发生任何交换，说明数列已经有序，可以提前结束排序。

  5. ‌重复‌：重复步骤2到步骤4，直到没有需要交换的元素为止‌1。

冒泡排序的算法原理

冒泡排序的核心思想是从待排序的元素中逐个比较相邻的两个元素，如果它们的顺序不符合要求（例如升序排序时，前一个元素大于后一个元素），则交换它们的位置。这个过程可以类比水中的冒泡现象，大的元素会逐渐"浮"到数组的末尾，而小的元素则会"沉"到数组的前面‌。

4，数组的三种初始化方式是什么?

静态初始化

是在声明数组的同时直接为数组元素分配空间并赋值。

动态初始化

是将数组定义和为数组元素分配空间并赋值的操作分开进行。首先使用new关键字创建数组对象，但不立即赋值，之后再逐个赋值。

默认初始化

是指数组在定义后，其元素会被隐式初始化为该类型的默认值。

java 复制代码 
public class Demo {
    public static void main(String[] args) {
        // 静态初始化
        int[] staticArray = {1, 2, 3, 4, 5};
        System.out.println(staticArray); // 输出: 1
        System.out.println(staticArray‌:ml-citation{ref="5" data="citationList"}); // 输出: 5
        
        // 动态初始化
        int[] dynamicArray = new int‌:ml-citation{ref="3" data="citationList"};
        dynamicArray = 1;
        dynamicArray‌:ml-citation{ref="1" data="citationList"} = 2;
        dynamicArray‌:ml-citation{ref="2" data="citationList"} = 3;
        dynamicArray‌:ml-citation{ref="4" data="citationList"} = 4;
        System.out.println(dynamicArray); // 输出: 1
        System.out.println(dynamicArray‌:ml-citation{ref="5" data="citationList"}); // 输出: 0（未赋值）
        
        // 默认初始化
        int[] defaultArray = new int‌:ml-citation{ref="3" data="citationList"};
        System.out.println(defaultArray); // 输出: 0（整数类型的默认值）
    }
}
相关推荐
Amarantine、沐风倩✨9 分钟前
设计一个监控摄像头物联网IOT（webRTC、音视频、文件存储）
java·物联网·音视频·webrtc·html5·视频编解码·七牛云存储
Kisorge35 分钟前
【C语言】指针数组、数组指针、函数指针、指针函数、函数指针数组、回调函数
c语言·开发语言
机智的叉烧39 分钟前
前沿重器[57] | sigir24：大模型推荐系统的文本ID对齐学习
人工智能·学习·机器学习
路在脚下@1 小时前
spring boot的配置文件属性注入到类的静态属性
java·spring boot·sql
森屿Serien1 小时前
Spring Boot常用注解
java·spring boot·后端
量子-Alex2 小时前
【多模态聚类】用于无标记视频自监督学习的多模态聚类网络
学习·音视频·聚类
轻口味2 小时前
命名空间与模块化概述
开发语言·前端·javascript
吉大一菜鸡2 小时前
FPGA学习（基于小梅哥Xilinx FPGA）学习笔记
笔记·学习·fpga开发
苹果醋32 小时前
React源码02 - 基础知识 React API 一览
java·运维·spring boot·mysql·nginx
晓纪同学3 小时前
QT-简单视觉框架代码
开发语言·qt
热门推荐
01Cube-Studio：开源大模型全链路一站式中台02优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间03玄机平台应急响应—webshell查杀04Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO05基于大语言模型（LLM）的合成数据生成、策展和评估的综述06(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明07构建高效的广告投放系统：应用架构的设计与实现08HCIA-datacom数通题库和录播视频资料09Docker 夺命连环 15 问10【一文读懂】NTN（非地面网络）技术介绍