Home

韧桂

思考,总结

Java基本语法

/**
 文档注释(两个星号,可被解析)
 这是我的第一个 Java程序
 @author rengui
 @version v1.0
 */

public class HelloJava{
    /*
    1.源文件以 .java 结尾
    2. 源文件中可以有多个 class 声明的类
    3. 类中可以有主方法(即 main() 方法),其格式是固定的:public static void main(String[] args){}
    4. main()方法是程序的入口,方法内是程序的执行部分。
    5. 一个源文件中只能有一个声明为 public 的类,同时要求此类的类名与源文件名一致。
    6. 每个语句都以 ";" 结束。
    7. 执行程序:①编译:java.exe 编译完,生成诸多个 .class 字节码文件。②运行: java.exe
    8. 多行注释不能嵌套。
    */
    public static void main (String[] args) {
		/*
		这是程序的输出语句
		格式如下:System.out.println();
		*/
        System.out.println("welcome to ningde!" + "Hello Java");
        System.out.println("    " + "*" + "      ");
    }
}

一、关键字

  • 关键字的定义和特点
    • 定义:被Java语言赋予了特殊含义,用做专门用途的字符串(单词)
    • 特点:关键字中所有字母都为小写

二、标识符:

  • Java 对各种 变量、方法、类和借口等要素命名时使用的字符序列称为标识符
  • 凡是自己可以起名字的地方都叫标识符。

(一)、定义合法标识符规则:

  1. 由26个英文字母大小写,0-9 ,_或 $ 组成
  2. 数字不可以开头。
  3. 不可以使用关键字和保留字,但能包含关键字和保留字。
  4. Java中严格区分大小写,长度无限制。
  5. 标识符不能包含空格。

(二)、 Java中的名称命名规范:(不遵守,也不会报错)

  • 包名:多单词组成时所有字母都小写:xxxyyyzzz
  • 类名、接口名:多单词组成时,所有单词的首字母大写:XxxYyyZzz
  • 变量名、方法名:多单词组成时,第一个单词首字母小写,第二个单词开始每个单词首字母大写:xxxYyyZzz
  • 常量名:所有字母都大写。多单词时每个单词用下划线连接:XXX_YYY_ZZZ

(三)、变量

  1. 定义变量的格式:数据类型 变量名 = 初始化值
  2. Java中每个变量必须先声明,后使用
  3. 变量的作用域:一对{ }之间有效
class Hello{
    public static void main(String[] args) {
        int a = 1;
        String b = "asdf";
        System.out.println(b);
    }
}

/*
变量之间的运算:(不考虑 Boolean。剩下: char byte short int long float double)
1. 自动类型转换
2. 强制类型转换
 */
class TestVeriable{
    public static void main(String[] args) {
        //自动类型转换:当容量小的数据与容量大的数据类型做运算时,容量小的会自动转换为容量大的数据类型。
        //char,byte,short ==>int  ==> long ==> float  ==> double
        //char,byte,short 之间做运算,默认结果为 int 类型
        int a = 12;
        short b = 2;
        int c = a + b;
        float d = 12.3F;
        float f = c + d;
        double g = f + 12.3;
        System.out.println(c);
        System.out.println(f);

        /*强制类型转换:容量大的转换为小的,要使用强制类型转换符:()
        强制类型转换存在的问题:导致精度的损失,
         */
        long h = 12345L;
        int m =(int)h;
        System.out.println(m);

        //平时常用的字符串,也是一种数据类型:String
        String  nation = "made in chan";
        System.out.println(nation);

        //字符串与基本数据类型之间的运算:只能是连接运算: +。得到的结果认为一个字符串。
        String str = "Hello";
        String str1 = str + m;//Hello12345
        System.out.println(str1);

        //先有字符串计算,则全为字符串计算。先有数字计算,再有字符串计算,则数字算完后再与字符串计算。
        char ch = 'a';
        System.out.println(str1 + a + ch);//Hello1234512a
        System.out.println(a + ch + str1);//109Hello12345
        System.out.println(ch + str1 + a);//aHello1234512
    }

}

三、 1.所有数字在计算机底层都以二进制形式存在。

  1. 计算机以补码的形式保存所有的整数。 正数的原码、反码、补码都相同 负数的补码是其反码加1。
  2. 原码:直接将一个数值换成二进制数。
  3. 反码:是对原码按位取反,只是最高位(符号位)确定为1。
  4. Java整数常量默认是int类型,当用二进制定义整数时,其第32位是符号位;当是long类型时,二进制默认占64位,第64位是符号位

1.原码(true form)是一种计算机中对数字的二进制定点表示方法。 原码表示法在数值前面增加了一位符号位(即最高位为符号位): 正数该位为0,负数该位为1(0有两种表示:+0和-0),其余位表示数值的大小。 例如,我们用8位二进制表示一个数,+11的原码为00001011,-11的原码就是10001011

