5、数组作业

最新推荐文章于 2023-12-26 14:46:13 发布
最新推荐文章于 2023-12-26 14:46:13 发布
阅读量3.1k 收藏 7
点赞数 1
分类专栏： 大数据——JAVA基础篇
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaoyoupei/article/details/110920617
版权

数组作业

一、填空题
1.数组会在内存中开辟一块________的空间，每个空间相当于之前的一个变量，称为数组的元素。数组的长度一经确定，就无法再改变。
2.要获取一个数组的长度，可以通过_______属性来获取，但获取的只是为数组分配的空间的数量，而不是数组中实际已经存放的元素的个数。
3.__仅仅是给出了数组名字和元素的数据类型，要想真正的使用数组还必须使用new关键字为它分配内存空间。
4.创建数组后，系统会给每一个数组元素一个默认的值，如String类型元素的默认值是 __。
5.在Java中有二维数组int [ ] [ ] array={{1,2,3},{4,5}} ，可以使用___________得到二维数组中第二维中第一个数组的长度。

二、选择题

  1. 在Java中，以下程序段能正确为数组赋值的是（ ）。（选择二项）

    A int a[]={1,2,3,4};
    B. int b[4]={1,2,3,4};
    C. int c[];c={1,2,3,4};
    D. int d[];d=new int[]{1,2,3,4};

  2. 数组元素的索引可以是（ ）。（选择一项）

    A 整型常量
    B. 整型变量
    C. 整型表达式
    D. 以上都可以

  3. 已知表达式int [] m={0,1,2,3,4,5,6};下面（ ）表达式的值与数组最大下标数相等。（选择一项）

    A m.length()
    B. m.length-1
    C. m.length()+1
    D. m.length+1

  4. 在Java中，以下定义数组的语句正确的是（ ）。（选择二项）

    A int t[10]=new int[ ];
    B. char [ ]a=”hello”;
    C. String [ ] s=new String [10];
    D. double[ ] d [ ]=new double [4][ ];

  5. 在Java中,下面代码的输出结果为（ ）。（选择一项）
    public static void main(String[] args) {
    int[] arrA = { 12, 22, 8, 49, 3 };
    int k = 0; int len = arrA.length;
    for (int i = 0; i < len; i++) {
    for (int j = i + 1; j < len; j++) {
    if (arrA[i] > arrA[j]) {
    k = arrA[i];
    arrA[i] = arrA[j];
    arrA[j] = k;
    }
    }
    }
    for (int i = 0; i < arrA.length; i++) {
    System.out.print(arrA[i]);
    if (i < arrA.length - 1) {
    System.out.print("，");
    }
    }
    }

    A 3，8，12，22，49
    B. 12，22，8，49，3
    C. 49，22，12，8，3
    D. 编译错误

  6. 分析下面的Java源程序，编译后的运行结果是（ ）。（选择一项）
    import java.util.*;
    public class Test {
    public static void main(String[ ] args) {
    int [ ] numbers=new int[ ]{1,2,3};
    System.out.println(Arrays.binarySearch(numbers, 2));
    }
    }
    输出
    A 输出：0
    B. 输出：1
    C. 输出：2
    D. 输出：3

  7. 以下选项中关于Java中方法的可变参数的说法正确的是（ ）。（选择二项）

    A 可变参数是JDK1.5增加的内容，用来表示方法的形参
    B. 一个方法可以没有可变参数，可以有1个或者多个可变参数
    C. 可变参数可以被当作数组参数来处理
    D. 可变参数对应的实参可以1个，2个，多个，但不能0个（可以为0个），还可以是一个数组

  8. 分析下面的Java程序，编译运行后的输出结果是（ ）。（选择一项）
    public class Example {
    String str = new String(“good”);
    char[] ch = { ‘a’, ‘b’, ‘c’ };
    public static void main(String args[]) {
    Example ex = new Example( );
    ex.change(ex.str, ex.ch);
    System.out.print(ex.str + “and”);
    System.out.print(ex.ch);
    }
    public void change(String str, char ch[]) {
    str = “test ok”;
    ch[0] = ‘g’;
    }
    }

    A goodandabc
    B. goodandgbc
    C. test okandabc
    D. test okandgbc

  9. 以下选项中能够正确创建一个数组的是（ ）。（选择二项）

    A. float []f[] = new float[6][6];
    B. float f[][] = new float[][];
    C. float [6][]f = new float[6][6];
    D. float [][]f = new float[6][];

