/*运算符之二：赋值运算符
=  +=  -=  *=  /=  %=

 */
public class SetValueTest {

    public static void main(String[] args) {
        //赋值符号：=
        int i1 = 10;
        int j1 = 10;

        int i2, j2;
        //连续赋值
        i2 = j2 = 10;

        int i3 = 10, j3 = 20;

        //****************
        int num1 = 10;
        num1 += 2;//num1 = num1 + 2;
        System.out.println(num1);//12

        int num2 = 12;
        num2 %= 5;//num2 = num2 % 5;
        System.out.println(num2);

        short s1 = 10;
        //s1 = s1 + 2;//编译失败
        s1 += 2;//不会改变变量本身的数据类型
        System.out.println(s1);

        //开发中实现+2的操作，有几种方法？（前提 int num = 10）
        //方式一： num = num + 2;
        //方式二： num +=2;(推荐)

        //开发中 如果希望实现+1的操作 有几种方法？
        //方法一 num = num +1;
        //方法二 num +=1;
        //方法三 num++;(推荐)


    }


}

CompareTest

public class CompareTest {
    public static void main(String[] args) {
        int i = 10;
        int j = 20;

        System.out.println(i == j);//false
        System.out.println(i = j);//20

        boolean b1 = true;
        boolean b2 = false;

        System.out.println(b2 == b1);//false
        System.out.println((b2 = b1));//true
        
    }
    
}

LogicTest

/*
&  && |  ||  ！ ……

 */
public class LogicTest {

    public static void main(String[] args) {

        //区分 & 与 &&
        //相同点1：&与&&的运算结果相同
        //相同点2：当符号左边是true时，二着都会执行符号右边的运算
        //不同点：当符号左边是false时，& 继续执行符号右边的运算。&&不再执行符号右边的运算
        //开发中，推荐使用&&
        boolean b1 = true;
        b1 = false;
        int num1 = 10;
        if (b1 & (num1++ > 0)) {
            System.out.println("我现在在北京");
        } else {
            System.out.println("我现在在南京");
        }
        System.out.println("num1=" + num1);


        boolean b2 = true;
        b2 = false;
        int num2 = 10;
        if (b2 && (num2++ > 0)) {
            System.out.println("我现在在北京");
        } else {
            System.out.println("我现在在南京");
        }
        System.out.println("num2=" + num2);


        //区分| 与 ||
        //相同点1：| 与|| 的运算结果相同
        //相同点2：当符号左边是false时，二者都会执行符号右边的运算
        //不同点3；当符号左边是true时，|继续执行符号右边的运算，||不再执行符号右边的运算
        //开发中，推荐使用||

        boolean b3 = false;
        b3 = true;
        int num3 = 10;
        if(b3 | (num3++ > 0)){
            System.out.println("我现在在北京");
        }else{
            System.out.println("我现在在南京");
        }
        System.out.println("num3 = "+num3);


        boolean b4 = false;
        b4 = true;
        int num4 = 10;
        if(b4 | (num4++ > 0)){
            System.out.println("我现在在北京");
        }else{
            System.out.println("我现在在南京");
        }
        System.out.println("num4 = "+num4);

    }

}

BitTest

/*运算符之五：位运算符（了解）

结论 1，位运算符操作范围的都是整型的数据
     2，<< 在一定范围内，每向左移1位，相当于 * 2
        >> 在一定范围内，每向右移1位，相当于 / 2

 */

public class BitTest {
    public static void main(String[] args) {
        int i = 21;

        System.out.println("i << 2 :" + (i << 2));
        System.out.println("i << 3 :" + (i << 3));
        System.out.println("i << 27 :" + (i << 3));

        int m = 12;
        int n = 5;
        System.out.println("m & n :" + (m & n));
        System.out.println("m | n :" + (m | n));
        System.out.println("m ^ n :" + (m ^ n));

        //联系：交换两个变量的值
        int num1 = 10;
        int num2 = 20;
        System.out.println("num1 = " + num1 + ",num2" + num2);

        //方式一：定义临时变量的方式（水和雪碧用一个空杯子作为介质）
        //int temp = num1;
        //num1 = num2;
        //num2 = temp;

        //方式二：甲乙在河中 甲跳到乙脖子上 乙跳到甲的位置 甲再跳到乙位置上
        //好处，不用定义临时变量
        //弊端：相加可能超出存储范围 局限性：只适用与数值类型
        //num1 = num1 + num2;
        //num2 = num1 -num2;
        //num1 = num1 - num2;

        //System.out.println("num1 = "+ num1 +",num2 = " + num2);

        //方法三，使用位运算符
        num1 = num1 ^ num2;
        num2 = num1 ^ num2;
        num1 = num1 ^ num2;

        System.out.println("num1 = " + num1 + ",num2 = " + num2);


    }
}

