【JavaSE】数组（134~173）

于 2023-01-30 16:10:58 发布
阅读量390 收藏 1
点赞数 2
分类专栏： # 一、JavaSE 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46707734/article/details/124730906
版权

数组

134.Eclipse的使用与数组-每天一考

1.循环结构是如何最后退出循环的，有哪些不同的情况请说明。

① 循环条件返回false
② 在循环体内，一旦执行到break，跳出循环
continue跳出当次循环；return结束方法

2.指出如下程序输出的结果：

label: for (int i = 1; i <= 4; i++) {
			for (int j = 1; j <= 10; j++) {
				if (j % 4 == 0) {
					continue label;
				}
				System.out.print(j);
			}
			System.out.println();
}
//正确结果：123123123123

3.一个数如果恰好等于它的因子之和，这个数就称为"完数"。例如6=1＋2＋3。编程 找出1000以内的所有完数。（因子：除去这个数本身的其它约数）

4.说明break和continue使用上的相同点和不同点

break:s witch-case 和 循环结构（结束当前循环），其后不可以声明执行语句
continue: 循环结构（结束当次循环），其后不可以声明执行语句

135.Eclipse的使用与数组-复习

136.Eclipse的使用与数组-Eclipse首次启动的设置

设置 workspace
首次启动,选择指定的工作空间(workspace)，用于存放 java 代码
在这里插入图片描述
注: 中间的蓝框, 不建议打钩. 如果打钩, 每次 Eclipse 会自动进入上面选中的
workspace 中.不利于 Eclipse 开启其他 workspace。点击”OK”,进入主界面.首次进入显示如下：
在这里插入图片描述
设置透视图(perspective)
进入 Eclipse 编辑界面以后,首先选择如下的红框,设置透视图:
在这里插入图片描述
点击”红框”，选择 JavaEE 透视图
在这里插入图片描述
添加透视图需要显示的结构
在如下的文本框（右上角位置）中依次输入相应结构的名字,调取出来。
在这里插入图片描述
结构 1：Package Explorer
在这里插入图片描述
结构 2：Navigator
在这里插入图片描述
设置编码集
在这里插入图片描述
在这里插入图片描述
设置字体,字形,字体大小
在这里插入图片描述
双击:Text Font
在这里插入图片描述
设置 package explorer 中右键:new 下显示的结构
windows->Customize Perspercitve
在这里插入图片描述
勾选常用的
保存当前透视图
在这里插入图片描述在这里插入图片描述
在这里插入图片描述

137.Eclipse的使用与数组-HelloWorld程序的编写和执行

创建工程
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

138.Eclipse的使用与数组-Eclipse使用的常见问题1

1.双击 Eclipse 启动图标，不能正常启动 Eclipse

启动不了的原因有很多种，这里需要大家从如下几个方面排查：

  1. 环境变量是否正确配置，需要在命令行输入 javac.exe 或 java.exe 进行检查
  2. 是否正确的安装了 JDK 和 JRE
  3. 安装的 JDK 的版本（32 位还是 64 位），必须与 Eclipse 版本一致
  4. 修改 Eclipse 安装目录下的 eclipse.ini 配置文件

2.进入 Eclipse 时，没有可选择的 workspace
在这里插入图片描述
3.如何导入已有的工程
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

4.如何导入已有的一个源文件
直接复制（ctrl + c）此源文件，直接在指定的工程的包下粘贴（ctrl + v）即可。

139.Eclipse的使用与数组-Eclipse使用的常见问题2