四、

public class Variable {
    public static void main(String[] args){
        int a = 3;  //a 的数据类型是 int,等于 3.
        //int 用来表示一个整数,取值范围在 -2^31 ~ 2^31-1。计算出来是 -2147483648 ~ 2147483647
        int b = 5;
        int c = 7;

        /*
        int variable;
        variable = 999;
        等于
        int variable = 999;
         */

        int x = 1;
        int y = a*x + b*x*x + c*x*x*x;
        System.out.println(y);

    }
}

整数类型 byte占用1个byte。值域-128~127 short占用2个byte。值域-32768~32767 int占用4个byte。值域-2147483648~2147483647.Java中整数缺省是int类型 long占用8个byte。值域-922337203685477808~922337203685477807

浮点(小数)类型 float占用4个byte,有精度,值域复杂+- double精度是float的两倍,占用8个byte,Java中浮点数缺省是double类型

布尔和字符数据类型 boolean占用1个byte,值域是true,false。代表真假 char占用2个byte,值域是所有字符

public class PrimaryTypes {
    public static void main(String[] args) {
        /*bit 和 byte
        一个二进制的位叫做一个bit。
        八个二进制的位,组成一个 byte。
         */


        /*整数类型
        byte占用 1 个byte。值域 -128 ~ 127
        short占用 2 个byte。值域 -32768 ~ 32767
        int 占用 4 个byte。值域 -2147483648 ~ 2147483647.Java中整数缺省(默认)是 int 类型
        long 占用 8 个byte。值域 -9223372036854774808 ~ 9223372036854774807
         */
        byte byteVar = 99;
        System.out.println(byteVar);

        short shortVar = -30000;
        System.out.println(shortVar);

        int intVar = 300000;
        System.out.println(intVar);

        long longVar = 99;

        long bigLongVar = 9999999999L; //L表示是long类型。一般用大写L,当然小写也可以,不过,小写易于与1混看。
        System.out.println(bigLongVar); //sout 加Tab 键可快速输入该语句。


        /*浮点(小数)类型
        float占用 4 个byte,有精度。值域复杂
        double 精度是 float 的两倍,占用 8 个byte。Java中浮点数缺省是 double 类型。
         */
        float floatVar = 100.1F;  //F表示float类型,大小写都可。
        System.out.println(floatVar);

        double doubleVar =100.1;
        System.out.println(doubleVar);


        /*boolean 占用 1 个byte,值域是 true,false。
        char 占用 2 个byte,值域是所有字符。
         */
        boolean condition = true;
        boolean fcondition = false;
        System.out.println(condition);

        char ch ='A';
        System.out.println(ch);
    }
}
public class ModCalc {
    public static void main(String[] args) {
        /*取模运算符:%
        1. 用来计算余数
        2. 负数也可以被取模
        3. 负数也可以取模
        4. 小数也可以取模
         */
        //int num = 10;
        int num = -10;

        System.out.println(num % 2);
        System.out.println(num % -3);
        System.out.println(num % 4);
        System.out.println(num % 5);
        System.out.println(num % -6);


        //int 除以int 还是 int ,不会变成浮点数
        int a = 10;
        int b = 3;
        double c = 3.0;
        System.out.println(a / b);
        System.out.println(a / c);


        /*
        布尔运算符:
        ! 叫做非运算符,not 运算符。!true 是 flase ,!false 是 true。
        & 叫做且运算符,and 运算符。true & flase 是flase,true & true 是 true。
        && 叫做且且运算符,andand 运算符。运算结果和 & 一样。常用&&,而不用& 。 &: 不管左边是true还是flase,右端都会进行计算。&&: 当左端为false时,右端不再进行计算。
        | 叫做或运算符,or 运算符。true | flase 是 flase,true | true 是 true, false | flase 是 flase。
        || 叫做或或运算符,oror 运算符.运算结果和 | 一样。常用||,而不用| 。|: 当左端为true 时,右端照样做运算。||:当左端为true 时,右端不再进行运算。
         */
        byte d = 10;
        int e = 10;

        System.out.println(d> e);

        /*运算符优先级,由上到下逐次降低
        算数》比较》布尔》等号
        ()
        !
        *,/,%
        +,-
        >,>=,<,<=
        ==
        !=
        &,&&,|,||
        =
         */

    }
}
public class BitCalc {
    public static void main(String[] args) {
        /*位运算符不会改变原变量的值
        按位运算符不会改变原本的变量的值
        位移运算符不会改变原本的变量的值
         */
        /*
        按位(bit)运算符.一般能不用就不用
        按位并(AND):&
        按位或(OR):|
        按位异或(XOR):^
        按位取反:~
         */
        int a = 0xF8;  //二进制的 1111 1000
        int b = 0xF4;  //二进制的 1111 0100
        int c = 0xFF;  //二进制的 1111 1111

        System.out.println(a& b);
        System.out.println(a | b);
        System.out.println(a ^ b);
        System.out.println(~c);


        /*
        位移运算符:
        >>:符号位不动,其余位右移,符号位后面正数补0,负数补1,又称带符号右移。
        >>>:符号位一起右移,左边补0,又称无符号右移。
        <<:左移,右边补0.左移没有带符号位一说,因为符号位在最左侧
         */
        int d = 0x400;
        System.out.println(d);
        System.out.println(d >> 1);
        System.out.println(d >> 2);

        System.out.println(d << 1);
        System.out.println(d >> 2);

        int e = -0x400;
        System.out.println(e);
        System.out.println(e >> 1);
        System.out.println(e >> 2);

        System.out.println(e << 1);
        System.out.println(e << 2);

        System.out.println(e >>> 1);
        System.out.println(e >>> 2);


        int base = 1;
        //0001
        int is_student_mask = base;
        //0010
        int is_programmer_mask = base << 1;
        //0100
        int is_driver_mask = base << 2;
        //1000
        int is_painter_mask = base << 3;

        //二进制是 0101
        int data = 5;

        //0101 & 0001 = 1
        boolean isStudent = (data & is_student_mask) != 0;
        System.out.println(isStudent);

        //0101 & 0010 = 0
        boolean isProgrammer = (data & is_programmer_mask) != 0;
        System.out.println(isProgrammer);

        //0101 & 0100 = 0100
        boolean isDriver = (data & is_driver_mask) != 0;
        System.out.println(isDriver);

        //0101 & 1000 = 0
        boolean isPainter = (data & is_painter_mask) != 0;
        System.out.println(isPainter);
    }
}
/*
三元运算符: (条件表达式)?表达式1:表达式2;
要求:表达式1与表达式2为同种数据类型。
     既是运算符,就一定会有运算的结果,结果的数据类型与表达式1,2的类型一致。
 三元运算符在一定程度上可以与if-else 互换。(三元运算符一定可以转换为if-else,反之不成立。)
 */
