JAVA基础:数组 (习题笔记)

一,编码题

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

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());获取随机数

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的时候即可。

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的个数,这样可以开辟新数组;从旧的数组之中,取出内容,并将其赋给新开辟的数组。

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的情况,表示查找不成功。

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}}

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,生成一百个随机数,放入数组,然后排序输出。

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月各月天数。

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类的方法快速实现。

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关键字创建数组对象,但不立即赋值,之后再逐个赋值。

  • 默认初始化

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

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(整数类型的默认值)
    }
}

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:/a/910301.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

网络层5——IPV6

目录 一、IPv6 vs IPv4 1、对IPv6主要变化 2、IPv4 vs IPv6 二、IPv6基本首部 1、版本——4位 2、通信量类——8位 3、流标号——20位 4、有效载荷长度——16位 5、下一个首部——8位 6、跳数限制——8位 7、源 、 目的地址——128位 8、扩展首部 三、IPv6地址 1…

AIRIS 是一种学习型人工智能,它正在自学如何玩 Minecraft

AI开发公司SingularityNET和人工超级智能联盟&#xff08;ASI Alliance&#xff09;表示,随着人工智能学习如何通过操作玩游戏,一种新的学习型AI已被留在Minecraft的实例中。名为AIRIS&#xff08;自主智能增强推断象征主义&#xff09;的AI基本上是从Minecraft内部开始学习如何…

嵌入式学习-网络高级-Day01

嵌入式学习-网络高级-Day01 【1】Modbus协议 起源 分类 优势 应用场景 【2】Modbus TCP 特点 组成 报文头&#xff1a;7个字节 寄存器&#xff08;存储数据&#xff09; 功能码 总结 练习 【3】工具安装 Modbus Slave、Poll安装 网络调试助手 wireshark 练习 【1】Modbus协议 起…

Java项目实战II基于Spring Boot的问卷调查系统的设计与实现(开发文档+数据库+源码)

目录 一、前言 二、技术介绍 三、系统实现 四、文档参考 五、核心代码 六、源码获取 全栈码农以及毕业设计实战开发&#xff0c;CSDN平台Java领域新星创作者&#xff0c;专注于大学生项目实战开发、讲解和毕业答疑辅导 一、前言 在当今信息爆炸的时代&#xff0c;问卷调查…

【c++语言程序设计】数组(对象数组)

数组是一种按照特定顺序排列的对象集合体&#xff0c;数组中的每个对象称为“元素”。数组的每个元素都用“数组名下标”的形式来表示&#xff0c;并且同一数组内的所有元素类型相同。数组可以由任何类型的数据构成&#xff08;除 void 外&#xff09;&#xff0c;且数组的概念…

5分钟跑起来:Java构建的AI人工智能智能问答系统_springboot_spring ai_LLM_人工智能_开源免费使用

Agenda&#xff1a; 1&#xff09;介绍一下AI支持下的智能问答系统有哪些主要模块 2&#xff09;一个可以跑起来的代码样例&#xff0c;说明怎么用Java构建这个AI智能问答系统 AI人工智能智能问答系统简介 智能问答系统是一种利用人工智能技术理解并回答用户提问的应用。该系…

如何基于pdf2image实现pdf批量转换为图片

最近为了将pdf报告解析成为文本和图片&#xff0c;需要将大量多页的pdf文件拆分下单独的一页一页的图像&#xff0c;以便后续进行OCR和图像处理&#xff0c;因此就需要实现将pdf2image&#xff0c;本文主要结合开源的pdf2image和poppler&#xff0c;实现了pdf转换为png格式图片…

Pytorch用BERT对CoLA、新闻组文本数据集自然语言处理NLP:主题分类建模微调可视化分析

原文链接&#xff1a;https://tecdat.cn/?p38181 原文出处&#xff1a;拓端数据部落公众号 自然语言处理&#xff08;NLP&#xff09;领域在近年来发展迅猛&#xff0c;尤其是预训练模型的出现带来了重大变革。其中&#xff0c;BERT 模型凭借其卓越性能备受瞩目。然而&#…

Kaggle:免费 GPU 使用指南,Colab 的理想替代方案

如果电脑显卡性能不足&#xff0c;又无法访问 Colab 的免费 GPU&#xff0c;那该怎么开始之后的学习呢&#xff1f; 答案是 Kaggle。 Kaggle 不仅提供免费的 GPU 计算资源&#xff0c;还可以直连而无需翻墙&#xff0c;同时不需要海外手机号验证。接下来&#xff0c;文章将详细…

Zookeeper 简介 | 特点 | 数据存储