常用快捷键

  • 1.补全代码的声明：alt + /
  • 2.快速修复: ctrl + 1
  • 3.批量导包：ctrl + shift + o
  • 4.使用单行注释：ctrl + /
  • 5.使用多行注释： ctrl + shift + /
  • 6.取消多行注释：ctrl + shift + \
  • 7.复制指定行的代码：ctrl + alt + down 或 ctrl + alt + up
  • 8.删除指定行的代码：ctrl + d
  • 9.上下移动代码：alt + up 或 alt + down
  • 10.切换到下一行代码空位：shift + enter
  • 11.切换到上一行代码空位：ctrl + shift + enter
  • 12.如何查看源码：ctrl + 选中指定的结构 或 ctrl + shift + t
  • 13.退回到前一个编辑的页面：alt + left
  • 14.进入到下一个编辑的页面(针对于上面那条来说的)：alt + right
  • 15.光标选中指定的类，查看继承树结构：ctrl + t
  • 16.复制代码： ctrl + c
  • 17.撤销： ctrl + z
  • 18.反撤销： ctrl + y
  • 19.剪切：ctrl + x
  • 20.粘贴：ctrl + v
  • 21.保存： ctrl + s
  • 22.全选：ctrl + a
  • 23.格式化代码： ctrl + shift + f
  • 24.选中数行，整体往后移动：tab
  • 25.选中数行，整体往前移动：shift + tab
  • 26.在当前类中，显示类结构，并支持搜索指定的方法、属性等：ctrl + o
  • 27.批量修改指定的变量名、方法名、类名等：alt + shift + r
  • 28.选中的结构的大小写的切换：变成大写： ctrl + shift + x
  • 29.选中的结构的大小写的切换：变成小写：ctrl + shift + y
  • 30.调出生成 getter/setter/构造器等结构： alt + shift + s
  • 31.显示当前选择资源(工程 or 文件)的属性：alt + enter
  • 32.快速查找：参照选中的 Word 快速定位到下一个 ：ctrl + k
  • 33.关闭当前窗口：ctrl + w
  • 34.关闭所有的窗口：ctrl + shift + w
  • 35.查看指定的结构使用过的地方：ctrl + alt + g
  • 36.查找与替换：ctrl + f
  • 37.最大化当前的 View：ctrl + m
  • 38.直接定位到当前行的首位：home
  • 39.直接定位到当前行的末位：end

140.Eclipse的使用与数组-数组的概述

数组(Array)，是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。

数组的常见概念：数组名、下标(或索引)、元素、数组的长度

数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。
创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是这块连续空间的首地址。
数组的长度一旦确定，就不能修改。
我们可以直接通过下标(或索引)的方式调用指定位置的元素，速度很快

141.Eclipse的使用与数组-一维数组的初始化

一维数组的声明方式：
type var[] 或 type[] var；
Java语言中声明数组时不能指定其长度(数组中元素的数)

//例如：
int a[];
int[] a1;
double	b[];
String[] c; //引用类型变量数组
int a[5];	//非法

在这里插入图片描述
定义并用运算符new为之分配空间后，才可以引用数组中的每个元素；

142.Eclipse的使用与数组-数组元素的调用

数组元素的引用方式：数组名[数组元素下标]

  • 数组元素下标可以是整型常量或整型表达式。如a[3] , b[i] , c[6*i];
  • 数组元素下标从0开始；长度为n的数组合法下标取值范围: 0 —>n-1；如int a[]=new int[3]; 可引用的数组元素为a[0]、a[1]、a[2]

143.Eclipse的使用与数组-数组的程度与遍历

每个数组都有一个属性length指明它的长度，例如：a.length 指明数组a的长
度(元素个数)
数组一旦初始化，其长度是不可变的。

144.Eclipse的使用与数组-数组元素的默认初始化值

对于基本数据类型而言，默认初始化值各有不同
对于引用数据类型而言，默认初始化值为null(注意与0不同！)

在这里插入图片描述

145.Eclipse的使用与数组-内存结构的简单说明

在这里插入图片描述

146.Eclipse的使用与数组-一维数组的内存解析

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

147.Eclipse的使用与数组-一维数组的课后练习1
148.Eclipse的使用与数组-一维数组的课后练习2

149.Eclipse的使用与数组-二维数组的理解和初始化