SanYuanTest

/*
1 结构：（条件表达式）？表达式1 ：表达式2
2 说明
        ①条件表达式的结果为boolean类型
        ②根据条件表达式真或假，决定来执行表达式1还是表达式2
                如果表达式为true，则执行表达式1
                如果表达式为false，则执行表达式2
        表达式1和表达式2要求是一致的 int string
        三元运算符可以嵌套使用 无限套娃哈哈哈

3 凡是可以使用三元运算符的地方，都可以改写成if-else
  反之，不成立。
4 如果程序可以使用三元运算符，又可以使用if-else结构，那么优先使用三元运算符。因为 简洁，执行效率高


 */
public class SanYuanTest {

    public static void main(String[] arga) {

        //获取两个整数的较大值
        int m = 12;
        int n = 5;

        int max = (m > n) ? m : n;
        System.out.println(max);

        //(m > n)? 2 : "n大";//编译错误

        //*************************
        n = 12;
        String maxstr = (m > n) ? "m大" : ((m == n) ? "m与n相等" : "n大");
        System.out.println(maxstr);

        //*************************
        //获取三个数的最大值
        int n1 = 12;
        int n2 = 30;
        int n3 = -43;

        int max1 = (n1 > n2) ? n1 : n2;
        int max2 = (max1 > n3) ? max1 : n3;
        System.out.println("三个数中的最大值为：" + max2);

        //不建议
        int max3 = (((n1 > n2) ? n1 : n2) > n3) ? ((n1 > n2) ? n1 : n2) : n3;
        System.out.println("三个数中的最大值为：" + max3);
        //改写成if-else

    }

}

流程控制（代码）

Scanner使用

ScannerTest

选择结构语句

IfTest

/*
结构一
if(条件表达式){
    执行表达式
}

结构二 二选一
if（条件表达式）{
    执行表达式1
}else{
    执行表达式2
}

结构三 n选一
if（条件表达式）{
    执行表达式1
}else if（条件表达式）{
    执行表达式2
}else if（条件表达式）{
    执行表达式3
}

.....

else{
    执行表达式n
}

 */
public class IfTest {
        public static void main(String[]arga){

        //举例一
        int heartBeats = 79;
        if (heartBeats < 60 || heartBeats > 100) {
            System.out.println("需要做进一步检查");
        }

        System.out.println("检查结束");


        //举例2
        int age = 23;
        if (age < 18){
            System.out.println("你还可以看动画片");
        }else{
            System.out.println("你可以看成人电影了");
        }


        //举例3
        if (age < 0){
            System.out.println("你输入的数据非法");
        }else if (age < 18){
            System.out.println("青少年时期");
        }else if (age < 35){
            System.out.println("青壮年时期");
        }else if (age < 60){
            System.out.println("中年时期");
        }else if (age < 120){
            System.out.println("你是要成仙啊");
        }


        //练习 获取三个数中较大值的实现


        int num1 = 10,num2 = 21,num3 = -21;
        int max;
        if (num1 >= num2 && num1 >= num3){
            max = num1;
        }else if (num2 >= num1 && num2 >= num3){
            max = num2;
        }else{
            max = num3;
        }
        System.out.println("三个数中的最大值为：" + max);

        }

}

IfWork

/*
岳小鹏参加Java考试，他和父亲岳不群达成承诺
如果
成绩为100，奖励一台BMW
成绩为（80，99】，奖励一台 iphone xs max；
成绩为【60，80】，奖励一个ipad；
其它时，什么奖励都没有
请从键盘输入岳小鹏的成绩，并加以判断

说明
1.如果多个条件表达式是互斥关系（或没有交集的关系），上面下面无所谓
                 是交集关系 需要根据实际情况来考虑
                 是包含关系 需要将范围小的声明在范围大的上面。否则，范围小的就没机会执行了

 */

public class IfWork {
    public static void main(String[]args){
        Scanner scan = new Scanner(System.in);

        System.out.println("请输入岳小鹏的期末成绩； （0-100）");
        int score = scan.nextInt();

        if (score == 100){
            System.out.println("奖励一台BMW");
        }else if (score > 80 && score <= 99 ){
            System.out.println("奖励一台iphone xs max");
        }else if (score >= 60 && score <= 80){
            System.out.println("奖励一台ipad");
        }else{
            System.out.println("什么奖励都没有");
        }



    }

}