public class Two {
    public static void main(String[] args) {
        int i = 10;
        int j = 20;
        //此时max记录了i与j的较大值
        int max = (i > j)? i : j;

        //String str = (i > j)? "i大" : "j大";
        String str = (i > j)? "i大" : (i == j)? "相等" : "j大";


        //互换
        if(i >= j){
            System.out.println("较大值为: " + i);
        }
        else {
            System.out.println("较大值为: " + j);
        }


        System.out.println(max);
        System.out.println(str);

    }
}

class TestConversion{
    public static void main(String[] args) {
        //手动的方式,从控制台输出 60 的十六进制。
        int i = 60;

        /*
        char c = 'a';
        char c1 = (char)(c +2);
        System.out.println(c1);  //c
        */
        int j = i & 15;//获取到i最低四位对应的值。1111为15.
        String k1 = (j <= 9)? j + "" : (char)(j - 10 + 'a') + "";//转为字符串类型。

        i = i >> 4;
        int z = i & 15;
        String k2 = (z <= 9)? z + "" : (char)(z -10 + 'a') + "";
        System.out.println(k2 +k1);
    }
}

//流程控制:顺序结构;分支结构(if-else; switch-case);循环结构(while; do…while;for(;;))

class TestIf1 {
    public static void main(String[] args) {
        /*格式三种。执行if-else时,一定选择其中的一个路径执行,
        而且也仅会选择一条路径。
        */
        int age = 28;
        if (age > 18){
            System.out.println("你已经是成年人了");
        }else{
            System.out.println("你还不能看成年电影");
        }

        if(age > 130 || age < 0){
            System.out.println("你估计不是人");
        }else if(age < 30){
            System.out.println("人家还很年轻,只有" + age + "岁");
        }else {
            System.out.println("你别追我了,我都有两个娃了");
        }
    }
}

1.根据变量的值,选择相应的case 去判断,一旦满足 case 条件,就执行case 的相应语句。 如果没有break或者未到程序结尾时,会继续执行其下的case 语句。 2/default 是可选的,而且位置是灵活的 3。变量可以是哪些数据类型:char byte short int 枚举 String 4.case 条件:其中条件只能是值,不能是取值范围

class TestSwitch1{
    public static void main(String[] args) {
        int i = 1;
        switch (i){
            case 0:
                System.out.println("zero");
            case 1:
                System.out.println("one");

            case 2:
                System.out.println("two");
                break;
            case 3:
                System.out.println("three");
            default:
                System.out.println("other");
                break;
        }
    }
}

对学生成绩大于60分的,输出“合格”。低于60分的,输出“不合格”。

注意:当多个case 语句处理的语句块一致时,可以统一书写。

