JAVA-02（语法介绍）
JAVA-02
Java流程控制
用户交互Scanner
Scanner类
属于IO流的类如果不关会一直占用资源
常用方法
【Scanner scanner = new Scanner(System.in);】
.next(); 遇到空格就结束接收
.nextLine(); 遇到enter就结束接收
.hasNext() 判断是否有输入
.hasNextInt() 判断是否有整数输入
.close(); 关闭
举例【instance】
package com.xy.base;
import java.util.Scanner;
public class Demo11 {
public static void main(String[] args) {
//创建一个扫描对象，用于接收键盘数据
Scanner scanner = new Scanner(System.in);
System.out.println("使用next方式接收：");
//判断用户有没有输入字符串
if(scanner.hasNext()){
//使用next接收
String str = scanner.next();
System.out.println("输入的内容为："+str);
}
System.out.println("使用nextLine方式接收：");
if(scanner.hasNext()){
//使用next接收
String str1 = scanner.nextLine();
System.out.println("输入的内容为："+str1);
}
System.out.println("请输入一个整数:");
//判断输入的是否为整数【判断是否有整数输入】
if(scanner.hasNextInt()){
int i = scanner.nextInt();
System.out.println("输入的整数为："+i);
}else{
System.out.println("输入的不是整数！");
}
//凡是属于IO流的类如果不关会一直占用资源
scanner.close();
}
}
输入多个数字，并求其总和与平均值，每输入一个数字用回车确认，通过输入非数字来结束并输出执行结果
package com.xy.base;
import java.util.Scanner;
public class Demo11_instance {
public static void main(String[] args) {
//输入多个数字，并求其总和与平均值，每输入一个数字用回车确认，通过输入非数字来结束并输出执行结果
int count = 0;
double sum = 0;
Scanner scanner = new Scanner(System.in);
System.out.println("请输入数据：");
//while判断是否是数字输入
while (scanner.hasNextDouble()){
count++;
sum = sum + scanner.nextDouble();
}
System.out.println(count + "个数据总和为：" + sum);
System.out.println(count + "个数据平均数为：" + sum/count);
//关闭！！！！！！不要忘记
scanner.close();
}
}
三种结构（顺序、选择、循环）
顺序结构
- Java最基本的结构，最简单的算法结构
- 任何算法都离不开的
- 一条一条从上到下执行
System.out.println("顺序结构！");
System.out.println("顺序结构！");
System.out.println("顺序结构！");
选择结构
1. if单选择结构
if(条件式){
//满足表达式执行的语句
}
2. if...else双选择结构
if(条件式){
//满足表达式执行的语句
}else{
//不满足表达式执行的语句
}
3. if...else if多选择结构
if(条件式1){
//满足表达式1执行的语句
}else if(条件式2){
//满足表达式2执行的语句
}else{
//都不满足执行的语句
}
4. 嵌套的if结构
if(条件式1){
if(条件式1){
//满足表达式1和2执行的语句
}
}else{
//不满足表达式1执行的语句
}
5. switch多选择结构
-
语法：
switch(expression){ //expression变量 case value: //【可选】判断变量的值是否等于value值 //语句 break; //【可选】 若不选，会有case穿透效果 case value: //语句 break; ... default: //【可选】 以上case都不满足时执行default //语句 } -
case穿透效果：如果当前case满足且结束没有break语句，那么将会执行下面所有的case，直到遇见break语句。
-
switch中的变量类型 ：byte、short、int或者char
-
从Java SE7开始支持字符串String类型
String x = "注意"; switch (x){ case "注意": System.out.println("注意"); case "协议": System.out.println("协议"); break; default: System.out.println("default"); }
循环结构
1. while循环
-
语法
while(布尔表达式){ //循环内容 }
2. do...while循环
-
语法
do{ //循环内容 }while(布尔表达式); -
while和do...while的区别
- while先判断再执行，do...while先执行在判断
- do...while至少执行一次，while可以一次也不执行
3. for循环
-
语法
for(初始化;布尔表达式;更新){ //循环内容 } -
最有效，最灵活的循环结构
-
循环次数是在执行之前就已经确定的
-
fou循环 ：先初始化，在判断真假，若为真则执行循环体，然后更新；若为假，则跳出循环
for (int i = 0; i < 5; i++) { System.out.println("i:" + i); System.out.println("第" + i + "次循环！"); } -
练习：打印九九乘法表
for(int i = 1 ; i < 10 ; i ++){ for (int j = 1 ; j <= i ; j ++){ //输出乘法并输出一个tab空格 System.out.print(j + "*" +i +"=" + j*i + "\t"); } //换行 System.out.println(); //等价于 System.out.print("\n"); } -
增强for循环【遍历数组】Java5引入的
int[] num = {10,20,30,40,50}; for(int n:num){ System.out.println(n); }
break&continue
-
break 强制退出循环
int i = 0; while(i < 100){ i++; if(i == 10){ break; } System.out.println(i); } -
continue 跳出本次循环，执行下一次【怂】
int j = 0; while (j < 10){ j++; if (j%2 == 0) { continue; } System.out.println(j); }
练习：打印三角形
public class Demo13_instance {
public static void main(String[] args) {
//规定5行
for(int i = 1 ; i <= 5 ; i ++){
//打印空的倒直角三角形
for(int j = 5 ; j >= i ; j --){
System.out.print(" ");
}
//打印正直角三角形
for (int j = 1 ; j <= i ; j ++){
System.out.print("*");
}
//打印关于另一半直角三角形
for(int j = 1 ; j <= i ; j ++){
System.out.print("*");
}
//换行
System.out.println();
}
}
}
运行输出：
方法（Java只有值传递）
介绍
- 方法是解决一类问题的步骤的有序集合
- 方法包含于类或对象中
- 方法在程序中创建，在其他地方被引用
- 一个方法最后只做一个功能，方便扩展
修饰符 返回值类型 方法名（参数类型 参数名）{
方法体
return 返回值; //返回返回值；终结方法
}
- 形参【形式参数】：在写方法时，在括号中的参数名，这里其实就是一个**占位符**
- 实参【实际参数】：在使用方法时，给方法传的参数
方法重载
- 定义：在一个类中，方法名相同，参数【形参】不同，返回值可同可不同
- 只是返回值不同，不构成重载
- 在执行时，编译器会根据调用方法的参数个数、参数类型去逐个匹配，如匹配出错，编译器报错
package com.xy.base;
public class Demo21 {
public static void main(String[] args) {
System.out.println(max(10,20));
System.out.println(max(10,20.1));
}
public static double max(double x , double y){
if (x > y){
return x;
}else if (x < y){
return y;
}else {
System.out.println("x=y");
return x;
}
}
public static int max(int x , int y){
if (x > y){
return x;
}else if (x < y){
return y;
}else {
System.out.println("x=y");
return x;
}
}
}
命令行传参
package com.xy.base;
public class Demo22 {
public static void main(String[] args) {
for (int i=0 ; i < args.length ; i++){
System.out.println("arg[" + i + "]" + args[i]);
}
}
}
①编译文件
②运行文件这里注意找对文件位置
③传递参数
④运行结果【打印】
可变参数【jdk1.5 引入】
-
在方法声明中，指定参数类型后加一个省略号（...）
-
一个方法只能指定一个可变参数，它必须是方法的最后一个参数
package com.xy.base; public class Demo23 { public static void main(String[] args) { Demo23 demo23 = new Demo23(); demo23.test(1,2,3,4,5); } public void test(int... i){ System.out.println(i[0]); } }
递归
-
自己调自己
-
一定要有出口【不可以一直递归，Java是栈机制，容易栈满】
package com.xy.base; public class Demo24 { //求阶乘 public static int f(int n){ if(n == 1){ return 1; }else{ return n*f(n-1); } } public static void main(String[] args) { System.out.println(f(25)); } }
数组
定义与使用
//定义数组 int nums2[]; 定义数组[c/c++风格]
int[] nums;
//分配空间
nums = new int[10];
//赋值
nums[0] = 1;
//二维数组
int[][] array = {{1,2},{1,3},{1,4}};
//遍历
for (int i = 0 ; i < array.length ; i ++){
for(int j = 0 ; j < array[i].length ; j ++){
System.out.print(array[i][j]+" ");
}
System.out.println();
}
使用
public class Demo32 {
public static void main(String[] args) {
int[] array = {1,2,3,4,5};
//打印数组
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
//计算所有元素的和
int sum = 0;
for (int i = 0; i < array.length; i++) {
sum = sum + array[i];
}
System.out.println("sum:"+sum);
//寻找数组中最大的数
int max = array[0];
for (int i = 1; i < array.length; i++) {
if(array[i] > max){
max = array[i];
}
}
System.out.println("max:"+max);
//forEach jdk1.5没有下标
for (int i : array) {
System.out.println(i);
}
//反转数组
int result[] = new int[array.length];
for(int i=0,j=array.length-1 ; i<array.length ; i++,j--){
result[j]=array[i];
}
//打印数组
System.out.println(Arrays.toString(result));
}
}
内存分析
- 堆：存放new的对象和数组；所有线程共享；不存放别的对象引用
- 栈：存放基本变量类型（包含这个基本类型的具体值）；引用对象的变量（会存放这个引用在堆里面的具体地址）
- 方法区：所有线程共享；包含所有的class和static变量
举例分析：
-
首先声明一个数组 ——> 栈中就有了这个数组的名字
-
然后给数组分配空间 ——> 堆中开辟了相应大小的空间
-
最后赋值 ——> 堆中的数组空间内开始有值
三种初始化状态
静态初始化:创建+赋值
int[] a = {1,2,3,4,5,6,7,8,9};
动态初始化
int[] b = new int[5];
b[0] = 1;
数组默认初始化
数组是引用类型，他的元素相当于类的实例变量，因此数组在一分配空间时就已经被默认初始为相应类型的默认值了。
数组的特点
- 数组一经创建就长度确定
- 同一数组元素类型相同
- 数组中的元素可以是任何数据类型
- 数组变量属于引用类型，数组也可以看成对象
- 数组对象本身是在堆中的
Arrays类（import java.util.Arrays）
学会使用官方API帮助文档，这里介绍两个
int[] array = {1,5,7,33,2,879};
//打印Arrays.toString()
System.out.println(Arrays.toString(array));
//排序
Arrays.sort(array);
System.out.println(Arrays.toString(array));
冒泡排序
public class Demo35_sort {
public static void main(String[] args) {
int[] array = {1,5,7,33,2,879};
sort(array);
System.out.println(Arrays.toString(array));
}
/**
* 冒泡排序
*/
public static int[] sort(int[] array){
int temp = 0;
for(int i = 0 ; i < array.length-1 ; i++){
boolean flag = false; //优化
for (int j = 0 ; j < array.length-1-i ; j++){ //因为经过i轮排序之后，后面的i个数据已经是有序的了，所以减掉i
if(array[j+1] < array[j]){
temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
flag = true;
}
}
if(flag == false){ //优化
break;
}
}
return array;
}
}
稀疏数组
-
定义：当一个数组中大部分元素都为0或同一数据时，可以使用稀疏数组来保存。
-
处理方式：
- 记录数组一共有几行几列，有多少个不同值
- 把具有不同值的元素的行和列以及值记录在一个小规模的数组中，从而缩小程序的规模
public class Demo36 {
public static void main(String[] args) {
//创建一个二维数组(原数组) 11*11 0:没有棋子 1：黑旗 2：白棋
int[][] array1 = new int[11][11];
array1[1][2] = 1;
array1[2][3] = 1;
System.out.println("输出原始数组:");
for(int[] ints : array1){
for(int anInt : ints){
System.out.print(anInt+"\t");
}
System.out.println();
}
//转换为稀疏数组保存
//获取有效值
int sum = 0;
for(int[] ints : array1){
for(int in : ints){
if(in != 0){
sum ++ ;
}
}
}
System.out.println("有效数值个数："+sum);
//创建一个稀疏数组
int[][] array2 = new int[sum+1][3];
array2[0][0] = 11;
array2[0][1] = 11;
array2[0][2] = sum;
//遍历数组，将非零值存放进稀疏数组
int count = 0;
for (int i = 0; i < array1.length; i++) {
for (int j = 0; j < array1[1].length; j++) {
if(array1[i][j] != 0){
count ++;
array2[count][0]=i; //二维数组的第count行的第0列存放数据的横坐标
array2[count][1]=j; //二维数组的第count行的第1列存放数据的纵坐标
array2[count][2]=array1[i][j]; //二维数组的第count行的第3列存放数据的值
}
}
}
//输出稀疏数组
System.out.println("稀疏数组");
for (int i = 0; i < array2.length; i++) {
System.out.println(array2[i][0]+"\t"
+array2[i][1]+"\t"
+array2[i][2]+"\t");
}
//还原
//创建数组
int[][] array3 = new int[array2[0][0]][array2[0][1]];
//读取数据并存储
for (int i = 1; i < array2.length; i++) {
array3[array2[i][0]][array2[i][1]] = array2[i][2];
}
//输出还原得到的数组
System.out.println("还原得到的数组：");
for (int i = 0; i < array3.length; i++) {
for (int j = 0; j < array3[i].length; j++) {
System.out.print(array3[i][j]+"\t");
}
System.out.println();
}
}
}
