Java基础---结构与数组与排序

一，分支（选择）结构

一，语法

1，单分支

//获取判断条件逻辑 start
Scanner input= new Scanner(System.in);
System.out.println("请输入张浩同学的java成绩");
int iJavas = input.nextInt();
System.out.println("请输入张浩同学的音乐成绩");
int iMusics = input.nextInt();
//获取判断条件逻辑 end
//给一个初始默认值
String sReturn = "老师不奖励他";

//根据逻辑：
//张浩Java成绩大于90分，并且音乐成绩大于80分时，
//或者java乘积等于100分，音乐成绩大于70分时
//老师奖励他
//进行if语句编写
if((iJava>90 && iMusics>80)||(iJavas==100 && iMusics>70)){
    sReturn = "老师奖励被咬了一口的apple6";
}

//输出结果
System.out.println(sReturn);

2，双分支

 

//获取判断条件逻辑 start
Scanner input = new Scanner(System.in);
System.out.println("请问六子吃了几碗粉：");
int num1 = input.nextInt();
System.out.println("请问刘子付了几碗钱");
int num2 = input.nextInt();
//获取判断条件逻辑 end

//开始判断
if(num1 == num2){
    //满足条件
    System.out.println("这就是公平！！！");
}else{
    //不满足条件
    System.out.println("你这不是欺负老实人吗？！！");
}

3，多分支

 

//获取判断条件逻辑 start
Scanner input = new Scanner(System.in);
System.out.prinln("请输入你的成绩：");
int i= input.nextInt();
String sReturn = "";
//获取判断条件逻辑 end

//进行判断
if(i>=80){
    sReturn = "良好";
}else if(i>=60){
    sReturn = "中等";
}else{
     sReturn = "差";
}
System.out.println("你本次的结果为："+sReturn);

4，嵌套分支

//由于if(){}else{}的逻辑如下
if(true){
	//代码
}else{
    //代码
}
//而且if(){}else{}本质也是代码，所以他自然可以嵌套在其他的if(){}else{}当中

//如下实例:
String sReturn= "";
if(score>10){
    sReturn = name+"同学，很遗憾你无缘参加决赛";
}else{
    if("男".equals(sex)){
        sReturn = "恭喜你"+name+ "进入男生组决赛";
    }else{
        sReturn = "恭喜你"+name+ "进入女生组决赛";
  	}
}
System.out,println(sReturn);

二，switch

Scanner input = new Scanner(System.in);
System.out.println("请输入你获得的名次：");
int mingCi = input.nexInt();
switch(mingCi){
    case 1:
        System.out.printlnl("恭喜你获得第一名");
        //如果不用break跳出，会继续执行之后的每一个case选项
        break;
    case 2:
        System.out.printlnl("恭喜你获得第二名");
        break;
    default:
        System.out.printlnl("谢谢参与");
        
}
//关于default
//default的位置是存在讲究的，一般情况下，我们会将default放在switch的最后一块
//如果所有的case都匹配不上，则会进匹配default当中
//如果进入某个case块（包括default） 那么， 当没有遇到break的时候
//会将该位置之后的所有case块（包括default）按照顺序执行

//比如你的代码如下：
switch(mingCi){
    case 1:
        System.out.printlnl("恭喜你获得第一名");
        //如果不用break跳出，会继续执行之后的每一个case选项 
    default:
        System.out.printlnl("谢谢参与");
    case 2:
        System.out.printlnl("恭喜你获得第二名");
}
//当mingCi为1的时候会执行24 28 30行代码
//当mingCi为2的时候会进入顺序执行30（因为有case匹配，所以不进default）
//当mingCi为3的时候只会执行28 30（因为所有的case都匹配不上，所以进入default）
//存在break，那么28及之后的30行都会被执行

给一个不需要break的场景例子

Scanner input = new Scanner(System.in);
int iCount = 0;
System.out.println("每过一个小时给计时器+1");
System.out.printlnl("现在是几点");
String time = input.next();
switch(time){
    case "20:00":
        iCount++;
    case "21:00":
        iCount++;
    case "22:00":
        iCount++;
    case "23:00":
        iCount++;
}
System.out.println("过"+iCount+"小时是24:00");

三，String的equals方法

对于字符串的比较我们不是用== 而使用equals方法调用，比如

String str="str";
if("str".equals(str)){
    //执行代码
}

当我们对于一个字符串对象和一个字符串比较时，如上图的str对象和”str“字符串比较

我们一定要将字符串”str“写在前面，否则当str对象为null（空）时，会抛出

NullPointerException——空指针异常

