vmware16虚拟机使用教程，java基础

}

执行过程：

<1>判断 while 后面的条件是否成立( true / false )

<2>当条件成立时，执行循环内的操作代码 ，然后重复执行< 1 >、< 2 >， 直到循环条件不成立为止

特点：先判断，后执行

do…while 循环

do{

循环操作

}while(判断条件);

执行过程：

<1>、 先执行一遍循环操作，然后判断循环条件是否成立

<2>、 如果条件成立，继续执行< 1 > 、< 2 >，直到循环条件不成立为止

特点： 先执行，后判断

由此可见，do…while 语句保证循环至少被执行一次！

for 循环。

for(循环变量初始化;循环条件;循环变量变化){

循环操作

}

执行过程：

<1>、 执行循环变量初始化部分，设置循环的初始状态，此部分在整个循环中只执行一次

<2>、 进行循环条件的判断，如果条件为 true ，则执行循环体内代码；如果为 false ，则直接退出循环

<3>、 执行循环变量变化部分，改变循环变量的值，以便进行下一次条件判断

<4>、 依次重新执行< 2 >、< 3 >、< 4 >，直到退出循环

特点：相比 while 和 do…while 语句结构更加简洁易读

附代码：

int sum = 0; // 保存不能被3整除的数之和

// 循环变量 i 初始值为 1 ,每执行一次对变量加 1，只要小于等于 100 就重复执行循环

for (int i = 1;      i<=100        ;      i++   ) {

// 变量 i 与 3 进行求模（取余），如果不等于 0 ，则表示不能被 3 整除

if (i % 3 != 0) {

sum = sum + i; // 累加求和

}

}

System.out.println(“1到100之间不能被3整除的数之和为：” + sum);

}

break和continue的区别：break是直接跳出循环，continue是跳过此次循环，循环仍进行。

附代码：

// 保存累加值

int sum = 0;

// 从1循环到10

for (int i = 1; i <= 10; i++) {

// 每次循环时累加求和

sum = sum + i;

// 判断累加值是否大于20，如果满足条件则退出循环

if ( sum>20 ) {

System.out.print(“当前的累加值为:” + sum);

break;//退出循环

}

}

int sum = 0; // 保存累加值

for (int i = 1; i <= 10; i++) {

// 如果i为奇数,结束本次循环，进行下一次循环

if (i%2!=0 ) {

continue;

}

sum = sum + i;

}

System.out.print(“1到10之间的所有偶数的和为：” + sum);

// 外层循环控制行数

