0
点赞
收藏
分享

微信扫一扫

Java个人笔记

MaxWen 2022-02-13 阅读 128
java开发语言后端

Java

1. java入门

1.1 常用的dos命令

dir命令显示盘符下的文件

cd..返回上一级

运用javac工具

清除命令cls,清屏指令

返回根目录即cd/

退出exit

1.2 path环境变量

作用：能够在任意一个文件都可以访问到javac和java工具

校验 

到其他盘符编写javac，看是否可以运行javac

1.3 hello world 案例编写和执行

java程序开发运行流程：编写代码，编译代码，运行代码

public class helloworld{
    public static void main(String[] args){
        System.out.println("helloworld");
    }
}

其中String和System要大写，不然会直接报错。

2. 基础语法

2.1 注释

  • 单行注释

    格式：//注释信息

  • 多行注释

    格式：/注释信息/ /* */

  • 文档注释

    格式：/注释信息/ /** **/

2.2 关键字

public:限制类名需要和文件名保持一致

class：用于创建一个类

  • 关键字的特点：

    全是小写

    编辑器显示特殊的颜色

2.3 常量

常量：在程序的执行中，其值不会发生改变的量（数据）

public class DemoConstant{
    /*
        常量的分类: .
        字符串常量:被双引号 所包裹的内容
        整数常量: 所有整数
        小数常量: 所有小数
        字符常量:被单引号包裹的内容,里面只能存放单个字符
        布尔常量:只有两值，true(真)， false (假)
            布尔常量单独打印没有意义，为了后面要学习的运算符，打基础
        空常量:null,数組部分详细讲解
            注意: nu11空常量不能输出打印
​
    */
    public static void main(String[] args){
        System.out.println("你好，猪头");
    }
}

2.4 变量介绍

变量就是内存中的存储空间，空间中存储着经常发生改变的量（数据）。

  • 定义变量格式

    数据类型 变量名=数据值；

2.5 数据类型

数据类型关键字内存占用（字节）取值范围
整数byte1-128~127
short2-32768~32767
int （默认）4-2的31次方到2的31次方-1
long8-2的62次方到2的62次方-1
浮点数float41.401298e-45到3.402823e+38(e-45=10的负4次方)
double（默认）84.9000000e到1.797693e+308
字符char20-65535
布尔boolean1ture,false

2.6 变量的定义和使用

public class  a{
    public static void main(String[] arag){
        //整数类型变量
        int a=10;
        //小数类型变量
        double b=12.3;
        //字符串类型变量
        char c='a';
        //布尔类型变量
        boolean d=true;
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);
    }
}
​
​
​

注意：

  1. 变量名不能重复定义

  2. 一条语句可以定义多个变量，但需要使用逗号进行分割

  3. 变量使用之前一定要进行赋值

  4. 定义float变量的时候，需要在数值后面加入F的标识，F可以大写也可以小写

    定义long变量的时候，需要在数值后面加入L的标识，L可以大写也可以小写

    public class  ab{
    public static void main(String[] arag)
    {
        long a=1000L;
        System.out.println(a);
​
        float b=12.3F;
        System.out.println(b);
    }
}

  5. 变量的作用域：只有在它所在的大括号中有效

2.7 键盘录入

import java.util.Scanner;
//步骤1：导包
public class  demo{
    public static void main(String[] arag){
        //步骤2：创建对象
        Scanner sc = new Scanner(System.in);
        //步骤3：使用变量接收数据
        int i = sc.nextInt();
        System.out.println(i);
    }
}

2.8 标识符

标识符：就是给类，方法，变量等起名字

定义规则：

  • 由数字，字母，下划线和美元符（$）组成

  • 不能以数字开头

  • 区分大小写

  • 不能是关键字

命名约定：

小驼峰命名法：方法，变量

  • 标识符是一个单词，首字母小写

  • 标识符是多个单词，首字母小写，其他单词首字母大写

大驼峰命名法：

  • 标识符是一个单词，首字母大写

  • 标识符是多个单词，每个单词首字母大写

