Java学习之路--struct--结构

package com.chao.struct;

/*
break
break在任何循环语句的主体部分，均可用break控制循环的流程
**break**用于强行终止退出循环，不执行循环剩余的语句，（break语句也在switch语句中使用）

continue
**continue**语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，
接着进行下一次是否执行循环的判定，执行continue下面的语句（即跳出当前循环不执行，继续执行下面的）
 */
public class BreakDemo {
    public static void main(String[] args) {
        int i = 0;
        while (i < 100){
            i++;
            System.out.println(i);
            if (i == 30){
                break;//如果i等于30，终止跳出当前循环，执行循环外的语句
            }
        }
        System.out.println("123");
    }
}

//
//

package com.chao.struct;

/*
continue
**continue**语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，
接着进行下一次是否执行循环的判定，执行continue下面的语句（即跳出当前循环不执行，继续执行下面的）
 */

public class ContinueDemo {
    public static void main(String[] args) {

        int i = 0;
        while (i < 100){
            i++;
            if (i%10 == 0){
                System.out.println("=====");
                continue;
            }
            System.out.println(i);
        }
    }
}

//
//

package com.chao.struct;
// 顺序结构
/*
Java的基本结构就是顺序结构，除非特别指明，否则就按照程序一句一句的执行
最简单的算法结构
任何一个算法都离不开的一种基本算法结构
 */
public class Demo01 {
    public static void main(String[] args) {
        System.out.println("11");
        System.out.println("22");
        System.out.println("33");
        System.out.println("44");
    }
}

//

package com.chao.struct;

import java.util.Scanner;

//选择结构
/*
if单选择结构
语法：
if(布尔表达式) {
}
 */
public class Demo02 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入内容： ");
        String str = scanner.nextLine();

        //equals:判断字符串是否相等
        if (str.equals("Hello")){//如果输入的字符串等于Hello，输出str的值，输入的字符串不是Hello,程序往下走
            System.out.println(str);
        }
        System.out.println("End");//输出End
        scanner.close();
    }
}

//

package com.chao.struct;

import java.util.Scanner;

//选择结构
/*
if双选择结构
语法:
if(布尔表达式){
//布尔表达式为true，走这一块
}else{
//布尔表达式为false，走这里
}
 */
public class Demo03 {
    public static void main(String[] args) {
    //考试分数大于60分就是及格，小于60分就是不及格
        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入成绩: ");
        int score = scanner.nextInt();

        if (score > 60){
            System.out.println("及格");
        }else{
            System.out.println("不及格");
        }
        scanner.close();
    }
}

//

package com.chao.struct;

import java.util.Scanner;

//选择结构
/*
if 多选择结构
语法：
if(布尔表达式1){
满足表达式1
}else if(布尔表达式2){
不满足表达式1，满足表达式2
}else if(布尔表达式3){
不满足表达式1，2，满足表达式3
...
}else {
}
 */
public class Demo04 {
    public static void main(String[] args) {
    //键盘输入成绩，90~100，输出优秀；80~90，输出良好，60~80，输出合格，60以下，输出不及格
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入成绩： ");
        int score = scanner.nextInt();

        if (score >=90){
            System.out.println("优秀");
        }else if (score >= 80){
            System.out.println("良好");
        }else if (score >= 60){
            System.out.println("合格");
        }else{
            System.out.println("不及格");
        }
        scanner.close();
    }
}

//

package com.chao.struct;

import java.util.Scanner;

//if 嵌套结构
/*
语法：
if(布尔表达式1){
        如果满足布尔表达式1（true）执行代码
        if(布尔表达式2){
        如果布尔表达式2的值为（true）执行代码
        }
    }
 */
public class Demo05 {
    public static void main(String[] args) {
        //输入一个数，输入的这个数在0~100这个范围，输入的这个数还在0~50这个范围
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个数：");
        int i = scanner.nextInt();

        if (i >= 0 && i <= 100){
            System.out.println("你输入的数在0-100之间");
            if (i >= 0 && i <= 50){
                System.out.println("非常好，你输入的这个数不仅在0-100之间，而且还在0-50之间");
            }
        }
        scanner.close();
    }
}

//

package com.chao.struct;

import java.util.Scanner;

//switch多选择结构
//switch  匹配一个具体的值
/*
语法：
switch(值变量){
    case 表达式1:
        语句(System.out.println("需要输出的内容"))
        break;//可以不加break,但是会造成case穿透问题
    case 表达式2:
        语句(System.out.println("需要输出的内容"))
        break;
    case 表达式3:
        语句(System.out.println("需要输出的内容"))
        break;
    default://default这一块可以不要，为了规范，还是写上比较好
        语句//值变量不匹配表达式1-表达式3时，写输出其他的
 */