class TestSwitch3 {
    public static void main(String[] args) {
        int score = 67;
//        if(score >= 60){
//            System.out.println("及格");
//        }else {
//            System.out.println("不及格");
//        }
        switch (score / 10) {
            case 10:
            case 9:
            case 8:
            case 7:
            case 6:
                System.out.println("及格");
                break;
            case 5:
            case 4:
            case 3:
            case 2:
            case 1:
            case 0:
                System.out.println("不及格");
                break;
            default:
                System.out.println("输入有误");
                break;
        }
    }
}

流程控制

/*
for 循环结构:
1.格式:
①初始化条件
②循环条件
③迭代条件
④循环体
for(①;②;③){
    //④
}
2.执行过程:❶-❷-④-③-②-④-③-②.......-④-③-②
        即直至循环条件不满足,退出当前循环。
 */

import java.util.Scanner;


public class Three {
    public static void main(String[] args) {
        for(int i = 0; i < 4; i++){
            System.out.println("Hello World");
        }

        int j = 1;
        for(System.out.print('a'); j < 3; System.out.print('b'), j++){
            System.out.print('c');
        }//acbcb

        //题目:输出 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("100以内的偶数个数为:" + count);
    }
}

编写程序FooBizBaz.java,从1循环到150并在每行打印一个值, 另外在每个3的倍数行上打印出“foo”,在每个5的倍数行上打印“biz”, 在每个7的倍数行上打印输出“baz”。

class FooBizBaz{
    public static void main(String[] args) {
        for(int i = 1;i <= 150;i++){
            System.out.print(i + " ");  //println 会换行
            if(i % 3 == 0){
                System.out.print("foo ");
            }
            if(i % 5 == 0){
                System.out.print("biz ");
            }
            if(i % 7 == 0){
                System.out.print("baz ");
            }
            System.out.println();//换行
        }
    }
}

输出所有的水仙花数,所谓水仙花数是指一个3 位数,其各个位上数字立方和等于其本身。 例如: 153 = 111 + 333 + 555

class ShuiXianHua{
    public static void main(String[] args) {
        for(int i =100;i < 1000; i++){//实现100~999的遍历
            int j1 = i / 100;//百位
            int j2 = (i - j1*100)/10;//十位  456 - 400 = 56 / 10 = 5
            int j3 = i % 10;//个位

            if(i == j1*j1*j1 + j2*j2*j2 + j3*j3*j3){
                System.out.println(i);
            }
        }
    }
}

while 循环结构: ①初始化条件 ②循环条件 ③迭代条件 ④循环体 1.格式: ① while(②){ ④ ③ }

  1. for 循环与while循环可以相互转换
class TestWhile{
    public static void main(String[] args) {
        //100以内的偶数的输出,及其和
        int i = 1;
        int sum = 0;
        while(i <= 100){
            if(i % 2 == 0){
                System.out.println(i);
                sum +=i;
            }
            i++;
        }
        System.out.println("100以内的偶数的和为:" + sum);
    }
}

dowhile 循环结构: ①初始化条件 ②循环条件 ③迭代条件 ④循环体 1.格式: ① do{ ④ ③ }while(②);

  1. do-while 与 while 的区别:do-while循环至少执行一次
class TestDoWhile{
    public static void main(String[] args) {
        //100以内的偶数的输出
        int i = 1;
        do{
            if(i % 2 == 0){
                System.out.println(i);
            }
            i++;
        }while (i <= 100);
    }
}

问题一:从键盘读入个数为 10 个的整数,并判断读入的正数和负数的个数, 问题二:从键盘读入个数不确定的整数,并判断读入的正数和负数的个数,输入为0时结束程序。

无限循环: for(;;){} 或者: while(true){ } 说明:一般情况下,在无限循环内部要有程序终止的语句,使用 break 实现。若没有,那就是死循环。

//import java.util.Scanner;
class TestExer{
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int a = 0;//记录正数的个数
        int b = 0;//记录负数的个数

        //for(;;){
        while (true){
            System.out.println("请输入一个整数:");
            int num = s.nextInt();
            if (num > 0)
                a++;
            else if (num < 0)
                b++;
            else
                break; //输入 0 时终止
        }
        /*
        //问题一
        for (int i = 0; i < 10;i++){
            System.out.println("请输入第" + (i + 1) + "个正数");
            int num = s.nextInt();
            if (num > 0)
                a++;
            else if (num < 0)
                b++;
        }
         */


        System.out.println("正数的个数为:" + a);
        System.out.println("负数的个数为:" + b);

    }
}