2.9 类型转换

  • 隐式转换:将数据类型中，取值范围小的数据，给取值范围大的类型赋值，可以直接赋值。

    public class demo1{
    public static void main(String[] arga){
        int a=10;   //int 4个字节
        double b=a; //double 8个字节
        System.out.println(b);
       
    }
}

注意：

  1. 小的数据类型,和大的数据类型运算,小的会提升为大的之后,再进行运算

  2. byte short char三种数据在运算的时候,不管是否有更高的数据类型,都会提升为int ,然后再进行运算

  • 强制转换：把一个表示数据范围大的数值或者变量赋值给另一个表示数据范围小的变量

    格式：目标数据类型 变量名= (目标数据类型)值或者变量;

    public class demo2{
    public static void main(String[] arag){
        int a=10;   
        byte b=(byte)a;
        System.out.println(b);
    }
}

  • 案例

    public class test{
    public static void main(String[] arag){
        byte a= 3;
        byte b= 4;
        /*
            前置知识点：1. 小的数据类型,和大的数据类型运算,小的                        会提升为大的之后,再进行运算
                      2. byte short char三种数据在运算的时                       候,不管是否有更高的数据类型,都会提升为                        int ,然后再进行运算
            错误原因：
                byte c= a+b,byte上升到int类型，然后结果就是                 int类型，赋值给byte，就是小赋大
        */
       // byte c= a+b;
       //解决方法
        byte c= (byte)(a+b);
        System.out.println(c);
        /*
        这里的3和4是两个常量，Java存在常量优化机制，会在编译           的时候就会让3和4进行相加，然后会自动判断7是否在byte的          取值范園内
        不在范围内:编译出错
        在范围内:通过编译
​
        */
        byte d= 3+4;
        System.out.println(d);
        long num=127873923L;
    }
}

3 . 运算符

3.1 算数运算符

运算符：对常量或者变量进行操作的符号

表达式：用运算符把常量或者变量连接起来符合Java语法的式子

public class demo3{
    public static void main(String[] args){
        System.out.println(10+30);
        System.out.println("-------------");
        System.out.println(10/2);
        System.out.println(10/3);
        System.out.println(10.0/3);
        System.out.println(10/3.0);
        System.out.println("-------------");
        System.out.println(5%2); //取余数
        System.out.println("-------------");
        int a=1;
        char b='a';
        System.out.println(a+b);
    }
}
​

3.2 字符串的加操作

public class demo4{
    public static void main(String[] args){
        int a=1;
        char b='a';
        System.out.println(a+b);
        System.out.println("-------------");
        //当字符串加运算中加号就是字符串连接符，而不是算术运算符
        System.out.println("大帅比"+666);
        System.out.println("大帅比"+true);
    }
}

字符加运算：a + b的运算中, a为int类型, b为char类型当( byte short char int )在-起运算的时候,都会提升为int之后,再进行运算char提升为int的过程,就是直找码表中,字符所对应的数值表示形式字符'a’查找到数值的97之后,在跟数值1进行运算,结果就是98,所以，最终输出在控制台的结果就是98

3.3 算术运算符

需求:键盘录入一个三位数,将其拆分为个位、十位、百位后,打印在控制台 分析: ①:使用Scanner键盘录入一个三位数 ②:个位的计算:数值%10 123除以10 (商12 ,余数为3) ③: 十位的计算:数值/ 10% 10 123除以10 ( 商12 ,余数为3 ,整数相除只能得到整数) 12除以10 (商1 ,余数为2 ) ④:百位的计算:数值/ 100 123除以100 (商1 ,余数为23) ⑤:将个位，十位百位拼接上正确的字符串,打印即可

