目录
6. 分⽀
● if
if (布尔表达式){
满⾜时执⾏语句
}else {
不满⾜时执⾏语句
}
●if~else 语句最好不要超过三层嵌套
●if(){ return ; } 表示结束判断,不再向下执行操作
●能 用 if(){}并列的,不要用 if 嵌套
卫语句:
把⾮法的操作,⽤ if 语句并列在前⾯,只要有异常操作就结束操作,然后把正常操作的逻辑写在下⾯。
//例子
if(错误操作){
return; //结束操作
}
if(正确操作){
......
}
●switch
//不能使用布尔表达式
switch (int|byte 整数类型|char|String|计算语句){
case :
case 1:
.....
break;
case 2:
....
break;
.....
default:
.....
break;
}
7.循环结构
●while 循环
while (boolean) {
//可以反复执行
}
●for循环
//for的⽆限循环
for(;;) {
System.out.println("你好");
}
//While的⽆限循环
while(true){
System.out.println("你好");
}
●双重for循环:
外层循环控制行数,数一下有几行就能确定外层循环。
内层循环控制列数,这一行打印多少个,到底要打印多少个要找出和当前行之间的一个关系。
//等腰正三角
@Test
public void test61(){
int rows=5;
for(int i = 1; i <= rows; i++) {
for (int j = 1; j <= rows - i; j++) {
System.out.print(" ");
}
for (int k = 1; k <= 2*i - 1; k++){
System.out.print("*");
}
System.out.println("");
}
}
●continue、break:
continue:跳出本次循环,继续下一次循环
break:跳出离他最近的那层循环
注意:
① 循环结构需要多些⼏次。
② while ⽤于不确定次数但是知道结束条件的语句,⽽ for 循环⽤于明确知道确定的次数⽽不知道结束条件的循环。
③ continue、break 都需要和 if 语句结合。
8.数组
●数组是最简单的数据结构。
数组:存放同一种类型数据的集合,在内存里面是开辟一块连续的区域。
● 声明数组: 数组类型 数组名称[]=null;
● 开辟数组: 数组名称= new 数组类型[⻓度]; int[] array = new int[4]; // 1、存放整数类型的数组 ; 2、长度是4; 3、只能存放int类型
● 数组定义的方式:
① 在定义的时候直接赋值: int[] array = {32,5,7,87}; int[] array = new int[]{32,5,7,87};
② 先定义后赋值: int[] array = new int[4]; array[0] = 34;
java.lang.Array Index OutOf Bounds Exception: 4 数组下标越界异常
// 范例:控制台输⼊⼀个数组:
Scanner scanner =new Scanner(System.in);
System.out.println("请输⼊成绩:");
int[] score = new int[5];
for (int i = 0; i < score.length; i++) {
score[i] = scanner.nextInt();
}
● 数组最重要操作就是遍历。
public void test10(){
int[] array = new int[4];
array[0] = 1;
array[1] = 2;
array[2] = 3;
array[3] = 4;
//数组正序遍历
for (int i = 0; i < array.length; i++) {
System.out.print(array[i]);
}
System.out.println();
//数组逆序遍历
for(int i = array.length - 1; i >=0; i--){
System.out.print(array[i]);
}
}
● ⼆维数组(了解)
●⼆维数组的定义
动态:数据类型 数组名称[][] = new 数据类型[⾏][列];
静态(对应上表数据):数据类型 数组名称[][] = new 数据类型[][]{{10,20,30,40},{11,21,31,41},{12,22,32,42},{13,23,33,43}}
第⼀⾏
public static void main(String[] args) {
int data[][]=new int[][]{{10,20,30,40},{11,21,31,41},{12,22,32,42},{13,23,33,43}};
for(int x=0;x<data.length;x++) {//第⼀层循环是为了输出⾏号
for(int y=0; y < data[x].length;y++) {//每⼀⾏⼜是⼀个⼀维数组,第⼆⾏就是遍历⼀维数组
System.out.print(data[x][y]+"\t");
}
System.out.println() ;
}
}
}
●数组可以和循环巧妙结合。
●语法:int[] stu=new int[];
●数组名称.lenght 可以获取数组⻓度;
●⼩标从 0 开始,下标最⼤值,是⻓度-1;
●Math.random()⽅法是⽣成⼤于等于 0 ⼩于 1 的随机数;
int[] a=new int[20];
int l=a.length;
int sum=0;
double av=0;
for(int i=0;i<l;i++) {
a[i]=(int) (Math.random()*50+50);//输出 50 到 100 之间的随机数; MAth.random()是输出 0 到 1 之间随机数
sum+=a[i];
av=sum/l;
}
System.out.println(sum);
System.out.println(av);
●数组可以只定以,不创建,例⼦:int[] a,b,c=new int[];这⾥,a 和 b 没有创建,但是定义了;c 即创建了⼜定义了;
●数组在定义时候可以初始化。int[] a = new int[]{20,30,40,50} 和 int[] a = {20,30,40,50}两种,第⼀种可以传递参数,第⼆种不可传递参数。
●数组的遍历 for(int i: s){}和直接 System 输出
●选择排序
//选择排序
public static void main(String[] args) {
int[] a=new int[] {6,28,104,90,19,200};
for(int i=0;i<=a.length-1;i++) {//i 代表轮数
for(int j=0;j<a.length;j++) {
if(a[j]<a[i]) {
int tmp=a[j];
a[j]=a[i];
a[i]=tmp;
}
}
}
for(int i=0;i<a.length;i++) {
System.out.println(a[i]+" ");
}
}
●冒泡排序
//冒泡排序
// 第⼀轮:9,1,5,2 ------------------------------------ ⽐较了 3 次
// 第⼆轮:9,5,1,2 --------------------------------------⽐较了 2 次
// 第三轮:9,5,2,1 --------------------------------------⽐较了 1 次
// 四个数,总共⽐较三轮:length - 1 轮
// 每轮⽐较了 length - i 次
public static void main(String[] args) {
int[] array = new int [] {1,5,9,2};
int temp = 0;
for (int i = 1; i <= array.length -1; i++) {
//外层循环控制总共⽐较多少轮:从第⼀轮开始:1200702Java—王浩
28
for (int j = 0; j < array.length - i; j++) {
//内层循环:每⼀轮⽐较的次数:从第⼀个索引开始:0
if (array[j] > array[j + 1]) {
temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp ;
}
}
}
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}
总结:
● 数组⽤的很少,但是⼀定会⽤,⽽且数组的相关逻辑⽐较麻烦;
● 把数组的排序和转置要弄明⽩;
● ⼀切以⼀维数组为主,要明⽩数组定义语法和内存关系(对象⼀致);
● 对象数组的定义语法。对象数组=多个对象;
● 数组有⼀个最⼤的天⽣短板;⻓度固定,限制数组的开发中的出现
● 数组排序:java.util.Arrays.sort(数组名称)。