三、判断题
1.数组可以声明为任何数据类型，包括任何基本数据类型和引用数据类型。（ ）
2.数组的长度是确定的，数组一旦被创建，它的大小就是不可以改变的。但是其元素类型可以是不同类型，允许出现混合类型。（ ）
3.声明数组并分配空间后，数组的每个元素将会赋予初始值。（ ）
4.创建数组后，系统会给每个数组元素一个默认值，如double型元素的默认值是0.0。（ T ）
5.数组的主要优点是按照索引查找某个元素效率高，同时按照元素值查询某个元素效率也很高，但是添加和删除元素需要大量移动元素，效率低下。（ ）
可以利用偏移地址来访问元素，效率高；可以利用折半方法查找元素，效率较高
6.数组的某个元素被传递给一个方法并被该方法修改，当被调用方法执行完毕时，这个元素中含有修改过的数值。（ ）
7.Java允许创建不规则数组，即Java多维数组中各行的列数可以不同。（ ）
8.对于数组int[][] t={{1,2,3},{4,5,6}}来说，t.length等于3，t[0].length等于2（ ）

四、简答题
1.数组的特点。

2.数组的优缺点
3.冒泡排序的算法。

五、编码题
1.数组查找操作：定义一个长度为10 的一维字符串数组，在每一个元素存放一个单词；然后运行时从命令行输入一个单词，程序判断数组是否包含有这个单词，包含这个单词就打印出“Yes”，不包含就打印出“No”。
2.获取数组最大值和最小值操作：利用Java的Math类的random()方法，编写函数得到0到n之间的随机数，n是参数。并找出产生50个这样的随机数中最大的、最小的数，并统计其中>=60的有多少个。
提示：使用 int num=(int)(n*Math.random());获取随机数
3.数组逆序操作：定义长度为10的数组，将数组元素对调，并输出对调前后的结果。
思路：把0索引和arr.length-1的元素交换，把1索引和arr.length-2的元素交换……
只要交换到arr.length/2的时候即可。
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的个数，这样可以开辟新数组；从旧的数组之中，取出内容，并将其赋给新开辟的数组。
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的情况，表示查找不成功。
6.二维数组遍历求和操作：用二重循环求出二维数组b所有元素的和：
int[][] b={{11},{21,22},{31,32,33}}
六、可选题
1.生成一百个随机数，放入数组，然后排序输出。
2.题目：输入某年某月某日，判断这一天是这一年的第几天？
分析：以3月5日为例，先把前两个月的加起来，然后再加上5天即本年第几天，特殊情况，闰年且输入月份大于3需考虑多加一天。可定义数组存储1-12月各月天数。
3.使用二分法查找有序数组中元素。找到返回索引，不存在输出-1。使用递归实现
4. 数组A：1，7，9，11，13，15，17，19；数组b：2，4，6，8，10
两个数组合并为数组c，按升序排列。 要求：使用Arrays类的方法快速实现。

数组作业答案

一、填空题

1.连续
2.length
3.声明数组
4.null
5.array[0].length

二、选择题

1.AD
2.D
3.B
4.CD
5.A
6.B
7.AC
8.B
9.AD

三、判断题

1.√
2.×
3.√
4.√
5.×
6.√
7.√
8.×

四、简答题