四，局部变量

//当我们声明的变量在某块代码块中，而不是全局
//此时该变量为局部变量，在声明的代码块以外的地方
//是无法调用或者修改该变量的
/例如：
 public static void main(String[] args){
    int i = 1;
    if(i>10){
        //此时的j为if代码块中的局部变量，无法在if模块以外使用(作用范围在7-8行中)
        int j=2;
    }
    //由于变量i是在main方法中声明，所以所有main方法中的代码都可以使用/修改i变量
    System.out.println(i);
    //由于变量j是在if代码块中声明，所以j只能作用在if代码块中（8-9行）在15行打印会直接报错
    //报j变量违背声明
    System.out.println(j);
}

2，循环结构

1，while循环

 

//循环变量声明和初始化；
while(循环条件){
    //循环操作！
    //循环变量的变化：【注意】
    //循环体（语句块）；
    //循环变量的变化：【注意】
}

2，do-while循环

 

特点：先执行，再判断

例如：

package com.kgc.day03;

import java.util.Scanner;

public class Test01 {
    public static void main(String[] args){
      //张浩同学先考试，考试完了，老师判断是否需要继续
        Scanner input = new Scanner(System.in);
        //用于判断的变量
        String flag="Y";
        do{
            if(!"Y".equals(flag)){
                System.out.println("张浩同学，你没有通过，需要重新考试");
                System.out.println();
            }
            System.out.println("张浩同学正在考试");
            System.out.println("老师 请问张浩同学是否合格，合格输入Y");
            flag=input.next();
        }while(!"Y".equals(flag));
        System.out.println("张浩同学你这次城通过了，可以不用再次考试");
                System.out.println("张浩同学通过了考试，非常开心");
    }
}

3，for循环

for(一号区域;二号区域;四号区域){
    三号区域
}
1，一号区域，写声明变量，此处为循环的最开始执行位置
2，二号区域，写循环的条件，此处为循环第二步执行的位置
3，三号区域：写循环的具体操作
4：四号区域，写变量的改变，循环具体操作结束之后我们会执行的位置
5：第二次循环开始，此时将不会在去执行一号区域内容直接进行二号区域判断
6：如果判断结果为true执行三号区域和四号区域，之后再次判断二区域
    如果判断结果为false将会结束循环，执行for循环之后的内容
    
//例如
    for(int i=1;i<=1000;i++){
 			System.out.println("第"+i+"遍");
}

（实际工作当中绝对不可能出现）for循环的四个区域均可以不写代码，如果你四个区域都没有写代码，那么我们发现你的这个线程卡在此处了，死循环，一直套在这里

//此时不报错，但是会一直卡住
for(;;){
}
//如果在这之后有代码会编译报错，无法执行代码
//如
System.out.println("1");
//此时第六行代码爆红，编译报错，无法编译

（实际工作当中可能出现），如果一号区域不写代码，不会影响，你可以把循环中使用的变量，放在for循环外面声明

//此时是正常输出，输出五次i的值，并且在第7行可以调用到i
//如果你的2int i0； 是写在一号区域，那么你第七行代码无法调用到i，i为for循环的局部变量
int i = 0;
for(;i<=5;i++){
	Systm.out.println("i");
}
Systm.out.println("你跑出了这个循环"+i);

(实际工作当中可能出现)如果二号区域不写代码，那么会将条件判断为true，会进入死循环，我们需要在三号区域中打破这个循环（使用break）

//如果不写循环条件，会视同循环条件为true，如果不存在break的情况，那么第8行代码会编译报错无法编译
for(int i=0;;i++){
    System.out.println(i);
    if(i==5){
        break;
    }
}
System.out.println("你跑出了这个循环");

（实际工作当中不会出现）如果三号区域不写代码，那么我们的for循环依旧会按照规则去执行，并且会执行四号区域逻辑

//该代码是正常运行的，并且在第六行打印的时候i的结果为6（因为i==6时才不满足条件，退出循环）
int i=0;
for(;i<=5;i++){
}
System.out.println("你跑出了这个循环"+i);

（实际工作当中不会出现）如果四号区域不写代码，那么我们可能会需要在三号区域中将该值进行调整

//该代码是正常运行的，并且在第六行打印的时候i的结果为6，（因为i==6时才不满足循环条件，退出循环）
for(int i=0;i<=5;){
    if(某种情况下){
		i++;
    }
}

4，break和continue

break打破本次的循环，使循环结束，执行循环之后的代码