public class Demo06 {
    public static void main(String[] args) {
        //键盘输入成绩：90 80 70 60 50，判断输入的成绩在·哪个区间，成绩情况
        // 输入的成绩为90，输出成绩在90~100之间，成绩优秀，
        // 输入的成绩为80，输出成绩在80~90之间，成绩良好，
        // 输入的成绩为70，输出成绩在70~80之间，再接再厉，
        // 输入的成绩为60，输出在60~70之间，成绩合格，
        // 输入的成绩为50，输出成绩小于60，不合格，挂科了
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入成绩：");
        int score = scanner.nextInt();

        switch(score){
            case 90:
                System.out.println("成绩在90~100之间，成绩优秀");
                break;
            case 80:
                System.out.println("成绩在80~90之间，成绩良好");
                break;
            case 70:
                System.out.println("成绩在70~80之间，再接再厉，继续努力");
                break;
            case 60:
                System.out.println("成绩在60~70之间，成绩合格");
                break;
            case 50:
                System.out.println("成绩小于60，成绩不合格，挂科了");
            default:
                System.out.println("成绩不属于90、80、70、60、50中的任何一个，无法判断");
        }
        scanner.close();
    }
}
//

package com.chao.struct;

import java.util.Scanner;

public class Demo07 {
    public static void main(String[] args) {
        //判断四季，键盘输入月份1-12的一个数字，判断输入这个数属于四季的什么季节（春季，夏季，秋季，冬季）
        /*
        2 3 4 --春季
        5 6 7 --夏季
        9 10 11 --秋季
        11 12 1 --冬季
         */
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入月份: ");
        String month = scanner.nextLine();
        System.out.println("你输入的月份是" + month + "月");

        switch(month){
            case "2":
            case "3":
            case "4":
                System.out.println(month + "月是春季");
                break;
            case "5":
            case "6":
            case "7":
                System.out.println(month + "月是夏季");
                break;
            case "8":
            case "9":
            case "10":
                System.out.println(month + "月是秋季");
                break;
            case "11":
            case "12":
            case "1" :
                System.out.println(month + "月是冬季");
                break;
            default:
                System.out.println("你输入的是啥勒，一年只有12个月都不知道？");
        }
        scanner.close();
    }
}
//

package com.chao.struct;
//循环结构
/*
循环结构分为三种：for循环，while循环，do-while循环
for循环:
语法：
for(条件语句){//条件语句写循环的条件，循环需要进行多少次
    语句
}
while循环:
语法:
while(布尔表达时式){
//while循环条件语句不满足时，一次循环也不会执行，布尔表达式为true时，程序一直执行，不加终止循环的条件，就陷入了死循环
//正常的业务编程中应该尽量避免死循环，会影响程序性能或者造成程序卡死崩溃
    语句
}
do-while循环://do-while循环至少循环一次
语法:
do{
}while(布尔表达式);
while和do...while的区别
1.while先判断后执行，do-while先执行后判断
2.do-while总是保证循环体会被至少执行一次！这是两者的主要区别
 */

public class Demo08 {
    public static void main(String[] args) {
        //使用while输出1~100
//        int i = 0;
//        while(i < 100){
//            i += 1;
//            System.out.println(i);
//        }
        //使用while循环输出1+2+3+...+100的和
        int j = 0;
        int sum = 0;

        while(j <= 100){
            sum += j;
            j++;
        }
        System.out.println("1-100的和为" + sum);

        //do-while循环写1+2+3+...+100的和
        int x = 0;
        int sum1 = 0;
        do {
            sum1 += x;
            x++;
        }while (x <= 100);
        System.out.println("1-100的和为" + sum1);
    }
}

//

package com.chao.struct;

public class DoWhileDemo01 {
    public static void main(String[] args) {
        //条件不满足，while循环一次也没执行
        //条件不满足，do-while循环执行了一次，才判断
        int a = 0;
        while (a < 0){
            System.out.println(a);
            a++;
        }
        System.out.println("=====");
        do {
            System.out.println(a);
            a++;
        }while (a < 0);
    }

}
//

package com.chao.struct;
/*
for循环
语法：
for(初始化;布尔表达式；更新){
//代码语句
}
1.for循环语句是支持迭代的一种通用结构，是最有效，最灵活的循环结构
2.for循环执行的次数是在执行前就确定的
3.快捷输入for循环，布尔表达式值.for
例如:for(int i = 1; i <= 100; i++){
}
可以这样输入:100.fori/forr(按下回车)就快速完成了
注:关于for循环的说明
最先执行初始化操作，可以声明一种类型，但可以初始化一个或多个循环控制变量，也可以是空语句
然后，检测布尔表达式，如果为true，循环体执行，如果为false，循环终止，开始执行循环体后面的语句
再次检测布尔表达式，循环执行上面的过程
 */
