本章介绍Java语言的环境搭建和编程基础，通过流程控制语句和数组锻炼逻辑思维
以下博客是根据黑马视频写的Javase全集博客笔记：黑马程序员全套Java教程_Java基础入门视频教程，零基础小白自学Java必备教程
（一）Java语言基础
（二）Java面向对象编程
（三）Java核心类库之（常用API、字符串类、集合类、泛型）
（四） Java核心类库之（异常机制）
（五）Java核心类库之（字符集/编码集、File类、递归、IO流：字节流、字符流、特殊操作流）
（六）Java核心类库之（类加载器、反射机制、模块化）
（七）Java核心类库之（Lambda表达式）
（八）Java核心类库之（接口组成更新、方法引用、函数式接口）
（九）Java核心类库之（Stream流：生成、中间、终结、收集操作）
（十）Java核心类库之（多线程：实现多线程、线程同步）
（十一）Java核心类库之（网络编程：网络编程入门、UDP通信程序、TCP通信程序）
1 Java环境搭建
1.1 JDK下载
或浏览器搜索java8download
1.2 JDK安装
傻瓜式点击下一步就行
改路径安装更改JDK路径和JRE路径
注意点：安装路径不要包含中文和空格，所有开发工具最好安装路径统一
1.3 JDK的安装目录
1.4 常用DOS命令
1.5 Path环境变量配置
1.右键电脑>属性>高级系统设置>高级>环境变量
2.系统变量配置：点击新建，名称为JAVA_HOME，变量值为jJava安装路径，如：F:\Java
3.编写Path变量：系统变量>path>编辑>新建>添加 %JAVA_HOME%\bin
4.验证：cmd窗口输入javac
1.6 IDEA编辑器
快速生成语句
快速生成main()方法：psvm，回车
快速生成输出语句：sout，回车
内容辅助键
Ctrl+Alt+space（内容提示，代码补全等）
快捷键
注释：
1.单行：选中代码Ctrl+/，再来一次，就是取消
2.多行：选中代码Ctrl+Shift+/，再来一次，就是取消
格式化：Ctrl+Alt+L
2 基本语法
2.1 注释
1.单行注释
格式：//注释信息
2.多行注释
格式：/*注释信息*/
3.文档注释
格式：/**注释信息*/
2.2 关键字
关键字的字母全部小写
常用的代码编辑器，针对关键字有特殊的颜色标记，非常直观。
2.3 常量
2.4 数据类型
2.4.1 数据类型
基本数据类型
整数（byte、short、int、long）
浮点数（float、double）
字符（char）
布尔（boolean）
引用数据类型
类（class）
接口（interface）
数组（[ ]）
2.4.2 内存占用和取值范围
2.5 变量
2.5.1 定义变量
数据类型+变量名=值
2.5.2 变量的注意事项
变量名不能重复
变量未赋值不能使用
long类型的变量定义时，为防止整数过大，值后面加L
float类型的变量定义时，为防止类型不兼容，值后面加F
一条语句可以定义多个变量，但需要使用逗号进行分割
数值不能超过变量取值范围
2.6 标识符
2.6.1 标识符定义规则
由字母、数字、下划线（_）和美元符（$）组成
不能以数字开口
不能是关键字
区分大小写
不能有空格
2.6.2 常用命名约定（驼峰法）
小驼峰命名法：方法、变量
标识符是一个单词时，首字母小写
范例：name
标识符由多个单词组成时，第一个单词首字母小写，其他单词首字母大写
范例：firstName
大驼峰命名法：类
标识符是一个单词时，首字母大写
范例：Student
标识符由多个单词组成时，全部首字母大写
范例：GoodStudent
2.7 类型转换
2.7.1 自动类型转换
把一个表示数据范围小的数值或变量赋值给另一个表示数据范围大的变量
范例：doubled = 10;
2.7.2 强制类型转换
把一个表示数据范围大的数值或变量赋值给另一个表示数据范围小的变量
格式：目标数据类型+变量名 = (目标数据类型)值或变量
范例：int k = (int)88.88
2.8 打印输出
System.out.print(打印内容) //打印后不换行
System.out.println(打印内容) //打印后换行
System.out.println() //没内容时起到换行效果
3 运算符
3.1 算术运算符
public static void main(String[] args) { int a = 6; int b = 4; System.out.println(a + b); //10 System.out.println(a - b); //2 System.out.println(a * b); //24 System.out.println(a / b); //1 System.out.println(a % b); //2 //除法得到商，取余得到余数 //整数相除只能得到整数，要想得到小数要有浮点数参与 System.out.println(6.0 / 4); //1.5 }
3.1.1 字符的“+”操作
字符进行“+”操作时，拿的是字符在计算机底层对应的数值进行操作
‘A’ > 65
‘a’ > 97
‘o’ > 48
算术运算符表达式中多个基本数据类型的值的时候，整个算术运算符的类型会自动提升
提升规则：
1.byte类型、short类型和char类型都会提升到int类型
2.整个表达式的类型自动提升到表达式中最高等级操作数同样类型
等级顺序：byte、short、char -> int -> long -> float -> double
范例：
public class Demo { public static void main(String[] args) { int i = 10; char c = '0'; System.out.println(i + c); //75 //char cj = i + c; //char类型会自动提升到int类型 int j = i + c; System.out.println(j); //75 //10.1是double类型高于int类型 //int k = 10 + 10.1; double k = 10 + 10.1; } }
3.1.2 字符串的“+”操作
当 “+” 操作出现字符串时，这个 “+” 是字符串连接符，而不是算术运算符
范例：
System.out.println('it'+6+66) //it666
在 “+” 操作中，如果出现字符串就是连接符，否则就是算术运算。当连续 “+” 操作时，从左到右依次执行。
范例：
System.out.println(1+99+'it') //100it
3.2 赋值运算符
注意事项：扩张的赋值运算符隐含强制类型转换。
3.3 自增自减运算符
++ 和 - - 可以放变量前面也可以放变量后面
单独使用时， ++ 和 - - 放变量前后结果都是一样的
参与操作使用时，如果放变量后面，先拿变量参与操作，后拿变量做++或- -；
参与操作使用时，如果放变量前面，先拿变量做++或- -，后拿变量参与操作。
范例：
public class Demo { public static void main(String[] args) { //单独使用 int i = 10; //i++; ++i; System.out.println(i); //11 //参与操作使用++在后面 int b = 10; int j = b++; System.out.println(b); //11 System.out.println(j); //10 //参与操作使用++在前面 int c = 10; int k = ++c; System.out.println(c); //11 System.out.println(k); //11 } }
3.4 关系运算符
关系运算符的结果都是boolean类型，要么true，要么false
3.5 逻辑运算符
符号 作用 说明
& 逻辑与 同真为真，其余为假（满足两个为真）
| 逻辑或 同假为假，其余为真（满足一个为真即可）
^ 逻辑异或 相同为false，不同为true
！ 逻辑非 取反
3.6 短路逻辑运算符
符号 作用 说明
&& 短路与 作用与&相同，但是有短路效果
|| 短路或 作用与竖线相同，但是有短路效果
范例：
public class Demo { public static void main(String[] args) { int i = 10; int j = 20; //&& :具有短路效果，符号左边为false的时候，右边就不执行 //如果符号左边为true，右边要继续执行 System.out.println((i++>100) && (j++>100)); //false & false, System.out.println("i="+i); //11 System.out.println("j="+j); //20 } }
注意事项：
1、逻辑与 &：无论左边真假，右边都要执行
2、短路与 &&：如果左边为真，右边执行；如果左边为假，右边不执行
3、逻辑或 | ： 无论左边真假，右边都要执行
4、短语或 ||：如果左边为假，右边执行；如果左边为真，右边不执行
3.7 三元运算符
格式：关系表达式 ? 表达式1 ：表达式2；
范例：a > b ? a : b;
计算规则：
首先计算关系表达式的值
如果值为true，表达式1的值就是运算结果；
如果值为false，表达式2的值就是运算结果。
范例：
public class Demo { public static void main(String[] args) { int i = 10; int j = 20; //输出两个数据中的较大值 int max = i > j ? i : j; System.out.println("max=" + max); //20 } }
3.8 Scanner使用的基本步骤
导包的三种方式：
1、手动导包：import java.util.Scanner;
2、快捷键导包：创建好Scanner对象后，鼠标放在Scanner上按Alt+Enter
3、自动导包：写Scanner单词创对象时，按tab补全导包
导包的步骤：
1.导包
import java.util.Scanner; //导包必须在定义类上面
2.创建对象
Scanner sc = new Scanner(System.in); //只有sc是变量名可以变，其他都不可以变
3.接收数据
int i = sc.nextInt(); //i是变量名可以变，其他都不能变 sc.nextInt(); //Ctrl+alt+v：补全生成左边的内容
3.9 案例：三个和尚
import java.util.Scanner; public class Demo { public static void main(String[] args) { //从键盘输出三个身高求出最高值 Scanner sc = new Scanner(System.in); //键盘输入三个数值 int height1 = sc.nextInt(); int height2 = sc.nextInt(); int height3 = sc.nextInt(); int temp = (height1>height2) ? height1:height2; int max = (temp>height3) ? temp:height3; System.out.println(max); } }
4 流程控制语句
4.1 流程控制语句分类
顺序结构
分支结构（if、switch）
循环结构（for、while、do…while）
4.2 if语句
4.2.1 if语句格式1
格式：
if(关系表达式) { 语句体; }
执行流程：
1、首先计算关系表达式的值
2、如果关系表达式的值为true就执行语句体
3、如果关系表达式的值为false就不执行语句体
4、继续执行后面的语句内容
4.2.2 if语句格式2
格式：
if(关系表达式) { 语句体1; }else { 语句体2; }
执行流程：
1、首先计算关系表达式的值
2、如果关系表达式的值为true就执行语句体1
3、如果关系表达式的值为false就执行语句体2
4、继续执行后面的语句内容
4.2.3 if语句格式3
格式：
if(关系表达式1) { 语句体1; }else if(关系表达式2){ 语句体2; } ... else { 语句体n+1; }
执行流程：
1、首先计算关系表达式1的值
2、如果值为true就执行语句体1；如果值为false就计算关系表达式2的值
3、如果值为true就执行语句体2；如果值为false就计算关系表达式3的值
…
4、如果没有任何关系表达式值为true就执行语句体n+1
范例：
import java.util.Scanner; public class Demo { public static void main(String[] args) { Scanner sc = new Scanner(System.in); System.out.println("请输入你的成绩"); int score = sc.nextInt(); if(score == 100){ System.out.println("满分"); }else if(score >= 90) { System.out.println("优秀"); }else if(score >= 80) { System.out.println("良好"); }else if(score >= 70) { System.out.println("中等"); }else if(score >= 60) { System.out.println("及格"); }else { System.out.println("不及格"); } } }
4.3 switch语句
格式：
switch(表达式) { case 值1: 语句体1; break; case 值2: 语句体2; break; ... default: 语句体n+1; break; //最后一个可以省略
格式说明
表达式：取值为byte、short、int、char，JDK5以后可以是枚举，JDK7以后可以是String
case：后面跟的是要跟表达式比较的值
break：表示中断结束的意思，用来结束switch语句
default：表示所有情况都不匹配的时候，就执行该处内容，和if语句中的else相似
执行流程：
1、首先计算表达式的值
2、以此和case后面的值进行比较，如果有对应值，就会执行相应语句，在执行过程中，遇到break就会结束
3、如果所有的case的值和表达式的值都不匹配，就会执行default里面的语句体，然后程序结束
注意事项：在switch语句中，如果case控制的语句后面不写break，将会出现穿透现象，在不判断下一个case的情况下，向下运行，直到遇到break，或者整体程序结束
案例：初夏秋冬（case穿透）
import java.util.Scanner; public class Demo { public static void main(String[] args) { Scanner sc = new Scanner(System.in); System.out.println("请输入一个月份"); int month = sc.nextInt(); switch(month) { //case穿透 case 1: case 2: case 12: System.out.println("冬季"); break; case 3: case 4: case 5: System.out.println("春季"); break; case 6: case 7: case 8: System.out.println("夏季"); break; case 9: case 10: case 11: System.out.println("秋季"); break; default: System.out.println("你输入的月份有误"); } } }
4.4 for循环语句
格式：
for(初始化语句;条件判断语句;条件控制语句){ 循环体语句; }
流程图
执行流程
1、执行初始化语句
2、执行条件判断语句，且看结果是true还是false
如果是false，循环结束；如果是true，继续执行
3、执行循环体语句
4、执行条件控制语句
5、返回到2继续
4.4.1 案例1: 输出数据
public class Demo { public static void main(String[] args) { // 输出1-5 for(int i=1;i<=5;i++) { System.out.print(i+" "); //1 2 3 4 5 } // 输出5-1 for(int i=5;i>0;i--) { System.out.print(i + " "); //5 4 3 2 1 } } }
4.4.2 案例2: 求1-5数据和
public class Demo { public static void main(String[] args) { int sum = 0; for(int i=1;i<=5;i++) { sum += i; } System.out.println(sum); //15 } }
4.4.3 案例3: 求1-100偶数数据和
public class Demo { public static void main(String[] args) { int sum = 0; for(int i=1;i<=100;i++) { //判断i是否为偶数 if(i%2==0){ sum += i; } } System.out.println(sum); } }
4.4.4 案例4: 打印1-100的数每行10个
public class Demo { public static void main(String[] args) { //打印1-100，每行10个 int a = 0; for(int i=0;i<100;i++){ a++; System.out.print(i+" "); if(a % 10 == 0){ //10代表每行10个，可以换为所需个数 System.out.println(); //10个后换行 } } } }
4.4.5 案例5: 水仙花数
什么是水仙花数？
1、水仙花数是一个三位数
111 333 456 999 530
2、水仙花数的个位、十位、百位的数字立方和等于原数
怎么获取个位、十位、百位上的数
1、个位数
371 ；1就是原始数字对10进行取余的运算结果；371 % 10 = 1
2、十位数
371；371通过除以10，可以将7移动到个位上去（整数）；371 / 10 = 37
37 ；37对10进行取余可以得到最后一位的值7 ； 37 % 10 = 7
3、百位数
371 ； 3就是原始数字除以100的结果（整除）；371 /100 = 3
4、思考：任意数字的指定位置上的数值如何求？
123456789 ； 先10000得到12345；再对10取余得到5
public class Demo { public static void main(String[] args) { for(int i=100;i<=999;i++) { int a = i % 10; //个位 int b = i / 10 % 10; //十位 int c = i / 100 ; //百位 if(a*a*a + b*b*b + c*c*c == i) { System.out.println("水仙花数："+i); //有153、370、371、407 } } } }
4.4.6 案例6: 统计水仙花个数
public class Demo { public static void main(String[] args) { int count = 0; //存放判断水仙花的次数 for(int i=100;i<=999;i++) { int a = i % 10; //个位 int b = i / 10 % 10; //十位 int c = i / 100 ; //百位 if(a*a*a + b*b*b + c*c*c == i) { count++; } } System.out.print("水仙花共有"+count+"个"); //4个 } }
4.5 while循环语句
用法：用来描述未知次数循环
格式：
初始化语句； while(条件判断语句) { 循环体语句;//比如：输出内容 条件控制语句; }
执行流程：
1、执行初始化语句；
2、执行条件判断语句，看其结果为true还是false
如果是false，循环结束；如果是true，继续执行
3、执行循环体语句
4、执行条件控制语句
5、回到2继续
案例：珠穆朗玛峰
public class Demo { public static void main(String[] args) { //需求：世界最高山峰是珠穆朗玛峰(8844.43米=8844430毫米) //假如我有一张足够大的纸，它的厚度是0.1毫米。 //请问，我折叠多少次，可以折成珠穆朗玛峰的高度? //1.定义计数器变量，用于统计折叠的次数 int count = 0; //2.定义纸张厚度变量 double paper = 0.1; //3.定义珠峰高度变量 int zf = 8844430; //不知道循环次数，更适合使用while while(paper<=zf) { //循环过程中每次纸张堆叠，厚度加倍 paper *= 2; //在循环中累加次数 count++; } //循环结束后打印 System.out.println(count); //27 } }
4.6 do…while循环语句
格式：
初始化语句； do{ 循环体语句;//比如：输出内容 条件控制语句; }while(条件判断语句);
执行流程：
1、执行初始化语句
2、执行循环体语句
3、执行条件控制语句
4、执行条件判断语句，看其结果为true还是false
如果是false，循环结束；如果是true，继续执行
5、回到2继续
4.7 三个循环的区别
4.7.1 第一
do…while：先输出一次再进行判断（最少输出一次）
for、while：先判断再输出
4.7.2第二
for循环结束后变量不能使用
while循环结束后还可以使用（打印变量次数）
4.7.3死循环
for语句
for(;;){ System.out.println("死循环"); }
while语句
while(true){ System.out.println("死循环了"); }
do…while语句
do{ System.out.println("死循环"); }while(true);
4.8 跳转控制语句
continue：用于循环中，基于条件控制，跳过某次循环体内容的执行，继续下一次执行
break：用于循环中，基于条件控制，终止循环体内容执行，结束当前整个循环
范例：
public class Demo { public static void main(String[] args) { for(int i=1;i<=5;i++) { if(i%2==0) { //continue; //为偶数时跳过输出，1 3 5 break; //当遇到偶数终止循环，只输出1 } System.out.println(i); } } }
4.9 循环嵌套
public class Demo { public static void main(String[] args) { //九九乘法表 for(int i=1;i<=9;i++) { for(int j=1;j<=i;j++) { //j<=i,当i=1时，j=1，输入一次后循环结束；i的值加1，i=2，j=1，输出两次后跳出... System.out.print(i +"*"+j + "=" + i*j +" "); } System.out.println(); } } }
4.10 Random使用步骤
作用：用于产生一个随机数
步骤：
1.导包：
import java.util.Random
2.创建对象：
Random r = new Random(); //r是变量名可变
3.获取随机数：
int number = r.nextInt(10); //获取数据的范围是：[0,10),包括0，不包括10 //number是变量名可变，数字10可变
案例：猜数字游戏
import java.util.Scanner; import java.util.Random; public class Demo { public static void main(String[] args) { //1.生成随机数1-100 Random r = new Random(); int number = r.nextInt(100)+1; // //4.不确定次数用while，死循环 while(true) { //2.键盘输出数字 Scanner b = new Scanner(System.in); System.out.println("请输入要猜的数字:"); int guessnumber = b.nextInt(); //3.比较 if(guessnumber>number) { System.out.println("你猜的数字"+guessnumber+"大了"); }else if(guessnumber<number) { System.out.println("你猜的数字"+guessnumber+"小了"); }else { System.out.println("猜对了"); break; } } } }
5 数组
数组（array [əˈreɪ] ）是一种用来存储多个相同类型数据的存储模型
5.1 数组定义格式
格式1（常用）
//数据类型[] 变量名； int[] arr; //定义了一个int类型的数组，数组名是arr
格式2
//数据类型 变量名[]; int arr[]; //定义了一个int类型的变量，变量名是arr数组
5.2 数组初始化
5.2.1 动态初始化
初始化时只指定初始化长度，由系统为数组分配默认初始化值
默认值：
int：默认值0
float：默认值0.0
boolean：默认值false
char：默认值是空字符
引用数据类型：默认值null
格式：
数据类型[] 变量名 = new 数据类型[数组长度];
范例：
//new：为数组申请内存空间 3：数组长度/数组中元素个数 int[] arr = new int[3]; System.out.print(arr[0]) //0 系统分配的默认初始化值
5.2.2 静态初始化
初始化指定数组元素，系统会根据元素个数，计算出数组的长度
格式：
数据类型[] 变量名 = new 数据类型[]{数据1，数据2，数据3,.....} 数据类型[] 变量名 = {数据1，数据2，数据3，....} //简化格式
范例：
int[] arr = new int[]{1,2,3}; System.out.println(arr[0]); int[] arr1 = {1,2,3}; System.out.println(arr1[0]); //1
5.3 数组元素访问
数组变量访问方式
格式：变量名
数组内部保存数据访问方式
格式：数组名[索引] //0、1、2、3…
int[] arr1 = {1,2,3}; System.out.println(arr1); //[I@1b6d3586:内存空间地址值 System.out.println(arr1[0]); //1 System.out.println(arr1[1]); //2 System.out.println(arr1[2]); //3
5.4 内存分配
栈内存：存储局部变量（定义在方法中的变量，如：arr，使用完毕立刻消失）
堆内存：存储new出来的内容（实体、对象）（垃圾回收器空闲时回收）
5.5 遍历数组
获取数组元素个数，格式：数组名.length
public class Demo { public static void main(String[] args) { int[] arr = {1,2,3,4,5}; for(int i=0;i<arr.length;i++) { System.out.println(arr[i]); // 1 2 3 4 5 } } }
5.6 获取数组最值
执行流程：
1、假设数组中的第一个元素为最大值
2、遍历数组，获取每一个元素，准备进行比较
3、如果比较的过程，出现了比max更大的，让max记录更大的值
4、循环结束后，打印最大值
public class Demo { public static void main(String[] args) { int[] arr = {2,6,7,8,1,3,5,4,9}; int max = arr[0]; for(int i=1;i<arr.length;i++) { if(arr[i] > max) { max = arr[i]; } } System.out.println(max); //循环结束后打印 } }
6 二维数组
6.1 二维数组格式
格式一 ：数据类型[ ][ ] 变量名;
int[][] arr;
格式二 ：数据类型 变量名[][];
int arr[][];
格式三 ：数据类型[] 变量名[];
int[] arr[];
6.2 动态初始化
格式：数据类型[ ][ ] 变量名 = new 数据类型[m][n];
m：行
n：列（每行可以存放多少数据）
范例：
public class Demo { public static void main(String[] args) { int[][] arr = new int[2][3]; for(int[] row : arr) { for(int data : row) { System.out.printf("%d\t",data); // 0 0 0 } // 0 0 0 System.out.println(); } } }
6.3 访问元素
public class Demo{ public static void main(String[] args){ /* 问题:二维数组中存储的是一维数组，那能不能存入[提前创建好的一维数组]呢？ */ int[] arr1 = {11,22,33}; int[] arr2 = {44,55,66}; int[] arr3 = {77,88,99,100}; int[][] arr = new int[3][3]; arr[0] = arr1; arr[1] = arr2; arr[2] = arr3; //输出二维数组 for(int[] row : arr) { for(int data : row) { System.out.printf("%d\t",data); //11 22 33 } //44 55 66 System.out.println(); //77 88 99 100 } System.out.println(arr[1][2]); //66 System.out.println(arr[2][3]); //100 } }
6.4 静态初始化
格式1：格式: 数据类型[ ][ ] 变量名 = new 数据类型[ ][ ] {{元素1，元素2…},{元素1,元素2…}};
int[][] arr = new int[][]{{11,22},{33,44}};
格式2（简化格式）：数据类型[][] 变量名 ={{元素1,元素2},{元素1,元素2…}};
int[][] arr = {{11,22},{33,44}};
6.5 遍历二维数组
public class Demo{ /* 需求:已知一个二维数组 arr = {{11,22,33},{44,55,66}} 遍历该数组，取出所有元素并打印 */ public static void main(String[] args){ int[][] arr = {{11,22,33},{44,55,66}}; // 遍历二维数组，取出里面每一个一维数组 for(int i = 0;i < arr.length;i++){ // 遍历一维数组,arr[i]就是每一个一维数组 for(int j = 0;j < arr[i].length;j++){ System.out.print(arr[i][j]+" "); //11 22 33 44 55 66 } } } }
前七章知识点案例总结
1.缝七过
public class Demo { public static void main(String[] args) { //个位是7，十位是7,7的倍数过 //i%10==7 i/10%10==7 i%7==0 for (int i = 1; i <= 100; i++) { if (i % 10 == 7 || i / 10 % 10 == 7 || i % 7 == 0) { System.out.print(i + " "); } } } }
2.不死神兔
public class Demo { public static void main(String[] args) { //1 int[] arr = new int[20]; //2 arr[0] = 1; arr[1] = 1; //3 for(int x=2;x< arr.length;x++) { arr[x] = arr[x-2] + arr[x-1]; //arr[2] = arr[0] +arr[1]; } System.out.println("第二十个月兔子个数为"+arr[19]); //6765 } }
3.百钱百鸡
public class Demo { public static void main(String[] args) { //1.第1层循环，用来表示鸡公范围，x=0,x<=20 for(int x=0;x<=20;x++){ //2.第2层循环，表示母鸡范围 for(int y=0;y<=33;y++){ //3.小鸡数量 int z = 100 -x -y; //4.三种鸡的总钱是否等于100 if(z%3==0 && 5*x+3*y+z/3==100){ System.out.println("公鸡个数："+x+","+"母鸡个数"+y+","+"小鸡个数"+z); // 公鸡个数：0,母鸡个数25,小鸡个数75 // 公鸡个数：4,母鸡个数18,小鸡个数78 // 公鸡个数：8,母鸡个数11,小鸡个数81 // 公鸡个数：12,母鸡个数4,小鸡个数84 } } } } }
4.数组元素求和
public class Demo { public static void main(String[] args) { int[] arr = {68,27,95,88,171,996,51,210}; int sum = 0; for(int i=0;i< arr.length;i++) { if(arr[i]%10!=7 && arr[i]/10%10!=7 && arr[i]%2==0){ sum += arr[i]; } } System.out.println(sum); //1362 } }
5.数组内容相同
public class Demo { public static void main(String[] args) { int[] arr = {11, 22, 33, 44, 55, 66}; //int[] arr2 = {11, 22, 33, 44, 55, 66}; //返回true int[] arr2 = {22, 11, 33, 44, 55, 66}; //返回false boolean a = compare(arr, arr2); System.out.println(a); } public static boolean compare(int[] arr, int[] arr2) { //比较长度 if (arr.length != arr2.length) { return false; } //比较元素内容 for (int i = 0; i < arr.length; i++) { if (arr[i] != arr2[i]) { return false; } } //都相同时 return true; } }
6.查找
import java.util.Scanner; public class Demo { public static void main(String[] args) { int[] arr = {19,28,35,42,56}; Scanner sc = new Scanner(System.in); System.out.println("请输入一个数"); int number = sc.nextInt(); int index = getIndex(arr,number); System.out.println("索引下标为："+index); } public static int getIndex(int[] arr,int number) { //索引变量 int index = -1; //遍历数组 for(int i=0;i< arr.length;i++){ if(number==arr[i]){ index = i; break; } } return index; } }
7.反转
public class Demo { public static void main(String[] args) { int[] arr = {11,22,33,44,55}; //初始化两个索引变量用逗号隔开 for(int start=0,end=arr.length-1;start<=end;start++,end--){ //反转 int temp = arr[start]; arr[start] = arr[end]; arr[end] = temp; } for(int i=0;i< arr.length;i++) { System.out.print(arr[i]+" "); //55 44 33 22 11 } } }
8.评委打分
import java.util.Scanner; public class Demo { public static void main(String[] args) { int[] arr = new int[6]; Scanner sc = new Scanner(System.in); //1.键盘输入六个评委的分数 for(int i=0;i< arr.length;i++) { System.out.println("请输入第"+(i+1)+"个评委打分："); arr[i] = sc.nextInt(); } //printArray(arr); //2.调用getMax int max = getMax(arr); //3.调用getMin int min = getMin(arr); //4.调用getSum int sum =getSum(arr); //5.计算平均分 int avg = (sum-max-min)/arr.length-2; System.out.println("选手最终得分是："+avg); } //获取所有元素和 public static int getSum(int[] arr) { int sum = 0; for(int i=0;i< arr.length;i++) { sum += arr[i]; } return sum; } //获取最小值 public static int getMin(int[] arr) { int min = arr[0]; for(int i=1;i< arr.length;i++) { if(arr[i] < min) { min = arr[i]; } } return min; } //获取最大值 public static int getMax(int[] arr) { int max = arr[0]; for(int i=1;i< arr.length;i++) { if(arr[i] > max) { max = arr[i]; } } return max; } //遍历数组 public static void printArray(int[] arr) { System.out.print("["); for(int i=0;i< arr.length;i++) { if(i==arr.length) { System.out.print(arr[i]); }else { System.out.print(arr[i]+","); } } System.out.print("]"); } }
8 import导包
格式：`import 包名;
范例：`Demo类中导入Student类的方法
Student类
package Student; public class Student { public void study(){ System.out.println("学习"); } }
Demo类
package test; import Student.Student; public class Demo { public static void main(String[] args) { Student s = new Student(); s.study(); //学习 } }