for (int i = 1; i<=4;i++             ) {

// 内层循环控制每行的*号数

// 内层循环变量的最大值和外层循环变量的值相等

for (int j = 1; j<=i;j++         ) {

System.out.print(“*”);

}

判断一个数（小于10位）的位数。

输入999，则输出 “它是个3位的数！”

if (num >= 0  && num<=999999999){

while(num != 0){

count++;

num/=10;

}

System.out.println(“它是个”+ count+“位的数！”);

} else{

System.out.println(“输入有误！”);

}

// 变量保存成绩

int score = 53;

// 变量保存加分次数

int count = 0;

//打印输出加分前成绩

System.out.println(“加分前成绩：”+score);

// 只要成绩小于60，就循环执行加分操作，并统计加分次数

for(;score<60;score++,count++){

// count++;

if(score>=60){

break;

}

}

//打印输出加分后成绩，以及加分次数

System.out.println(“加分后成绩”+score);

System.out.println(“共加了”+count+“次！”);

记住：eslip软件 用快捷键方式可以省略一些长输入，

如：用 输入：syso+ alt键再加/   就可以实现System.out.println();  的输入

public static void main (String[] args) 的快捷键是main+alt+/

关于 Java 数组的 12 个最佳方法

1.  声明一个数组

String[] aArray = new String[5];

String[] bArray = {“a”,“b”,“c”, “d”, “e”};

String[] cArray = new String[]{“a”,“b”,“c”,“d”,“e”};

2.  输出一个数组

int[] intArray = { 1, 2, 3, 4, 5 };

String intArrayString = Arrays.toString(intArray);

// print directly will print reference value

System.out.println(intArray);

// [I@7150bd4d

System.out.println(intArrayString);

// [1, 2, 3, 4, 5]

3.  从一个数组创建数组列表

String[] stringArray = { “a”, “b”, “c”, “d”, “e” };

ArrayList arrayList = new ArrayList(Arrays.asList(stringArray));

System.out.println(arrayList);

// [a, b, c, d, e]

4.  检查一个数组是否包含某个值

String[] stringArray = { “a”, “b”, “c”, “d”, “e” };

boolean b = Arrays.asList(stringArray).contains(“a”);

System.out.println(b);

// true

5.  连接两个数组

int[] intArray = { 1, 2, 3, 4, 5 };

int[] intArray2 = { 6, 7, 8, 9, 10 };

// Apache Commons Lang library

int[] combinedIntArray = ArrayUtils.addAll(intArray, intArray2);

6.  声明一个内联数组（Array inline）

method(new String[]{“a”, “b”, “c”, “d”, “e”});

7.  把提供的数组元素放入一个字符串

// containing the provided list of elements

// Apache common lang

String j = StringUtils.join(new String[] { “a”, “b”, “c” }, ", ");

System.out.println(j);

// a, b, c

8.  将一个数组列表转换为数组

String[] stringArray = { “a”, “b”, “c”, “d”, “e” };

ArrayList arrayList = new ArrayList(Arrays.asList(stringArray));

String[] stringArr = new String[arrayList.size()];

arrayList.toArray(stringArr);

for (String s : stringArr)

System.out.println(s);

9.  将一个数组转换为集（set）

Set set = new HashSet(Arrays.asList(stringArray));

System.out.println(set);

//[d, e, b, c, a]

10.  逆向一个数组

int[] intArray = { 1, 2, 3, 4, 5 };

ArrayUtils.reverse(intArray);

System.out.println(Arrays.toString(intArray));

//[5, 4, 3, 2, 1]

11.  移除数组中的元素

int[] intArray = { 1, 2, 3, 4, 5 };

int[] removed = ArrayUtils.removeElement(intArray, 3);//create a new array

System.out.println(Arrays.toString(removed));

12.  将整数转换为字节数组

byte[] bytes = ByteBuffer.allocate(4).putInt(8).array();

for (byte t : bytes) {

System.out.format("0x%x ", t);

}

在详细说下上述内容：

1、声明数组

语法：数据类型[] 数组名；或者：数据类型 数组名[]；

例：int（数据类型）[] scores（数组名）;int（数据类型） scores（数组名）[]

声明数组的方法和生命变量的方法很像只是在数据类型或者数据名的后面加上了[]

2、分配空间

语法：数组名 = new  数据类型 [数组长度];

例：scores = new int [5];

简单地说，就是指定数组中最多可存储多少个元素.

3、赋值

分配空间后就可以向数组中放数据了，数组中元素都是通过下标来访问的

scores[0] = 89;

4、处理数组中数据

int[] scores = {1,2,3,4};（创建一个长度为4的整形数组）等价于int[] scores=new int[]{1,2,3,4}

数组名.length  用于获取数组的长度

// 定义一个整型数组，并赋初值

int[] nums = new int[] { 61, 23, 4, 74, 13, 148, 20 };

int max = nums[0]; // 假定最大值为数组中的第一个元素

int min = nums[0]; // 假定最小值为数组中的第一个元素

double sum = 0;// 累加值

double avg = 0;// 平均值

for (int i = 0; i < nums.length; i++) { // 循环遍历数组中的元素

// 如果当前值大于max，则替换max的值

if(nums[i]>max)

{

max=nums[i];

}

// 如果当前值小于min，则替换min的值

if(nums[i]<min)

{

min=nums[i];

}

// 累加求和

sum=sum+nums[i];

}

avg=sum/nums.length;

// 求平均值

System.out.println(“数组中的最大值：” + max);

System.out.println(“数组中的最小值：” + min);

System.out.println(“数组中的平均值：” + avg);

}

语法：  Arrays.sort(数组名);

可以使用 sort( ) 方法实现对数组的排序，只要将数组名放在 sort( ) 方法的括号中，就可以完成对该数组的排序（按升序排列）

语法：  Arrays.toString(数组名);

可以使用 toString( ) 方法将一个数组转换成字符串，该方法按顺序把多个数组元素连接在一起，多个元素之间使用逗号和空格隔开

例如结果例子：输出数组nums中的元素：[25，7，126，53，14，86] [game, movie, sports]

使用 foreach 操作数组  foreach 并不是 Java 中的关键字，是 for 语句的特殊简化版本，在遍历数组、集合时， foreach 更简单便捷。

for(元素类型 元素变量（自定义的名称）：遍历对象){

执行的代码

}

使用 foreach 操作数组的效果和for的效果时一样的但是代码简洁

二维数组：

（1）声明数组并分配空间：数据类型[][]=new 数据类型[行的个数][列的个数];

数组类型[][] 数组名;

数组名=new 数据类型[行的个数][列的个数];