import java.util.Scanner;
//步骤1：导包
public class  demo5{
    public static void main(String[] arag){
        //使用Scanner键盘录入一个三位数
        Scanner sc =new Scanner(System.in);
        System.out.println("请输入一个三位数：");
        int num = sc.nextInt();
        //个位的计算:数值%10
        int ge = num%10;         //123%10=3
        //十位的计算:数值/ 10% 10
        int shi = num/10 %10;    //123/10=12   12%10=2
        //百位的计算:数值/ 100
        int bai = num/100;        //123/100=1
        //将个位，十位百位拼接上正确的字符串,打印即可
        System.out.println("整数"+num+"个位数为"+ge);
        System.out.println("整数"+num+"十位数为"+shi);
        System.out.println("整数"+num+"百位数为"+bai);
    }
}

数值拆分公式

个位：数值%10

十位：数值/10%10

百位：数值/10/10%10

千位：数值/10/10/10%10

3.4 自增自减运算符

public class demo6{
    /*
    单独使用的时候，++，——，无论是放前面还是放后面，结果都一样。
    */
    public static void main{
        int a=10;
        ++a;
        System.out.println(a);
        int b=10;
        --b;
        System.out.println(b);
    }
}
public class demo7{
    public static void main(String[] args){
        //++在前：先对该变量做自增（++）或者自减（--）,然后再拿变量参与操作。
        int a=10;
        int b=++a;
        System.out.println(a);
        System.out.println(b);
        //++在后，先将该变量原来的值，取出来参与操作，随后再进行自增，自减。
        int aa=10;
        //bb=10
        int bb=aa++;//aa=11
        System.out.println(aa);
        System.out.println(bb);
        int num=123;
        System.out.println(num++);  //123,先打印num，然后再自增
        System.out.println(num);   //这里就是124，自增增加完成
        //System.out.println(10++);
        //10++  -->10=10+1；错误
    }
}

3.5 赋值运算符

符号作用说明
=赋值a=10 ,将10赋值给变量a
+=加后赋值a+=b，将a+b的值赋值给a
-=减后赋值a-=b，将a-b的值赋值给a
*=乘后赋值a*=b，将axb的值赋值给a
/=除后赋值a/=b，将a/b的值赋值给a
%=取余后赋值a%=b,将a/b的余数给a
public class demo8{
    public static void main{
        int a=10;
        a+=10;
        System.out.println(a);
        short s=10;
        //s=s+1;
        s=(short)(s+1);
        System.out.println(s);
        short ss=10;
        ss+=1;
        System.out.println(ss);
        //赋值运算符自带强制类型转换
    }
}

3.6 逻辑运算符

&（与）：并且

|（或）：或者

！（非）：取反

^（异或）：

public class demo9{
    public static void main(String[] args){
        System.out.println(true&false);
        System.out.println(true&true);
        System.out.println(false&false);
        System.out.println(false&true);
        System.out.println("-------------------------------");
        System.out.println(true|false);
        System.out.println(true|true);
        System.out.println(false|false);
        System.out.println(false|true);
        System.out.println("-------------------------------");
        System.out.println(true^false);      //true
        System.out.println(true^true);       //false
        System.out.println(false^false);     //false
        System.out.println(false^true);      //true
        System.out.println("-------------------------------");
        System.out.println(!true);
        System.out.println(!!true);
    }
}

  • 短路逻辑运算符

    符号作用说明
    &&短路与作用和&相同，但是有短路的效果
    ||短路或作用和|相同，但是有短路的效果
    public class note1 {
    /*
        &&符号这边为false时，右边就不执行了
        &无论左边是true还是false，右边都要执行
    */
    public static void  main(String[] args){
        int x=3;
        int y=4;
        System.out.println(++x>4&y--<5);//false
        System.out.println("x="+x);  //4
        System.out.println("y="+x);  //4  y--<5没有执行
    }
}
​

3.7 三元运算符

  • 格式：关系表达式？表达式1：表达式2

    执行流程：

    首先计算关系表达式的值

    如果值为true，取表达式1的值

    如果值为false，取表达式2的值

public class note1 {
    public static void  main(String[] args){
        int x=3;
        int y=4;
        int max = x>y ?x:y;
        System.out.println(max);
    }
}

案例：三个和尚

public class note2{
    public static void main{
        int height1=150;
        int height2=210;
        int height3=165;
        //比较获取较大值
        int tempmax=a>c?a:b;
        int max=tempmax>c?tempmax:c;
        System.out.println(max);
    }
}