Java 语言里提供了支持多维数组的语法。

如果说可以把一维数组当成几何中的线性图形，那么二维数组就相当于是一个表格

对于二维数组的理解，我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存
在。其实，从数组底层的运行机制来看，其实没有多维数组。

在这里插入图片描述
在这里插入图片描述

150.Eclipse的使用与数组-二维数组的长元素调用

package com.atguigu.java;
/*
 * 二维数组的使用
 * 
 * 1.理解：
 * 对于二维数组的理解，我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存在。
 * 其实，从数组底层的运行机制来看，其实没有多维数组。
 * 
 * 2. 二维数组的使用:
 *   ① 二维数组的声明和初始化
 *   ② 如何调用数组的指定位置的元素
 *   ③ 如何获取数组的长度
 *   ④ 如何遍历数组
 *   ⑤ 数组元素的默认初始化值 :见 ArrayTest3.java
 *   ⑥ 数组的内存解析 :见 ArrayTest3.java
 */
public class ArrayTest2 {
	public static void main(String[] args) {
		//1.二维数组的声明和初始化
		int[] arr = new int[]{1,2,3};//一维数组
		//静态初始化
		int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}};
		//动态初始化1
		String[][] arr2 = new String[3][2];
		//动态初始化2
		String[][] arr3 = new String[3][];
		//错误的情况 
//		String[][] arr4 = new String[][4];
//		String[4][3] arr5 = new String[][];
//		int[][] arr6 = new int[4][3]{{1,2,3},{4,5},{6,7,8}};
		
		//也是正确的写法：
		int[] arr4[] = new int[][]{{1,2,3},{4,5,9,10},{6,7,8}};
		int[] arr5[] = {{1,2,3},{4,5},{6,7,8}};
		
		//2.如何调用数组的指定位置的元素
		System.out.println(arr1[0][1]);//2
		System.out.println(arr2[1][1]);//null
		
		arr3[1] = new String[4];
		System.out.println(arr3[1][0]);
		
		//3.获取数组的长度
		System.out.println(arr4.length);//3,arr4里面放了三个元素
		System.out.println(arr4[0].length);//3
		System.out.println(arr4[1].length);//4
		
		//4.如何遍历二维数组
		for(int i = 0;i < arr4.length;i++){
			
			for(int j = 0;j < arr4[i].length;j++){
				System.out.print(arr4[i][j] + "  ");
			}
			System.out.println();
		}
		
	}
}

151.Eclipse的使用与数组-二维数组的长度和遍历

152.Eclipse的使用与数组-二维数组元素默认初始化值

package com.atguigu.java;
/*
 * 二维数组的使用：
 * 	规定：二维数组分为外层数组的元素，内层数组的元素
 * 		int[][] arr = new int[4][3];
 * 		外层元素：arr[0],arr[1]等
 * 		内层元素：arr[0][0],arr[1][2]等
 * 
 *   ⑤ 数组元素的默认初始化值 
 *   针对于初始化方式一：比如：int[][] arr = new int[4][3];
 *      外层元素的初始化值为：地址值
 *      内层元素的初始化值为：与一维数组初始化情况相同
 *      
 *   针对于初始化方式二：比如：int[][] arr = new int[4][];
 *   	外层元素的初始化值为：null
 *      内层元素的初始化值为：不能调用，否则报错。
 *   
 *   ⑥ 数组的内存解析 
 * 
 */
public class ArrayTest3 {
	public static void main(String[] args) {
		
		int[][] arr = new int[4][3];
		System.out.println(arr[0]);//[I@15db9742 
		System.out.println(arr[0][0]);//0
		
//		System.out.println(arr);//[[I@6d06d69c
		
		System.out.println("*****************");
		float[][] arr1 = new float[4][3];
		System.out.println(arr1[0]);//地址值
		System.out.println(arr1[0][0]);//0.0
		
		System.out.println("*****************");
		
		String[][] arr2 = new String[4][2];
		System.out.println(arr2[1]);//地址值
		System.out.println(arr2[1][1]);//null
		
		System.out.println("*****************");
		double[][] arr3 = new double[4][];
		System.out.println(arr3[1]);//null
//		System.out.println(arr3[1][0]);//报错
		
	}
}