public class ForDemo01 {
    public static void main(String[] args) {
        int a = 1;//初始化条件

        while (a <= 100){//条件判断
            System.out.println(a);//循环体
            a += 2;//迭代
        }
        System.out.println("while循环结束！");

        //初始化//条件判断//迭代
        for (int i = 1; i <= 100; i++){
            System.out.println(i);
        }
        System.out.println("for循环结束！");
    }
}

//

package com.chao.struct;

//for循环输出1-100的偶数和，1-100的奇数和
public class ForDemo02 {
    public static void main(String[] args) {
        int evenSum = 0;//evenSum，偶数
        int oddSum = 0;//oddSum，奇数
        for (int i = 0; i <= 100; i++) {
            if (i%2 == 0){//这个数除2取余为0是偶数，不为0是奇数
                //Java中用%取余（用法：a % b，a除以b取余）,!=(不等于)
                evenSum += i;
            }else {
                oddSum += i;
            }
        }
        System.out.println("1-100的偶数和为" + evenSum);
        System.out.println("1-100的奇数和为" + oddSum);
    }
}

//

package com.chao.struct;

//使用while循环或for循环输出1-1000之间能被5整除的数，且每行输出3个
public class ForDemo03 {
    public static void main(String[] args) {
        int i = 0;
        System.out.println("1-1000之间能被5整除的数有: ");
        while(i < 1000){
            if(i%5 == 0){
                System.out.print(i + "\t");
            }
            if(i%(5*3) == 0){//每行输出3个
                System.out.println();
                //System.out.print("\n");
            }
            i++;
        }

        System.out.println("\n");
        for (int j = 0; j < 1000; j++) {
            if(j%5 == 0){
                System.out.print(j + "\t");
//                j++;
            }
            if(j%(5*3) == 0){
                System.out.println();
                //System.out.print("\n");
            }
        }
    }
}

//

package com.chao.struct;

//for循环嵌套输出99乘法表
/*
println和print的区别，println--换行打印，print--当前行打印
System.out.println();---()括号里可以不写内容
System.out.print();---()括号里必须有内容
 */
public class ForDemo04 {
    public static void main(String[] args) {
        //正三角型的99乘法表
        /*
        1*1=1
        1*2=2  2*2=4
        1*3=3  2*3=6  3*3=9
        1*4=4  2*4=8  3*4=12 4*4=16
        1*5=5  2*5=10 3*5=15 4*5=20 5*5=25
        1*6=6  2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
        1*7=7  2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
        1*8=8  2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
        1*9=9  2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
         */
        for (int i = 1; i <= 9; i++){
            for (int j = 1; j <= i; j++){
                System.out.print(j + "*" + i + "=" + j*i + "\t");//"\t"是Java语言默认的制表符合
//                if (i == j){
//                    System.out.print("\n");//当换行条件成立时，进行换行打印，法1
                }
            System.out.println();//换行打印，法2
            }
        }

//        System.out.println("===========");
//        //倒三角型的99乘法表
//        /*
//        9*1=9    9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81
//        8*1=8    8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64
//        7*1=7    7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49
//        6*1=6    6*2=12 6*3=18 6*4=24 6*5=30 6*6=36
//        5*1=5    5*2=10 5*3=15 5*4=20 5*5=25
//        4*1=4    4*2=8  4*3=12 4*4=16
//        3*1=3    3*2=6  3*3=9
//        2*1=2    2*2=4
//        1*1=1
//         */
//        for (int i = 9; i >= 1; i--) {
//            for (int j = 1; j <= i; j++){
//                System.out.print(i + "*" + j + "=" + i*j + "\t");
//                if (i == j){
//                    System.out.print("\n");
//                }
//            }
//        }
//
//        System.out.println("=========");
//        //长方形的99乘法表
//        for (int i = 1; i <= 9; i++){
//            for (int j = 1; j <= 9; j++){
//                System.out.print(i + "*" + j + "=" + i*j + "\t");
//                if (i == j){
//                    System.out.println(" ");
//                }
//            }
//        }
}

//

package com.chao.struct;

/*
增强for循环，Java5引入的，多使用在数组和集合操作
格式：
//声明语句：
声明新的局部变量，该变量的类型必须和数组元素的类型匹配，其作用域限定在循环语句块，其值与此时数组元素的值相等
表达式：
表达式是要访问的数组名，或者是返回值为数组的方法
for(声明语句 : 表达式){
//代码语句
}
 */