public class Test01 {
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        //声明一个可以在全局操作的变量
        String flag="";
        while(true){
           System.out.println("请问现在张浩同学是否合格了？如果合格输入Y");
           flag=input.next();
           if(!"Y".equals(flag)){
               System.out.println("张浩同学你这次没有合格，需要继续学习");
               System.out.println("上午阅读教材，学习理论部分");
           }else{
//               System.exit(0);
               System.out.println("恭喜你退出了循环");
               break;
            }
       }
    }
}

continue结束本次循环，进行下一次循环

package com.kgc.day03;
public class Test01 {
    public static void main(String[] args){
       int num = 0;
       while(num<=99){
           num++;
           //只打印奇数，如果是偶数我们呢跳过本次循环
           if(num%2==0){
      //跳过本次循环（第12行代码不执行，，但不结束循环，循环依旧会执行）
            continue;
           }
           System.out.println(num);
       }
    }
}

当循环，遇到break，那么就不会继续执行循环，并且不会再次进行循环条件判断

当循环，遇到continue那么就不会继续执行循环，但是会再次进行循环条件判断，如果满足继续循环

5，嵌套循环

各循环可互相嵌套

一般不超过三层

外层循环变量变化一次，内层循环变量要变化一遍

第一步是1

第二步是2

如果2判断是T，则进入4，如果是F则进入10

第三步（2为T）是4，（2为F）是10

第四步 （2为T 是5

第五步 （2为T 是6

第六步（6为T）是8，（6为F）是9

第七步 （6为T）是7

第八步 （6为T）是6

第九步（6为T）是8，（6为T）是9

第十步（6为F）3

第十一步（2为T）是4，（2为F）是10

······

 二，数组

1，数组声明时内存空间存储关系

 

第一行是一个byte的变量

第二行时byte长度为8的数组

第三行时一个short的变量

第四行是一个长度为4的short数组

第五行是一个int的变量

第六行是一个长度为2的int数组

第七行是一个long的变量

 

 

我们的数组对象声明后会在栈内存中存储该变量，但我们存储的只是一个堆内存的引用地址

我们实际修改数组中的值是修改对应堆内存位置的值

 2，什么是数组

数组本质是内存中的一串连续的空间

数组用来存储固定长度的变量的一个整体，

可以理解为

一栋楼房和一套房子的关系

tips：数组只可以存储他声明四规定的类型

概念：【一组】【类型相同的】【连续的】【存储空间的表示】

优点：

一个存储单位存多个值

空间连续（遍历）

下标（索引）定位

缺点：

长度固定

类型固定

插入和删除

3，数组的使用

package com.kgc.day05;

public class Test01 {
    public static void main(String[] args) {
        String[] nameArrray;
        //第一步声明：数据类型【】 数组名称;
        nameArrray = new String[30];
        //第二部初始化：数组名称 = new 数据类型【长度】;
        nameArrray[0] = "张三";
        nameArrray[1] = "李四";
        nameArrray[2] = "王五";
        nameArrray[3] = "赵六";
        //第三步赋值：数组名称【下标】= 值;
        //下标取值范围：0-names.length-1
        //下标越界报错，数组下标越界异常
        System.out.println(nameArrray[2]);
        //第四步使用

    }
}

特殊方式：

1，数据类型【】 数组名称 = （值1，，，值n）;

String[] nameArray={"张三","李四","王五"};

在一个数组中，如果我们使用一般的声明方式，我们会将数组的整体长度进行声明，并且将所有的值都附上默认初始值。

注意：数组初始化后所有元素都有默认无效初值

String：null

char: (char)0

int: 0

double :0.0

boolean: false

如果是使用的特殊方式，则会自动将长度变为你写入的长度，不存在默认初始值的问题

特殊方式二：

int[] scores = new int[]{89,79,76};

4，获取数组总长度

通过数组的变量名称，调用

int[] scores = new int []{89,76,79};
//可以获得数组的总长度
int i = scores.length;

5，求最大值

6，增强遍历for循环

 

对于数组，集合这类数据类型我们可以使用增强遍历for循环

使用语法位

for(数据类型 变量名：数组名){

//正常使用该变量，如：

System.out.print(变量名);

}

7，在已经确定顺序的数列中插入一个数字

package com.kgc.day06;

import java.util.Scanner;