153.Eclipse的使用与数组-二维数组的内存解析

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
154.数组-每天一考
155.数组-复习：Eclipse的使用
156.数组-复习：数组的概述_数据结构概述
157.数组-复习：一维数组与二维数组
158.数组-二维数组练习：基本操作
159.数组-二维数组练习：杨辉三角
160.数组-算法：数组元素的赋值

161.数组-算法：数值型数组元素的操作

package com.atguigu.java;
/*
 * 算法的考查：求数值型数组中元素的最大值、最小值、平均数、总和等
 * 
 * 定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，
 * 然后求出所有元素的最大值，最小值，和值，平均值，并输出出来。	
 * 要求：所有随机数都是两位数。
 * 
 * [10,99]
 * 公式：(int)(Math.random() * (99 - 10 + 1) + 10)
 * 
 */
public class ArrayTest1 {
	public static void main(String[] args) {
		int[] arr = new int[10];
		
		for(int i = 0;i < arr.length;i++){
			arr[i] = (int)(Math.random() * (99 - 10 + 1) + 10);
		}
		
		//遍历
		for(int i = 0;i < arr.length;i++){
			System.out.print(arr[i] + "\t");
		}
		System.out.println();
		
		//求数组元素的最大值
		int maxValue = arr[0];
		for(int i = 1;i < arr.length;i++){
			if(maxValue < arr[i]){
				maxValue = arr[i];
			}
		}
		System.out.println("最大值为：" + maxValue);
		
		//求数组元素的最小值
		int minValue = arr[0];
		for(int i = 1;i < arr.length;i++){
			if(minValue > arr[i]){
				minValue = arr[i];
			}
		}
		System.out.println("最小值为：" + minValue);
		//求数组元素的总和
		int sum = 0;
		for(int i = 0;i < arr.length;i++){
			sum += arr[i];
		}
		System.out.println("总和为：" + sum);
		//求数组元素的平均数
		int avgValue = sum / arr.length;
		System.out.println("平均数为：" + avgValue);
	}
}

162.数组-课后练习：数组赋值

package com.atguigu.exer;
/*
 * 使用简单数组
(1)创建一个名为ArrayExer2的类，在main()方法中声明array1和array2两个变量，他们是int[]类型的数组。
(2)使用大括号{}，把array1初始化为8个素数：2,3,5,7,11,13,17,19。
(3)显示array1的内容。
(4)赋值array2变量等于array1，修改array2中的偶索引元素，使其等于索引值(如array[0]=0,array[2]=2)。打印出array1。
 * 
 * 思考：array1和array2是什么关系？array1和array2地址值相同，都指向了堆空间的唯一的一个数组实体。
 * 拓展：修改题目，实现array2对array1数组的复制
 */
public class ArrayExer2 {
	public static void main(String[] args) {  //alt + /
		int[] array1,array2;
		
		array1 = new int[]{2,3,5,7,11,13,17,19};
		
		//显示array1的内容
		for(int i = 0;i < array1.length;i++){
			System.out.print(array1[i] + "\t");
		}
		
		//赋值array2变量等于array1
		//不能称作数组的复制。
		array2 = array1;
		
		//修改array2中的偶索引元素，使其等于索引值(如array[0]=0,array[2]=2)
		for(int i = 0;i < array2.length;i++){
			if(i % 2 == 0){
				array2[i] = i;
			}
			
		}
		System.out.println();
		//打印出array1
		for(int i = 0;i < array1.length;i++){
			System.out.print(array1[i] + "\t");
		}
	}
}

163.数组-算法：数组的复制