IfWork2

/*
编写程序：由键盘输入三个整数分别存入变量num1 num2 num3
对他们进行排序（使用if-else if-else）并从小到大输出

 */

public class IfWork2 {
    public static void main(String[] args) {
        int num1 = 10, num2 = 20, num3 = 30;
        if (num1 >= num2) {
            if (num3 >= num1) {
                System.out.println(num2 + "," + num1 + "," + num3);
            } else if (num3 <= num2) {
                System.out.println(num3 + "," + num2 + "," + num1);
            } else {
                System.out.println(num2 + "," + num3 + "," + num1);
            }

        } else {
            if (num3 >= num2) {
                System.out.println(num1 + "," + num2 + "," + num3);
            } else if (num3 <= num1) {
                System.out.println(num3 + "," + num1 + "," + num2);
            } else {
                System.out.println(num1 + "," + num3 + "," + num2);
            }


        }


    }


}

IfWork3

//测算狗的年龄

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

        int dogAge = 6;
        if (dogAge >= 0 && dogAge <= 2) {
            System.out.println("相当于人的年龄：" + dogAge * 10.5);
        } else if (dogAge > 2) {
            System.out.println("相当于人的年龄：" + "（2 * 10.5 + （dogAge - 2） * 4）");
        } else {
            System.out.println("狗狗还没出生了！");

        }

        //如何获取一个随机数：10 - 99
        int value = (int) (Math.random() * 90 + 10);//[0.0,1.0)到[0.0,90.0)到[10.0,100.0)到[10,99]
        System.out.println(value);
        //公式：[a，b] ： （int)(Math.random() * (b - a + 1) + a)


    }

}

IfWork4

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

        Scanner scan = new Scanner(System.in);

        System.out.println("请输入你的身高： （cm） ");
        int height = scan.nextInt();
        System.out.println("请输入你的财富： （千万） ");
        double wealth = scan.nextDouble();
        System.out.println("请输入你是否帅： （true/false）");
        boolean isHandsome = scan.hasNext();


        if (height >= 180 && wealth >= 1 && isHandsome) {
            System.out.println("我一定要嫁给他！！！");
        } else if (height >= 180 || wealth >= 1 || isHandsome) {
            System.out.println("嫁吧，比上不足，比下有余。");
        } else {
            System.out.println("不嫁！");
        }


    }


}

SwitchTest

/*
说明：①根据switch表达式中的值，依次匹配各个case中的常量。一旦匹配成功，则进入到相应case结构中，调用其执行语句。
     当调用完执行语句以后，则依然继续向下执行其他case结构中的执行语句，直到遇到break关键字
     或此switch-case结构末尾结束为止。

     ②break，可以使用在switch-case结构中，表示一旦执行到此关键字，就跳出switch-case结构

     ③switch结构中的表达式，只能是如下的6种数据类型之一：byte short char int 枚举类型(JDK5.0新增) String类(7.0新增)

     ④case 之后只能声明常量。不能声明范围

     ⑤break关键字是可选的

     ⑥default:相当于if else结构中的else
      default结构是可选的，而且位置是灵活的

     */

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

        int number = 1;
        switch (number) {

            case 0:
                System.out.println("zero");
                break;
            case 1:
                System.out.println("one");
            case 2:
                System.out.println("two");
                break;
            case 3:
                System.out.println("three");
                break;
            default:
                System.out.println("other");

                //如果switch-case结构中的多个case的执行语句相同，则可以考虑合并


                int score = 78;
                switch (score / 10) {
                    case 0:
                    case 1:
                    case 2:
                    case 3:
                    case 4:
                    case 5:
                        System.out.println("不及格");
                        break;
                    case 6:
                    case 7:
                    case 8:
                    case 9:
                    case 10:
                        System.out.println("及格");
                        break;

                }
        }
    }

}

SwitchTest2