public class Test02 {
    public static void main(String[] args) {
        int[] num = new int[]{10,20,30,40,50,0};
        for (int i = 0; i < 6; i++) {
            System.out.println("intArray[" + i + "] = " + num[i]);
        }
        Scanner input = new Scanner(System.in);

        System.out.println("请问你要插入的数字是：");
        int iNum = input.nextInt();

        //找到插入的位置index
        int index = 0;
        for (int i = 0; i < num.length; i++) {
            if (iNum < num[i]) {
                index = i;
                break;
            }
        }

        //往后移一位
        for (int j = num.length - 1; j > index; j--) {
            num[j] = num[j - 1];
        }

        //插入
        num[index] = iNum;

        for (int i = 0; i < 6; i++) {
            System.out.println("num[" + i + "] = " + num[i]);

        }
    }
}

8，java.util.Arrays常用方法

 

package com.kgc.day06;
import java.util.Arrays;
public class ARRAYS {
    public static void main(String[] args) {
        int a[]={20,3,32,1,72,26,35};
        int b[]={3,5,7,8,54,23,9};
        int c[]={3,5,7,8,54,23,9};

        System.out.println("转换前："+a);
        //数组转换字符串
        String str=Arrays.toString(a);
        System.out.println("转换为字符串："+str);

        System.out.println("");
        //对数组array的元素进行升序排列
        System.out.println("原数组："+Arrays.toString(a));
        Arrays.sort(a);
        System.out.println("排序后："+Arrays.toString(a));

        System.out.println("");
        //所以元素都赋成特定值
        System.out.println("赋值前："+Arrays.toString(a));
        Arrays.fill(a,10);
        System.out.println("赋值后："+Arrays.toString(a));

        System.out.println("");
        //判断两个数组是否相等(对应位置上的元素是否相等)
        boolean boo=Arrays.equals(a,b);
        boolean boo2=Arrays.equals(b, c);
        System.out.println("a:"+Arrays.toString(a));
        System.out.println("b:"+Arrays.toString(b));
        System.out.println("c:"+Arrays.toString(c));
        System.out.println("a与b是否相等？"+boo);
        System.out.println("b与c是否相等？"+boo2);

        System.out.println("");
        //把数组复制成特定长度的数组
        int d[]=Arrays.copyOf(b,b.length);
        System.out.println("d:"+Arrays.toString(d));
        System.out.println("b:"+Arrays.toString(b));

        System.out.println("");
        //查询数组下标
        int i=Arrays.binarySearch(b, 5);
        System.out.println("数组b中数字5的下标是："+i);
    }
}

9，二维数组

//声明
public static void main(String[] args){
    int[][] scores;
    scores=new int[5][];
    scores[0]=new int [13];
    //...
    //或者
    int [][] scores1 = new int [5][];
    
    scores1[0][0] = 1;
}

//直接声明的同时同时赋值（只能一口气把二维数组全部赋值）
int [][]scores = new int [][]{{90,85,92,78,54},{76,63,80,},{87}};
int scores[][] = {{90,85,92,78,54},{76,63,80},{87}};

//使用---我们在遍历二维数组的时候是采取的双层嵌套循环写法遍历所有的内容

 

 关于长度（length属性）调用

 

三，排序

1，冒泡排序

package com.kgc.day06;

import java.util.Random;
import java.util.Scanner;

public class maopao {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int [] num = new int [7];
//        for(int i=0;i< num.length;i++){
//            System.out.println("请输入第"+(i+1)+"个数：");
//            num[i]=input.nextInt();
//        }

        Random r= new Random();
        for(int i=0;i<7;i++){
            num[i]=r.nextInt(50);
        }

        System.out.print("[");
        for(int i=0;i<7;i++){
            System.out.print(num[i]);
            if(i==num.length-1){
                System.out.println("]");
            }else{
                System.out.print(", ");
            }
        }

        boolean flag;

        for(int m=0;m< num.length-1;m++){
            flag=true;
            for(int n=0;n< num.length-1-m;n++){
                if(num[n]>num[n+1]){
                    flag=false;
                    int temp= num[n];
                    num[n]=num[n+1];
                    num[n+1]=temp;
                }
            }
            if(flag){
                break;
            }
        }

        System.out.println("排序后的数组为：");
        for (int j = 0; j < num.length; j++) {
            System.out.print(num[j] + "  ");
        }
    }
}

2，插入排序

for (int i = 1; i < num.length; i++) {
            for (int j = i - 1; j >= 0 && num[j + 1] < num[j]; j--) {

                    int temp = num[j];
                    num[j] = num[j + 1];
                    num[j + 1] = temp;

            }
        }

3，选择排序

 for(int i=0;i< num.length-1;i++){
            int min=i;
            for(int j=i;j< num.length;j++){
                if(num[min]>num[j]){
                    min=j;
                }
            }
            int temp=num[i];
            num[i]=num[min];
            num[min]=temp;
        }