package com.atguigu.java;
/*
 * 算法的考查：数组的复制、反转、查找(线性查找、二分法查找)
 * 
 * 
 */
public class ArrayTest2 {
	
	public static void main(String[] args) {
		
		String[] arr = new String[]{"JJ","DD","MM","BB","GG","AA"};
		
		
		//数组的复制(区别于数组变量的赋值：arr1 = arr)
		String[] arr1 = new String[arr.length];
		for(int i = 0;i < arr1.length;i++){
			arr1[i] = arr[i];
		}
		
		//数组的反转
		//方法一：
//		for(int i = 0;i < arr.length / 2;i++){
//			String temp = arr[i];
//			arr[i] = arr[arr.length - i -1];
//			arr[arr.length - i -1] = temp;
//		}
		
		//方法二：
//		for(int i = 0,j = arr.length - 1;i < j;i++,j--){
//			String temp = arr[i];
//			arr[i] = arr[j];
//			arr[j] = temp;
//		}
		
		//遍历
		for(int i = 0;i < arr.length;i++){
			System.out.print(arr[i] + "\t");
		}
		
		System.out.println();
		//查找（或搜索）
		//线性查找：
		String dest = "BB";
		dest = "CC";
		
		boolean isFlag = true;
		
		for(int i = 0;i < arr.length;i++){
			
			if(dest.equals(arr[i])){
				System.out.println("找到了指定的元素，位置为：" + i);
				isFlag = false;
				break;
			}
			
		}
		if(isFlag){
			System.out.println("很遗憾，没有找到的啦！");
			
		}
		//二分法查找：(熟悉)
		//前提：所要查找的数组必须有序。
		int[] arr2 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
		
		int dest1 = -34;
		dest1 = 35;
		int head = 0;//初始的首索引
		int end = arr2.length - 1;//初始的末索引
		boolean isFlag1 = true;
		while(head <= end){
			
			int middle = (head + end)/2;
			
			if(dest1 == arr2[middle]){
				System.out.println("找到了指定的元素，位置为：" + middle);
				isFlag1 = false;
				break;
			}else if(arr2[middle] > dest1){
				end = middle - 1;
			}else{//arr2[middle] < dest1
				head = middle + 1;
			}

			
		}
		
		if(isFlag1){
			System.out.println("很遗憾，没有找到的啦！");
		}
		
		
	}
}

164.数组-算法：数组元素的反转
165.数组-算法：线性查找
166.数组-算法：二分法查找

167.数组-算法和排序算法的概述

衡量排序算法的优劣：
1.时间复杂度：分析关键字的比较次数和记录的移动次数
2.空间复杂度：分析排序算法中需要多少辅助内存
3.稳定性：若两个记录A和B的关键字值相等，但排序后A、B的先后次序保 持不变，则称这种排序算法是稳定的。

排序算法分类：内部排序和外部排序。
内部排序：整个排序过程不需要借助于外部存储器（如磁盘等），所有排序操作都在内存中完成。
外部排序：参与排序的数据非常多，数据量非常大，计算机无法把整个排序过程放在内存中完成，必须借助于外部存储器（如磁盘）。外部排序最常见的是多路归并排序。可以认为外部排序是由多次内部排序组成

在这里插入图片描述

168.数组-算法：冒泡排序的实现

在这里插入图片描述

package com.atguigu.java;
/*
 * 数组的冒泡排序的实现
 * 
 */
public class BubbleSortTest {
	public static void main(String[] args) {
		
		int[] arr = new int[]{43,32,76,-98,0,64,33,-21,32,99};
		
		//冒泡排序
		for(int i = 0;i < arr.length - 1;i++){
			
			for(int j = 0;j < arr.length - 1 - i;j++){
				
				if(arr[j] > arr[j + 1]){
					int temp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = temp;
				}
				
			}
			
		}
		
		
		
		
		for(int i = 0;i < arr.length;i++){
			System.out.print(arr[i] + "\t");
		}
		
	}
}