1、简介 zk就是一个分布式文件系统&#xff0c;不过存储数据的量极小。 1. zookeeper是一个为分布式应用程序提供的一个分布式开源协调服务框架。是Google的Chubby的一个开源实现&#xff0c;是Hadoop和Hbase的重要组件。主要用于解决分布式集群中应用系统的一致性问题。 2. 提…

神经网络基础--什么是神经网络?? 常用激活函数是什么???

前言 本专栏更新神经网络的一些基础知识&#xff1b;案例代码基于pytorch&#xff1b;欢迎收藏 关注&#xff0c; 本人将会持续更新。 神经网络 1、什么是神经网络 人工神经网络&#xff08; Artificial Neural Network&#xff0c; 简写为ANN&#xff09;也简称为神经网络…

大模型也要“私人定制“?最新综述带你解锁AI的个性化服务 | 综述!扩散模型:AI艺术创作背后的“魔法引擎“

大模型领域的发展日新月异&#xff0c;每天都有许多有趣的论文值得深入品读。下面是本期觉得比较有意思的论文&#xff1a; 1、大模型也要"私人定制"&#xff1f;最新综述带你解锁AI的个性化服务 2、综述&#xff01;扩散模型&#xff1a;AI艺术创作背后的"魔法…

【MySQL 保姆级教学】深层理解索引及其特性(重点)--上(11)

MySQL与磁盘 1. MySQL与内存和磁盘的联系2. 认识磁盘2.1 MySQL与存储2.2 磁盘结构2.3 扇区2.4 定位扇区 3. MySQL与磁盘交互基本单位4. 建立共识5. 索引的理解5.1 建立一个表并查询5.2 为何 I/O 交互要是Page 6. B树 Vs B 树数6.1 不同存储引擎支持的索引结构类型6.2 B树 Vs B树…

1分钟教你利用ai工具免费制作养生视频,自动化批量操作,效率提升10倍!

养生这个是未来比较火爆的一个赛道,很多人越来越注重养生&#xff0c;你会发现抖音各种健身操博主&#xff0c;视频播放数据都很不错。很多人上一秒说的养生&#xff0c;下一秒又熬起了夜。年纪轻轻就喝起了枸杞续命。 有想做视频号带货的家人&#xff0c;其实可以考虑养生赛道…

思通数科纸质档案扫描与识别与档案馆应用场景介绍

在传统档案馆中&#xff0c;纸质文件的处理和管理是一个重要且繁琐的环节&#xff0c;特别是面对庞大的历史资料库。思通数科的AI能力平台提供了一种高效的数字化解决方案&#xff0c;利用OCR技术将纸质档案中的信息自动提取并转化为数字文本&#xff0c;具体过程包括以下几个步…

AutoCAD的Dwg版本代号、R版本参数值以及二次开发时VS、.NET版本关系

Dwg的AC版本代号 出处&#xff1a;https://www.autodesk.com.cn/support/technical/article/caas/sfdcarticles/sfdcarticles/CHS/drawing-version-codes-for-autocad.html 以下是AutoCAD图形的不同版本代号&#xff1a; MC0.0 - DWG Release 1.1 AC1.2 - DWG R1.2 AC1.4 - DW…

微服务day02

教学文档&#xff1a; 黑马教学文档 Docker Docker的安装 镜像和容器 命令解读 常见命令 案例 查看DockerHub&#xff0c;拉取Nginx镜像&#xff0c;创建并运行容器 搜索Nginx镜像&#xff1a;在 www.hub.docker.com 网站进行查询 拉取镜像&#xff1a; docker pull ngin…

脉冲全闭环EtherCAT运动控制器的固件升级

本文导读 随着产品的发展&#xff0c;正运动技术产品的固件也在不断更新与完善&#xff0c;新固件较老固件会解决一些客户的新需求与软件上的bug&#xff0c;增加了一些指令和功能&#xff0c;添加了更多的 EtherCAT从站与io模块。因此&#xff0c;升级固件是常用功能。推荐优…

用 Python 爬取淘宝商品价格信息时需要注意什么?

用 Python 爬取淘宝商品价格信息时&#xff0c;需要注意以下方面&#xff1a; 一、法律和道德规范&#xff1a; 遵守法律法规&#xff1a;网络爬虫的行为应在法律允许的范围内进行。未经淘宝平台授权&#xff0c;大规模地爬取其商品价格信息并用于商业盈利等不当用途是违法的…

三周精通FastAPI:35 最常用的模板引擎Jinja2

官方文档&#xff1a;https://fastapi.tiangolo.com/zh/advanced/templates/ 模板 FastAPI 支持多种模板引擎。 Flask 等工具使用的 Jinja2 是最常用的模板引擎。 在 Starlette 的支持下&#xff0c;FastAPI 应用可以直接使用工具轻易地配置 Jinja2。 安装依赖项 安装 ji…