/*

编写程序：从键盘上输入2019年的 month 和 day 要求通过程序输入的日期为2019年的第几天

说明：
1.凡是可以使用switch-case的结构，都可以转换为if-else。反之，不成立
2.我们写分支结构时，当发现既可以使用switch-case，(同时，switch中表达式的取值情况不太多)
  又可以使用if-else时，我们优先switch-case。因为switch-case执行效率比较高

 */

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

        Scanner scan = new Scanner(System.in);
        System.out.println("请输入2019年的month:");
        int month = scan.nextInt();
        System.out.println("请输入2019年的day");
        int day = scan.nextInt();

        int sumDays = 0;
        //妙啊
        switch (month) {
            case 12:
                sumDays += 30;
            case 11:
                sumDays += 31;
            case 10:
                sumDays += 30;
            case 9:
                sumDays += 31;
            case 8:
                sumDays += 31;
            case 7:
                sumDays += 30;
            case 6:
                sumDays += 31;
            case 5:
                sumDays += 30;
            case 4:
                sumDays += 31;
            case 3:
                sumDays += 28;
            case 2:
                sumDays += 31;
            case 1:
                sumDays += day;


        }

        System.out.println("2019年" + month + "月" + day + "日是当年的第" + sumDays + "天");
    }
}

/*判断一年是否是闰年的标准
1 可以被4整除，但不可被100整除
2 可以被400整除
 */


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

        Scanner scan = new Scanner(System.in);
        System.out.println("请输入year：");
        int year = scan.nextInt();
        System.out.println("请输入month:");
        int month = scan.nextInt();
        System.out.println("请输入day");
        int day = scan.nextInt();

        int sumDays = 0;

        switch (month) {
            case 12:
                sumDays += 30;
            case 11:
                sumDays += 31;
            case 10:
                sumDays += 30;
            case 9:
                sumDays += 31;
            case 8:
                sumDays += 31;
            case 7:
                sumDays += 30;
            case 6:
                sumDays += 31;
            case 5:
                sumDays += 30;
            case 4:
                sumDays += 31;
            case 3:
                //sumDays += 28;
                //判断是否是闰年
                if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
                    sumDays += 29;
                } else {
                    sumDays += 28;
                }


            case 2:
                sumDays += 31;
            case 1:
                sumDays += day;

        }

        System.out.println(year + "年" + month + "月" + day + "日是当年的第" + sumDays + "天");

    }

}

循环结构语句

ForTest

/*
For循环结构的使用
一，循环结构的四个要素
1，初始化条件
2，循环条件---是boolean类型
3，循环体
4，迭代条件

二，for循环的结构
for(1;2;4){
    3
}

 */
public class ForTest {
    public static void main(String[] args) {

        for (int i = 1; i <= 50; i++) {
            System.out.println("Hello World!");
        }

        int num = 1;
        for (System.out.println('a'); num <= 3; System.out.println('c'), num++) {
            System.out.println('b');
        }
        //输出结果：abcbcbc


        //遍历：遍历100以内的所有偶数，输出所有偶数的和,输出偶数的个数
        int sum = 0;//记录所有偶数的和
        int count = 0;//记录偶数的个数
        for (int i = 1; i <= 100; i++) {

            if (i % 2 == 0) {
                System.out.println(i);
                sum += i;
                count++;
            }

        }
        System.out.println("总和为：" + sum);
        System.out.println("总个数为：" + count);


    }
}

ForTest1

/*
编写程序从1循环到150，并在每行打印一个值，
另外在每个3的倍数行上打印 foo
在每个5的倍数行上打印 biz
在每个7的倍数行上打印输出 baz

 */
public class ForTest1 {
    public static void main(String[] args) {

        for (int i = 1; i <= 150; i++) {

            System.out.println(i + "");

            if (i % 3 == 0) {
                System.out.println("foo");
            }
            if (i % 5 == 0) {
                System.out.println("biz");
            }
            if (i % 7 == 0) {
                System.out.println("baz");
            }


        }

    }


}

ForTest2

/*
题目 输入两个正整数m和n，求其最大公约数和最小公倍数
比如 12和20最大公约数为4，最小公倍数是60

 */
public class ForTest2 {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);

        System.out.println("请输入第一个正整数：");
        int m = scan.nextInt();

        System.out.println("请输入第二个正整数");
        int n = scan.nextInt();
        //获取最大公约数
        //获取两个数中的较小值
        int min = (m <= n) ? m : n;
        for (int i = min; i >= 1; i--) {
            if (m % i == 0 && n % i == 0) {
                System.out.println("最大公约数为：" + i);
                break;//一旦在循环中执行到break，就跳出循环
            }

        }

        //获取最小公倍数
        //1.获取两个数中的较大值
        int max = (m >= n)? m : n;
        //2.遍历
        for (int i = max;i <= m*n;i++ ){
            if (i % m == 0 && i % n == 0){

                System.out.println("最小公倍数：" + 1);
                break;
            }

        }
    }
    
}