（2）赋值:数组名[行的索引][列的索引]=值;

也可以声明数组的同时为其赋值：数据类型[][] 数组名={{123},{456}};

（3）处理数组：

需要了解的：在定义二维数组时也可以只指定行的个数，然后再为每一行分别指定列的个数。如果每行的列数不同，则创建的是不规则的二维数组

附代码：

// 定义两行三列的二维数组并赋值

String[][] names={{“tom”,“jack”,“mike”},{“zhangsan”,“lisi”,“wangwu”}};

// 通过二重循环输出二维数组中元素的值

//names.length行数

for (int i = 0; i < names.length  ; i++) {

//names[i].length列数

for (int j = 0; j < names[i].length; j++) {

System.out.println(   names[i][j]);

}

System.out.println();

}

定义一个方法

所谓方法，就是用来解决一类问题的代码的有序组合，是一个功能模块。

语法：访问修饰符 返回值类型 方法名（参数列表）{

方法体

}

其中：

1、访问修饰符：方法允许被访问的权限范围， 可以是 public、protected、private 甚至可以省略 ，其中 public 表示该方法可以被其他任何代码调用

2、返回值类型：方法返回值的类型，如果方法不返回任何值，则返回值类型指定为 void ；如果方法具有返回值，则需要指定返回值的类型，

并且在方法体中使用 return 语句返回值

3、方法名：定义的方法的名字，必须使用合法的标识符

4、参数列表：传递给方法的参数列表，参数可以有多个，多个参数间以逗号隔开，每个参数由参数类型和参数名组成，以空格隔开

根据方法是否带参、是否带返回值，可将方法分为四类：

无参无返回值方法 无参带返回值方法 带参无返回值方法 带参带返回值方法

java中无参无返回值方法的使用

如果方法不包含参数，且没有返回值称为无参无返回值的方法。

方法的使用：

第一定义方法

1、 方法体放在一对大括号中，实现特定的操作

2、 方法名主要在调用这个方法时使用，需要注意命名的规范，一般采用第一个单词首字母小写，其它单词首字母大写的形式

第二调用方法

当需要调用方法执行某个操作时，可以先创建类的对象，然后通过对象名.方法名();来实现

1、 如果方法的返回类型为 void ，则方法中不能使用 return 返回值！

2、 方法的返回值最多只能有一个，不能返回多个值

3、 方法返回值的类型必须兼容，例如，如果返回值类型为 int ，则不能返回 String 型值，即：return类型必须和方法返回值类型相同；

4、由于方法执行后会返回一个结果，因此在调用带返回值方法时一般都会接收其返回值并进行处理。

import java.util.Arrays;

public class HelloWorld {

public static void main(String[] args) {

HelloWorld hello = new HelloWorld();

int ages = hello.getMaxAge();

System.out.println(“最大年龄为：” + ages);

}

public int getMaxAge() {

int[]ages={18,23,21,19,25,29,17};

Arrays.sort(ages);

return ages[ages.length-1];

}

}

public class HelloWorld {

//完成 main 方法

public static void main(String[] args) {

// 创建对象，对象名为hello

HelloWorld hello = new HelloWorld();

// 调用方法并将返回值保存在变量中

int maxAge=hello.getMaxAge();

// 输出最大年龄

System.out.println(“最大年龄为：” + maxAge);

}

/*

* 功能：输出学生年龄的最大值

* 定义一个无参的方法，返回值为年龄的最大值

* 参考步骤：

* 1、定义一个整形数组 ages ，保存学生年龄，数组元素依次为 18 ,23 ,21 ,19 ,25 ,29 ,17

* 2、定义一个整形变量 max ,保存学生最大年龄，初始时假定数组中的第一个元素为最大值

* 3、使用 for 循环遍历数组中的元素，并与假定的最大值比较，如果比假定的最大值要大，则替换当前的最大值

* 4、使用 return 返回最大值

*/

public int getMaxAge() {

int[] ages={18,23,21,19,25,29,17};

int max=ages[0];

for(int i=0;i<ages.length;i++){

if(max<ages[i]){

max=ages[i];

}

}

return max;

}

}

1.在方法中加入参数列表接收外部传入的数据信息.

2.我们把定义方法时的参数称为形参，目的是用来定义方法需要传入的参数的个数和类型；把调用方法时的参数称为实参，是传递给方法真正被处理的值。

3.调用带参方法时，必须保证实参的数量、类型、顺序与形参一一对应

4.调用方法时，实参不需要指定数据类型，