嵌套循环:循环中还可以声明循环。相当于内层循环的整体充当外层循环的循环体。 若外层循环执行 m 次,内层循环执行 n 次,整个程序执行 m*n 次。 for(;;){ for(;;){

} } 或者: while(){
for(;;){

} }
class TestForFor{
    /*
    *****
    *****
    *****
    *****
     */
    public static void main(String[] args) {
        for(int j = 0;j < 4;j++){//外层循环控制行数
            for(int i = 0;i < 5;i++){//内层循环控制列数
                System.out.print("*");
            }
            System.out.println();
        }
//        for(int i = 0;i < 5;i++){
//            System.out.print("*");
//        }
//        System.out.println();
//        for(int i = 0;i < 5;i++){
//            System.out.print("*");
//        }
//        System.out.println();
//        for(int i = 0;i < 5;i++){
//            System.out.print("*");
//        }
//        System.out.println();
        /*
        *
        **
        ***
        ****
         */
        for(int j = 0;j < 4;j++){//外层循环控制行数
            for(int i = 0;i < j + 1;i++){//每行输出 j + 1 个。
                System.out.print("*");
            }
            System.out.println();
        }

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

/*
----*
---* *
--* * *
-* * * *
* * * * *
i  j(-)  k(*)
0   4    1
1   3    2
2   2    3
3   1    4
4   0    5
 * * * *
  * * *
   * *
    *
 */
        //上半部分:
        for(int i = 0;i < 5;i++){
            //输出“-”
            for(int j = 0;j < 4-i;j++){
                //System.out.print("-");
                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("-");
                System.out.print(" ");
            }

            //输出“* ”
            for(int k = 0;k < 4 - i;k++){
                System.out.print("* ");
            }
            System.out.println();
        }
    }
}

1 * 1 = 1 2 * 1 = 2 2 * 2 = 4 … 9 * 1 = 9 …… 9 * 9 = 81

class TestJiuJiu{
    public static void main(String[] args) {
        for(int i = 1;i <= 9;i++){//一共有 9 行
            for(int j = 1;j <= i;j++){//每行有 i 个等式
                System.out.print(i + "*" + j + "=" + i*j + "\t");
            }
            System.out.println();//换行
        }
    }
}

100 以内的所有质数 质数是指在大于1的自然数中,除了1和它本身以外不再有其他因数的自然数。

class TestPrimeNumber{
    public static void main(String[] args) {
        long start = System.currentTimeMillis();//获取系统当前的毫秒数
        boolean flag = false;
        for(int i = 2;i <= 100000;i++){//实现100以内的自然数的遍历
            //如何判断i是否为一个质数
            //for(int j = 2;j < i;j++){
            for(int j = 2;j <= Math.sqrt(i);j++){//根号i
                if(i % j == 0){
                    flag = true;
                    break;//8 % 2/3/4/5..7出现第三个质数时,直接过滤
                }
            }
            //if(flag == false){
            if(!flag){
                System.out.println(i);
            }
            flag = false;//初始化,如果没有初始化,则一旦数据为true,后边数据就不会执行上一步if语句。
        }
        long end = System.currentTimeMillis();
        System.out.println("所花费的时间为:" + (end - start));
    }
}

class TestPrimeNumber1{
    public static void main(String[] args) {
        long start = System.currentTimeMillis();//获取系统当前的毫秒数
        l:for(int i = 2;i <= 100000;i++){//实现100以内的自然数的遍历
            //如何判断i是否为一个质数
            //for(int j = 2;j < i;j++){
            for(int j = 2;j <= Math.sqrt(i);j++){//根号i
                if(i % j == 0){
                    continue l;
                }
            }
                System.out.println(i);
        }
        long end = System.currentTimeMillis();
        System.out.println("所花费的时间为:" + (end - start));
    }
}

break:使用在 switch-case 中或者循环中 如果使用在循环中,表示:结束当前循环

continue:使用在循环结构中 表示:结束当次循环

理解break和continue中标签的使用

在break和continue语句之后不能添加其他语句,因为永远也不会被执行。

class TestBreakContinue{
    public static void main(String[] args) {
//        for(int i = 1;i <= 10;i++){
//            if(i % 4 == 0){
//                //break;
//                continue;
//            }
//            System.out.println(i);
//        }
//        for(int i = 1;i < 5;i++){
        label:for(int i = 1;i < 5;i++){
            for(int j = 1;j <= 10;j++){
                if(j % 4 == 0){
//                    break;
//                    continue
                    break label;
//                    continue label;
                }
                System.out.print(j);
            }
            System.out.println();
        }
    }
}

一个数如果恰好等于它的因子之和,这个数就称为”完数”。(因子:除去这个数本身正的约数) 例如6=1+2+3.编程 找出1000以内的所有完数

class WanShu {
    static int count;
    public static void main(String[] args) {
        int factor = 0;
        for (int i = 1; i <= 1000; i++) {
            //每执行完一次如下的循环,就会将i的所有的因子累加到factor中。
            for (int j = 1; j < i; j++) {
                if(i % j==0)
                    factor += j;
            }
            if(factor == i){
                System.out.println(i);
                count++;
            }
            factor = 0;
        }
        System.out.println("1-1000之间的完数个数为:" + count);
    }
}

数组:

import java.util.Arrays;
import java.util.Scanner;