4. 条件控制语句

4.1 顺序结构语句

public class note2 {
    public static void main(String[] args){
        System.out.println(1);
        System.out.println(2);
        System.out.println(3);
        System.out.println(4);
        System.out.println(5);
    }
}

按照代码先后顺序，依次执行

4.2 IF语句

  • if语句格式

    格式：

    if (关系表达式){

    语句体；

    }

    public class note3{
    
    public static void main(String[] args){
        System.out.println("开始")
        int age=19;
        if (age>=18){
            System.out.println("可以上网吧");
        }
        System.out.println("结束")
    }
}

    注意：

    1. if语句所控制的的语句体，如果是一条语句，大括号可以省略不写

    2. if语句小括号后面，没有分号

  • if语句格式2

    if (关系表达式){

    语句体；

    }

    else{

    语句体2；

    }

    public class note3{
    System.out.println("开始")
    public static void main{
        int num=19;
        if (num%2==0){
            System.out.println("偶数");
        }
        else{
            System.out.println("奇数");
        System.out.println("结束")
    }
}

  • if语句格式3

    if (关系表达式){

    语句体；

    }

    else if{

    语句体2；

    }

    else{

    语句体3；

    }

    import java.util.Scanner;
public class note4{
    public static void main(String[] args){
        //1.使用Scanner录入考试成绩
        System.out.println("请输入您的成绩");
        Scanner sc =new Scanner(System.in);
        int score = cs.nextInt();
        //2.判断是否在合法范围之内
        if (score>=0 && score<=100){
            //合法成绩
            if (score>=95 & score<=100){
                System.out.println("自行车一辆");
            }
            else if (score>=90 & score<=94){
                System.out.println("游乐场");
            }
            else if (score>=80 & score<=89){
                System.out.println("变形金刚");
            }
            else{
                System.out.println("挨顿打");
            }
        }
        else{
           System.out.println("你的成绩输入有误"); 
        }
    }
}
​

4.3 switch语句

  • 格式：

    switch (表达式){

    case 值1：

    语句体1；

    break；

    case 值1：

    语句体1；

    break；

    ……

    default:

    语句体n+1；

    break；

    }

    public class note5 {
    public  static void main(String[] args){
        int week=100;
        switch (week){
            case 1:
                System.out.println("星期一");
                break;
            case 2:
                System.out.println("星期二");
                break;
            case 3:
                System.out.println("星期三");
                break;
            case 4:
                System.out.println("星期四");
                break;
            case 5:
                System.out.println("星期五");
                break;
            case 6:
                System.out.println("星期六");
                break;
            case 7:
                System.out.println("星期天");
                break;
            default:
                System.out.println("数据有误");
                break;
        }
    }
}
​

    注意：

    1. case给出的值不允许重复

    2. case后面的值只能是常量，不能是变量

  • case穿透现象

    import java.util.Scanner;
public class note6 {
    /*
    case穿透现象如何产生
    switch语句中，case省略break语句，就会开始case穿透
    现象：
    当开始case穿透，后续case就不会具有匹配效果，内部的语句就会执行
    直到科技break，或者switch语句执行完后，才会结束
    */
    public static void  main(String[] args){
        System.out.println("请输入星期数：");
        Scanner sc =new Scanner(System.in);
        int week=sc.nextInt();
​
        switch (week){
            case 1:
                System.out.println("工作日");
                break;
            case 2:
                System.out.println("工作日");
                break;
            case 3:
                System.out.println("工作日");
                break;
            case 4:
                System.out.println("工作日");
                break;
            case 5:
                System.out.println("工作日");
                break;
            case 6:
                System.out.println("休息日");
                break;
            case 7:
                System.out.println("休息日");
                break;
            default:
                System.out.println("数据有误");
                break;
        }
    }
}
​
​
​
​
​
//优化：
import java.util.Scanner;
public class note6 {
    /*
    case穿透现象如何产生
    switch语句中，case省略break语句，就会开始case穿透
    现象：
    当开始case穿透，后续case就不会具有匹配效果，内部的语句就会执行
    直到科技break，或者switch语句执行完后，才会结束
    */
    public static void  main(String[] args){
        System.out.println("请输入星期数：");
        Scanner sc =new Scanner(System.in);
        int week=sc.nextInt();
​
        switch (week){
            case 1:
            case 2:
            case 3:
            case 4:
            case 5:
                System.out.println("工作日");
                break;
            case 6:
            case 7:
                System.out.println("休息日");
                break;
            default:
                System.out.println("数据有误");
                break;
        }
    }
}
​

5. 循环

5.1 FOR循环

格式：

for (初始化语句；条件判断语句；条件控制语句){

循环体语句；

}

public class note7 {
    public static void main(String[] args){
        for(int i=1;i<=3;i++){
            /*
            int i=1 初始化
            i<=3 条件判断
            i++ 条件控制语句
            */
            System.out.println("折返跑");
        }
    }
}
​

  • 案例

    public class note8 {
    public static void main(String[] args){
        for(int i=1;i<=5;i++){
            System.out.println(i);
        }
        System.out.println("--------------打印1-5，5-1");
        for(int i=5;i>=1;i--){
            System.out.println(i);
        }
        System.out.println("--------------求和");
        int sum=0;
        for(int i=1;i<=5;i++){
            sum=i+sum;//sum+=i
        }
        System.out.println(sum);
        System.out.println("--------------偶数求和");
        int sum1=0;
        for(int i=1;i<=100;i++){
            if (i%2==0){
                sum1+=i;
            }
        }
        System.out.println(sum1);
        System.out.println("----------水仙花数");
        /*
        水仙花数即：个位，十位，百位数字的立方等于原数
        例如371=3^3+7^3+1^3=27+343+1=371
        */
        for(int i=100;i<=999;i++){
            int ge=i%10;
            int shi=i/10%10;
            int bai=i/100;
            if(ge*ge*ge+shi*shi*shi+bai*bai*bai==i){
                System.out.println(i);
            }
        }
        System.out.println("----------统计，水仙花数优化");
        int count=0;
        for(int i=100;i<=999;i++){
            int ge=i%10;
            int shi=i/10%10;
            int bai=i/100;
            if(ge*ge*ge+shi*shi*shi+bai*bai*bai==i){
                //判断打印水仙花数过程中拼接空格，但不换行，当一行有两个时换行
                System.out.print(i+" ");
                count++;
                if(count%2==0){
                    System.out.println();
                }
            }
        }
    }
}
​

5.2 while循环

格式：

初始化语句：

while （条件判断语句）{

循环体；

条件控制语句；

}

public class note9 {
    public static void  main(String[] args){
        int i=1;
        while (i<=100){
            System.out.println(i);
            i++;
        }
        while (i<=520) {
            System.out.println("i love you");
            i++;
        }
    }
}
​

  • 案例

    public class note9 {
    public static void  main(String[] args){
        /*
            需求:世界最高山峰是珠穆朗玛峰(8844.43米=8844430毫           米) ,假如我有一张足够大的纸,它的厚度是0.1毫米。
            请问,我折叠多少次,可以折成珠穆朗玛峰的高度?
        */
        int count=0;
        double paper=0.1;
        int zf=8844430;
        while (paper <=zf){
            paper *=2;
            count++;
            System.out.println(paper);
        }
        System.out.println(count);
    }
}
​

  • do……while循环语句

    格式：

    初始化语句

    do{

    循环体语句；

    条件控制语句；

    }while（条件判断语句）；

    执行流程：

    1. 执行初始化语句

    2. 执行循环体语句

    3. 执行条件控制语句

    4. 执行条件判断语句，看其结果是true还是false

      如果是false，循环结束

      如果是true，继续执行

    5. 回到2步骤继续

    public class par1 {
    /*
    特点：
    do…while循环，无论循环条件是否满足，都至少会执行一次循环体。
    原因：do…while循环是从上到下依次执行
     */
    public static void main(String[] args){
        int i=11;
        do{
            System.out.println("大帅哥，帅小伙");
            i++;
        }while (i<=10);
        System.out.println(i);
    }
}
​

三种循环的区别

for循环和whie循环先判断条件是否成立,然后决定是否执行循环体(先判断后执行) do..while循环先执行一次循环体 , 然后判断条件是否成立,是否继续执行循环体(先执行后判断)

for和while的区别:

  • 条件控制语句所控制的自增变量,因为归属for循环的语法结构中,在for循环结束后,就不能再次被访问到了

  • 条件控制语句所控制的自增变量,对于while循环来说不归属其语法结构中,在while循环结束后,该变量还可以继续使用

    public class part2 {
    public  static void  main(String[] args){
        for (int i =1;i<=5;i++){
            //for循环内部[定义]的变量，在循环后，就会从内存中消失
            System.out.println(i);
        }
        //System.out.println(i);错误:找不到符号i
        System.out.println("-----------------");
        //while循环
        int a=1;
        while (a<=5){
            System.out.println(a);
            a++;
        }
        System.out.println(a+"...");
    }
​
}
​

三种循环的场景:

  • 明确循环次数 ,推荐使用for循环

  • 不明确循环次数 ,推荐使用while循环

  • do..while循环 ,很少使用

死循环

public class par3 {
    public static void main(String[] args){
        for(;;){
            System.out.println("停不下来了");
        }
        while(true){
            System.out.println("停不下来了");
        }
    }
}

5.3 跳转控制语句

public class par4 {
    public  static  void  main(String[] args){
        for(int i=1;i<=24;i++){
            if (i==4){
                continue;
            }
            System.out.println(i+"层到了");
        }
        for(int t=20;t<=80;t++){
            if(t==60){
                break;
            }
            System.out.println(t+"岁正在上班");
        }
    }
}
​

5.4 Random

作用：随机产生一个随机数

步骤

  1. 导包

    import java.util.Random;

  2. 创建对象

    Random r=new Random();

  3. 获取随机数

    int number = r.nextInt(10);

    获取数据范围：[0,10]包括0，不包括10

import java.util.Random;
public class par5 {
    public static void main(String[] args){
        Random r=new Random();
        for(int i=1;i<=10;i++) {
            int num = r.nextInt(10)+1;//随机数1-10
            System.out.println(num);
        }
    }
}
​

6.快捷键

psvm+回车快速生成main方法
sout +回车快速生成输出话句
alt+1打开\隐藏工程目录結构
alt+4打开\隐藏控制台
Ctrl + alt+ L格式化代码
Alt + enter代码修正提示
CtrL + D向下复制一行
CtrL + X剪切当前行
CtrL + /批量加入单行注释，再按一次就是取消
Ctrl + shift + /批量加入多行注释，再按一次就是取消
Alt+shift+↑上移当前行
Alt+shift+↓下移当前行

7.数组

数组是一种容器，用来存储（同种数据类型）的多个值

  • 格式一

  • 数组类型[] 变量名

  • 范例：int[] array

  • 格式二

  • 数组类型 变量名[]

  • 范例：int array[]

package array;
​
public class marray1 {
    /*
    数组类型[] 变量名
    数组类型 变量名[]
     */
    public static void main(String[] args) {
        //数据类型的[变量]，变量没有进行初始化，就直接使用了，这就是错误原因
        //int[] arr=创建数组容器;
        char[] carr;
        System.out.println(carr);
        int a=10;
        System.out.println(a);
​
    }
}
​

7.1初始化

  • 动态初始化：初始化时只指定数组长度，由系统为数组分配初始值

  • 格式：数据类型[]变量名=new 数据类型[数组长度]；

  • 范例：int[] arr=new int[3];

package array;
​
import jdk.management.resource.internal.inst.SocketOutputStreamRMHooks;
​
public class array2 {
    public static void main(String[] args) {
        /*通过new关键字创建一个int类型的数组容器，
        该容器可以存储5个int类型的整数，
        该容器被arr数组变量所记录
        打印数组变量的时候1，会打印出数组的内存地址
         */
        int [] arr=new int[5];
        System.out.println(arr);
        //[I@4554617c数组的内存地址
        /*
        @:分隔符
        [：当前的空间的是一个数组类型
        I：当前数组容器中所存储的数据类型
        4554617c：十六进制内存地址
         */
        byte[] barr=new byte[3];
        System.out.println(barr);
        //[B@74a14482
    }
}
​

7.2 数组元素访问

数组元素访问格式

数组名[索引]

访问数组容器中的空间位置

package array;
​
public class array3 {
    public static void main(String[] args) {
        int[] arr =new int[3];
        System.out.println(arr);
        System.out.println(arr[0]);//默认的初始化值为0
        System.out.println(arr[1]);
        System.out.println(arr[2]);
​
​
        System.out.println("----------------------");
        arr[0]=11;
        arr[1]=13;
        arr[2]=15;
        System.out.println(arr[0]);//默认的初始化值为0
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }
}
​

Java内存分配

Java程序在运行时,需要在内存中分配空间。

为了提高运算效率，就对空间进行了不同区域的划分

每一片区域都有特定的处理数据方式和内存管理方式。

  • 栈内存:方法运行时，进入的内存，局部变量都存放于这块内存当中

  • 堆内存: new出来的内容都会进入堆内存，并且会存在地址值

  • 方法区:字节码文件(.class文件)加载时进入的内存

  • 本地方法栈:调用操作系统相关资源

  • 寄存器:交给CPU去使用

数据类型默认值
整数0
浮点数0.0
布尔false
字符空字符
引用数据类型null()
package array;
​
public class array4 {
    public static void main(String[] args) {
        int[] arr1=new int[2];
        arr1[0]=11;
        arr1[1]=19;
        System.out.println(arr1[0]);
        System.out.println(arr1[1]);
        System.out.println("-------------------");
        int[ ] arr2=new int[3];
        System.out.println(arr2);
        arr2[0]=33;
        arr2[1]=31;
        arr2[2]=34;
        System.out.println(arr2[0]);
        System.out.println(arr2[1]);
        System.out.println(arr2[2]);
​
    }
}
​
package array;
​
public class array5 {
    /*
    两个数组指向相同
     */
    public static void main(String[] args) {
        int[] arr1=new int[2];
        arr1[0]=11;
        arr1[1]=22;
        /*
        数组类型的变量应该记录什么
        地址值
         */
        int[] arr2=arr1;
        arr2[0]=33;
        System.out.println(arr1[0]);
        System.out.println(arr1[1]);
        System.out.println("-------------");
        System.out.println(arr2[0]);
        System.out.println(arr2[1]);
    }
}
​

 

7.3 数组初始化

1. 静态初始化

静态初始化：初始化时，就可以指定数组要存储的元素，系统还会自动计算出该数组的长度。

  • 格式：数据类型 [] 变量名 = new 数据类型[] {数据1，数据2，数据3，......}；

  • 简化格式：数据类型[]变量名={数据1，数据2，.....}；

package array;
​
public class arr6 {
    public static void main(String[] args) {
        /*
        静态初始化：初始化时，就可以指定数组要存储的元素，系统还会自动计算出该数组的长度。
​
        - 格式：数据类型 [] 变量名 = new 数据类型[] {数据1，数据2，数据3，......}；
        - 简化格式：数据类型[]变量名={数据1，数据2，.....}；
​
         */
        int[]arr=new int[]{11,34,66};
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        System.out.println("----------");
        int[]arr1={11,34,66};
        System.out.println(arr1[0]);
        System.out.println(arr1[1]);
        System.out.println(arr1[2]);
    }
}
​

  • 两种初始化的区别

  • 动态初始化:手动指定数组长度,由系统给出默认初始化值。

  • 静态初始化:手动指定数组元素,系统会根据元素个数，计算出数组的长度

应用场景

  • 动态初始化:只明确元素个数，不明确具体数值，推荐使用动态初始化

    例:使用数组容器来存储键盘录入的5个整数

  • 静态初始化:需求中已经明确了要操作的具体数据,直接静态初始化即可

7.4 数组操作的两个常见小问题

  • 索引越界：访问不存在的（ArrayIndexOutOfBounds Exception ）

public class array4 {
    public static void main(String[] args) {
        int[] arr1=new int[2];
​
        System.out.println(arr1[0]);
    }
}

  • 空指针:访问的数组已经不再指向堆内存的数据，造成空指针异常

public class array4 {
    public static void main(String[] args) {
        int[] arr1=new int[2];
        System.out.println(arr1[0]);
        arr=null;
        System.out.println(arr1[0]);
    }
}

 

  • null :空值,引用数据类型的默认值,表示不指向任何有效对象

7.5 数组常见操作

  • 遍历

package array;
​
public class arr7 {
    /*
    数组的遍历
    动态获取数组元素的个数：数组名.length
     */
    public static void main(String[] args) {
        int[] arr ={12352,3,1,34,4};
        System.out.println("arr数组元素的个数"+arr.length);
        for(int i=0;i<5;i++){
            System.out.println(arr[i]);
        }
    }
}
​

  • 获取最值

    package array;
​
public class arr7 {
    public static void main(String[] args) {
        int[] arr ={12352,3,1,34,4};
        int max=arr[0];
        System.out.println("arr数组元素的个数"+arr.length);
        for(int i=1;i<arr.length;i++){
            if(arr[i]>max){
                max=arr[i];
            }
        }
        System.out.println(max);
    }
}
​

  • 求和

    package array;
​
import java.util.Scanner;
​
public class arr7 {
    public static void main(String[] args) {
        //键盘录入对象，准备键盘录入
        Scanner sc =new Scanner(System.in);
        //定义求和变量，准备记录累加后的结果
        int sum=0;
        //动态初始化一个长度为5的int数组，准备存储键盘录入的数值
        int[] arr =new int[5];
        //将键盘录入的数组存储到数组中
        for(int i =0;i<arr.length;i++){
            System.out.println("请输入第"+(i+1)+"个整数");
            //arr[i]=10;
            arr[i]=sc.nextInt();
        }
        //遍历数组
        for (int i = 0; i < arr.length; i++) {
            sum+=arr[i];
        }
        System.out.println(sum);
    }
}

  • 评委打分

    package array;
​
import java.util.Scanner;
​
public class arr8 {
    public static void main(String[] args) {
        //定义一个数组，用动态初始化完成数组元素的的初始化
        int[] arr = new int[6];
        //键盘录入
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < arr.length; i++) {
            System.out.println("请输入第" + (i + 1) + "值：");
            int score = sc.nextInt();
            if (score >= 0 && score <= 100) {
                //合法分值
                arr[i] = score;
            } else {
                //非法分值
                System.out.println("输入有误");
                i--;
            }
        }
        for (int i= 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        //最值
        int max = arr[0];
        //System.out.println("arr数组元素的个数" + arr.length);
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        System.out.println("最大值为："+max);
        int min = arr[0];
        //System.out.println("arr数组元素的个数" + arr.length);
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] < min) {
                min = arr[i];
            }
        }
        System.out.println("最小值为："+min);
​
        int sum =0;
        for (int i = 0; i < arr.length; i++) {
            sum+=arr[i];
        }
        //计算平均分
        int avg=(sum-min-max)/(arr.length-2);
        System.out.println("平均值为："+avg);
    }
}
举报

相关推荐

JAVA个人笔记

java开发语言后端

java日期 个人笔记

java

个人笔记-java项目

java开发语言后端

Java集合（个人整理笔记）

java开发语言

java Format相关 个人笔记

java

个人笔记整理——JAVA面向对象

java开发语言后端

个人JAVA学习笔记总结(2)

java-ee

git个人笔记

vue.jsjavascriptnpm

A*算法个人笔记

算法

个人笔记-selenium

python爬虫selenium
0 条评论