ForWhileTest

/*
从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束程序

 */

import java.util.Scanner;

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

        Scanner scan = new Scanner(System.in);

        int positiveNumber = 0;//记录正数的个数
        int negativeNumber = 0;//记录负数的个数


        for (; ; ) {//while (true){

            int number = scan.nextInt();
            //判断number的正负情况
            if (number > 0) {
                positiveNumber++;
            } else if (number < 0) {
                negativeNumber++;
            } else {
                //一旦执行break，跳出循环
                break;
            }

        }
        System.out.println("输入的正数的个数为：" + positiveNumber);
        System.out.println("输入的负数的个数为：" + negativeNumber);
    }
}

ForForTest

/*
1.将一个循环结构声明在另一个循环结构的循环体中

外层循环
内层循环

内层循环结构遍历一遍，只相当于外层循环循环体执行了一次
假设外层循环需要执行m次，内层循环需要执行n次，此时内层循环的循环体一共执行了m * n次

外层循环控制行数，内层循环控制列数
 */
public class ForForTest {
    public static void main(String[] args) {

        /*
         ******
         ******
         ******
         ******
         */

        for (int j = 1; j <= 4; j++) {
            for (int i = 1; i <= 6; i++) {
                System.out.print("*");//注意是print
            }
            System.out.println();
        }

        /*      i(行号)   j(*的个数)
         *       1        1
         **      2        2
         ***     3        3
         ****    4        4
         *****   5        5
         */
        for (int i = 1; i <= 5; i++) {//控制行数
            for (int j = 1; j <= i; j++) {//控制列数
                System.out.print("*");
            }
            System.out.println();
        }





        /*      i(行号)   j（*的个数） 规律：i+ j = 5 换句话说：j = 5 - i；
         ****    1        4
         ***     2        3
         **      3        2
         *       4        1


         */
        for (int i = 1; i <= 4; i++) {
            for (int j = 1; j <= 5 - i; j++) {
                System.out.print("*");
            }
            System.out.println();
        }



        //上半部分
        for (int i = 0;i < 5;i++){
            //输出空格
            for (int j = 0;j < 4 - i;j++){
                System.out.print(" ");
            }

            //输出*
            for (int k = 0;k < i + 1;k++){
                System.out.print("* ");
            }
            System.out.println();
        }
        //下半部分
        for (int i = 0;i < 4;i++){
            for (int j = 0;j < i + 1;j++){
                System.out.print(" ");
            }
            for (int k = 0;k < 4 -i;k++){
                System.out.print("* ");
            }
            System.out.println();
        }
    }
}

WhileTest

/*
一，循环结构的四个要素
1，初始化条件
2，循环条件---是boolean类型
3，循环体
4，迭代条件
二，While循环的结构

1
While(2){
    3;
    4;
}

1.写while循环千万小心不要丢了迭代。一旦丢了，就可能导致死循环。要避免死循环
2.for循环和while循环可以相互转换
 区别：for循环和while循环的初始化条件部分的作用范围不同

 */
public class WhileTest {
    public static void main(String[] args) {

        //遍历100以内的所有偶数
        int i = 1;
        while (i <= 100) {

            if (i % 2 == 0) {
                System.out.println(i);
            }
            i++;

        }

        System.out.println(i);//101

    }
}

DoWhileTest

/*
一，循环结构的四个要素
1，初始化条件
2，循环条件---是boolean类型
3，循环体
4，迭代条件
二，While循环的结构

1
do{
    3;
    4;
}while(2);

1-3-4-2-3-4 ....

 */
public class DoWhileTest {
    public static void main(String[] args) {

        //遍历100以内的偶数,并计算所有偶数的和及偶数的个数
        int num = 1;
        int sum = 0;//记录总和
        int count = 0;//记录个数
        do {

            if (num % 2 == 0) {
                System.out.println(num);
                sum += num;
                count++;
            }

            num++;

        } while (num <= 100);

        System.out.println("总和为：" + sum);
        System.out.println("总个数为：" + count);

        //**************体会do-while至少执行一次的情况****************
        int number1 = 10;
        while (number1 > 10){
            System.out.println("i am while");
            number1--;
        }

        int number2 = 10;
        do {
            System.out.println("i am do while");
            number2--;
        }while (number2 > 10);
    }
}

跳出语句

BreakContinueTest