public class Four {
    public static void main(String[] args) {
        boolean b = true;
        //1. 如何定义一个数组
        //1.1 数组的声明
        String[] names;
        int[] scores;
        //1.2 初始化
        //第一种:静态初始化:初始化数组与给数组元素赋值同时进行。
        names = new String[]{"春","夏","秋","冬"};

        //第二种:动态初始化:初始化数组与给数组元素赋值分开进行。
        //不管是动态还是静态初始化数组,一定在创建的时候,就指明了数组的长度。
        scores = new int[4];//数组个数/长度
        //2.如何调用相应的数组元素:通过数组元素的下角标的方式来调用
        //下角标从 0 开始,到 n-1 结束。其中 n 表示数组的长度
        scores[0] = 87;
        scores[1] = 79;
        scores[3] = 97;
        //3.数组的长度:通过数组的 length 属性
        System.out.println(names.length);//4
        System.out.println(scores.length);//4
        //4.如何遍历数组元素
        for(int i = 0;i < names.length;i++){
            System.out.println(names[i]);
        }
    }
}
class TestArray{
    public static void main(String[] args) {

        //对于基于基本数据类型的变量创建的数组:byte short int long float double char boolean
        //1.对于 byte short int long 而言,创建数组以后,默认值为 0 .
        int[] a = new int[4];
        a[0] = 61;
//        a[1] = 71;
//        a[2] = 81;
        a[3] = 91;
        //遍历数组的元素
        for (int i = 0;i < a.length;i++){
            System.out.println(a[i]);
        }
        System.out.println();
        //2.对于 float double 而言,默认值是 0.0 。
        float[] b = new float[4];
        b[0] = 62.2F;
//        a[1] = 72.2F;
//        a[2] = 82.2F;
        b[3] = 92.2F;
        //遍历数组的元素
        for (int i = 0;i < b.length;i++){
            System.out.println(b[i]);
        }
        System.out.println();
        //3.对于 char 而言,默认为空格。
        char[] c = new char[4];
        //遍历数组的元素
        for (int i = 0;i < c.length;i++){
            System.out.println(c[i]);
        }
        System.out.println();
        //4.对于 boolean 而言,默认为 false 。
        boolean[] d = new boolean[4];
        //遍历数组的元素
        for (int i = 0;i < d.length;i++){
            System.out.println(d[i]);
        }
        System.out.println();
        //5. 对于引用数据类型的变量构成的数组而言,默认初始化值为 null 。以 String 为例。
        String[] strs = new String[4];
        strs[0] = "AA";
        strs[1] = "BB";
//        strs[2] = "CC";
        strs[3] = "DD";
        //遍历数组的元素
        for (int i = 0;i < strs.length;i++){
            System.out.println(strs[i]);
        }
        System.out.println();
        //另例,引用自定义类。
        Person[] Pers = new Person[4];
        for (int i = 0;i < Pers.length;i++){
            System.out.println(Pers[i]);
        }
    }
}

class Person{

}

数组一旦初始化,其长度是不可变的

