变量
变量是指内存中的一个存储区域，该区域要有自己的名称（变量名）、类型（数据类型）、该区域的数据在同一个数据类型的范维内不断变化值。
每个变量都有自己的作用范围，叫做作用域。
注意事项
1、Java中的变量必须声明后才能进行使用。否则编译报错。
2、变量在使用之前必须要进行初始化才能使用变量，否则编译报错。
3、不允许在同一段代码区域中声明相同名称的变量，否则编译报错。
4、每个变量都有自己独立的作用域（作用范围），变量的作用域：在一对{}中为有效区间。
5、在main（）方法中声明的变量叫做局部变量，局部变量的作用范围：从声明开始到方法体结束。
声明和使用
声明：数据类型 变量; 例如： int age;
赋值：变量名 = 值; 例如：age = 20;
声明同时赋值：数据类型 变量名 = 值; 例如：int age = 20;
使用：通过变量名访问变量的值；例如：System.out.println(age);
public class TestVar{
public static void main(String[] args){
//s声明变量
int age;
//初始化变量
age = 20;
//打印变量
System.out.println(age);
//声明并初始化变量
String name = "leesin";
//打印变量
System.out.println(name);
}
}
输出结果
20
leesin
数据类型
什么是数据类型
数据类型是为了区分不同特点的数据而数据类别。
数据类型分类：
Java分为”基本数据类型“和”引用数据类型“
基本数据类型有8种。
引用数据类型包括所有的：数组、类、接口、枚举、和标注。
枚举可以看成特殊的类，标注可以看出成特殊的接口。
基本数据类型
基本数据类型是Java事先定义好的 ，用关键字命名的数据类型。
基本数据类型分为：
整型：byte、short、int、long
浮点型：float、double
字符型：char
布尔型：boolean
整型
用于表示整数（不包含小数部分）的基本数据类型
根据分配的内存空间大小不同，又分为四种类型
| 数据类型 |
占用的空间大小 |
取值范围 |
| byte（字节型） |
8位，1个字节 |
-128（-2^7）~127（2^7-1） |
| short（短整型） |
16位，2个字节 |
-32768（-2^15）~32767（2^15 - 1） |
| int（整型） |
32位，4个字节 |
-2,147,483,648（-2^31）~2,147,483,647（2^31 - 1） |
| long（长整型） |
64位，8个字节 |
-9,223,372,036,854,775,808（-2^63）~9,223,372,036,854,775,807（2^63 -1） |
浮点型
浮点型是表示浮点数的基础类型
单精度浮点型：float（需使用F/f进行标明） 例如：float number = 1.5f
双精度浮点型：double（默认类型） 例如： double numble = 5.15
| 数据类型 |
占用的空间大小 |
取值范围 |
| float（单精度浮点型） |
32位，4个字节 |
1.4E-45~3.4028235-E38 |
| double（双精度浮点型） |
64位，8个字节 |
4.9E-324~1.7976931348623157E-308 |
字符型
以char关键字进行标识
字符型用于保存单个字符或汉字
char采用unicode编码方式（8位的ASCII码包含在其中）
字符型占两个字节（也可可以赋值0-65535的数字）
public class TestVar{
public static void main(String[] args){
//声明char类型变量，赋值字符串a
char char_word = 'a'; //字符型变量赋值需要使用单引号
//声明char类型变量，赋值97
char char_temp = 97; //字符a对应的ASCII码就是97
//输出两个变量查看值
System.out.println("char_word变量输出结果是："+char_word);
System.out.println("char_temp变量输出结果是："+char_temp);
}
}
输出结果
char_word变量输出结果是：a
char_temp变量输出结果是：a
布尔型
布尔型是用于表示逻辑状态（TRUE和FALSE）的基本数据类型
布尔型特点：
用boolean关键字标识
只有明确的两种值，true或者false
public class TestVar{
public static void main(String[] args){
//创建boolean类型变量b_first 并赋值true；
boolean b_first = true;
//创建boolean类型变量b_second 并赋值false；
boolean b_second = false;
//输出两个变量查看值
System.out.println(b_first);
System.out.println(b_second);
}
}
输出结果
true
false
数据类型转换
整型、实型（常量）、字符串类型可以混合运算。运算中，不同类型的数据先转化位同一类型，然后进行运算。
转换从低级到高级
byte、short、char->int->long->float->double
转换规则
1、不能对boolean类型进行类型转换
2、不能把对象类型转换成不相关类的对象
3、在把容量大的类型转换位容量小的类型时必须使用强制类型转换
4、转换过程中可能导致溢出或损失精度。例如：
int i= 128;
byte b = (byte)i;
因为byte类型时8位，最大值位127，所以当int强制转换位byte类型时，值128就会导致溢出。
5、浮点数到整数的转换时通过舍弃小数的到的，而不是四舍五入。例如：
(int)23.7 == 23;
(int)-45.89f == -45;
自动类型转换
必须满足转换前的数据类型的位数要低于转换后的数据类型，例如：short数据类型的位数位16位，就可以自动转换位数为32位的int类型，同样float的数据类型位数为32，可以自动转换为64为的double类型。
案例
public class Test{
public static void main(String[] args){
char c1 = 'a';//定义一个char类型
int i1 = c1;//char自动类型转换为int
System.out.println("char自动类型转换int后值为：" + i1);
char c2 = 'A';//定义一个char类型
int i2 = c2+1;//char类型和interesting类型计算
System.out.println("char类型和int计算后的值等于：" + i2);
}
}
运行结果为
char自动类型转换int后值为：97
char类型和int计算后的值等于：66
解析：c1的值为字符a，ASCII码表中对应的int类型值为97，A对应的值为65，所以i2 = 65+1 =66
强制类型转换
1、转换的数据类型必须是兼容的
2、格式：(type)value type是强制类型转换后的数据类型
案例
public class Test{
public static void main(String[] args){
int i1 = 123;
byte b = (byte)i1;//强制类型转换为byte
System.out.println("int强制转换类型为byte后的值等于：" + b);
}
}
运行结果为
int强制转换类型为byte后的值等于：123
隐含强制类型转换
整数的默认类型为int类型，当把一个整数赋值为byte类型时，其实默认有一个强制类型转换，编译器会判断这个整数是否在byte类型的范围之内，true则会被赋值，就是隐含强制类型转换，false则报不兼容错误。
规则
1、整数的默认类型是int
2、浮点型不存在这种情况，因为在定义float类型是必须在数字后面跟上F或者f
案例
public class Test{
public static void main(String[] args){
byte b = 3; //定义b的数据类型，并赋值
b = 6+10;
System.out.println(b);
}
}
输出结果
隐含强制类型转换后：16
编译报错案例
public class Test{
public static void main(String[] args){
byte b = 3; //定义b的数据类型，并赋值
byte b1 = 4;
byte b2 = 5;
b = b1+b2;
System.out.println(b);
}
}
输出结果
Test.java:6: 错误: 不兼容的类型: 从int转换到byte可能会有损失
b = b1+b2;
解析
第一段代码被赋值的是常量，编译器先计算表达式的结果，判断结果在byte范围之内于是就把int类型强制转换为byte赋值给b；
第二段代码被赋值的是变量，变量的值是不确定的，编译器无法判断是否超出byte类型的取值范围，没办法进行强制转换；
运算符
运算符也称为操作符，用于数据计算和处理，或改变特定对象的值。运算符按其操作数的个数类分，可分为一元运算符、二元运算符和三元运算符/按照运算符对数据的操作结果分类可以分为以下几种。
算术运算符
+ 加 -减 *乘 /除 %取余
整数运算时，0不能作为除数，浮点运算时，0.0可以，但是结果无穷大
注意事项：
1、当两个整数进行除法运算时，结果只取整数部分，小数部分舍弃
2、当希望结果中保留小数部分，具体方法如下：
a.将其中一个操作数强转为double类型再做运算
b.将其中一个操作数乘以1.0提升为double类型再运算（推荐）
3、0不能作为除数，否则产生 算术异常：/by zero 。但是0.0可以作为除数但是结果无穷大，编程中尽量避免0和0.0作为除数
测试demo
public class TestAri {
public static void main(String[] args) {
int a = 10;
int b = 4;
//打印变量值
System.out.println(a); //10
System.out.println(b); //4
//相加
System.out.println(a+b); //14
//相减
System.out.println(a-b); //6
//相乘
System.out.println(a*b); //40
//相除
System.out.println(a/b); //2
//取余
System.out.println(a%b); //2
//整数相除，只取整数部分，小数舍弃
System.out.println(5/2); //2
//将5先转为double类型
System.out.println((double)5/2); //2.5
//将2转为double类型
System.out.println(5/(double)2); //2.5
//先运算在转为都double类型
System.out.println((double)(5/2));//2.0
//先用double
System.out.println(1.0 * 5/2); //2.5
//0不能作为除数
//System.out.println(5/0); // by zero at day04.TestAri
//0.0作为除数结果为无穷大
System.out.println(5/0.0); //Infinity
//0除以0.0结果为查无此数
System.out.println(0/0.0); //NaN Not a Number
}
}
连接运算符
“+”可以实现字符串的连接。同时可以实现字符串与其他数据类型的相连
注意事项：
1、当+两边的操作数中只要有一个字符类型，则按照字符连接符类处理，结果依然是字符
2、当+两边的操作数都不是字符串时，则按照算术运算符来处理
测试demo
public class TestAri{
public static void main(String[] args) {
//当+两边的操作数中只要有一个字符类型，则按照字符连接符类处理
System.out.println(1+2+"4");
System.out.println("4"+1+2);
//当+两边的操作数都不是字符串时，则按照算术运算符来处理
System.out.println(1+2);
}
}
自增减运算符
+ 表示加法或连接 ++ 表示自增，也就是让自身的数值加1
- 表示减法 -- 表示自减，也就是让当前变量自身的数值减1
++（--）可分为前++（--）和 后++（--）
当++在前时先进行加1的操作，然后再进行其他运算
当++在后时前进行其他运算，然后再进行加1的操作
-- 同理，也就是无其他*或/等运算符参与时在前在后结果并无区别
测试demo
public class TestSelf {
public static void main(String[] args) {
int a = 3;
System.out.println(a);
//当++在后时先进行其他运算，然后再进行加1的操作
int b = a++;
// 先进行将a赋值给b的操作，再进行a自增1。所以打印b得到的是a赋值的结果
System.out.println(a); //4
System.out.println(b); //3
//当++在前时先加1，进行其他运算，所以得到的是+1+a等于5
System.out.println(++a);
//当++在后时先进行打印操作，然后再+1，所以这里也是输出5
System.out.println(a++);
//这里并无算术操作，是上一个输出操作后a进行自得到的6
System.out.println(a);
//算术测试
System.out.println(a); //6
//当++在后时先进行其他运算，然后再进行加1的操作
System.out.println(a++ + ++a); // 这里是先进行
++ + ++a的运算得8，然后再a + 8 =14
System.out.println(a); //这里得到得就是上面先进性得 ++ + ++a得结果 8
}
}
赋值运算符
赋值运算符将右边表达式得运算结果赋值给左边变量得运算符
1、简单赋值
= 表示赋值运算符，用于将=右边得数据赋值给=左边得变量，覆盖改变了原来得数值
2、复合赋值
= 、+= 、-= 、*= 、/= 、%=
测试demo
public class TestAssign {
public static void main(String[] args) {
int a = 10;
int b = 5;
//简单赋值
a = b;
System.out.println(a); // 5
//符合赋值 = 、+= 、-= 、*= 、/= 、%=
a /= b;
System.out.println(a); //此时上个运算已将b赋值给a，所以a /= b等于 5/5得1
}
}
比较运算符
比较运算符是用来判断两个表达式或值大小得关系运算符
> 表示是否大于
< 表示是否小于
== 表示是否等于
<= 表示是否小于等于
!= 表示是否不等于
>= 表示是否大于等于
关系运算符参与得表达式最终结果为boolean类型， True（真）和False（假）
测试demo
public class TestRelation {
public static void main(String[] args) {
int a = 3;
int b = 5;
// >、 <、 ==、 <=、 !=、 >=
System.out.println(a>b); //False
System.out.println(a
=b); //False
}
}
逻辑运算符
逻辑运算符操作数为boolean表达式
java提供的逻辑运算符有 &&（与） ||（或） ！（非）
&&（与） 表示逻辑与运算符，相当于“并且”，同真为真，一假为假
||（或） 表示逻辑或运算符，相当于“或者”，一真为真，同假为假
！（非） 表示逻辑非运算符，相当于“取反”，真为假，假为真
&& 和 || 具备短路的特性：如果通过第一个表达式的是即可得出最后的结果则不计算第二个表达式
短路的特性：
&&：若第一个条件为假则整个表达式一定为假，此时跳过第二个条件的执行
|| ： 若第一个条件为真则整个表达式一定为假，此时跳过第二个条件的执行
测试demo
public class TestLogic {
public static void main(String[] args) {
int a = 5;
//判断a是否大于10并且小于99，如果满足返回true，否则返回false
System.out.println(a>=10 && a<=99);
boolean b = false;
boolean c = true;
//&&（与） 表示逻辑与运算符，相当于“并且”，同真为真，一假为假。
System.out.println(b && c); //b是假，只要其中一个是假就返回假
//||（或） 表示逻辑或运算符，相当于“或者”，一真为真，同假为假
System.out.println(b || c); //c是真，只要有一个是真就返回真
//！（非） 表示逻辑非运算符，相当于“取反”，真为假，假为真
System.out.println(!b);
System.out.println(!c);
System.out.println("-----------------------");
int d = 3;
int e = 2;
//短路的特性：&& 若第一个条件为假则整个表达式一定为假，此时跳过第二个条件的执行
boolean d1 = (++d == 3 && ++e ==3); //第一个为假，所以跳过第二个表达式。返回false
System.out.println(d1); //false
System.out.println(d); //4
System.out.println(e); //2
System.out.println("-----------------------");
//短路的特性：|| 若第一个条件为真则整个表达式一定为假，此时跳过第二个条件的执行
boolean d2 = (++d == 5 || ++e ==3); //第一个为真，所以跳过第二个表达式。返回false
System.out.println(d2); //false
System.out.println(d); //4
System.out.println(e); //2
}
}
条件/三目运算符
语法格式
条件表达式 ？ 表达式1 ： 表达式2
执行流程
判断条件是否成立
若成立，则执行表达式1
若不成立，执行表达式2
测试demo
import java.util.Scanner;
public class TestThreeEye {
public static void main(String[] args) {
//创建安一个Scanner对象
Scanner scan = new Scanner(System.in);
System.out.println("请输入一个整数：");
int num = scan.nextInt();
//使用三目运算符进行判断并打印
System.out.println(num < 0 ? "负数" : (num > 0 ? "正数" : "零"));
}
}
选择结构
当需要进行条件判断的时候，并且根据条件是否成立来选择执行某一段代码的时，需要选择结构。
if
1、语法
if（条件表达式）{
语句块1； -----多条语句的集合，也可以是一条语句。
}
语句块2；
2、执行流程
判断条件表达式是否成立
假如条件成立，则执行语句块1，执行语句块2
假如不成立，则执行语句块2
演示英雄选择
import java.util.Scanner;
public class TestIf {
public static void main(String[] args) {
System.out.println("1、盲僧 2、劫 3、嘉文");
System.out.println("请选择：");
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
if(num == 1) {
System.out.println("掌控自己掌控敌人");
}
if(num == 2) {
System.out.println("无形之刃最为致命");
}
if(num == 3) {
System.out.println("犯我德邦者，虽远必诛！");
}//如果接收的参数没有符合的，则输出下面的语句块2.如果没有语句块2，则不作输出
System.out.println("超出选择");
}
}
if-else
1、语法
if（条件表达式）{
语句块1；
}
else{
语句块2；
}
语句块3
2、执行流程
判断条件是否成立
若成立，执行语句块1，执行语句块3；
不成立，执行语句块2，执行语句块3；
演示一个简单的考试成绩判断
import java.util.Scanner;
public class TestIfelse {
public static void main(String[] args) {
//演示一个简单的考试成绩判断
System.out.println("请输入您的考试成绩：");
Scanner sc = new Scanner(System.in);
int score = sc.nextInt();
if(score >= 60) {
System.out.println("成绩合格");
}else {
System.out.println("不合格");
}
}
}
if-else if-else
1、语法
if（条件表达式1）{
语句块1；
}else if（条件表达式2）{
语句块2；
}else{
语句块3；
}
语句块4；
2、执行流程
判断条件表达式1是否成立
成立，执行语句块1，执行语句块4
不成立，判断条件表达式2是否成立
成立，执行语句块2，执行语句块4
不成立，执行语句块3，执行语句块4
演示一个简单的买购票系统
public class TestIfelseIfelse {
public static void main(String[] args) {
//提示用户输入身份信息
System.out.println("请输入您的身份信息：");
Scanner sc = new Scanner(System.in);
//使用变量接收身份信息
String str = sc.next();
if("军人".equals(str)) {
System.out.println("免票");
}else if("学生".equals(str)) {
System.out.println("半票");
}else {
System.out.println("全票");
}
}
}
swich-case
1、语法
swich（）{
case 字面值1：
语句块；
break；
case 字面值2：
语句块2；
break；
default：
语句块3；
}
语句块4；
2、执行流程
计算变量/表达式的数值 判断是否匹配字面值1；
如果匹配，则执行语句块1，执行语句块4；
如果不匹配，则判断是否匹配字面值2；
匹配，则执行语句块2，执行语句块4；
不匹配，则执行语句块3，执行语句块4；
演示一个简单的买购票系统
import java.util.Scanner;
public class SwitchCase {
public static void main(String[] args) {
//提示输入身份
System.out.println("请输入身份：1、军人 2、学生 ");
//接收信息
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
switch(num){
case 1:
System.out.println("军人乘车免票");
break;
case 2:
System.out.println("学生乘车半票");
break;
default:
System.out.println("群众乘车全票");
break;
}
}
}
循环结构
当需要在某个场合进行条件的判断，有所选择的执行一段代码，需要分支结构
当需要在某个场合重复去做某一件事，需要循环结构
for循环
1、语法
for（初始表达式;条件表达式；修改初始表达式的表达式）{
循环体1；
}
循环体2；
2、执行流程
执行初始表达式=》判断条件表达式是否成立
成立 执行循环体1=》修改初始条件测表达式=》判断条件表达式是否成立
不成立 执行循环体2
注意：
for（初始表达式;条件表达式；修改初始表达式的表达式）{
循环体1；
}
for循环的括号和大括号中声明的变量都叫做块变量，作用域只限于for循环，而再方法中声明的变量称之为局部便变量，作用域包含整个方法
循环输入5个商品的价格，并计算平均价格
public class TestFor {
public static void main(String[] args) {
Scanner h = new Scanner(System.in);
int x=0;
for(int a=1;a<=5;a++) {
System.out.println("请输入第"+a+"个商品的价格：");
int num = h.nextInt();
x+=num;
}
System.out.println("商品总价格为："+x);//商品总价格为：15
System.out.println("商品平均价格为："+x/5);//商品平均价格为：3
}
}
while循环
1、语法
while(条件表达式){
循环体；
}
语句块
2、执行流程
判断条件表达式是否成立
成立，执行循环体 =》判断条件表达式是否成立
不成立，执行语句块
3、注意
while循环和for循环是可以互补的
while循环通过使用明确循环条件但不明确循环册数的场合中
for循环通常使用再明确循环次数/范围的场合中使用
for（；；）{} 和 while（true）{} 都是表示无限循环的方式
While循环打印1-10
public class TestWhile {
public static void main(String[] args) {
int i = 0;
while(i<=10) {
System.out.println(i);
i++;
}
System.out.println("跳出while循环");
}
}
do-while
1、语法
do{
循环体；
}while（条件表达式）；
语句块；
2、执行流程
执行循环体=》判断条件表达式是否程立
成立。执行循环体=》判断条件表达式是否成立
不成立，执行语句块
3、注意
do-while循环通常使用再至少需要执行一次循环体的场合中，而while循环可以不执行
do-while打印1-10
public class TestDoWhile {
public static void main(String[] args) {
int i=1;
do {
System.out.println(i);
i++;
}while(i<=10);//do-while循环结构在小括号的后面有分号，其他循环则没有
}
}
三个循环的区别
执行顺序
while 循环： 先判断，再执行
do-while循环：先执行，再判断
for循环；先判断，再执行
适用情况
循环次数确定的情况，通常选用for循环
循环次属不确定的情况，通常选用while或者do-while循环
数组
数组是一组数据类型相同的数据的组合，将这些数据统一的管理起来
数组是一个引用数据类型,数组内存的类型可以是基本类型，也可以是引用类型
别人的讲解
数组的定义（声明）
数据类型[] 数组名字：
int[] x;
char[] y;
boolean[] z;
String[] m;
其他的定义方式：
int x[];
int []x;
数组的赋值（初始化）
静态初始化 有长度 有元素
int[] array = new int[]{10,23,30,40,50};
int[] array = {10,20,30,40,50};
动态初始化 有长度 没有元素（不是真的没有 是保存默认值）
int[] array = new int[5];
整数默认值--0
浮点数默认值--0.0
字符类型默认值--char对应0的字解码 比如 97对应a 65对应A 48对应‘0’
布尔型默认值--false
引用数据默认值--null
访问元素
通过元素在数组的位置index（索引/下标）来访问
索引是有取值范围的【从0开始-数组长度-1】
如果数组的索引超出了上述范围
会出现一个运行异常 ArrayIndexOutOfBoundsException (数组索引超出边界)
数组元素的遍历（轮询）
通过循环的方式访问数组的每一个元素
JDK1.5版本之后 新的特性 增强for循环： forEach
for(自定义的变量（用于接收数组内的每一个元素）: 遍历的数组Array){
}
正常的for
有三个必要条件 index索引 找到某一个位置
可以通过index直接访问数组的某一个位置 存值 取值都可以
增强的for
有两个必要条件 用来取值的变量 用来的遍历的数组 没有index索引
不能存值 只能取值
没有index索引 找不到元素到底是哪一个
数组练习
用数组来存储1-100之间的奇数
public class Test0 {
public static void main(String[] args){
//静态初始化a、b数组
int[] a = new int[]{1,2,3,4};
int[] b = new int[]{5,6,7,8};
//堆内存的数组空间长度一旦确定 不能再次发生改变。那我们定义一个动态数组器调换元素作用
int[] x = new int[4];
//for循环将a数组中的元素赋值到x数组中，现在x{1,2,3,4}
for (int i=0;i<a.length;i++){
x[i] = a[i];
}
//for循环将b数组中的元素赋值到a数组中，现在a{5,6,7,8}
for (int i=0;i<a.length;i++){
a[i] = b[i];
}
//for循环将x数组中的元素赋值到b数组中，现在b{1,2,3,4}
for (int i=0;i<a.length;i++){
b[i] = x[i];
}
//while循环遍历替换后的a和b中的元素
int z = 0;
while(z<a.length){
System.out.println(a[z]);
System.out.println(b[z]);
z++;
}
}
}
a{1,2,3,4} b{5,6,7,8}内的元素位置对应互换
public class Test1 {
public static void main(String[] args) {
//将数组a{1、2、3、4} b{5、6、7、8}内的元素位置对应互换
//1、每次循环将两个数组中对应位置的元素互换（循环对此，受长度限制）
int[] a = {1,2,3,4};
int[] b = {5,6,7,8};
for(int i = 0;i<a.length;i++) {
int x = a[i];
a[i] = b[i];
b[i] = x;
System.out.println(a[i]);
System.out.println(b[i]);
}
//2、直接交换数组a和b数组的引用地址（不用循环，不受长度限制）
int [] y = a;
a = b;
b = y;
for(int z : a) {
System.out.println(z);
}
for(int z : b) {
System.out.println(z);
}
}
}
a{1,2,3,4,5,6}内的元素位置逆向调换
public class Test2 {
public static void main(String[] args) {
//静态生成一个数组
int[] a = new int[]{1,2,3,4,5,6,7,7,9};
//通过第三个int元素介入，每次循环从外向内进行元素互换
for(int i=0;i<a.length/2;i++) {
int x = a[i];
a[i] = a[(a.length-1)-i];
a[(a.length-1)-i] = x;
}
for(int y:a) {
System.out.println(y);
}
}
}
a{1,2,3,4,5,6}计算数组所有元素的平均值
public class Test3 {
public static void main(String[] args){
//静态定义一组数据
int[] a = new int[]{1,2,3,4,5};
//定义一个数值为0的int类型变量，用于接收a数组内的元素进行相加
int sum = 0;
//while遍历数组a中的元素，进行相加
int i = 0;
while(i<a.length){
sum = sum+a[i];
i++;
}
//打印出平均值
System.out.println(sum/a.length);
}
}
{1,3,5,7,9,0,2,4,6,8}找出最大值和最小值
public class Test4 {
public static void main(String[] args){
/*
* 1、定义一个值为0的int数据类型对象，用来接收a数组的元素
* 2、遍历a数组的元素，没次赋值给int对象
* 3、下一次遍历是判断当前int对象和上一次遍历被赋值的int对象谁更大，
* 如果当前遍历对象更大则进行赋值，更小则进行下一次遍历。
* 4、最小值思路反之
*/
//静态定义一数组
int[] a = new int[]{1,3,5,7,9,0,2,4,6,8};
int MaxNum = 0;
for(int i = 0;i<a.length;i++){
if(a[i]>MaxNum){
MaxNum = a[i];
}
}
int MinNum = 0;
for(int x = 0;x<a.length;x++){
if(a[x]<MinNum){
MinNum = a[x];
}
}
System.out.println("a数组中的最大值是："+MaxNum);
System.out.println("a数组中的最小值是："+MinNum);
}
}
a{1,2,3} b{4,5} 合并两个数组
public class Test5 {
public static void main(String[] args) {
//创建两个数组
int[] a = {1,2,3};
int[] b = {4,5};
//创建一个新数组向内添加内容
int[] NewArray = new int[a.length+b.length];
//将a数组的元素添加进NewArray
for(int i = 0;i<a.length;i++) {
NewArray[i] = a[i];
}
//将b数组的元素添加进NewArray
for(int i = 0;i<b.length;i++) {
NewArray[a.length+i] = b[i];
}
//遍历输出NewArray
for(int x:NewArray) {
System.out.println(x);
}
}
}
{5,4,2,3,1}升序排列
public class Test6 {
public static void main(String[] main) {
int[] a = { 5, 4, 2, 3, 1 };
for (int x = 1; x < 5; x++) {//重复执行升序循环
for (int i = 4; i >= x; i--) {//找出一个最小数进行升序替换
// 如果后面的数比前面的数大，就进行替换
if (a[i] < a[i-1]) {
int change = a[i];
a[i] = a[i-1];
a[i-1] = change;
}
}
}
for (int x : a) {
System.out.println(x);
}
}
}
二维数组
一维数组本质上就是一段连续的内存空间，用于存放多个类型相同的数据。
二维数组本质就是有一堆数组组成的数组，其实就是每个元素为一组数组的数组。
定义格式
格式1：
数据类型[][] 变量名 = mew 数据类型[m][n];
m表示这个二维数组有多少个一维数组
n表示每一个一维数组的元素个数
举例：
int[][] arr =new int[3][2];
定义一个二维数组arr
这个二维数组有3个一维数组，名称为arr[0],arr[1],arr[2]
每一个以一维数组有2个元素，可以通过arr[m][n]来获取元素
格式2：
数据类型[][] 变量名 = new 数据类型[][]{{元素}，{元素}，{元素}}；
数据类型[][] 变量名 = {{元素}，{元素}，{元素}}；
举例：
int[][] arr = {2，9}，{1，2，3}，{4，5}；
数组的初始化
静态初始化
int[][] array = {{1,2},{3,4,5},{6,7,8,9}};
动态初始化
int[][] array = new int[3][2];
array --> {{x,x},{x,x},{x,x}}
二维数组练习
求公司年销售额总额
某公司按季度和月份统计的销售数据如下：单位（万元）
第一季度：22，44，66
第二季度:77，55，66
第三季度：60，48，50
第四季度：70，58，66
public class ArrsTest {
public static void main(String[] args) {
//初始化一个二维数组
int[][] arr = {{22,44,66},{77,55,66},{60,48,50},{70,58,66}};
//初始化一个int类型变量，用来接收最后的总额
int x = 0;
//第一个循环用来输出二维数组中有多少个一维数组
for(int i =0;i<arr.length;i++) {
System.out.println("我是第"+(i+1)+"季度");
//第二个循环用来输出每个一维数组，并将值赋给x
for(int j = 0;j<arr[i].length;j++) {
System.out.println(arr[i][j]+"万");
x += arr[i][j];
}
}System.out.println("全年销售总额为："+x+"万");
}
}
我是第1季度
22万
44万
66万
我是第2季度
77万
55万
66万
我是第3季度
60万
48万
50万
我是第4季度
70万
58万
66万
全年销售总额为：682万