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

一,编码题

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(整数类型的默认值)
    }
}
相关推荐
morning_judger3 分钟前
【设计模式系列】原型模式(十一)
java·设计模式·原型模式
Dontla5 分钟前
《Rust语言圣经》Rust教程笔记17:2.Rust基础入门(2.6模式匹配)2.6.2解构Rust Option<T>
笔记·算法·rust
Romanticroom7 分钟前
Ballman_ford 的应用(有限边的最短路问题)LeetCode787.K站中转内最便宜航班
java·开发语言
李兆龙的博客10 分钟前
问题排查:C++ exception with description “getrandom“ thrown in the test body
开发语言·c++
工作不忙13 分钟前
c++多线程QThreadpool调用Python脚本时崩溃报错的解决方案二
开发语言·c++·windows·python·开源软件
阿萨姆.35714 分钟前
结对编程 --- 软件工程
java·软件工程·结对编程
「QT(C++)开发工程师」15 分钟前
如何学习Python编程?
开发语言·python·学习
Trouvaille ~17 分钟前
【C++篇】跨越有限与无限的边界:STL之set容器中的自我秩序与无限可能
开发语言·数据结构·c++·容器·stl·set·红黑树
鹿屿二向箔18 分钟前
基于 JAVASSM(Java + Spring + Spring MVC + MyBatis)框架开发一个九宫格日志系统
java·spring·mvc
潘帕斯的雄鹰21 分钟前
【1个月速成Java】基于Android平台开发个人记账app学习日记——第7天,申请阿里云SMS短信服务SDK
java·学习·阿里云·sms·短信服务sdk