class TestArray1{
    public static void main(String[] args) {
        int[] i = new int[]{12,13,14};
        int[] j = new int[10];  //定义一个长度长一点的数组
        for(int k = 0;k < i.length;k++){
            j[k] = i[k];//拷贝过来
        }
        j[3] = 15;
        j[4] = 16;

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

1.(1)定义类Pritimive,在类中定义一个有3个元素的boolean类型的数组t作为其成员变量。数组元素未赋值。 定义类TestPritimive,在TestPritimive的main()方法中创建Pritimive对象d,输出其成员变量t的三个元素值。 练习目的:检验基本数据类型数组创建时的自动赋值。 (2)给对象d的成员变量t赋值为{true,true,true},并输出t的三个元素值。

class TestPritimive{
    public static void main(String[] args) {
        //创建 Pritimive 的对象 d 。
        Pritimive d = new Pritimive();
        //遍历 d 的数组元素
        for(int i = 0;i < d.t.length;i++){
            System.out.println(d.t[i]);
        }
        //给 d 的数组元素重新赋值
        d.t[0] = true;
        d.t[1] = true;
        d.t[2] = true;
        for(int i = 0;i < d.t.length;i++){
            System.out.println(d.t[i]);
        }
    }
}
class Pritimive{
    boolean[] t = new boolean[3];
}
  1. 从键盘读入学生成绩,找出最高分,并输出学生成绩等级。 成绩>=最高分-10 等级为’A’ 成绩>=最高分-20 等级为’B’ 成绩>=最高分-30 等级为’C’ 其余 等级为’D’

提示:先读入学生人数,根据人数创建int数组,存放学生成绩。

//import java.util.Scanner;
class TestStudentScore{
    public static void main(String[] args) {
        //1.创建Scanner 的对象,并从键盘获取学生的个数 n 。
        Scanner s = new Scanner(System.in);
        System.out.println("请输入学生的个数:");
        int count = s.nextInt();//count用来记录学生的个数
        //2.根据输入的学生的个数 n,创建一个长度为 n 的int 型的数组。
        int[] scores = new int[count];
        int maxScore = 0;
        //3. 依次从键盘获取 n 个学生的成绩,并赋给相应的数组元素,并获取 n 个学生中的最高分。
        System.out.println("请输入" + count + "个成绩:");
        for(int i = 0;i < scores.length;i++){
            int score = s.nextInt();//依次从键盘获取学生的成绩
            scores[i] = score;
            if(scores[i] > maxScore){
                maxScore = scores[i];
            }
        }
        //4.遍历学生成绩的数组,并根据学生成绩与最好分的差值,赋予相应的等级,并输出。
        System.out.println("最高分为:" + maxScore);
        for(int i = 0;i < scores.length;i++){
            char level;
            if(scores[i] >= maxScore - 10){
                level = 'A';
            }else if(scores[i] >= maxScore - 20){
                level = 'B';
            }else if(scores[i] >= maxScore - 30){
                level = 'C';
            }else{
                level = 'D';
            }
            System.out.println("student " + i + " score is " + scores[i] + " grade is " + level);
        }
    }
}

二维数组

class TestArray2{
    public static void main(String[] args) {
        int[][] scores2;
        String[][] names;
        //1. 二维数组的初始化
        scores2 = new int[][]{ {1,2,3}, {4,5,6}, {7} };//静态初始化

        names = new String[6][5];//动态初始化的方式一
        names = new String[6][];//动态初始化的方式二。先指定行数,
//        names = new String[][6];//非法
//        names = new String[][];//非法
        names[0] = new String[5];//指定第几行有第几列
        names[1] = new String[3];
        names[2] = new String[4];
        names[3] = new String[7];
        names[4] = new String[8];
        names[5] = new String[5];

        //2. 如何来引用具体的某一个元素
        int[][] i = new int[3][2];//int[] i[] = new int[3][2]; //一样
        i[1][0] = 90;
        i[2][1] = 100;
        //3.数组的长度
        //二维数组的长度,length 属性
        System.out.println(i.length);//3 输出行数
        //二维数组中元素的长度
        System.out.println(i[0].length);//2 输出第一行的列数
        //4.如何遍历二维数组
        for(int m = 0;m < scores2.length;m++){//控制行数
            for(int n = 0;n < scores2[m].length;n++){
                System.out.print(scores2[m][n] + "  ");
            }
            System.out.println();

        }
//        //5.内存结构
//        int[] x,y[];
//        //等同于
//        int[] x;//一维 int x[];
//        int[] y[];//二维 int y[][];  int[][] y;

    }
}

数组的常见异常

class TestException{
    public static void main(String[] args) {
        //1. 数组下标越界的异常:java.lang.ArrayIndexOutOfBoundsException
        int[] i = new int[10];
//        i[0] = 90;
//        i[10] = 99;//应为0~9

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

        //2.空指针的异常:java.lang.NullPointerException
        //第一种
//        boolean[] b = new boolean[3];
////        b = null;//不应加该语句
//        System.out.println(b[0]);
        //第二种
//        String[] str = new String[4];
//        str[3] = new String("AA");//str[3] = "AA" //少了该语句后,str[3].toString()找不到地址
//        System.out.println(str[3].toString());
        //第三种
//        int[][] j = new int[3][0];
//        j[2][0] = 12;
    }
}

获取 arr 数组中所有元素的和。使用 for 的嵌套循环即可。 3 8 2 2 7 9 0 1 6

class TestGetSum{
    public static void main(String[] args) {
        int[][] m = new int[][]{ {3, 8, 2},{2, 7},{9, 0, 1, 6} };
        int sum = 0;
        for (int i = 0;i < m.length;i++){
            for(int j = 0;j < m[i].length;j++){
                System.out.print(m[i][j] + "\t");
                sum += m[i][j];
            }
            System.out.println();
        }
        System.out.println("总和为:" + sum);
    }
}

使用二维数组打印一个 10 行杨辉三角. 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 ….

【提示】

  1. 第一行有 1 个元素, 第 n 行有 n 个元素
  2. 每一行的第一个元素和最后一个元素都是 1
  3. 从第三行开始, 对于非第一个元素和最后一个元素的元素. yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];
//import java.util.Scanner;

class TestYangHui {
    public static void main(String[] args) {
        int[][] yangHui = new int[10][];
        //1. 初始化二维数组
        for(int i = 0;i < yangHui.length;i++){
            yangHui[i] = new int[i + 1]; //指定某行有几列
        }
        //2. 显式的为二维数组的每个元素赋值。
        for(int i = 0; i< yangHui.length; i++){
            for(int j = 0; j < yangHui[i].length;j++){
                yangHui[i][0] = yangHui[i][i] = 1;//每一行的第一列都为 1 。每一行的最后一列也都为 1 .

                if (i > 1 && j > 0 && j < i){
                    yangHui[i][j] = yangHui[i-1][j] + yangHui[i-1][j-1];

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

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

        Scanner sc = new Scanner(System.in);
        System.out.println("请输入杨辉三角的行数:");
        int n = sc.nextInt();

        int[][] triangle = new int[n][];
        for (int i = 0; i < triangle.length; i++) {
            triangle[i] = new int[i + 1];

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

1.求数组元素的最大值、最小值、平均数、总和等 2.数组的复制、反转 3.数组元素的排序

class TestArray3{
    public static void main(String[] args) {
        int[] arr = new int[]{11,15,12,13,18,2020,2019,23};

        //最大值
        int max = arr[0];//把数组中第一个值赋为最大值,再将其他值与其比较
        for(int i = 1;i < arr.length;i++){//刚刚第一个值已拿出来,故而从第二个值开始
            if(max < arr[i]){
                max = arr[i];
            }
        }
        System.out.println("数组的最大值为:" + max);
        System.out.println();

        // 最小值
        int min = arr[0];
        for(int i = 1;i < arr.length;i++){
            if(min > arr[i]){
                min = arr[i];
            }
        }
        System.out.println("数组的最小值为:" + min);
        System.out.println();

        // 总和
        int sum = 0;
        for(int i = 0;i < arr.length;i++){
            sum +=arr[i];
        }
        System.out.println("总和为:" + sum);

        // 平均数
        int avg = 0;
        avg = sum / arr.length;
        System.out.println("平均值为:" + avg);

        //数组的复制
        int[] arr1 = new int[arr.length];
        for(int i = 0;i < arr1.length;i++){
            arr1[i] = arr[i];
        }
        //遍历
        for (int i = 0;i < arr.length;i++){
            System.out.print(arr1[i] + "\t");
        }

        //数组的反转
        //1.
        for(int i = 0;i < arr.length/2;i++){
            int temp = arr[i];
            arr[i] = arr[arr.length - 1 - i];
            arr[arr.length - 1 - i] = temp;
        }
        //遍历
        System.out.println();
        System.out.println("反转1后:");
        for(int i = 0;i < arr.length;i++){
            System.out.print(arr[i] + "\t");
        }
        //2.
        for(int x = 0,y = arr.length - 1;x < y;x++,y--){
            int temp = arr[x];
            arr[x] = arr[y];
            arr[y] = temp;
        }
        //遍历
        System.out.println();
        System.out.println("反转2后:");
        for(int i = 0;i < arr.length;i++){
            System.out.print(arr[i] + "\t");
        }

        //使用冒泡排序使数组元素从小到大排序
        /*
冒泡排序:排序思想:
相邻两元素进行比较,如有需要则进行交换,
每完成一次循环就将最大元素排在最后(如从小到大排序),
下一次循环是将其它的数进行类似操作。
 */
//        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;
//                }
//            }
//        }
//        //遍历
//        System.out.println();
//        System.out.println("排序后:");
//        for (int i = 0;i < arr.length;i++){
//            System.out.print(arr[i] + "\t");
//        }
//
//        //直接选择排序使数组元素从小到大排序
//        for(int i = 0;i < arr.length - 1;i++){
//            int t = i;//默认i处是最小的
//            for(int j = i;j < arr.length;j++){
//                //一旦在i 后发现存t在比其小的元素,就记录那个元素的下角标
//                if(arr[t] > arr[j]){
//                    t = j;
////                    int temp = arr[j];
////                    arr[i] = arr[j];
////                    arr[j] = temp;
//                }
//            }
//            if(t != i) {
//                int temp = arr[t];
//                arr[t] = arr[i];
//                arr[t] = temp;
//            }
//        }

        Arrays.sort(arr);//可直接导入该包快速排序,手动写算法参考上边两则。
        //遍历
        System.out.println();
        System.out.println("排序后2:");
        for (int i = 0;i < arr.length;i++){
            System.out.print(arr[i] + "\t");
        }

    }
}

使用简单数组 (1)创建一个名为TestArray的类,在main()方法中声明array1和array2两个变量,他们是int[]类型的数组。 (2)使用大括号{},把array1初始化为8个素数:2,3,5,7,11,13,17,19。 (3)显示array1的内容。 (4)赋值array2变量等于array1,修改array2中的偶索引元素,使其等于索引值(如array[0]=0,array[2]=2)。打印出array1。

思考:array1和array2是什么关系? 拓展:修改题目,实现array2对array1数组的复制

class TestArry4{
    public static void main(String[] args) {
        int[] array1,array2;
        array1 = new int[]{2,3,5,7,11,13,17,19};

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

        array2 = new int[array1.length];
        //给array2赋值
        for(int i = 0;i < array2.length;i++){
            if(i % 2 == 0){
                array2[i] = i;
            }else {
                array2[i] = array1[i];
            }
        }

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

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

韧桂 2019-12-30