/*
相同点 关键字后面泵声明执行语句

break:  结束当前循环(switch-case与循环结构中使用)
continue:  结束当次循环(循环结构中使用)
 */
public class BreakContinueTest {
    public static void main(String[] args) {

        for (int i = 1; i <= 10; i++) {

            if (i % 4 == 0) {
                //break;//123
                continue;//123567910
            }
            System.out.print(i);
        }

        System.out.println("\n");
        //**********************

        Label:
        for (int i = 1; i <= 4; i++) {

            for (int j = 1; j <= 10; j++) {

                if (j % 4 == 0) {
                    //break;//默认跳出包裹此关键字最近的一层循环
                    //continue;

                    //break label;//结束指定标识的一层循环结构 (标签)
                    continue Label;//结束指定标识的一层循环结构当次循环
                }

                System.out.println(j);
            }

            System.out.println();
        }


    }
}

数组（代码）

数组概念

ArrayTest

/*
一，数组的概述
    1.数组的理解：数组(Array)，是多个相同类型数据按一定数据排列的集合，
    并使用一个名字命名，并通过编号的方式对这些数据进行统一管理

    2.数组相关的概念
    数组名
    元素
    角标，下标，索引
    数组的长度：元素的个数

    3.数组的特点：
    ①.数组是有序排列的
    ②.数组本身属于引用数据类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型
    ③.创建数组对象会在内存中开辟一整块连续的空间
    ④.数组的长度一旦确定，就不能修改

    4.数组的分类
       ①按照维数：一维数组 二维数组 多维
       ②按照数组元素的类型：基本数据类型元素的数组，引用数据类型的数组

    5.一维数组的使用
       ①一维数组的声明和初始化
       ②.如何调用数组的指定位置的元素：通过角标的方式调用。
       ③.如何获取数组的长度
       ④.如何遍历数组
       ⑤.数组元素的默认初始化值
       ⑥.数组的内存解析

 */
public class ArrayTest {

    public static void main(String[]args){

        //1.一堆数组的声明和初始化
        int num;//声明
        num = 10;//初始化
        int  id = 1001;//声明+初始化

        int [] ids;//声明
        //1.1静态初始化：数组的初始化和数组元素的赋值操作同时进行
        ids = new int[]{1001,1002,1003,1004};
        //1.2动态初始化：数组的初始化和数组元素的赋值操作分开进行
        String[] names = new String[5];//先把位置造好

        //2.如何调用数组的指定位置的元素：通过角标的方式调用。
        //数组的角标（或索引）从0开始的，到数组的长度-1结束。
        names[0] = "陈";
        names[1] = "刘";
        names[2] = "丁";
        names[3] = "华";
        names[4] = "徐";

        //3.如何获取数组的长度
        //属性：length
        System.out.println(names.length);//5
        System.out.println(ids.length);//4

        //4.如何遍历数组
        /*System.out.println(names[0]);
        System.out.println(names[1]);
        System.out.println(names[2]);
        System.out.println(names[3]);
        System.out.println(names[4]);*/

        for (int i = 0;i < names.length;i++){
            System.out.println(names[i]);
        }

        //5.数组元素的默认初始化值
        //数组元素是整型：0
        //数组元素是浮点型：0.0
        //数组元素是char型：0
        //数组元素是boolean型：false

        //数据类型是引用数据类型：null
        int[] arr = new int[4];
        for (int i = 0;i < arr.length;i++){
            System.out.println(arr[i]);
        }
        System.out.println("***************");

        short[] arr1 = new short[4];
        for (int i = 0;i < arr1.length;i++){
            System.out.println(arr[i]);
        }
        System.out.println("*************");
        float[] arr2 = new float[5];
        for(int i = 0;i < arr2.length;i++){
            System.out.println(arr2[i]);
        }
        System.out.println("***************");
        //char型
        char[] arr3 = new char[4];
        for (int i = 0;i < arr3.length;i++){
            System.out.println("----"  + arr3[i] + "****");
        }

        if (arr3[0] == 0){
            System.out.println("你好！");
        }

        System.out.println("***************");
        boolean[] arr4 = new boolean[5];
        System.out.println(arr4[0]);

        System.out.println("***************");
        String[] arr5 = new String[5];
        System.out.println(arr5[0]);
        if (arr5[0] == null){
            System.out.println("今天不错！");
        }


    }

}

数组练习

ArrayDemo1

/*
从键盘读入学生成绩，找出最高分，并输出学生成绩等级
成绩》=最高分-10 等级为A
成绩》=最高分-20 等级为B
成绩》=最高分-30 等级为C
其余           等级为D
 */