169.数组-算法：快速排序的说明

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

package com.atguigu.java;

/**
 * 快速排序
 * 通过一趟排序将待排序记录分割成独立的两部分，其中一部分记录的关键字均比另一部分关键字小，
 * 则分别对这两部分继续进行排序，直到整个序列有序。
 */
public class QuickSort {
	private static void swap(int[] data, int i, int j) {
		int temp = data[i];
		data[i] = data[j];
		data[j] = temp;
	}

	private static void subSort(int[] data, int start, int end) {
		if (start < end) {
			int base = data[start];
			int low = start;
			int high = end + 1;
			while (true) {
				while (low < end && data[++low] - base <= 0)
					;
				while (high > start && data[--high] - base >= 0)
					;
				if (low < high) {
					swap(data, low, high);
				} else {
					break;
				}
			}
			swap(data, start, high);
			
			subSort(data, start, high - 1);//递归调用
			subSort(data, high + 1, end);
		}
	}
	public static void quickSort(int[] data){
		subSort(data,0,data.length-1);
	}
	
	
	public static void main(String[] args) {
		int[] data = { 9, -16, 30, 23, -30, -49, 25, 21, 30 };
		System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
		quickSort(data);
		System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
	}
}

170.数组-排序算法打的横向对比

排序算法性能对比
在这里插入图片描述
各种内部排序方法性能比较
1.从平均时间而言：快速排序最佳。但在最坏情况下时间性能不如堆排序和归并排序。
2.从算法简单性看：由于直接选择排序、直接插入排序和冒泡排序的算法比较 简单，将其认为是简单算法。对于Shell排序、堆排序、快速排序和归并排序 算法，其算法比较复杂，认为是复杂排序。
3.从稳定性看：直接插入排序、冒泡排序和归并排序时稳定的；而直接选择排 序、快速排序、 Shell排序和堆排序是不稳定排序
4.从待排序的记录数n的大小看，n较小时，宜采用简单排序；而n较大时宜采用改进排序

排序算法的选择
(1)若n较小(如n≤50)，可采用直接插入或直接选择排序。
当记录规模较小时，直接插入排序较好；否则因为直接选择移动的记录数少于直接插入，应选直接选择排序为宜。
(2)若文件初始状态基本有序(指正序)，则应选用直接插入、冒泡或随机的快速排序 为 宜 ；
(3)若n较大，则应采用时间复杂度为O(nlgn)的排序方法：快速排序、堆排序或归并排序。

171.数组-Arrays工具类的使用

在这里插入图片描述

package com.atguigu.java;

import java.util.Arrays;

/*
 * java.util.Arrays:操作数组的工具类，里面定义了很多操作数组的方法
 */
public class ArraysTest {
	public static void main(String[] args) {
		
		//1.boolean equals(int[] a,int[] b):判断两个数组是否相等。
		int[] arr1 = new int[]{1,2,3,4};
		int[] arr2 = new int[]{1,3,2,4};
		boolean isEquals = Arrays.equals(arr1, arr2);
		System.out.println(isEquals);
		
		//2.String toString(int[] a):输出数组信息。
		System.out.println(Arrays.toString(arr1));
		
			
		//3.void fill(int[] a,int val):将指定值填充到数组之中。
		Arrays.fill(arr1,10);
		System.out.println(Arrays.toString(arr1));
		

		//4.void sort(int[] a):对数组进行排序。
		Arrays.sort(arr2);
		System.out.println(Arrays.toString(arr2));
		
		//5.int binarySearch(int[] a,int key)
		int[] arr3 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
		int index = Arrays.binarySearch(arr3, 210);
		if(index >= 0){
			System.out.println(index);
		}else{
			System.out.println("未找到");
		}		
	}
}

172.数组-数组中常见的异常

在这里插入图片描述

173.数组-数组的总结

