DAY03 DAY03 - 锐客网

DAY03 1 流程控制 1.1 Scanner
1.1.1 基本使用基本语法：Scanner scanner = new Scanner(System.in);
通过next()与nextLine()来获取字符串，通过hasNext()与hasNextLine()判断是否还有输入的数据

Scanner scanner = new Scanner(System.in);
String string;
if(scanner.hasNext())
//使用next进行输入，读取后续内容
//有效字符之前的空格会去掉，遇到有效字符后，在第一个空格处停止
string = scanner.next();
?
if(scanner.hasNext())
//使用nextLine进行输入，读取下一行的内容
string = scanner.nextLine();
?
//io流，结束时将之关闭
scanner.close();

1.1.2Scanner进阶使用

Scanner scanner = new Scanner(System.in)
int i = 0;
float f = 0.0;
//输入整数
if(scanner.hasNextInt()){
i = scanner.nextInt();
}
//输入浮点数
if(scanner.hasNextFloat()){
i = scanner.nextFloat();
}
scanner.close();

1.2 控制结构
1.2.1 顺序不可或缺
1.2.2 选择

if单选择：if……
if双选择：if……else
if多选择结构：if……else if……else if……else
if嵌套
switch多选择结构

//exp可以是byte、short、int或char，javase7开始支持String（底层通过hashCode()实现）
switch(exp){
//case后必须为常量
case valuea:
xxx;
break; //可选，遇到会跳出switch
case valueb:
xxx;
break;
dafault:
xxx;
}

idea如何反编译？
1.2.3 循坏

while：先判断后执行
do-while：先执行后判断，至少执行一次
for：最有效最灵活的循环
idea输入100.for自动帮忙输出for(int i = 0; i < 100; i++){}
增强for循坏：用于数组、集合和列表等

int[] num = {10,20,30,40,50};
//遍历数组中的元素
for(int x:num){
System.out.println(x);
}

break、continue和goto
break强制退出break所在的当前循环，跳出去下面的语句
continue终于一个循环的这一次循环过程，跳转至循环条件判断处
goto：用label标签实现，不需过多了解

2. Java方法方法是语句的集合，可以完成一个特定的功能。
补充（static）：

用来修饰成员变量和成员方法，被修饰的成员是属于类的，而不是单单是属于某个对象的。意味着它为该类的所有实例所共享，也就是说当某个类的实例修改了该静态成员变量，其修改值为该类的其它所有实例所见。既然属于类，就可以不靠创建对象来调用了。
类变量：当 static 修饰成员变量时，该变量称为类变量。该类的每个对象都共享同一个类变量的值。任何对象都可以更改该类变量的值。
静态方法：当 static 修饰成员方法时，该方法称为静态方法。静态方法在声明中有 static ，可直接使用类名来调用。可以在main方法中不创建对象地直接调用。
引用自：https://segmentfault.com/a/1190000021768849
作者：叶文洁

2.1 方法定义

修饰符
返回值类型
方法名
参数类型
- 实参
- 形参

方法体

定义格式：
修饰符返回值类型方法名(形参表){
方法体
}

2.2 方法的重载
一个类中，名字相同，而参数不同（参数列表不同）的两个方法。返回类型可以相同也可以不同。

2.3 命令行传参
javac 与java命令行注意事项：
可以直接去Xxx.java文件所在目录用：javac Xxx.java来编译
但是必须切换到最外层包所在src处用：java pkg.Xxx来运行
其中，运行时可以后接命令行参数，如：
java pkg.Xxx wo ai ni

//args数组会存储命令行参数 wo ai ni
public static void main(String args[]){
//依次换行输出wo ai ni
for(String i:args){
System.out.println(i);
}
}

2.4 可变参数
java1.5后新特性

public static void main(String[] args){
int i = new Xxx.test(1,2); //会输出3
}
//...代表可变参数，即i可以是任意多个的int数，可理解为数组
//只能指定一个可变参数，并且必须放在参数表的最后一个
public void test(int... i){
System.out.println(i[0]+i[1]);
}

2.5递归
某个方法自己调用自己，注意：必须要在满足一定条件的时候停止调用自己。

递归头
不调用自己的语句
递归体
调用自己的语句

减少使用递归！！！
3. 数组相同类型若干数据的有序集合

3.1 数组的声明与创建
定义格式：dataType[] array = new dataType[len];