1、答：数组是可以保存一组数据的一种数据结构，它本身也会占用一个内存地址，因此数组是引用类型
·一个数组中只能保存一种类型的数据，可以保存基本类型，也可以保存Object。一个int,一个String是不能同时保存在一个数组内的(如果是对象型数组，注意存放的每一个对象都必须被实例化)。数组的长度规定好即固定，无论其保存的数据是否填满数组，数组一旦定义好就不可以修改长度，如果要修改就必须重新定义一个新数组或者引用其他的数组，因此数组的灵活性较差，数组拥有边界检查，尝试获取不在数组范围内的值时，会抛出ArrayIndexOutOfBoundsException异常
2、答：优点：使用方便，查询效率比链表高，内存唯一连续的区域缺点：大小固定，不适合动态存储，不方便动态添加
3、答：按照从小到大或者从大到小的顺序进行交换,这样一趟过去后,最大或最小的数字被交换到了最后一位,然后再从头开始进行两两比较交换,直到倒数第二位时结束

五、编码题
1.定义一个长度为10 的一维字符串数组，在每一个元素存放一个单词；然后运行时从命令行输入一个单词，程序判断数组是否包含有这个单词，包含这个单词就打印出“Yes”，不包含就打印出“No”。

public class Test {
	// 思路：遍历数组时当有值与输入字符串相同时使用一个boolean记录状态
	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是参数。
提示： int num=(int)(n*Math.random());
并找出产生50个这样的随机数中最大的、最小的数，并统计其中大于等于60的有多少个。

public class Test {
	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的数组，将数组元素对调，并输出对调前后的结果。

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

public class Test {
	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。

public class BinarySearch {
	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}}
public class Test {
	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.生成一百个随机数，放入数组，然后排序输出。

public class Test {
	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.println(i);
		}
	}
}

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

public class Test {
	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.使用二分法查找有序数组中元素。找到返回索引，不存在输出-1。使用递归实现

public class BinarySearch {
	public static void main(String[] args) {		
		int[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
		System.out.println(searchRecursive(array, 0, array.length - 1, 20));
	}
	/**
	 * 执行递归二分查找，返回第一次出现该值的位置	 * 
	 * @param array  已排序的数组
	 * @param start 开始位置
	 * @param end 结束位置
	 * @param findValue  需要找的值
	 * @return 值在数组中的位置，从0开始。找不到返回-1
	 */
	public static int searchRecursive(int[] array, int start, int end,
			int findValue) {
		// 如果数组为空，直接返回-1，即查找失败
		if (array == null) {
			return -1;
		}	
		if (start <= end) {
			// 中间位置
			int middle = (start + end) / 1;
			// 中值
			int middleValue = array[middle];
			if (findValue == middleValue) {
				// 等于中值直接返回
				return middle;
			} else if (findValue < middleValue) {
				// 小于中值时在中值前面找
				return searchRecursive(array, start, middle - 1, findValue);
			} else {
				// 大于中值在中值后面找
				return searchRecursive(array, middle + 1, end, findValue);
			}
		} else {
			// 返回-1，即查找失败
			return -1;
		}
	}
}
  1. 现在给出两个数组：
    数组A：“1，7，9，11，13，15，17，19：；
    数组b：“2，4，6，8，10”
    两个数组合并为数组c，按升序排列。
    要求：使用Arrays类的方法快速实现。
public class Test {
	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
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
用Java实现随机生成100个随机数并放在数组里，排序并输出
weixin_45139543的博客
11-14 1万+
在这里插入代码片package Day04.Day04_Practice; import java.util.Random; /*生成一百个随机数，放入数组，然后排序输出。 */ public class Practice08 { public static void main(String[] args) { Random random = new Random(); int [] arr = new int[100];//动态初始化一个长度为100的数组
【小白学Java】Test04》》》数组练习题
北慕辰的博客，欢迎各位大佬光临！！
07-04 2467
一、填空题 1.数组会在内存中开辟一块___连续_____的空间，每个空间相当于之前的一个变量，称为数组的元素。数组的长度一经确定，就无法再改变。 2.要获取一个数组的长度，可以通过__.length_____属性来获取，但获取的只是为数组分配的空间的数量，而不是数组中实际已经存放的元素的个数。 3.__声明数组 __仅仅是给出了数组名字和元素的数据类型，要想真正的使用数组还必须使用new关键字为它分配内存空间。 4.创建数组后，系统会给每一个数组元素一个默认的值，如String类型元素的默认值是__ nu
数组作业及答案
weixin_39571268的博客
04-24 6780
一、填空题 1.数组会在内存中开辟一块________的空间，每个空间相当于之前的一个变量，称为数组的元素。数组的长度一经确定，就无法再改变。 2.要获取一个数组的长度，可以通过________属性来获取，但获取的只是为数组分配的空间的数量，而不是数组中实际已经存放的元素的个数。 3._________仅仅是给出了数组名字和元素的数据类型，要想真正的使用数组还必须使用new关键字为它分配内存空间。...
数组合并
weixin_30929011的博客
04-23 1064
问题： 现在给出两个数组： 数组a："1,7,9,11,13,15,17,19" 数组b："2,4,6,8,10" 两个数组合并为数组c。 思路（个人）：已知数组a和数组b中的元素，定义一个长度为a,b两数组元素之和的数组，使用for循环和if语句将a,b两个数组中的元素遍历赋值给新数组，将其合并到新数组中（可以使用Arrays中的静态方法sort()对新数组中的元素进行...
【数组】作业，练习，巩固，综合练习2
qq_49047454的博客
07-21 311
A、JAVA程序的main方法必须写在类里面B、JAVA程序中可以有多个main方法C、JAVA程序中代码的执行可以不从main开始D、JAVA程序的main方法中如果只有一条语句，可以不用{}(大括号)括起来。A、for循环体语句中，可以包含多条语句，但要用大括号括起来B、for循环只能用于循环次数已经确定的情况C、在for循环中，不能使用break语句跳出循环D、for循环是先执行循环体语句，后进行条件判断。String[]a={"我","爱","中","国"};...
4.4 二维数组相关内容
qq_47360019的博客
09-30 425
第四章第四节
java数组作业
09-16
请参照String类，对一个封装了字节数组的类提供如下函数 public class MyByteArray { private byte[] data; public MyByteArray(byte[] data) { this.data = data; } //返回字节数据b在字节数组中的位置 ...
5.数组作业答案1
08-08
5. **数组中查找特定元素** - 在编码题的第一部分，程序通过遍历数组，使用`equals()`方法比较元素与输入的字符串，找到匹配项时，设置一个布尔标志变量`flag`为true，最后根据`flag`的值判断数组是否包含目标字符...
数组作业
02-10
数组作业通常涉及理解数组的概念、操作以及在实际问题中的应用。在这个ArrayHomework-master项目中，我们可以探讨以下几个关于数组的重要知识点： 1. **数组定义**： 数组是一种线性数据结构，它存储同一类型的...
第六章数组作业题.zip
04-17
从提供的文件名来看，我们有两个文件：一个源代码文件（张明辉数组作业.c）和一个可能包含问题解答或示例图像的图片文件（第六章数组作业题.jpg）。 首先，让我们详细讨论一下数组这个主题。 数组是由相同类型的...
JavaScript数组作业一
08-28
考察基本数组的使用情况 let arr = [ { name: "数学", score: 99, }, { name: "英语", score: 97, }, { name: "语文", score: 96, }, ]; // 1. 找到语文的成绩 不能直接使用索引 // 2. 计算出总成绩...
错题总结--黑马程序员之基础班入班考试
fengbird的博客
09-12 6134
8、下列关于变量和常量的说法正确的是（AD   ） A. 常量表示不能被改变的值，例如1、2、“abc”都是常量 B. 常量表示常见的变量 C. int x = 0;代码中，x表示常量，0表示变量 D. 在同一个大括号｛｝内，定义的变量不能够重名 此题答案为A，而我选择的是D，把A漏了，究其原因是因为对常量的定义认识不够深刻，常量就是表示不能被改变的值。 11、下列
两个数组合并排序的java实现
热门推荐
qq_42846655的博客
08-06 1万+
两个数组合并排序的java实现 本文主要描述了两个数组的合并排序，用Java代码实现的几种方法 方法一 用于合并两个有序数组，默认升序 package com.cyl.day05; /** * 数组A：“1，7，9，11，13，15，17，19”； * 数组b：“2，4，6，8，10” ； * 两个数组合并为数组c，按升序排列。 *...
数组练习之二分查找详解
最新发布
optimistic_chen的博客
12-26 962
二分查找也叫做折半查找，二分查找是查找有序元素注意：必须是有序元素列的一种算法，它的目的在于更加节约时间和空间，结果是如果查找的元素存在，则返回其位置，否则返回NULL。比如存在1——100的数字，我们需要找到40这个元素，你每次输入一个数字，我告诉你它大了，小了，正确。
Java二维数组详解
2301_76161469的博客
07-31 8264
静态初始化虽然未指定二维数组的行和列，但编译器会在编译时会根据{}中的元素个数来确定数组行与列的大小。我们可以先找到一维数组，再找到该一维数组中要输出的元素。在使用二维数组时，若未对二维数组进行初始化，数组中的元素为默认值。若数组中的元素为基本数据类型，默认值为基本数据类型对应的默认值，二维数组的本质其实就是一维数组，只不过每个元素又是一个一维数组。如图所示，对于一个二维数组来说，数组元素中存放的是。若数组中的元素为引用类型，默认值为。在Java中，创建二维数组时，方法，将二维数组转换为字符串。
Java基础：（七）数组
地球村
08-17 1087
创建数组 数组是相同类型数据的有序集合 1.相同类型的若干个数据,按照一定先后次序排列组合而成。 2.其中,每一个数据称作一个数组元素 3.每个数组元素可以通过一个下标来访问它们 数组特点 1.其长度是确定的。数组一旦被创建，它的大小就是不可以改变的 2.其元素必须是相同类型,不允许出现混合类型 3.数组中的元素可以是任何数据类型，包括基本类型和引用类型 数组属引用类型 length, elem...
Java---pta1错题
qq_45725890的博客
09-28 2976
实例化和创建对象是一个概念 1-7数组的长度 比方int[] arry=new int[5]; 请问如何使用length获取数据的长度？ length后面有没有() String[] str=new String[10]; java中基本数据类型包含哪些？ int float double boolean char byte 引用类型 类的对象 String 数组 枚举。等等 数组的使用必循先...
java二级选择题答案_2017下半年计算机等级考试二级Java模拟试题及答案（24）
weixin_35011928的博客
02-26 972
1、Java允许创建不规则数组，即Java多维数组中各行的列数可以不同。√2、Java语言中的数组元素只能是基本数据类型而不能为对象类型。×3、Java语言中的数组元素下标总是从0开始，下标可以是整数或者整型表达式。√4、在Java的方法中定义一个常量要用const关键字。×5、Java语言中的数组元素只能是基本数据类型而不能是对象类型。×6、同C语言一样，在Java语言中，自定义方法必须放在主调...
JAVA---数组1---一维数组
卿霜寒墨的博客
05-24 308
什么是数组？ 数组是用来存储具有相同数据类型的数据的集合，可以使用共同的名字来引用数组中储存的数据，数组可以存储任何类型的数据，包括原始数据类型和对象，但是一旦指定了数组的类型，就只能用来存储指定类型的数据。 数组提供了一种数据凤族的便利方法。在数组中，每一项数据都经过编号，可以通过数组的下标（即数据在数组中的索引值，从0开始。例如，数组中第一项数据的下标为0，第二项数据的下标为1，第N项数据的下标为N-1）来方便的访问。 Java语言中数组的特点 Java中的数组，既能存储原始数据类型，又能存储对象类型
php数组的作业,0417php数组的操作
05-19
5. 数组长度 可以使用 count() 函数来获取数组的长度。例如： ``` echo count($fruits); // 输出 2 ``` 6. 遍历数组 可以使用 for 循环遍历数组，也可以使用 foreach 循环遍历数组。例如： ``` for ($i = 0; $i...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

友培

数据皆开源！

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值