public class ForDemo05 {
    public static void main(String[] args) {
        int[] number = {10,20,30,40,50};//定义一个数组，使用静态初始化的方式

        //遍历数组中的元素，普通for写法
        for (int i = 0; i < 5; i++){
            System.out.println(number[i]);
        }

        System.out.println("========");
        //遍历数组的元素，增强for写法
        for (int x : number){
            System.out.println(x);
        }
    }
}

//

package com.chao.struct;

public class TestDemo {
    public static void main(String[] args) {
        //打印三角形 5行
        /*
        详解:第一个*出现位置：i = 1进入，j=5，大于1，打印五个空格（j从5递减到1需要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(" ");
        }
//            System.out.println("*");
        //加上这里打印成一个菱形
//        for (int i1 = 1; i1 <= 5; i1++) {
//            for (int j = 1; j <= i1; j++) {
//                System.out.print(" ");
//            }
//            for (int j = 5; j >= i1; j--) {
//                System.out.print("*");
//            }
//            for (int j = 5; j > i1; j--) {
//                System.out.print("*");
//            }
//            System.out.println();
//            }
//        }
    }
}

//

package com.chao.struct;

public class TestDemo01 {
    public static void main(String[] args) {
        //打印菱形 -- 打印出来的菱形行数要为奇数，定义行数row定义为偶数
        int row = 12;//定义行数
        int maxNum = (row + 1) / 2;

        //菱形上半部正三角打印
        for (int i = 1; i < maxNum; i++){
            //打印空格
            for (int j = 1; j <= maxNum - i; j++){
                System.out.print(" ");
            }
            //打印内容
            for (int k = 1; k <= (2*i) - 1; k++){
                System.out.print("*");
            }
            //换行打印
            System.out.println();
        }
        //正三角

        //菱形下部倒三角打印
        for (int i = row - maxNum; i > 0; i--){
            //打印空格
            for (int j = 1; j <= maxNum - i; j++){
                System.out.print(" ");
            }
            //打印内容
            for (int k = 1; k <= (2*i) - 1; k++){
                System.out.print("*");
            }
            //换行打印
            System.out.println();
        }
        //倒三角
    }
}

//

package com.chao.struct;

public class TestDemo02 {
    public static void main(String[] args) {
        //打印爱心，爱心里内容：I Love You
        System.out.println(callBack("*"));
    }

    public static String callBack(String input) {

        int[] array = { 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1,
                0, 0, 1, 1, 4, 5, 2, 3, 4, 1, 0, 1,

                0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,
                0, 0, 0, 0, 0, 0 };

        StringBuffer sb = new StringBuffer();

        for (int i = 0; i < array.length; i++) {

            if (i % 7 == 0)

                sb.append("  \n");

            if (array[i] == 0)

                sb.append("   ");

            else if (array[i] == 4)

                sb.append("  ");

            else if (array[i] == 5)

                sb.append(" I ");

            else if (array[i] == 2)

                sb.append("Love ");

            else if (array[i] == 3)

                sb.append("You");

            else

                sb.append("  " + input);

        }

        return sb.toString();

    }
}

//

package com.chao.struct;

public class TestDemo03 {
    public static void main(String[] args) {
        //打印爱心 分三个大部分 上中下

        for (int i = 0, k = 0; i < 14; i++) {// 打印行

            // 上部分 上分为 四个部分

            if (i < 3) {

                for (int j = 0; j < 5 - 2 * i; j++) {// 1、空心

                    System.out.print(" ");

                }

                if (i == 2) {// 2、*

                    for (int j = 0; j < 6 + 4 * i - 1; j++) {

                        System.out.print("*");

                    }

                    for (int j = 0; j < 7 - 4 * i + 2; j++) {// 3、空心

                        System.out.print(" ");

                    }

                    for (int j = 0; j < 6 + 4 * i - 1; j++) {// 4、*

                        System.out.print("*");

                    }

                } else {

                    for (int j = 0; j < 6 + 4 * i; j++) {// 2、*

                        System.out.print("*");

                    }

                    for (int j = 0; j < 7 - 4 * i; j++) {// 3、空心

                        System.out.print(" ");

                    }

                    for (int j = 0; j < 6 + 4 * i; j++) {// 4、*

                        System.out.print("*");

                    }

                }

            } else if (i < 6) {// 中间

                for (int j = 0; j < 29; j++) {

                    System.out.print("*");

                }

            } else {// 下部分 6

                if (i == 13) {

                    for (int j = 0; j < 2 * (i - 6); j++) {// 打印空格

                        System.out.print(" ");

                    }

                    System.out.print("*");

                } else {

                    for (int j = 0; j < 2 * (i - 6) + 1; j++) {// 打印空格

                        System.out.print(" ");

                    }

                    for (int j = 1; j < 28 - 4 * k; j++) {

                        System.out.print("*");

                    }

                    k++;

                }

            }

            System.out.println();// 换行

        }
    }
}