//声明
//首选
int[] nums;
//次选，可以用，但不用
//int nums[];
?
//创建
nums = new int[10]; //可以存10个int值
?
//赋值,未赋值默认未0，引用类型默认为null
nums[0] = 1;
?
//获取数组长度
int len = nums.length;

3.2 Java内存

堆
- 存放new的对象和数组
- 可被所有线程共享，不会存放别的对象引用
栈
- 存放基本类型变量
- 引用对象的变量：引用在堆里的具体地址
方法区
- 可被所有线程共享
- 包含了所有的class和static变量

一个例子

声明数组

文章图片

创建数组

文章图片

给数组元素赋值

文章图片

Java的数组会有越界检查：ArrayIndexOutOfBoundsException

3.3 数组初始化

//静态初始化
int[] a = {1,2,3,4,5};
?
//动态初始化:其中每个元素的默认值同变量各类型默认值一致
//如：int为0，float为0.0，非基本类型为null
int[] b = new int[10];

3.4 数组特点

数组大小固定的，一经确定不可改变

数组属于引用类型
数组本身就是对象，Java中的对象是在堆中，故数组对象本身是在对中
数组的引用（地址）在栈中

idea中使用数组名.for 自动补全增强的for-each循环

3.5 使用数组

数组可做参数
数组可做返回值

3.6 多维数组
如二维数组：数组中的元素又是一个数组

//声明加静态初始化
int[][] array = {{1,2},{3,4}};
?
//动态初始化
int[][] array1 = new int[3][4];

3.7 Arrays类

其中的方法都是static修饰的，使用的时候可以直接使用类名来调用，而不用新建对象来调用
常用功能
- toString(array):将数组转化为String
- sort(array):将数组升序排序
- equals：比较数组中元素是否相等
- binarySearch:对排序好的数组进行二分查找
- fill(array,value):将数组中数组填充为value，也可以重载填充指定位置

3.8 冒泡排序
两层循环，外层轮数，内层比较

int[] a = {1,3,6,5,8,9,7};
//判断一共有多少轮
for(i = 0; i
//优化标志
boolean flag = false;

//比较相邻两个数，满足条件时交换相应位置的值
for(j=0; j//>为降序排序，改为<择为升序排序
if(a[j+1]>a[j]){
int temp;
temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;

flag = true; //发生交换则将flag置为true
}
}
//flag为false时，说明值没有发生交换，顺序已经排好了,结束
if(flag == flase){
break;
}
}

3.9 稀疏数组

概念：数组中大部分值相同（为0，或为同一值）时，可使用稀疏数组来保存该数组；
处理方式
- 记录一共有几行几列，有多少个不同的值
- 把具有不同值的元素的行列及值记录在一个小规模的数组中从而缩小程序规模

如图：

文章图片

注意，第一个元素存储的时原数组中的行列数以及有多少个除0外的不同值。后续元素存放的是，每一个不同值的位置以及其值。

int[][] a = new int[6][7];
a[0][3] = 22;
a[0][6] = 15;
a[1][1] = 11;
a[1][5] = 17;
a[2][3] = -6;
a[3][5] = 39;
a[4]0] = 91;
a[5][2] = 28;
?
//将原始数组转化为稀疏数组
int num = 0;
//1.记录有多少个不为0的数
for(int i = 0; i< a.length-1; i++){
for(int j = 0; j < a[i].length-1; j++){
if(a[i][j] != 0) num++;
}
}
?
//2.创建稀疏数组
int[][] b = new int[num+1][3];
?
//3.首元素
b[0][0] = a.length; //行数
b[0][1] = a[0].length; //列数
b[0][2] = num; //有多少个不为0的数
?
//4.记录后续元素
num = 0;
for(int i = 0; i< a.length; i++){
for(int j = 0; j < a[i].length; j++){
if(a[i][j] != 0){
num++;
b[num][0] = i; //不为0元素所在行
b[num][1] = j; //不为0元素所在列
b[num][2] = a[i][j]; //不为0元素的值
}
}
}
?
//将稀疏数组还原
//1.创建稀疏数组
int[][] c = new int[b[0][0]][b[0][1]];
?
//2.还原它的值
for(int n = 1; n <= b[0][2]; n++){
int i = b[n][0]; //不为0的元素所在行
int j = b[n][1]; //不为0的元素所在列
int v = b[n][2]; //不为0的元素的值
c[i][j] = v; //将对应值还原到对应位置
}