5. 方法的参数可以是基本数据类型，如 int、double 等，也可以是引用数据类型，如 String、数组等

6.当方法参数有多个时，多个参数间以逗号分隔

public class HelloWorld {

public static void main(String[] args) {

// 创建对象，对象名为hello

HelloWorld hello = new HelloWorld();

// 调用方法，传入两门课程的成绩

hello.calcAvg(94, 81);//调用的方法名和定义的方法的名称要一致

}

/*

* 功能：计算两门课程考试成绩的平均分并输出平均分

* 定义一个包含两个参数的方法，用来传入两门课程的成绩

*/

public void calcAvg(int score1,int score2){  //要明确方法的类型，

double avg=(score1+score2)/2.0;如果是void，则不要返回值，如果是其他的类型，需要有返回值

System.out.println(“平均分：”+avg);

}

import java.util.Arrays;

public class HelloWorld {

public static void main(String[] args) {

HelloWorld hello = new HelloWorld();

int[] scores={79,52,98,81};

//调用方法，传入成绩数组，并获取成绩的个数

int count=hello.sort(scores);

System.out.println(“共有”+count+“个成绩信息！”);

}

/*

* 功能：将考试成绩排序并输出，返回成绩的个数

* 定义一个包含整型数组参数的方法，传入成绩数组

* 使用Arrays类对成绩数组进行排序并输出

* 方法执行后返回数组中元素的个数

*/

public int sort(int[] scores){

Arrays.sort(scores);

System.out.println(Arrays.toString(scores));

//返回数组中元素的个数

return scores.length;

}

}

判断方法重载的依据：

1、 必须是在同一个类中

2、 方法名相同

3、 方法参数的个数、顺序或类型不同

4、 与方法的修饰符或返回值没有关系

//导入java.util.Arrays;

public class HelloWorld {

public static void main(String[] args) {

// 创建对象，对象名为hello

HelloWorld hello = new HelloWorld();

// 调用方法并将返回值保存在变量中

int[] nums = hello.getArray(8);

// 将数组转换为字符串并输出

System.out.println(Arrays.toString(nums));

}

/*

* 功能：创建指定长度的int型数组，并生成100以内随机数为数组中的每个元素赋值

* 定义一个带参带返回值的方法，通过参数传入数组的长度，返回赋值后的数组

*/

public int[] getArray(int length) {

// 定义指定长度的整型数组

int[] nums = new int[length];

// 循环遍历数组赋值

for ( int i=0;i<nums.length;i++) {

// 产生一个100以内的随机数，并赋值给数组的每个成员

nums[i]=(int)(Math.random()*100);

}

return nums; // 返回赋值后的数组

}

}

定义一个包含整型数组参数的方法，用来接收成绩数组，进行成绩排序并输出前三名

import java.util.Arrays;

public class HelloWorld {

public static void main(String[] args) {

int[] scores = {89, -23, 64, 91, 119, 52, 73};

HelloWorld hello = new HelloWorld();

int[] backScore = hello.getArays(scores);

for(int i=0;i<3;i++){

System.out.println(“第”+(i+1)+“名的成绩是:”+backScore[i]);

}

}

public int[] getArays(int[] scores){

int count = 0;

int[] score = new int[3];

Arrays.sort(scores);

for(int i = scores.length-1; i>=0; i–){

if((scores[i]>100) && (scores[i]<0)){

continue;

}else{

score[count] = scores[i];

count++;

if(count == 3){

break;

}

}

}

return score;

}

}

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

最后

2020年在匆匆忙忙慌慌乱乱中就这么度过了，我们迎来了新一年，互联网的发展如此之快，技术日新月异，更新迭代成为了这个时代的代名词，坚持下来的技术体系会越来越健壮，JVM作为如今是跳槽大厂必备的技能，如果你还没掌握，更别提之后更新的新技术了。

更多JVM面试整理：

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。**

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。[外链图片转存中…(img-P1ufBjh4-1713436241865)]

[外链图片转存中…(img-yqn1OqKC-1713436241866)]

[外链图片转存中…(img-cS2E5djT-1713436241866)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

最后

2020年在匆匆忙忙慌慌乱乱中就这么度过了，我们迎来了新一年，互联网的发展如此之快，技术日新月异，更新迭代成为了这个时代的代名词，坚持下来的技术体系会越来越健壮，JVM作为如今是跳槽大厂必备的技能，如果你还没掌握，更别提之后更新的新技术了。

[外链图片转存中…(img-ac1nMAVD-1713436241866)]

更多JVM面试整理：

[外链图片转存中…(img-JfXTG2VF-1713436241866)]

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！