public class ArrayDemo1 {
    public static void main(String[]args){
        //1.使用Scanner，读取学生个数
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入学生人数：");
        int number = scanner.nextInt();

        //2、创建数组，存储学生成绩，动态初始化
        int[] scores = new int[number];
        //3,给数组中的元素赋值
        System.out.println("请输入" + number + "个学生成绩：");
        for (int i = 0;i < scores.length;i++){
            scores[i] = scanner.nextInt();
        }
        //4.获取数组中的元素的最大值：最高分
        int maxScorce = 0;
        for (int i = 0;i < scores.length;i++){
            if (maxScorce < scores[i]){
                maxScorce = scores[i];
            }
        }
        //5.根据每个学生成绩与最高分的差值，得到每个学生的等级，并输出等级和成绩
        char level;
        for (int i = 0;i < scores.length;i++){
            if (maxScorce - scores[i] <= 10){
                level = 'A';
            }else if (maxScorce - scores[i] <= 20){
                level = 'B';
            }else if (maxScorce - scores[i] <= 30){
                level = 'C';
            }else{
                level = 'D';
            }

            System.out.println("student" + (i+1) + scores[i] + ",grade is " + level);
        }
    }
}

YangHuiTest

/*
使用二维数组打印一个10行杨辉三角

1 第一行有一个元素，第n行有n个元素
2 每一行的第一个元素和最后一个元素都是1
3 从第三行开始，对于非第一个元素和最后一个元素的元素 即
yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];
 */
public class YangHuiTest {

    public static void main(String[] args) {
        //1.声明并初始化二维数组
        int[][] yangHui = new int[10][];

        //2.给数组的元素赋值
        for (int i = 0; i < yangHui.length; i++) {
            yangHui[i] = new int[i + 1];

            //2.1给首末元素赋值
            yangHui[i][0] = yangHui[i][i] = 1;
            //2.2给每行的非首末元素赋值
            // if (i > 1) {
                for (int j = 1; j < yangHui[i].length - 1; j++) {
                    yangHui[i][j] = yangHui[i - 1][j - 1] + yangHui[i - 1][j];
                }
                //}

            }

            //3.遍历二维数组
            for(int i = 0; i < yangHui.length; i++) {
                for (int j = 0; j < yangHui[i].length; j++) {
                    System.out.print(yangHui[i][j] + "  ");
                }
                System.out.println();
            }


        }
    }

二维数组

ArrayTest2

/*
二维数组的使用
1.一堆数组的声明和初始化
2.如何调用数组的指定位置的元素：通过角标的方式调用。
3.如何获取数组的长度
4.如何遍历数组
5.数组元素的默认初始化值
6.数组的内存解析
 */
public class ArrayTest2 {
    public static void main(String[] args) {
        //1.二维数组的声明和初始化
        int[] arr = new int[]{1, 2, 3};//一堆数组
        //静态初始化
        int[][] arr1 = new int[][]{{1, 2, 3}, {4, 5}, {6, 7, 8}};
        //动态初始化1
        String[][] arr2 = new String[3][2];
        //动态初始化2
        String[][] arr3 = new String[3][];

        //也是正确的写法：
        int[] arr4[] = new int[][]{{1, 2, 3}, {4, 5, 9, 10}, {6, 7, 8}};
        int[] arr5[] = {{1, 2, 3}, {4, 5}, {6, 7, 8}};//可省略new int 也是正确的写法

        //2.如何调用数组的指定位置的元素
        System.out.println(arr1[0][1]);//2
        System.out.println(arr2[1][1]);//null

        arr3[1] = new String[4];
        System.out.println(arr3[1][0]);

        //3.获取数组的长度
        System.out.println(arr4.length);//3
        System.out.println(arr4[0].length);//3
        System.out.println(arr4[1].length);//4

        System.out.println("**********************");
        //4.如何遍历二维数组
        for (int i = 0; i < arr4.length; i++) {

            for (int j = 0; j < arr4[i].length; j++) {
                System.out.print(arr4[i][j] + " ");
            }
            System.out.println();
        }
    }
}

ArrayTest3

/*
规定：二维数组分为外层数组的元素，内层数组的元素
        int[][] arr = new int[4][3];
        外层元素：arr[0],arr[1]
        内层元素：arr[0][0],arr[1][2]

        2.数组元素的默认初始化值
针对初始化方式一：比如 int[][] arr = new int[4][3];
        外层元素的初始化值为 地址值
        内层元素的初始化值为 与一维数组初始化情况相同

针对于初始化方式二 比如 int[][] arr = new int[4][];
        外层元素的初始化值为 null
        内层元素的初始化值为 不能调用，否则报错

        数组的内存解析
 */