Hvitur
关注
专栏目录
4-JavaSE 数组
weixin_52221977的博客
06-06 94
Java的数组介绍：数组概述、数组的使用、多维数组（二维数组）、冒泡排序
循环结构小总结：
A15333774432的博客
08-01 258
循环结构小总结
JAVA基础学习笔记
weixin_44021180的博客
03-23 820
一.面型对象（上） 第一部分：习题 1.JDK,JRE,JVM三者之间的关系，以及JDK、JRE包含的主要结构有哪些？ 三者是包含关系 JDK=JRE+JAVA开发工具（javac.exe java.exe javadoc.exe） JRE=JVM+JAVA核心类库 2.为什么要配置path环境变量？如何配置？ 为了在任何一个文件路径下都可以执行JAVA的开发工具 JAVA_HOME=bin的上一层目录 path=%JAVA_HOME%\bin 3.常用的几个命令行操作都有哪些？(至少4
在循环中循环退出的条件有三种情况
hhm51she3271314的博客
05-31 2303
循环退出的条件
使用简单数组 (1) 创建一个名为TestArray的类，在main()方法中声明array1和array2两个变量， 他们是int[]类型的数组（数组练习）
Madge_jodie的博客
10-21 1703
使用简单数组 (1) 创建一个名为ArrayTest的类，在main()方法中声明array1和array2两个变量， 他们是int[]类型的数组。 (2)使用大括号{}，把array1初始化为8个素数：2,3,5,7,11,13,17,19。 (3) 显示array1的内容。 (4) 赋值array2变量等于array1，修改array2中的偶索引元素，使其等于索引值 (如array[0]=0,array[2]=2)。打印出array1 ...
Java-笔记5-复习
weixin_34289744的博客
05-05 107
1. 循环结构是如何最后退出循环的，有哪些不同的情况请说明。 ① 循环条件返回false ② 在循环体内，一旦执行到break，跳出循环 continue；return 2.指出如下程序输出的结果： label: for (int i = 1; i <= 4; i++) { for (int j = 1; j <= 10; j++) { ...
JavaSE进阶-02-数组.pdf
09-10
JavaSE进阶课程中，数组是一个重要的概念，它在编程中起到了存储一组相同类型数据的作用。数组被设计成一种引用数据类型，意味着它在内存中占据连续的空间，并且可以存储基本类型（如int、float）或引用类型（如对象...
javase数组对象
最新发布
10-14
JavaSE中的数组对象是一种特殊的对象，它可以存储固定数量的同类型元素。数组对象在创建时需要指定元素类型和数组长度，一旦创建后，数组长度就不能再改变了。 例如，创建一个包含5个整数的数组对象可以使用以下...
JavaSE进阶数组讲义
08-30
【JavaSE进阶数组讲义】深入解析 数组在Java编程语言中扮演着重要的角色，它是数据结构的基础，用于存储一组具有相同类型的元素。数组的特点包括： 1. **数组的本质**：数组是一种引用数据类型，它在内存中表现为...
JavaSE之数组与集合类
07-21
在这个话题中，我们将探讨Java中的数组和集合类，这些都是JavaSE阶段的重要知识点。 首先，让我们从面向对象编程说起。面向对象编程（OOP）是Java语言的基础，与面向过程编程不同，后者关注的是执行步骤，而OOP更...
Java练习_第五天
OceanStar的博客
02-03 637
1. 循环结构是如何最后退出循环的，有哪些不同的情况请说明。 ① 循环条件返回false ② 在循环体内，一旦执行到break，跳出循环 ③ continue；return 2.指出如下程序输出的结果[我算错了，下次仔细]： label: for (int i = 1; i <= 4; i++) { for (int j = 1; j <= 10; j++) { if (...
计算机中有符号整数的取值范围
weixin_71751896的博客
06-08 3922
计算机中有符号整数的取值范围
Java SE学习(一)
qq_44630167的博客
03-02 337
Java SE 学习（一）引言知识框架学习开始~CMD中的命令行快捷键java简介配置环境变量：编译——运行Java：Hello World注释良好的编程风格 引言 考研失败，换一条路线走一走也许能走通吧。 立一个这个月学完Java SE和 My SQL的flag，希望要坚持下去啊。 3月31前学会javaSE哟 知识框架 学习开始~ CMD中的命令行快捷键 dir：列出当前目录下的文件及文件夹 md：创建目录 rd：删除目录 cd：进入指定目录 cd…：退回到上一级目录 cd\：退回到根目录 d
001Java常用的DOS命令
传说中国的博客
03-28 100
常用的DOS命令： dir : 列出当前目录下的文件以及文件夹 md : 创建目录 rd : 删除目录 cd : 进入指定目录 cd… : 退回到上一级目录 cd: 退回到根目录 del : 删除文件 exit : 退出 dos 命令行 echo javase>1.doc ： 创建并且将javase写入文件 环境变量临时配置方式：通过dos命令中set命令完成 set：用于查看本机的所有环境变量的信息。 set 变量名：查看具体一个环境变量的值。 set 变量名=：清空一个环境变量的值。 set 变
Java语言概述
微风洋洋的博客
01-19 6400
亲爱的观众老爷们：        大家好！ 我是微风洋洋 今天这篇文章就是来和大家聊聊Java语言的概述，也就是入门篇，接下来会陆续发布后面深入的内容，请大家持续关注。感恩！ 文章目录一、Java知识图谱二、软件开发基础知识软件开发常用的DOS命令三、计算机编程语言介绍四、Java语言概述Java简史Java技术体系平台Java语言的应用方向五、Java语言的特点六、Java的环境搭建七、常用的Java开发工具 一、Java知识图谱
JavaSE| 数据类型| 运算符| 进制与补码反码等
weixin_30824479的博客
11-12 254
JavaSE JavaSE是学习JavaWeb、JavaEE以及Android开发的基础 边听边思考边做“笔记” 　　不要完全依赖书和视频； 　　捷径：敲、狂敲； 　　规范：加注释； 难点，不懂的记录下时间再回头看； 在敲代码中学习知识点，加深知识的理解。 1.基础常识 软件开发： 软件，即一系列按照特定顺序组织的计算机数据和指令的集合。分为系统软件...
计算机组成原理
热门推荐
qq_24925393的博客
08-06 2万+
计算机系统有硬件和软件两部分组成，软件又可分为系统软件和应用软件 硬件：看得见摸得着的电子元器件，如主机，外部设备 软件：人们事先编制的具有特殊功能的程序 程序通常存放在计算机主存储器或者辅存里 直接执行机器语言的程序：实际机器M（机器语言机器） 符号式的程序设计语言：汇编语言（汇编语言机器称为虚拟机器，实际不存在，使人们感受到存在的具有翻译功能的机器，先将汇编语言翻译成机器语言，
ARM处理器指令系统二 指令格式 存储器访问指令
LemonMi的专栏
07-18 1845
;文件名：TEST1.S ;功能：实现两个寄存器相加 ;说明：使用ARMulate软件仿真调试 AREA RESET,CODE,READONLY ;声明代码段RESET ENTRY ;标识程序入口 CODE32 ;声明32位ARM指令 START MOV R0,#0 ;设置参数 MOV R1,#10 LOOP BL ADD_SUB ;调用子程序ADD
Java学前基础知识
linjingtu的博客
08-04 733
软件开发： 软件，即一系列按照特定顺序组织的计算机数据和指令的集合。有系统软件和应用软件之分。 人机交互方式： 1. 图形化界面这种方式简单直观，使用者易于接受，容易上手操作 2. 命令行方式，需要有一个控制台，输入特定的指令，让计算机完成一些操作。较为麻烦，需要记录一些命令。 常用的DOS命令 dir：列出当前目录下的文件以及文件夹 md：创建目录 rd:删除目录 cd：进入
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Hvitur

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值