java历史背景
1995年sun公司发布java第一个版本
2009年甲骨文收购sun公司
2011年发布java7
2014年发布java8
JavaSE/JavaEE/JavaME
公司中主要运用JavaEE
Java语言是跨平台的
即：一个编译好的.class文件是可以在多个系统下运行
Java语言是解释性语言
Java运行机制
JDK/JRE
JDK（Java开发工具包）javaDevelopmentKit是给开发人员使用的
JDK=JRE+Java开发工具 [Java Javac Javadoc javap]
JRE（Java运行环境）
JRE=JVM+Java核心类库
运行已经开发好的Java程序，只需要安装JRE
配置环境变量
环境变量的作用：为了在DOS任意目录可以去使用java和javac命令
打开DOS命令行，任意目录下敲击javac/java如果出现参数信息，配置成功
1.计算机属性环境变量下的pc用户变量中，新建变量名为JAVA_HOME，变量值为已安装的jdk的目录
2.环境变量下的pc用户变量，点击Path编辑->新建，输入%JAVA_HOME%\bin
%JAVA_HOME%代表引用jdk安装目录,多处引用不建议写死
说明：环境变量配置在用户变量中，只针对这个用户生效，如果配置在系统变量中则对所有用户生效
控制台编译问题
在文件目录下输入cmd打开控制台，编译成功出现.class字节码文件
编译后，每一个类都对应一个.class文件
问题1：编码格式不一致导致无法编译，控制台编码格式为GBK
已解决，在sublim上设置文件编码为GBK
问题2：程序编写错误,类名不加括号
//错误示范
public class Run(){}
应改为
public class Run{}
其中class也要小写
问题3：文件名与类名需一致
错误：类Run是公共的, 应在名为 Run.java 的文件中声明
文件名为Test.java，程序类名为Run，将文件名Test更改为类名即可Run.java
如果源文件只包含一个public类，则文件名必须按该类名命名
Java开发注意事项和细节说明
主要五点：
1.一个源文件最多只能有一个public类，其他类个数不限
2.如果源文件包含一个public类，则文件名必须按该类名命名
3.当mian方法在非public类中，其他类个数不限时，也可以将mian方法写在非public类中
4.编译时按public类名来编译，运行时按含有main方法的类名
5.修改了源码需要重新编译
public class Hello{
public static void main(String[] args){
System.out.println("1");
}
}
class Dog{
public static void main(String[] args){
System.out.println("2");
}
}
class Tiger{
public static void main(String[] args){
System.out.println("3");
}
}
如何快速的学习技术或知识点？
20年开发经验之谈
1.思考新的技术对程序有那些帮助？用传统技术来实现有何区别？
2.把新技术的基本原理和语法学会（不要考虑细节）
3.快速入门，直接找案例练习，能实现基本业务（公司中老板要求新技术时先快速实现）
4.开始研究技术的注意事项，使用细节及规范，如何优化（没有止境）
Java转义字符
运用转义字符首先编码格式要正确
1.转义字符”\“
反斜杠:
想要输出1个反斜杠需要转义,实际代码是2个反斜杠
想要输出2个反斜杠需要转义,实际代码是4个反斜杠
System.out.println("C:\\jvaSoftware\\jvacode");
System.out.println("\\\\");//\\
输出：C:\JavaSoftware\javacode
System.out.println("C:\\\\jvaSoftware\\\\jvacode");
输出：[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-v17yubH1-1631611423198)(C:\Users\pc\AppData\Roaming\Typora\typora-user-images\image-20210902182926062.png)]
System.out.println("老韩说：\"要好好学java！\"");
输出：老韩说：”要好好学java！”
2.回车\r
System.out.println("韩顺平教育\r北京");
输出：北京平教育
说明：因为\r只是回车不是换行，故光标会出现在最前面，北京替换了韩顺
idea上输出为北京
3.制表符\t
相当于Tab键
4.换行符\n
文档注释
可被JDK中提供的工具javadoc解析，生成一套以网页文件形式体现的程序说明文档，一般写在类上面
/*
@author 杜润伍
@version 1.0
*/
public class Comment{
public static void main(String[] args){
System.out.println("helloworld");
}
}
利用指令生成网页文件
控制台指令：javadoc -d 文件夹名 -xx -yy Comment.java（需要生成那些对应的Javadoc标签xx=author yy=version …）
-d代表我要把生成的文档放到那个文件目录
注意：文件目录地址的反斜杠在控制台输入时需要转义
Java代码规范
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Jt4JmUDi-1631611423201)(C:\Users\pc\AppData\Roaming\Typora\typora-user-images\image-20210902223444867.png)]](https://img-blog.csdnimg.cn/9681a59166064622820a51078d04f1ee.png)
//行尾风格
if(){
sout
}
//次行风格
if()
{
sout
}
java开发者也是用的行尾风格
相对路径和绝对路径
…\到上一级目录
相对路径：test100—>adc—>D盘—>abc2—>test200(abc2下的test200)
绝对路径：D盘—>abc2—>test200
常用DOS命令
DOS磁盘操作系统DiskOperatingSystem
DOS命令—>DOS系统—>windows文件系统
dir 查看当前目录
tree 查看指定目录所有子集目录
cd 切换到某某路径
盘符号，表示切换到某某路径
1.切换到C盘
cd /D c:
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Astqg1sb-1631611423203)(C:\Users\pc\AppData\Roaming\Typora\typora-user-images\image-20210903100908591.png)]](https://img-blog.csdnimg.cn/a6979c1481df4ceabdfdde8e03bac762.png)
2.切换到当前盘下的其他目录
cd 文件路径
3.切换到根目录
cd \
…\ 到上一级目录
cls 清屏
exit 退出
md 创建目录
目录就是文件夹
rd 删除目录
echo 创建文件 可输入内容
echo ok > hello.txt 创建了hello.txt 文件内容ok
echo hello> hello.txt 创建了hello.txt 文件内容hello
type 创建空文件
type aaa > abc.txt 创建了abc.txt 文件内容空白
move 剪切
move bbb.txt C:\JavaSoftware\abc
copy 拷贝文件
copy bbb.txt C:\JavaSoftware\abc
拷贝的时候可以修改文件名abc为abc2，复制的文件名为abc2
del 删除文件
del ccc.txt
Java数据类型
byte num1 = 10;//占1个字节
short num2 = 10;//占2个字节
int num3 = 10;//占4个字节
不同的数据类型占的空间大小不一样
num1,num2,num3在内存中分配的数据空间大小是不一样的
整型
整数类型默认int
浮点型
浮点数类型默认double,double精度比float更精确
double类型默认值是0.0d
double类型十进制数形式
.512=0.512（可以省略前面的0）
科学计数法
5.12e2（5.12*10^2）//512
double num1 = 5.12e2;//512.0 浮点型要加.0
5.12E-2（5.12/10^2）//0.0512
double num2 = 5.12E-2;//0.0512
面试题：
1.浮点数在机器中存放形式的简单说明：浮点数=符号位+指数位+尾数位
2.从第一点的存储机制来看，尾数部分可能丢失，造成精度损失（小数都是近似值）
基本数据类型的默认值
long和float什么时候加L和F?
这里主要依据存储空间的字节大小来判断
Java浮点型常量默认double型,声明float型常量，需加F或f
小转大可以（因为double的范围远比float大），大转小不兼容
比如一张单人床只能睡1个人或者0个人，但是不能睡3个人或者更多
float n1 = 1.1;//错误，double转化到float会有损失，不兼容
double n2 = 1.1F;//float可以转换到double
double n3 = 1.1;//常规写法
float n4 = 1.1F;//常规写法
浮点数的使用陷阱
double num = 8.1/3;//2.6999999999999
小数在相加的时候都是近似值
double price1 = 49.23;
double price2 = 50.25;
System.out.println(price1 + price2);//99.47999999999999
字符类型char
字符常量用单引号 ’ ‘
char c1 = '\t';//斜杠t合起来表示一个字符，斜杠表示转义
特别注意
char a = '1';//注意这样也是可以是，1也是字符
char本质是一个整数，在输出时是Unicode码对应的字符
public class Test{
public static void main(String[] args){
char c1 = 'a';
System.out.println((int)c1);//97
char c2 = 97;
System.out.println(c2);//a
char c3 = '韩';
System.out.println((int)c3);//38889
char c4 = 38889;
System.out.println((int)c4);//韩
char c5 = 'a';
System.out.println(c5+10);//107
char num = 'b'+1;//98+1==>99
System.out.println((int)num);//99对应的是c在int强转为99
System.out.println(num);//没有int强转直接输出c 99对应的ASCII码为c
char n = a;//错 字符必须加‘’
System.out.println(n);
}
}
字符存储读取机制
编码表
ASCII码一共用到多少个字符？128
标准的ASCII码是7位码
ASCII码使用指定的7位或8位二进制数组合来表示128或256种可能的字符。标准ASCII码也叫基础ASCII码，使用7位二进制数来表示所有的大写和小写字母，数字0到9、标点符号，以及在美式英语中使用的特殊控制字符
一个字符的ASCII码占用存储空间为1个字节
gbk是国家标准，utf-8是国际标准，所以utf-8的通用性更强
所以有时候utf-8的文件无法转换为gbk文件
1个字节=8位 2个字节=16位 3个字节=24位
Unicode码兼容ASCII码
boolean
boolean isPass = 1;//错误
不可以0或非0的整数替代false和true，这点和C语言不同
Java里面boolean的值只能是true或false
基本数据(自动转换)
char num1 = 'a';//97 char可以转换为int
double num2 = 80;//80.0
//只要满足低精度向高精度转换，可以跨越，如int直接转double
1.有多种数据类型混合运算时系统首先自动将所有数据转换成容量大的那种数据类型
int n1 = 10;float f1 = n1 + 1.1;//报错
这里1.1是double类型
解决方案如下
dobule f1 = n1 + 1.1;//直接用double接收
或
float f1 = n1 + 1.1F;
2.byte可以转short，但是char这种数据类型在byte和short之间不发生自动转换
机制：先判断范围再去适配数据类型
byte b1 = 10;//-128~127
根据（byte和short）与char之间不会发生自动转换,测试如下
public class Test{
public static void main(String[] args) {
char c1 = 10;
byte b1 = c1;
}
}
public class Test{
public static void main(String[] args) {
byte b1 = 10;
char c1 = b1;
}
}
public class Test{
public static void main(String[] args) {
short s1 = 10;
char c1 = s1;
}
}
public class Test{
public static void main(String[] args) {
char c1 = 10;
short s1 = c1;
}
}
3.byte short char 它们三者可以计算，在计算时转为int类型
byte b1 = 1;
short s1 = 1;
short s2 = b1 + s1;//错
byte b1 = 1;
byte b2 = 2;
byte b3 = b1 + b2;//错
4.boolean类型不参与转换
5.表达式结果类型自动转换为操着数中的最大的类型
byte num1 = 1;
short num2 = 100;
int num3 = 1;
double num4 = 1.1;
double num = num1 + num2 + num3 + num4;
基本数据(强制转换)
自动转换的逆过程，将容量大的数据类型转换为容量小的数据类型，使用强转符（），会造成精度降低或溢出，格外小心。
int n1 = (int)1.9;
System.out.println(n1);//1 精度损失
byte b1 = 2000;
System.out.println(b1);//-48 数据溢出
常规强转
public class Test{
public static void main(String[] args) {
int n1 = 100;
char n2 = (char)n1;
System.out.println(n2);
}
}
String类型转基本类型
使用基本数据类型对应的包装类的相应方法，得到基本数据类型
基本类型转String类型就加个“ ”
public class Test{
public static void main(String[] args) {
String num = "100";
int num1 = Integer.parseInt(num);
byte num2 = Byte.parseByte(num);
short num3 = Short.parseShort(num);
long num4 = Long.parseLong(num);
float num5 = Float.parseFloat(num);
double num6 = Double.parseDouble(num);
boolean b = Boolean.parseBoolean("true");
System.out.println(num1);
System.out.println(num2);
System.out.println(num3);
System.out.println(num4);
System.out.println(num5);
System.out.println(num6);
System.out.println(b);
}
}
怎么把字符串转成char？
String类型字符串.char(0)得到的是一个字符，而不是数字
练习
1.n3=30;n5=8;
2.
public class Test{
public static void main(String[] args) {
char c1 = '\n';
char c2 = '\t';
char c3 = '\r';
char c4 = '\\';
char c5 = '1';
char c6 = '2';
char c7 = '3';
System.out.println(c1);
System.out.println(c2);
System.out.println(c3);
System.out.println(c4);
System.out.println(c5);
System.out.println(c6);
System.out.println(c7);
}
}
public class HelloWorld {
public static void main(String []args) {
String book1 = "长歌行";
String book2 = "白夜行";
System.out.println(book1 + book2);
char sex1 = '男';
char sex2 = '女';
System.out.println(sex1 + sex2);
double price1 = 49.23;
double price2 = 50.25;
System.out.println(price1 + price2);//小数在相加的时候都是近似值
}
}
长歌行白夜行
52906
99.47999999999999
public class HelloWorld {
public static void main(String []args) {
String name = "性名";
String age = "年龄";
String score = "成绩";
String sex = "性别";
String hobby = "爱好";
System.out.print(name + "\t" + age + "\t" +
score + "\t" + sex + "\t" + hobby
+ "\n" + "xx" + "\t" + "xx" + "\t" +
"xx" + "\t" + "xx" + "\t" + "xx");
}
}
性名 年龄 成绩 性别 爱好
xx xx xx xx xx
复盘做练习错误
1.读题不够严谨
2.一个题目至少思考三遍，从各个维度
3.答案能不能优化
4.学习老师的解题思路
怎么提升学习效率？
Java设计者如何管理接口、类、异常
算数运算符
除法
public class HelloWorld {
public static void main(String []args) {
System.out.println(10/4);//2
System.out.println(10.0/4);//2.5
double d = 10/4;
System.out.println(d);//2.0
}
}
10/4都是整数，java中会舍去小数点后面的，等于2
10.0是double类型，精度提升,保留小数点后面的结果
10/4都是整数舍去小数点后面，2在转换double类型，得2.0（先看右边的）
取模
取模运算是求两个数相除的 余数
公式 a%b = a - a / b * b 正负号取决于a
如果a是小数会进行类型强转
System.out.println(10%3);//1
System.out.println(-10%3);//-1
System.out.println(10%-3);//1
System.out.println(-10%-3);//-1
-10%-3 = -1
10/3都是整数，结果=3
-10 - （-10/-3）*（-3）= -10 -（-9）= -1
++
这里把i=1付给了临时变量
public class HelloWorld {
public static void main(String []args) {
int days = 59;
int week = 59 / 7;
int day = 59 % 7;
System.out.println("合"+ week + "个星期零"+ day + "天");
}
}
合8个星期零3天
public class HelloWorld {
public static void main(String []args) {
double fahrenheit = 234.5;
double centigrade = (double)5/9*(fahrenheit-100);//5/9是整数结果为0
System.out.println(centigrade + "摄氏度");
}
}
这题没仔细看公式，要考虑公式和java语言的特性
逻辑运算符
短路与&&
如果第一个条件为假，则整个结果必为假，因此后面的条件没必要在执行和判断，效率高
public class HelloWorld {
public static void main(String []args) {
int a = 4;
int b = 10;
if(a < 1 && ++b < 50){
System.out.println("ok");
}
System.out.println("a=" + a + "b=" + b);
}
}
a<1为false，因为是短路与，后面不在执行和判断，故a=4b=10
public class HelloWorld {
public static void main(String []args) {
int a = 4;
int b = 10;
if(a < 1 & ++b < 50){
System.out.println("ok");
}
System.out.println("a=" + a + "b=" + b);
}
}
a<1为false，因为是逻辑与，后面继续执行和判断，故a=4b=11
短路或||
如果第一个条件为真，则整个结果必为真，因此后面的条件没必要在执行和判断，效率高
public class HelloWorld {
public static void main(String []args) {
int a = 4;
int b = 10;
if(a < 1 || ++b > 50){
System.out.println("ok");
}
System.out.println("a=" + a + "b=" + b);
}
}
a<1成立，结果为true，后面不执行和判断，输出ok，a=4,b=10
public class HelloWorld {
public static void main(String []args) {
int a = 4;
int b = 10;
if(a < 1 || ++b > 50){
System.out.println("ok");
}
System.out.println("a=" + a + "b=" + b);
}
}
a<1成立，结果为true，输出ok，由于是逻辑或后面继续执行，a=4,b=11
逻辑异或^
boolean b = (1>2)^(1<2);
System.out.println(b);
true
boolean b = (1<2)^(2<3);
System.out.println(b);
false
练习
1.x=6 y=6
2.x=6,y=5
3.x=11,y=6
4.x=11,y=5
特别注意：y=true是把true赋值给y,注意=是赋值，==是等于
t 47 t 48
f 49 t 50
z=50
赋值运算符
三元运算符
int a = 10;
int b = 99;
int num = a > b ? a++ : b--;
System.out.println(num);//99
这里需要特别注意,a>b为false，所以先返回b把值赋给num，在进行b–,所以num=99而不是98,b的值是98
使用细节
表达式结果自动转换为数据运算中的最大数据类型，也可强转
三元运算符也可转if-else
练习
int n1 = 55;
int n2 = 33;
int n3 = 123;
int max1 = n1 > n2 ? n1 : n2;
int max2 = max1 > n3 ? max1 ： n3;
System.out.println(max2);//123
用一个三元运算符怎么实现？
int max = (n1 > n2 ? n1 : n2) > n3 ? (n1 > n2 ? n1 : n2) : n3 ;System.out.println(max);//123
不推荐第二种，第一种可读性更好
运算符优先级
命名规范
Scanner
System.in从键盘输入
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
Scanner myscanner = new Scanner(System.in);
System.out.println("请输入名字：");
String name = myscanner.next();// 获取键盘输入的字符串
System.out.println("请输入性别：");
String sex = myscanner.next();
System.out.println("请输入年龄：");
int age = myscanner.nextInt();
System.out.println("请输入薪资：");
double sal = myscanner.nextDouble();
System.out.println(name + sex + age +sal );
}
}
进制（重要！！！）
二进制，11是怎么到100的,如上图，逢二进一，两个1满2进位，然后又满二进位得100
八进制，0~7满8进位，得10
进制转换
联想记忆：转十进制用乘权相加（这里联想记忆，因为二进制转十进制是乘权相加，所以所有转十进制都是乘权相加），反之用十进制去转的都用倒除法
其他进制转十进制（这里采用乘权相加）
二进制转十进制
八进制转十进制
十六进制转十进制
练习
1.2^8
+2^7
+2^3
+2^3
+2^2=396
2.1326
3.2629
十进制转其他进制（这里采用倒除法）
十进制转二进制
这里结果，倒除法计算得100010只有6位，但是一个字节是八位，所以前面加两个0，得0B00100010
十进制转八进制
这里为什么不是8位？
十进制转十六进制
A B C D E F
10 11 12 13 14 15
联想记忆：只记住了A=10，到时候查询直接念A,10,B,11,C,12,D,13,E,14,F,15
也可以这样记忆：数ABCD跟1234对应，因为A是10,所有对应 11，12，13，14时相应减一，比如D对应的是4，减一就是3，故D是13
1.0B01111011
2.01246
3.0x22D0
二进制转八进制
二进制转十六进制
从低位开始，四位一组
1.0xE5
2.0x396
十六进制转二进制
1.0B0010 1001 1000
2.0B1010 1011 0010 1001
如何联想记忆？
今天看的视频，联想记忆
记忆主要是记和忆
比如记忆一大段知识点
找出其中最有特点的最容易记住的
然后以这个最容易记住的为核心把知识串起来记忆
这个up说的更深入，它把最容易记住的进一步转换为身边的实物更一步加强记忆
反正就是
找出知道点核心，做一个树状发散结构，就是思维导图把
这样记住的基本不会忘记
反正记不住也别死背
记住了就回想，从最核心的点，一直延申，到每一个分支就把知识回忆出来然后继续想下一个知识点，最后记忆的时候读出来，可以刺激大脑
复盘2021/9/5的学习问题(复盘spend20min)
5：30起床-23点（目前） 一共17.5hour
起床加过早30分钟
上厕所9次浪费2hour（拉肚子）
做饭1hour
今天一天看B站娱乐视频 4h(其中包含上厕所1h)
大概学习时间 = 17.5 - （0.5+1(折中)+5）= 11hour
今日实际学习时间 = 11hour-2hour(拿快递，买东西，说话，网络聊天) = 9hour
到11点学习（94-70）24集，今日目标至100集（未完成！！！）
今天消遣过度，明天尽量把刷视频的时间缩短在1hour，提升学习效率，断断续续最浪费时间了
5点半早起做的挺好，不午休晚上学习也有精神，持续保持，循序渐进！！！Come on
二进制说明
原码、反码、补码（重点！！难点）
0为整数1为负数
运算用补码
运算结果用原码
面试题：为什么计算机都是以补码的方式运行的？
答：补码可以统一正数和负数
位运算符
可以理解&是* |是+
异或^就是相异出1，相同出0
练习
计算2&3
计算-2的按位取反
这里需要特别注意的是，位运算后的结果是00000000 00000000 00000000 00000001这个结果就是正数，所以结果需要的原码也是这个。
计算2的按位取反
思路分析：
运行补码，结果原码
2是正数，三码相同，补码等于原码，直接写出补码
00000000 00000000 00000000 00000010
进行位运算，按位取反，得出运算后的补码
11111111 11111111 11111111 11111101
可以看出运算后的补码是负数，所以先根据运算后的补码得到反码，在在从反码得到最终的结果原码
又因为负数的反码 = 负数的补码 - 1（这里符号位不变），得出
11111111 11111111 11111111 11111100
最后根据反码取反得到原码（同样符号位不变），得出
10000000 00000000 00000000 00000011
因为符号位是1，所以结果为-3
思考题
2.2&3
2的补码：00000000 00000000 00000000 00000010
3的补码：00000000 00000000 00000000 00000011
按位与： 00000000 00000000 00000000 00000010
2&3的结果=2
3.2|3
2的补码：00000000 00000000 00000000 00000010
3的补码：00000000 00000000 00000000 00000011
按位或： 00000000 00000000 00000000 00000011
2|3结果=3
4.-5按位取反
-5原码：10000000 00000000 00000000 00000101
反码： 11111111 11111111 11111111 11111010
补码： 11111111 11111111 11111111 11111011
位运算: 00000000 00000000 00000000 00000100
位运算的结果为正数，原码就等于补码，因为是正数，-5按位取反的结果为4
5.13&7
13的补码：00000000 00000000 00000000 00001101
7的补码： 00000000 00000000 00000000 00000111
按位与： 00000000 00000000 00000000 00000101
结果为5
6.5|4
5的补码：00000000 00000000 00000000 00000101
4的补码：00000000 00000000 00000000 00000100
按位或： 00000000 00000000 00000000 00000101
结果=5
7.-3^3
-3原码： 10000000 00000000 00000000 00000011
-3反码： 11111111 11111111 11111111 11111100
-3补码： 11111111 11111111 11111111 11111101
3补码： 00000000 00000000 00000000 00000011
按位异或：11111111 11111111 11111111 11111110
反码： 11111111 11111111 11111111 11111101
原码： 10000000 00000000 00000000 00000010
结果-2
3，2，0，
-10.5%3结果为-1.5 -10.5 - （(int)-10.5 / 3 *3）= -10.5 -（-3 * 3）= -10.5 + 9 = -1.5
double默认初始值类型是3d
int i = 48;没错，可是（i+1）是int类型，不能把Int类型赋值给char
short.char.byte运算时直接转int类型
同理
内存分析法
顺序控制
if-else分支控制
单分支
import java.util.Scanner;//jdk—>开发工具包—>接口/异常/类
public class Test {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入年龄：");
int age = scanner.nextInt();
if (age > 18) {
System.out.println("送入监狱！");
}
}
}
这里if判断如果只有一条执行语句，可以省略不写，但不推荐
双分支
双分支只会执行一个条件，要么true要么false
练习
韩顺平教育~
//1.
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入数1：");
double num1 = scanner.nextDouble();
System.out.println("请输入数2：");
double num2 = scanner.nextDouble();
double sum = num1 + num2;
if (num1 > 10.0 && num2 < 20.0) {
System.out.println("两数之和为：" + sum);
}
}
}
//2.
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入数1：");
int num1 = scanner.nextInt();
System.out.println("请输入数2：");
int num2 = scanner.nextInt();
double sum = num1 + num2;
if (sum % 3 == 0 && sum % 5 == 0) {
System.out.println("能被整除");
}else {
System.out.println("不能被整除");
}
}
}
//3.
import java.util.Scanner;
public class Test{
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入年份：");
int year = scanner.nextInt();
if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
System.out.println(year + "年是闰年");
}else {
System.out.println(year + "年不是闰年");
}
}
}
多分支
嵌套分支
实际开发中嵌套不要超过三层
package com.jt;
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
Scanner myScanner = new Scanner(System.in);
System.out.println("请输入成绩：");
double score = myScanner.nextDouble();
if (score > 8.0) {
System.out.println("请输入性别：");
char gender = myScanner.next().charAt(0);
System.out.println("晋级成功！");
if (gender == '男') {
System.out.println("恭喜进入男子组决赛");
}else if (gender == '女') {
System.out.println("恭喜进入女子组决赛");
}else {
System.out.println("性别输入有误不能进入决赛");
}
}else{
System.out.println("淘汰");
}
}
}
package com.home;
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入月份:");
int month = scanner.nextInt();
if (month >= 1 && month <= 12) {
System.out.println("请输入年龄：");
int age = scanner.nextInt();
if (month >= 4 && month <= 10) {
//旺季
int price = 60;
if (age > 60) {
System.out.println("票价：" + price / 3);
} else if (age > 18) {
System.out.println("票价：" + price);
} else if (age > 0 && age < 18) {
System.out.println("票价：" + price / 2);
} else {
System.out.println("年龄输入错误！");
}
} else {
//淡季
int price = 40;
if (age >= 18){
System.out.println("票价：" + price);
}else {
System.out.println("票价：" + price / 2);
}
}
}else {
System.out.println("年份输入错误！");
}
}
}
switch分支结构
switch穿透性
package com.home;
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入字符 :");
char day = scanner.next().charAt(0);
switch (day){
case 'a':
System.out.println("星期一");
break;
case 'b':
System.out.println("星期二");
break;
case 'c':
System.out.println("星期三");
break;
case 'd':
System.out.println("星期四");
break;
case 'e':
System.out.println("星期五");
break;
case 'f':
System.out.println("星期六");
break;
case 'g':
System.out.println("星期七");
break;
default:
System.out.println("输入错误！");
}
System.out.println("swtich已退出");
}
}
如果default写在最后，default后面有没有break不重要了，没有也会退出
swtich注意事项和细节讨论
1.数字1也是字符，所以char a = ‘1’;char和int是可以相互转换的
2.下图满足细节一，表达式返回类型和char的常量类型一致，都是double，但是不满足细节2,表达式返回类型不能使用double
3.case的值必须是常量，‘a’也是常量
4.当整个swtich语句的表达式在匹配时没有匹配到对应的case，则执行default,如果default没写，则程序不执行任何case语句，不报错
5.穿透性，没写break就继续执行下面的语句
练习
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入字母（a~e） :");
char a = scanner.next().charAt(0);
switch (a){
case 'a':
System.out.println('A');
break;
case 'b':
System.out.println('B');
break;
case 'c':
System.out.println('C');
break;
case 'd':
System.out.println('D');
break;
case 'e':
System.out.println('E');
break;
default:
System.out.println("输入错误！");
}
System.out.println("swtich已退出");
}
}
import java.util.Scanner;
public class Test {
public static void main(String[] args) {//核心思路，用成绩/60取整
Scanner scanner = new Scanner(System.in);
System.out.println("请输入成绩 :");
double score = scanner.nextDouble();//注意成绩是用double接收
if (score >= 0 && score <= 100){
int a = (int)score/60;
switch (a){
case 0:
System.out.println("不合格");
break;
case 1:
System.out.println("合格");
break;
}
}
}
}
public class Test {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入月份 :");
int month = scanner.nextInt();
if (month <= 12 && month >= 1){
switch (month){
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;
case 12:
case 1:
case 2:
System.out.println("冬季");
break;
}
}
}
}
什么时候用swtich和if？
swtich什么时候用？
表达式不能用浮点型，适用类型有enum枚举,byte,short,int,char和String
参数不多，而且数据类型符合swtich表达式的类型
if什么时候用？
结果为boolean
区间判断，例如>1或者<5,结果需要为boolean类型的时候
for循环控制
for循环里面最后一个语句，写++i和写i++有什么区别么?
我的理解
把for循环拆分出来看，其实就是四个顺序（1->2->4->3）执行的条件
如果for(int i = 0;i < 2;i++){语句块}
按照顺序就是
1.变量参数int i = 0
2.循环条件i < 2
3.待执行的操作（ 语句块）
4.参数运算i++
这里可以看出，如果是自增或自减运算，++i和i++没有区别，因为是单独执行
内存分析法
把循环变量 int i = 0写到外面的作用域更大，i++也可以写到循环体里
public class Test {
public static void main(String[] args) {
int count = 0;
int sum = 0;
int stare = 1;
int end = 100;
int t = 5;
for (int i = stare; i <= end; i++) {
if (i % t == 0){
System.out.println(i);
count++;
sum += i;
}
}
System.out.println("count = " + count);
System.out.println("sum = " + sum);
}
}
练习
我的写法
老师的写法复用性更好，比如需要修改参数，那么我的写法就没用了；
化繁为简，先死后活
while循环
i最后等于11
public class Test {
public static void main(String[] args) {
int i = 1;
while (i <= 100){
if (i % 3 == 0){
System.out.println(i);
}
i++;//循环的迭代卸载if外面
}
System.out.println("##");
int n = 40;
int m = 200;
while (n <= m){//先把m写死利于思考
if (n % 2 == 0){
System.out.println(n);
}
n++;
}
}
}
do while
至少执行一次
练习
int n = 1;
int m = 200;
int count = 0;
do {
if (n % 5 == 0 && n % 3 != 0){//先把m写死利于思考
count++;
}
n++;
} while (n <= m);
System.out.println(count);
Scanner scanner = new Scanner(System.in);
char lsp;
do {
System.out.println("闪电五连鞭！piapiapia");
System.out.println("韩顺平：给不给？（y/n）");
lsp = scanner.next().charAt(0);
}while (lsp == 'n');
System.out.println("给还不行吗~");
多重循环控制
内层循环一遍完了j=3，为false，不输出，跳出内存，i++ 等于1，又进入内存，j又重新定义，j=0
练习
1.2.
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
double socre;
double sumclass = 0.0;
int a = 3;
int b = 5;
int num = 0;
for (int i = 1; i <= a; i++) {
double sum = 0.0;
for (int j = 1; j <= b; j++) {
System.out.println("请输入学生成绩：");
socre = scanner.nextDouble();
sum += socre;
sumclass += socre;
if ((int)socre / 60 == 1){
num++;
}
}
System.out.println(i + "班的平均分为：" + sum / b);
}
System.out.println("所有班级的平均分为：" + sumclass / (a * b));
System.out.println("三个班的及格人数为：" + num + "人");
}
}
九九乘法表
for (int i = 1; i <= 9; i++) {
for (int j = 1; j <= i; j++) {
System.out.print(j + " * " + i + " = " + j * i + "\t");
}
System.out.println();
}
1.化繁为简
把整个设计思路拆分为每一个小部分，小部分做起来很轻松，然后一层一层往上加
第一步
先设计出矩形星星，这里用两层for嵌套即可
第二步
把矩形变成三角形，直接用j<i
第三步
把内层变成13579，按照2* i - 1的规律（看图得）
第四步
内层输出前面输出空格，空格的数量根据 层数-1来设定（看图得），怎样才能在内层输出之前输出呢，就在内层前在加个for输出
第五步
抛空，只第一个星星和最后一个星星
第六步
添加判断，最后一行中间不用抛空，当运行到最后一行正常输出即可
2.先死后活
把层数i设为变量，可以随时改变三角形的大小，修改大小只需要修改变量值即可，效率高
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入数字：");
int a = scanner.nextInt();
for (int i = 1; i <= a; i++) {
for (int k = 0; k < a - i; k++) {
System.out.print(" ");
}
for (int j = 1; j <= 2 * i - 1; j++) {
if (j == 1 || j == 2 * i - 1 || i == a){
System.out.print("*");
}else {
System.out.print(" ");
}
}
System.out.println();
}
}
}
还真是想了半天，我太菜了┭┮﹏┭┮
public class Test {
public static void main(String[] args) {
int a = 5;
for (int i = 1; i <= a; i++) {
for (int k = 1; k <= a - i ; k++) {
System.out.print(" ");
}
for (int j = 1; j <= 2 * i - 1; j++) {
if (j == 1 || j == 2 * i - 1){
System.out.print("*");
}else {
System.out.print(" ");
}
}
System.out.println(" ");
}
for (int i = a - 1 ; i >= 1 ; i--) {
for (int k = 1 ; k <= a - i ; k++) {
System.out.print(" ");
}
for (int j = 2 * i - 1; j >= 1 ; j--) {
if (j == 2 * i - 1 || j == 1 ){
System.out.print("*");
}else {
System.out.print(" ");
}
}
System.out.println(" ");
}
}
}
改进版本
package com.home;
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入：");
int a = scanner.nextInt();
for (int i = 1; i <= a; i++) {
for (int k = 1; k <= a - i ; k++) {
System.out.print(" ");
}
for (int j = 1; j <= 2 * i - 1; j++) {
if (j == 1 || j == 2 * i - 1 || j == i){
System.out.print("*");
}else if (i == a){
if (j % 2 != 0){
System.out.print("*");
}else {
System.out.print(" ");
}
} else {
System.out.print(" ");
}
}
System.out.println(" ");
}
for (int i = a - 1 ; i >= 1 ; i--) {
for (int k = 1 ; k <= a - i ; k++) {
System.out.print(" ");
}
for (int j = 2 * i - 1; j >= 1 ; j--) {
if (j == 2 * i - 1 || j == 1 || j == i){
System.out.print("*");
}else {
System.out.print(" ");
}
}
System.out.println(" ");
}
}
}
break
是结束最近的循环，不是退出去，外层的循环继续执行, 如果没有标签，则退出最近的循环体
默认break 等价于 break abc2;
如果写成break abc1;
j = 0,i = 2
控制台输出
i = 0
i = 1
练习
public class Test {
public static void main(String[] args) {
int sum = 0;
for (int i = 1; i <= 100 ; i++) {
System.out.println(i);
sum += i;
if (sum > 20){
System.out.println("当sum大于20,此时的值为" + i + ", sum = "+ sum);
break;
}
}
//System.out.println("sum = " + sum);
}
在循环外输出变量i 的方法
1.将循序中变量在外部定义
int i = 0;
for(; i <= 100 ;i++){}
2.在外部定义一个新的变量，在循环体被将i赋值给n ，最后输出n
for(int i = 0; i <= 100 ;i++){
n = i;
}
package com.home;
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
for (int i = 1; i <= 100 ; i++) {
int count = 3 - i;
System.out.println("请输入用户名：");
String username = scanner.nextLine();
System.out.println("请输入密码：");
String password = scanner.nextLine();
System.out.println("用户名：" + username);
System.out.println("密码：" + password);
if (username == "丁真" && password == "666"){
System.out.println("登录成功！");
break;
}else {
if (i <= 2){
System.out.println("用户名或密码输入错误（还有" + count + "次机会）");
}else if (i == 3){
System.out.println("账户封禁30天");
break;
}
}
}
}
}
这里一直判断失败，我感觉是scanner.nextLine()的问题，换成next()也没用
最后只能调用equals来判断才成功，
==和equals的区别到底是？
==
基本数据类型（byte/int/short/long/float/double/boolean/char）==是比较的值
引用数据类型是比较的堆内存的地址
equals 一般字符串比较
equals源码是比较的地址，但是String重写了equals方法，使其比较 值的内容是否相等
第二种写法可以避免空指针，后面异常会讲
package com.home;
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
for (int i = 1; i <= 100 ; i++) {
System.out.println("请输入用户名：");
String username = scanner.nextLine();
System.out.println("请输入密码：");
String password = scanner.nextLine();
if (username.equals("丁真") && password.equals("666")){
System.out.println("登录成功！");
break;
}else {
if (i <= 2){
System.out.println("用户名或密码输入错误（还有" + (3 - i) + "次机会）");
}else if (i == 3){
System.out.println("账户封禁30天");
break;
}
}
}
}
}
用户名密码错误输入示范
老是的写法是真的细致，特别是这个次数count的写法
continue
结束本次的循环，直接到i++，开始下一次
**在for循环里，如果执行continue则不会执行下面的语句，直接执行i++部分，开始下一层循环
这题目真好啊，老师讲了我才明白
i = 1，i++ 得 2，continue直接开始第二次while循环，i=2,i++ 得3,输出i=3 ，开始第三次循环，i=3，i++得4，输出4，第四次循环，i=4,i++得 5输出我i=5 不<=4,while结束
控制台输出
i=3
i=4
i=5
return
因为return是在main方法里面，所有直接退出程序，不会执行下面的go on
本章作业
public class Test {
public static void main(String[] args) {
int money = 100000;
int count = 0;
while (money > 50000){
money -= money * 5 / 100;
count++;
if (money <= 50000) break;
}
while (money <= 50000 && money >= 1000){
if (money < 0) break;
money -= 1000;
count++;
}
System.out.println("经过了" + count + "个路口");
}
}
1.money应该是double类型
2.每次扣百分之五可以转化一下*0.95
3.一个while更简洁
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入整数：");
int number = scanner.nextInt();
if (number > 0){
System.out.println(">0");
}else if (number == 0){
System.out.println("=0");
}else {
System.out.println("<0");
}
}
}
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入年份：");
int year = scanner.nextInt();
if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0){
System.out.println("是闰年");
}else {
System.out.println("不是闰年");
}
}
}
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入一个三位数：");
int number = scanner.nextInt();
//153
int unit = number % 10;
int ten = (int)(number % 100 / 10);
int hundredth = (int)(number / 100);
if (number == (unit * unit * unit + ten * ten * ten + hundredth * hundredth * hundredth)){
System.out.println("是水仙花数");
}
}
}
啥也不输出
public class Test {
public static void main(String[] args) {
int count = 0;
for (int i = 1; i <= 100 ; i++) {
if (i % 5 != 0){
count++;
System.out.print(i + " ");
if (count % 5 == 0) System.out.println();
}
}
}
}
public class Test {
public static void main(String[] args) {
for (int i = 97; i <= 122 ; i++) {
char a = (char) i;
System.out.println(a);
}
for (int i = 65; i <= 90 ; i++) {
char a = (char) i;
System.out.println(a);
}
}
}
for循环中直接用char定义变量
public class Test {
public static void main(String[] args) {
double sum1 = 0;
double sum2 = 0;
for (int i = 1; i <= 100; i++) {
if (i % 2 == 0){
sum1 += 1.0 / i;
}
}
for (int i = 1; i <= 100; i++) {
if ((i + 1) % 2 == 0){
sum2 += 1.0 / i;
}
}
System.out.println(sum2 - sum1);
}
}
代码写完要优化啊
必须用1.0，如果用整数1则1/2…所有的分数结果为0
public class Test {
public static void main(String[] args) {
int sum = 0;
for (int i = 1; i <= 100; i++) {
for (int j = 1; j <= i; j++) {
System.out.print(j + " ");
sum += j;
}
System.out.println(" ");
}
System.out.println(sum);
}
}
用一个for，两次累加
public class Test {
public static void main(String[] args) {
int sum1 = 0;
int sum2 = 0;
for (int i = 1,j = 1; i <= 100; i++,j++) {
sum1 += j;
sum2 += sum1;
}
System.out.println(sum2);
}
}
听懂和会做是两码事，一定勤加练习
数组Array
int i = 0;i < 6能更好表达总数
所以不要这么写
int i = 0;i <= 5
知识点总结：
1.数组是引用类型
2.下标从0开始
3.数组长度 数组名.length
格式
空指针异常
只声明了数组，但是没有new，此时数组为null
怎样使用数组？
1.数组元素已知
静态初始化
2.元素未知
先new出来数组，在一个个赋值
实际开发中根据需求来使用
数组注意事项和细节
1.还是精度转换的问题，低精度不能接收高精度，精度不兼容
例：double转int或者String转int
练习
public class Test {
public static void main(String[] args) {
char array[] = new char[26];
for (char i = 'A',j = 0; i < 'A' + array.length; i++,j++) {
array[j] = i;
System.out.println(array[j]);
}
}
}
如果只是获得最大值
public class Test {
public static void main(String[] args) {
int[] arr = {4,-1,9,10,23};
int max = 0;
for (int i = 0; i < arr.length; i++) {//0,1,2,3,4
if (max < arr[i]){
max = arr[i];
}
}
System.out.println(max);
}
}
如果还需要获得index
public class Test {
public static void main(String[] args) {
int[] arr = {4,-1,90,10,23};
int[] max = new int[1];
int maxIndex = 0;
for (int i = 0; i < arr.length; i++) {//0,1,2,3,4
if (max[0] < arr[i]){
max[0] = arr[i];
maxIndex = i;
}
}
System.out.println(max[0] + "+" + maxIndex);
}
}
public class Test {
public static void main(String[] args) {
int[] arr = {4,-1,9,10,23};
int sum = 0;
int average = 0;
for (int i = 0; i < arr.length; i++) {//0,1,2,3,4
sum += arr[i];
average = sum / arr.length;
}
System.out.println(sum);
System.out.println(average);
}
}
数组赋值机制
地址拷贝/引用传递
数组在默认情况下是引用传递，赋的值是地址，赋值方式为引用赋值
数组赋值是 地址拷贝/引用传递/引用赋值
引用传递
在内存中只要分配了数据空间，一定会对应一个地址
数组拷贝
public class Test {
public static void main(String[] args) {
int[] arr1 = {10,20,30};
int[] arr2 = new int[arr1.length];
for (int i = 0; i < arr1.length; i++) {
arr2[i] = arr1[i];
}
}
}
数组反转
方式1
方式2
public class Test {
public static void main(String[] args) {
int[] arr1 = {10,20,30};
int[] arr2 = new int[arr1.length];
for (int i = arr1.length - 1,j = 0; i >= 0; i--,j++) {
arr2[j] = arr1[i];
}
arr1 = arr2;
}
}
数组添加
我这里不用定义num，老师的方法更简洁，直接把+1写死，然后用赋值用新数组的长度-1赋值，比我的思路更好
public class Test {
public static void main(String[] args) {
int[] arr1 = {1,2,3};//3
char answer;
Scanner scanner = new Scanner(System.in);
do {
int num = 1;
int arr2[] = new int[arr1.length + num];//5
for (int i = 0; i < arr1.length; i++) {
arr2[i] = arr1[i];
}
System.out.println("请输入");
arr2[arr1.length - 1 + num] = scanner.nextInt();
num++;
arr1 = arr2;
System.out.println("是否继续添加（y/n）:");
answer = scanner.next().charAt(0);
}while (answer == 'y');
}
}
老师思路：
化繁为简，先把死的写出来
再加上输入
数组缩减
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
/*
思路：
1.new新数组，长度为旧数组length-1
2.遍历旧数组给新数组赋值
3.把新数组引用传递给旧数组
*/
int arr[] = {1,2,3,4,5};//特别注意,这里需要放在循环外面，避免每次循环又从新讲数组定义
do {
Scanner scanner = new Scanner(System.in);
int arrNew[] = new int[arr.length - 1];
for (int i = 0; i < arrNew.length; i++) {
arrNew[i] = arr[i];
}
arr = arrNew;
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t");
}
System.out.println("是否继续缩减?(y/n)");
char answer = scanner.next().charAt(0);
if (answer == 'n' || arr.length == 1) break;
}while (true);
}
}
排序
冒泡排序
public class Test {
public static void main(String[] args) {
/*
思路：
1.冒泡法的排序思路，每两个数进行比较，其最大值右移，通过比较，每一轮的最大值右移至最后一位，比较需要n-1轮（n为数组length），5个数比较4轮即可
2.每一轮比上一轮少比较一次（因为每一轮会把最大值移动至末尾，所以每一轮的最大值不需要在下一轮进行再次比较）,第一轮比较次数为n-1次（五个数比较出最大值只需要四次），后面每一轮再-1
3.需要两层for，外层代表总轮数，外层次数为length-1（n个数比较n-1次即可得出最大值）
4.内存for，定义 i=0 ,次数为length - 1 - i
5.两数比较，最大值右移，如果最大值在左边需要交换位置（需要定义一个temp来做中间量）
*/
int[] arr = {24,69,80,57,13};
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");
}
}
}
优化，如果发现该次排序一次都没有交换，则终止程序
思路：定义一个计数器变量，每一轮开始前刷新为0，把计数器放在比较大小交换的语句块里，如果这一轮一次都 没有交换，说明已经不用排序了，则计数器也不会变化，所以如果计数器count一轮比较后还是等于0，则 无需再比较，直接break
package com.home;
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
int[] arr = {1,2,7,6,5};
for (int i = 0; i < arr.length - 1; i++) {
int count1 = 0;
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;
count1++;
}
}
if (count1 == 0) break;
for (int k = 0; k < arr.length; k++) {
System.out.print(arr[k] + "\t");
}
System.out.println();
}
}
}
查找
二维数组
每一个数组里面又是一个数组
1.如果要访问第3行数组的第2个值，应该写arr[2] [1]
2.外层for是二维数组的长度，arr.length
3.内存for是二维数组中的一维数组的长度，arr[i].length表示二维数组的元素的长度，就等于一位数组的长度
二维数组的使用
注意第一个一维数组的大小为1，第二个为2…
直接按着上面的数据写就行，不需要Scanner
不要想复杂了
**重点在给每一个一维数组开辟空间 arr[i] = new int[1 + i]
不开辟空间就是null
public class Test {
public static void main(String[] args) {
/*
1
2 2
3 3 3
*/
int arr[][] = new int[3][];
//给每一个一维数组的长度赋值
for (int i = 0; i < arr.length; i++) {
//第一个一维数组的长度为1...
arr[i] = new int[1 + i];//1,2,3...
}
//给一维数组的每个元素赋值，根据元素个数
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length ; j++) {
arr[i][j] = 1 + i;
}
}
//遍历输出
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length ; j++) {
System.out.print(arr[i][j] + " ");
}
System.out.println();
}
}
}
静态初始化
二维数组的每一个元素都是一维数组
练习
public class Test {
public static void main(String[] args) {
int arr[][] = {{4,6},{1,4,5,7},{-2}};
int sum = 0;
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
sum += arr[i][j];
}
}
System.out.println(sum);
}
}
杨辉三角
public class Test {
public static void main(String[] args) {
/*
杨辉三角
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
...
*/
int[][] arr = new int[10][];
//给每一个一维数组赋值
for (int i = 0; i < arr.length; i++) {//arr[i].length,二维数组中第i个一维数组的长度
//定义一维数组的大小
//第一行有一个元素，第n行有n个元素
arr[i] = new int[1 + i];//new的作用是给每一个一维数组开辟空间
for (int j = 0; j < arr[i].length; j++) {
/*
赋值规则：
1.每一行第一个元素和最后一个元素为1
2.从第3行开始,第一行和最后一行元素为1除外,
其余每一个元素arr[i][j]的值为arr[i-1][j-1] + arr[i-1][j]
*/
if (j == 0 || j == arr[i].length - 1){
arr[i][j] = 1;//定义一维数组元素为1
}else {
arr[i][j] = arr[i - 1][j - 1] + arr[i - 1][j];
}
}
}
//遍历输出二维数组
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
System.out.print(arr[i][j] + " ");
}
System.out.println();
}
}
}
二维数组使用细节和主要事项
1.格式可以为int[] arr[]或者int arr[] []
2.二维数组中一维数组的长度可以不一致
二维数组的练习
1531
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