public class ArrayTest3 {
    public static void main(String[]args){

        int[][] arr = new int[4][3];
        System.out.println(arr[0]);//地址值
        System.out.println(arr[0][0]);//0

        //System.out.println(arr);//地址值

        System.out.println("**************");
        float[][] arr1 = new float[4][3];
        System.out.println(arr1[0]);//地址值
        System.out.println(arr1[0][0]);//0.0

        System.out.println("**************");

        String[][] arr2 = new String[4][2];
        System.out.println(arr2[1]);//地址值
        System.out.println(arr2[1][1]);//null


    }
}

数组的复制，反转，查找

ArrayExer2

/*
算法的考查：数组的复制 反转 查找（线性查找 二分法查找）
 */
public class ArrayExer2 {
    public static void main(String[]args){

        String[] arr = new String[]{"jj","dd","mm","bb","gg","aa"};

        //数组的复制（区别与数组的赋值：arr1 = arr2）
        String[] arr1 = new String[arr.length];
        for (int i = 0;i < arr1.length;i++){
            arr1[i] = arr[1];
        }

        //数组的反转
        //方式一：
        /*
         for (int i = 0;i < arr.length / 2;i++){
            String temp = arr[i];
            arr[i] = arr[arr.length - i - 1];
            arr[arr.length - i - 1] = temp;
        }
         */


        //方式二：
        for (int i = 0,j = arr.length - 1;i < j;i++,j--){
            String temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }

        //遍历
        for (int i = 0;i < arr.length;i++){
            System.out.print(arr[i] + "\t");

        }
        System.out.println();


        //查找（或搜索）
        //线性查找：

        String dest = "bb";

        boolean isFlag = true;

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

            if (dest.equals(arr[i])){
                System.out.println("找到了指定的元素，位置为：" + i);
                isFlag = false;
                break;
            }
        }
        if (isFlag){
            System.out.println("很遗憾，没有找到哦！");
        }

        //二分法查找(折半查找)
        //前提：所要查找的数组必须有序
        int[] arr2 = new int[]{-98,-34,2,34,54,66,79,105,210,333};

        int dest1 = -34;
        int head = 0;//初始的首索引
        int end = arr2.length - 1;//初始的末索引
        boolean isFlag1 = true;
        while (head <= end){

            int middle = (head + end)/2;

            if (dest1 ==arr2[middle]){
                System.out.println("找到指定的元素，位置为：" + middle);
                isFlag1 = false;
                break;
            }else if(arr2[middle] > dest1){
                end = middle - 1;
            }else {//arr2[middle] < dest1
                head = middle + 1;
            }
        }

        if (isFlag1){
            System.out.println("很遗憾，没有找到啦！");
        }


    }
}

冒泡排序

BubbleSortTest

/*
数组的冒泡排序的实现
 */
public class BubbleSortTest {
    public static void main(String[] args){

        int[] arr = new int[]{43,32,76,-98,0,64,33,-21,32,99};

        //冒泡排序
        for (int i = 0;i < arr.length - 1;i++){

            for (int j = 0;j < arr.length - 1 - i;j++){

                if (arr[j] > arr[j + 1]){
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }

            }
        }
        for (int i = 0;i < arr.length;i++){
            System.out.println(arr[i] + "\t");
        }


    }
}

数组常见异常

ArrayExceptionTest

/*
数组中的常见异常
1.数组角标越界的异常：ArrayIndexOutOfBoundsException

2.空指针异常:NullPointerException
 */
public class ArrayExceptionTest {
    public static void main(String[] args) {

        //角标越界
        int [] arr = new int[]{1, 2, 3, 4, 5};

        //for (int i = 0;i <= arr.length;i++){
        //    System.out.println(arr[i]);
        //}

        //2.2 空指针异常
        //情况一：
        //int[] arr1 = new int[]{1,2,3};
        //arr1 = null;
        //System.out.println(arr1[0]);

        //情况二：
        //int [][] arr2 = new int[4][];
        //System.out.println(arr2[0][0]);

        //情况三：
        //String[] arr3 = new String[]{"AA","BB","CC"};
        //arr3[0] = null;
        //System.out.println(arr3[0].toString());
    }
}