java学习笔记

.ccl

已于 2024-02-15 16:56:39 修改

阅读量876

点赞数 13

文章标签：学习笔记 java

于 2024-02-06 15:56:36 首次发布

本文链接：https://blog.csdn.net/2301_76876837/article/details/135187027

版权

一、命令行的使用

呈现目录：dir

进入到文件夹里面：cd + 目录1\目录2\

回到上一层目录：cd..

回到根目录：cd/ 或 cd\

删除文件目录（必须是空的）：rd 文件目录名

删除当前目录下指定文件：del + 文件名

二、字面量

package cn.bwl.zimianliang;

public class ZiMianLiangDemo {
    public static void main(String[] args) {
        // 数据在程序中的书写格式

        //1.整数
        System.out.println(50);

        //2.小数
        System.out.println(50.3);

        //3.字符 单引号括起来 只能写一个字符
        System.out.println('s');
        System.out.println(' ');
        System.out.println('a');
//        System.out.println('');
        System.out.println('\n');
        System.out.println('b');
        System.out.println('\t');

        //4.字符串 双引号括起来 里面随便写
        System.out.println("中");
        System.out.println("");
        System.out.println("国");
        System.out.println(" ");
        System.out.println("HelloWorld");

        //5.布尔 结果为：true/false
        System.out.println(true);
        System.out.println(false);

        //6.空 要输出的话按字符串的形式输出
        System.out.println("null");
//        System.out.println(null);



    }
}

三、变量的使用

package cn.bwl.variable;

public class Variable {
    public static void main(String[] args) {
        //1.存储一个数据的
        //数据类型 变量名 = 数据；

        //2.存放整形的一个变量
        int i = 12;
        System.out.println(i);

        //3.存放小数的变量
        double d = 3.2;
        System.out.println(d);
        System.out.println("-----------------------------");

        //4.优点：方便管理代码
        int a = 666;
        System.out.println(a);
        System.out.println(a);
        System.out.println(a);
        System.out.println(a);
        System.out.println(a);
        System.out.println("-----------------------------");


        //5.变量里的内容是可以被替换的
        int s = 23;
        System.out.println(s);
        s = 78;
        System.out.println(s);
        s = s + 1;
        System.out.println(s);
        System.out.println("-----------------------------");

        //6.需求：钱包里有9.5，先放进去10元，又拿出来 5元，现在钱包里还有多少
        double money = 9.5;
        money = money + 10;
        money = money - 5;
        System.out.println(money);

    }
}

注意事项

package cn.bwl.variable;

public class VariableDemo2 {
    public static void main(String[] args) {
        //变量的注意事项
        //1.先声明，后使用
        int s = 23;
        System.out.println(s);

        //2.什么类型的变量，只能存什么类型的数据
//        int a = 23.4;
        int b = 334;

        //3.变量存在访问范围,同一个范围内，多个变量的名字不能一样4
        {
            int c = 34;
//            int c = 78;
            System.out.println(c);
            System.out.println(s);
        }
//        System.out.println(c);
        b = 67;

        //4.变量定义时可以不给赋初始值，但使用时变量里必须有值
        int f;
//        System.out.println(f);
        f = 39;
        System.out.println(f);

    }
}

        int 中国 = 65;
//        int 2w = 34;
//        double class = 58;
        int Class = 5555;

        int $ = 58;
//        int _ = 38;

标识符的定义规范

变量名：首字母小写，驼峰，int studyVariable = 89;
类名：驼峰

八种数据类型

byte short int long

float double

char

boolean

package cn.bwl.variable;

public class VariableDemo2 {

    public static void main(String[] args) {
        //八种基本数据类型
        //1.整形 byte short int long
        byte b = 127;//byte -128~127
//    byte b2 = 128;//越界

        short s = 3846;
//    short s2 = 37823; //越界

        int i = 37842923;
        int i2 = -435567899;

//    long l = 2343567858;//因为整数类型默认int ,所以后面要加个L/l
        long l2 = 3724689L;

        //2.浮点型 默认double
        float f = 23460.45F;//定义float 要加F/f
        double d = 3456765.685;

        //3.字符型
        char c = 'd';
        char c2 = '中';
//    char c3 = "中国";

        //4.布尔类型
        boolean bb = true;
        boolean bb2 = false;

        //补充引用数据类型
        String ss = "中国";
    }

}

四、类型转换

1.自动类型转换

package cn.bwl.type;

public class TypeDemo1 {
    public static void main(String[] args) {
        //1.自动类型转换 byte-short-int-long-float-double
        // 数据类型范围小的转换给数据类型范围大的
        byte b = 47;
        int i = b;
        System.out.println(i);

        int i2 = 3445;//4位
        double d = i2;//8位
        System.out.println(d);

        //char可以赋给int
        char c = 'a';//2字节 16位 00000000 01100001
        int i3 = c;//4字节 32位 00000000 00000000 00000000 01100001
        System.out.println(i3);

    }
}

2，表达式类型转换

package cn.bwl.type;

public class TypeDemo2 {
    public static void main(String[] args) {
        //表达式自动类型转换
        byte b = 32;
        int i = 25;
        long l = 234L;
        long rs1 = b + i + l;//转换成范围最大的数据类型
        System.out.println(rs1);

        double d = b + i + 10.0;
        System.out.println(d);

        byte b2 = 127;
        byte b3 = 27;
//        byte = b2 + b3;//byte short char在表达式中直接转换成int类型，
        int rs2 = b2 + b3;//因为计算结果超过了byte类型的范围

    }
}

3.强制类型转换

package cn.bwl.type;

public class TypeDemo3 {
    public static void main(String[] args) {
        //强行将类型范围大的转换成类型范围小的

        int i = 20;
//        byte b = i;
        byte b = (byte) i;//强制类型转换
        System.out.println(b);

        //强制类型转换，数据可能有溢出
        int i2 = 340;
        byte i3 = (byte) i2;
        System.out.println(i3);

        //强制类型转换,浮点型转换成整形
        double d = 43.5;
        int i4 = (int) d;
        System.out.println(i4);

    }
}

五、运算符

1.算术运算符，+ 做连接符

package cn.bwl.yunsuanfu;

public class YunSuanfuDemo1 {
    public static void main(String[] args) {
        //算术运算符 + - * / %
        int i = 10;
        int j = 2;
        System.out.println(i + j);
        System.out.println(i - j);
        System.out.println(i * j);
        System.out.println(i / j);
        System.out.println(5 / 2);
        System.out.println(5.0 / 2);

        int a = 5;
        int b = 2;
        System.out.println(1.0 * a / b);

        System.out.println(i % j);
        System.out.println(a % b);
        System.out.println("--------------------------");

        //+ 作连接符，连接字符串
        //能算则算，不能算就在一起
        int g = 5;

        System.out.println(5 + "abc" );//5abc
        System.out.println("sdfdg" + 5);//sdfdg5
        System.out.println("baowenli" + 5 + "liu");//baowenli5liu
        System.out.println(5 + 'a' + "baowenli");// a = 97 , 102baowenli

        

    }
}

2.自增自减

package cn.bwl.yunsuanfu;

public class YunSuanFuDemo2 {
    public static void main(String[] args) {
        //自增、自减运算符
        int a = 10;
        System.out.println(a++);
        System.out.println(++a);

        int b = 10;
        System.out.println(b--);
        System.out.println(--b);

        System.out.println("-----------------");
        int x = 12;
        int rs1 = x++;//先用后加
        System.out.println(x);//13
        System.out.println(rs1);//12

        int x2 = 12;
        int rs2 = ++x2;//先加后用
        System.out.println(x2);//13
        System.out.println(rs2);//13

        System.out.println("--------------------------");
        //运算
        int m = 5;
        int n = 3;
        //分三步
        //m 5 6 5 4
        //n 3 4 3
        //             6 -  5  + 5   -  4  +  4  +3
        int result = ++m - --m + m-- - ++n + n-- +3;
        System.out.println(result);//9
        System.out.println(m);//4
        System.out.println(n);//3

        //练习
        int c = 10;
        int d = 5;
        //c 10 11 12 11
        //d 5 4 5
        //            10  + 12  -  4  -  5  + 1 + 12
        int result2 = c++ + ++c - --d - ++d + 1 + c--;
        System.out.println(result2);//26
        System.out.println(c);//11
        System.out.println(d);//5

    }

}

3. 扩展赋值运算符

package cn.bwl.yunsuanfu;

public class YunSuanFuDemo3 {
    public static void main(String[] args) {
        //扩展赋值运算符
        //+=
        double a = 10;
        double b = 2;
        a += b;//a = (double)(a + b);
        System.out.println(a);

        //-=
        double i = 10;
        double j = 2;
        i -= j;//i = (double)(i + j);
        System.out.println(i);

        int m = 10;
        int n = 5;
//        m *= n;//m = (int)(m * n);50
//        m /= n;//m = (int)(m / n);2
        m %= n;//m = (int)(m % n);
        System.out.println(m);
    }
}

4.关系运算符

package cn.bwl.yunsuanfu;

public class YunSuanFuDemo4 {
    public static void main(String[] args) {
        //关系运算符
        int a = 10;
        int b = 5;
        boolean c = a > b;
        System.out.println(a >= b);//true
        System.out.println(2 >= 2);//true
        System.out.println(a < b);//false
        System.out.println(a <= b);//false
        System.out.println(2 <= 2);//true
        System.out.println(a != b);//true
        System.out.println(2 != 2);//false
        System.out.println(5 == 5);//true
        System.out.println(a = b);//z注意 =是赋值
    }
}

5.逻辑运算符

package cn.bwl.yunsuanfu;

public class YunSuanFuDemo5 {
    public static void main(String[] args) {
        //逻辑运算符
        //1，与 & ，同真才为真
        double d = 9.9;
        int i = 10;
        boolean re = d >= 10 & i <=20;
        System.out.println(re);//false

        //2，或 | ，同假才为假
        double d1 = 9.9;
        int i1 = 10;
        boolean re1 = d1 >= 10 & i1 <=9;
        System.out.println(re1);//false

        //3.非 ！ 取反
        System.out.println(!false);
        System.out.println(!true);
        System.out.println();

        //4.异或 结果不同才为true
        System.out.println(true ^ true);//false
        System.out.println(false ^ false);//false
        System.out.println(true ^ false);//true
        System.out.println(false ^ true);//true

        //5.短路与 && 左为false，则右边不执行
        int j = 1;
        System.out.println(2 >= 3 && ++j <= 10);//false
        System.out.println(j);

        //6.短路或 || 左边为真，则右边不执行
        System.out.println(2 <= 3 || ++j <= 10);//true
        System.out.println(j);


    }
}

6.三元运算符以及优先级

package cn.bwl.yunsuanfu;

public class YunSuanFuDemo6 {
    public static void main(String[] args) {
        //三元运算符  优先级
        double d = 90;
        String re1 = d > 60 ? "成绩合格" : "成绩不及格";
        System.out.println(re1);

        int a =10;
        int b =20;
        int re2 = a > b ? a : b;
        System.out.println(re2);

        //输出三个数中最大的
        int i = 32;
        int j = 66;
        int k = 65;
        //先比较两个数的大小
        int teap = i > j ? i : j;
        //再拿teap和第三个数比较
        int re3 = teap > k ? teap : k;
        System.out.println(re3);

        //优先级 && 高于 ||
        System.out.println(2 > 3 || 4 > 5 && 7 > 4);//false
        System.out.println((2 < 3 || 4 < 5) && 7 > 4);//true


    }
}

7.键盘录入

8.习题

package cn.bwl.practice;

import java.util.Scanner;

public class Question1 {
    public static void main(String[] args) {
        //自己写的时候没有用到强制类型转换
        System.out.println("请输入父亲的身高：");
        Scanner sc = new Scanner(System.in);
        int father = sc.nextInt();
        System.out.println("请输入母亲的身高：");
        int mother = sc.nextInt();
//        int father = 177;
//        int mother = 165;
        int son = (int)((father + mother) * 1.08 / 2);
        int daughter = (int)((father * 0.923 + mother) / 2);
        System.out.println("儿子的身高：" + son + "cm");
        System.out.println("女儿的身高：" + daughter + "cm");
    }
}

package cn.bwl.practice;

import java.util.Scanner;

public class Question1 {
    public static void main(String[] args) {
        //自己写的时候没有用到强制类型转换
        System.out.println("请输入父亲的身高：");
        Scanner sc = new Scanner(System.in);
        int father = sc.nextInt();
        System.out.println("请输入母亲的身高：");
        int mother = sc.nextInt();
//        int father = 177;
//        int mother = 165;
        int son = (int)((father + mother) * 1.08 / 2);
        int daughter = (int)((father * 0.923 + mother) / 2);
        System.out.println("儿子的身高：" + son + "cm");
        System.out.println("女儿的身高：" + daughter + "cm");
    }
}

package cn.bwl.practice;

public class Question3 {
    public static void main(String[] args) {
        //要定义变量表示菜的价格
        //使用三元运算符
//        int money = 24  * 3 + 3 * 8 + 3 * 5;
//        if (money > 100) {
//            money *= 0.9;
//            System.out.println("小明要付" + money + "元");
//        }
//        System.out.println("小明要付" + money + "元");
        int fish = 24;
        int peanut = 8;
        int rice = 3;
        int money = fish * 3 + peanut * 3 + rice * 5;
        System.out.println("打折前的价格" + money);
        int fee = money > 100 ? (int)(money * 0.9) : money;
        System.out.println("打折后的价格" + fee);
    }
}

六、流程控制语句

1.分支结构

package cn.bwl.branch;

public class IfDemo1 {
    public static void main(String[] args) {
        //1.判断温度是否大于37度
        int temp = 40;
        if (temp > 39.8){
            System.out.println("此人温度不正常");
        }
        //2.判断钱包余额
        int money = 99;
        if (money > 99){
            System.out.println("可以给出红包");
        } else {
            System.out.println("余额不足");
        }
        //3.判断公司员工的绩效
        int score = 98;// [60,70) D,[70,80)C,[80,90)B,[90,100]A
        if (score >= 60 && score < 70){
            System.out.println("您的绩效为D");
        } else if (score >= 70 && score < 80){
            System.out.println("你的绩效为C");
        } else if (score >= 80 && score < 90){
            System.out.println("你的绩效为C");
        } else if (score >= 90 && score <= 100){
            System.out.println("你的绩效为C");
        } else {
            System.out.println("输入的数据有误");
        }
    }
}

switch

package cn.bwl.branch;

public class SwitchDemo2 {
    public static void main(String[] args) {
        String week = "周八";
        switch (week){
            case "周一" :
                System.out.println("埋头苦干，解决bug");
                break;
            case "周二" :
                System.out.println("求大牛程序员帮忙");
                break;
            case "周三" :
                System.out.println("今晚啤酒、龙虾、小烧烤");
                break;
            case "周四" :
                System.out.println("主动帮助新来的女程序解决bug");
                break;
            case "周五" :
                System.out.println("今晚吃鸡");
                break;
            case "周六" :
                System.out.println("与王婆介绍的小芳相亲");
                break;
            case "周日" :
                System.out.println("郁郁寡欢，准备上班");
                break;
            default:
                System.out.println("你输入的星期数有问题");
        }
    }
}

switch的注意事项：

package cn.bwl.branch;

public class SwitchDemo3 {
    public static void main(String[] args) {
        //switch的注意事项
        //1.switch后面括号里的只能是 byte short int char 枚举 String 不能是 float double long 型的
        int a = 10;
        double d = 98.8;
        double q = 0.1;
        double p = 0.2;
        double c = q + p;
        System.out.println(c);
        switch (a){
            case 10:
                System.out.println(666);
        }
        //2.case 后面的值为字面量，字面量的值也不同，不能是变量
        int i = 20;
        switch (i) {
            case 10:
                System.out.println(i);
            case 20:
                System.out.println(i);
        }
        //3.不要忘记写break,否则可能会发生穿透
        String week = "周三";
        switch (week){
            case "周一" :
                System.out.println("埋头苦干，解决bug");
                break;
            case "周二" :
                System.out.println("求大牛程序员帮忙");
                break;
            case "周三" :
                System.out.println("今晚啤酒、龙虾、小烧烤");
                //break;
            case "周四" :
                System.out.println("主动帮助新来的女程序解决bug");
                break;
            case "周五" :
                System.out.println("今晚吃鸡");
                break;
            case "周六" :
                System.out.println("与王婆介绍的小芳相亲");
                break;
            case "周日" :
                System.out.println("郁郁寡欢，准备上班");
                break;
            default:
                System.out.println("你输入的星期数有问题");
        }
    }
}

用穿透性解决难题

package cn.bwl.branch;

public class SwitchDemo4 {
    public static void main(String[] args) {
        //switch穿透性解决一些问题
        String week = "周三";
        switch (week){
            case "周一" :
                System.out.println("埋头苦干，解决bug");
                break;
            case "周二" :
            case "周三" :
            case "周四" :
                System.out.println("请求大牛程序员帮忙");
                break;
            case "周五" :
                System.out.println("自己整理代码");
                break;
            case "周六" :
            case "周日" :
                System.out.println("郁郁寡欢，准备上班");
                break;
            default:
                System.out.println("你输入的星期数有问题~~~");
        }
    }
}

2.循环结构

for循环批量表示数据

package cn.bwl.xunhuan;

public class ForDemo1 {
    public static void main(String[] args) {
        for(int i = 0; i < 3; i++){
            //0 1 2
            System.out.println("HelloWorld1");
        }
        System.out.println("----------------");
        for(int i = 1; i <= 5; i++){
            //i 1 2 3 4 5
            System.out.println("HelloWorld2");
        }
        System.out.println("----------------");
        for(int i = 1; i <= 10; i += 2){
            //i 1 3 5 7 9
            System.out.println("HelloWorld3");
        }
    }
}

package cn.bwl.xunhuan;

public class ForDemo2 {
    public static void main(String[] args) {
        //1.输出1~100之间的数
        for (int i = 1; i <= 100; i++) {
            System.out.println(i);
        }
        //2.求1~100之间的和
        //定义一个变量表示数字的和
        int sum = 0;
        //3.找到1~100中的所用数
        for (int i = 1; i <= 100; i++) {
            sum +=i;
        }
        System.out.println(sum);
        //4.求1~100之间的奇数和
        //定义一个变量表示奇数和
        int sum2 = 0;
        for (int i = 1; i <= 100; i += 2) {
            sum2 += i;
        }
        System.out.println(sum2);
        //5.求1~100之间的奇数和
        //定义一个变量表示奇数和
        int sum3 = 0;
        //表示1~100之间的数
        for (int i = 1; i <= 100; i++) {
            //if判断是否为奇数
            if (i % 2 ==1){
                sum3 += i;
            }
        }
        System.out.println(sum3);
    }
}

while

package cn.bwl.xunhuan;

public class WhileDemo3 {
    public static void main(String[] args) {
        int i = 0;
        while (i < 5){
            System.out.println("HelloWorld!");
            i++;
        }

    }
}

package cn.bwl.xunhuan;

public class WhileDemo4 {
    public static void main(String[] args) {
        //while循环的小案例，0.1cm厚的纸，折叠多少次达珠穆朗玛峰的高度8848860
        //定义两个变量表示山和纸
        int mountain = 8848860;
        double paper = 0.1;

        //定义一个变量记录执行的次数
        int count = 0;
        //while循环控制 （不知道执行次数）
        while (paper < mountain){
            paper *= 2;
            count++;
        }
        System.out.println("折叠了" + count + "次");
        System.out.println("纸张厚度为" + paper);
    }
}

do-while

package cn.bwl.xunhuan;

public class DoWhileDemo5 {
    public static void main(String[] args) {
        int i = 0;
        do {
            System.out.println("HelloWorld1");
        }while (i > 3);
        //do-while会先执行一次，再进行判断
        do {
            System.out.println("HelloWorld2");
        }while (false);
        System.out.println("-----------------------");

        //三种循环的区别
        //for while 几乎无差别，for 知道循环的执行次数
        for (int i1 = 0; i1 < 3; i1++) {
            System.out.println("HelloWorld3");
        }
//        System.out.println(i1);
        int j = 0;
        while (j<3){
            System.out.println("HelloWorld4");
            j++;
        }
        System.out.println(j);//3
    }
}

死循环

package cn.bwl.xunhuan;

public class SiXunHuanDemo6 {
    public static void main(String[] args) {
        //死循环用在服务器程序，类似于百度，微信

//        for ( ; ; ){
//            System.out.println("hellWorld");
//        }

//        while (true){
//            System.out.println("hellWorld");
//        }
        
        do {
            System.out.println("hello");
        }while (true);
    }
}

循环嵌套

package cn.bwl.xunhuan;

public class XunHuanQianTaoDemo7 {
    public static void main(String[] args) {
        //for可以嵌套while，do while 三者互相嵌套
        for (int i = 0; i < 4; i++) {
            for (int i1 = 0; i1 < 5; i1++) {
                System.out.println("HelloWorld"+ i);
            }
            System.out.println("------------------");
        }
        //案例
        //打印
        //****
        //****
        //****
        for (int i = 1; i <= 3; i++) {//外层循环控制有几行
            for (int i1 = 1; i1 <= 4; i1++) {//内层循环控制每行打几列
                System.out.print("*");
            }
            //每一行打完之后进行换行
            System.out.println();

        }

    }
}

3.break continue

package cn.bwl.tiaozhuan;

public class BreakAndContinue {
    public static void main(String[] args) {
        //break 只能在循环中使用，跳出当前的循环
        for (int i = 1; i <= 5; i++) {
            System.out.println("我爱你" + i);
            if (i == 3){
                break;
            }
        }

        //continue 只能在循环中使用，结束当前循环进入下一循环
        for (int i = 1; i <= 5; i++) {
            if (i == 3){
                continue;
            }
            System.out.println("Hello" + i);
        }

    }
}

4.随机数 random

package cn.bwl.suijishu;

import java.util.Random;

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

        Random r = new Random();
        for (int i =1; i <= 14; i++) {
            int re = r.nextInt(10);//产生0~9的随机数，括号里要写10
            System.out.println(re);
        }
        System.out.println("-----------------");

        //减加法 求随机数的范围表示1~10
        //(1~10)-1 -> 0~9
//        int re2 = r.nextInt(10+1);

        for (int j = 1; j <= 20 ;j++) {
            int re2 = r.nextInt(10) + 1;
            System.out.println(re2);
        }
        System.out.println("-----------------");

        //表示3~18的随机数20个
        //3~18 -3 -> 0~15
        for (int k =1; k <=20; k++) {
            int re3 = r.nextInt(16) + 1;
            System.out.println(re3);
        }
    }
}

小游戏

package cn.bwl.suijishu;

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

public class RandomTest2 {
    public static void main(String[] args) {
        //1.产生一个随1~100机数
        Random r = new Random();
        int rannum = r.nextInt(100) + 1;

        //2.哦用户输入一个数，用死循环，直到猜到为止
        Scanner sc = new Scanner(System.in);
        while (true){
            System.out.println("请你输入一个数字：");
            int guessnum = sc.nextInt();

            //3，比较用户输入的字与随机数的大小

            if (guessnum > rannum){
                System.out.println("您输入的数字过大");
            } else if (guessnum < rannum){
                System.out.println("您输入的数字过小");
            } else {
                System.out.println("恭喜你猜中了数字，去买单");
                break;
            }
        }
    }
}

七、数组

1.数组的定义

一种容器，同种数据类型的多个值

2.数组的初始化

初始化，就是在内存中，为数组容器开辟空间，并将数据存入容器中的过程

静态初始化数组

package cn.bwl.array;

public class Demo1 {
    public static void main(String[] args) {
        //静态初始化数组
        //数据类型[] 数组名 = new 数据类型[]{元素一，元素二，}；
        int[] age = new int[]{22, 47, 48};
        double[] weight = new double[]{32.4, 54.4, 49.5, 93.4};

        //简写
        //数据类型[] 数组名 = {元素一，元素二，}；
        int[] a = {93, 49, 94, 93, 30};
        


    }
}

直接打印数组名出现的是，地址值，而不知数组中的值

数组的地址值，表示数组在内存中的位置

package cn.bwl.array;

public class Demo1 {
    public static void main(String[] args) {
        //静态初始化数组
        //数据类型[] 数组名 = new 数据类型[]{元素一，元素二，}；
        int[] age = new int[]{22, 47, 48};
        double[] weight = new double[]{32.4, 54.4, 49.5, 93.4};

        //简写
        //数据类型[] 数组名 = {元素一，元素二，}；
        int[] a = {93, 49, 94, 93, 30};

        //也可定义为
        // 数据类型 数组名[] = {元素1，元素2，元素3，...};
        byte b[] = {23,89,39};

        //数组名可以找到数组首地址，引用数据类型
        System.out.println(age);//[I@1b6d3586
        System.out.println(weight);//[D@4554617c
        System.out.println(a);//[I@74a14482
        System.out.println(b);//[B@1540e19d

        //地址值
        //【  代表数组
        //I  代表数据类型 I 整形 D 浮点类型
        //@   间隔符号
        //1b6d3586 真正的地址值 16进制
        //通常把整体称作地址值，但是真正的地址是数字

    }
}

3.数组元素访问

package cn.bwl.array;

public class Demo2 {
    public static void main(String[] args) {
        //数组元素访问的应用

        //1.获取 获取数组中的元素
        //格式：数组名【索引】
        //定义数组
        int[] arr = {1 , 2 ,3 ,4 ,5};
        //获取到的元素要放到变量中
        int result = arr[0];
        System.out.println(result);

        //2.存储 往数组中存储数据
        //格式：数组名【索引】= 具体数据 / 变量；
        arr[0] = 100;
        System.out.println(arr[0]);

    }
}

数组名 [索引]

索引，又叫下标，角标

4.数组元素的遍历

1.定义

不要简单的认为是打印，而是取出数据的过程，

利用循环，结束条件为arr.length

package cn.bwl.array;

public class Demo3 {
    public static void main(String[] args) {
        //数组的遍历
        //定义一个数组
        int[] arr = {1,2,3,4,5};

        //输出数组中的元素
        //格式：数组名[索引]
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        System.out.println(arr[3]);
        System.out.println(arr[4]);
        System.out.println("-------------------");

        //重复进行一件事，利用循环
        for (int i = 0; i < 5; i++) {
            System.out.println(arr[i]);
        }
        System.out.println("-------------------");


        //当数组内元素个数未知时，此时，循环的结束条件很难求
        //求得，此时需要用 数组名.length 求数组长度（arr.length.fori）
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);

        }
    }
}

2.数组求和

package cn.bwl.array;

public class Demo4 {
    public static void main(String[] args) {
        /*定义一个数组，存储1，2，3，4，5
        遍历数组中每一个元素的值，并求数组中每一个数据的和*/

        //定义数组
        int[] arr = {1,2,3,4,5};

        //定义sum总数
        int sum = 0;

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

    }
}

3.数组中能被3整除的个数

package cn.bwl.array;

public class Demo5 {
    public static void main(String[] args) {
        /*定义一个数组，1，2，3，4，5，6，7，8，9，10
        遍历数组，求出能被三整除的元素的个数
         */

        //定义数组
        int[] arr = {1,2,3,4,5,6,7,8,9,10};

        //遍历数组，判断能否被3整除,
        //定义自增变量i
        int i = 0 ;
        for (int j = 0; j < arr.length; j++) {
            if (arr[j] % 3 == 0){
//                System.out.println(arr[j]);
                i++;
            }
        }
        System.out.println(i);
    }
}

4.遍历的过程中去修改里面的数据

package cn.bwl.array;

public class Practice3 {
    public static void main(String[] args) {
        /*定义一个数组，1，2，3，4，5，6，7，8，9，10
        遍历数组
        要求：
        当前数字为奇数，扩大为二倍
        为偶数，缩小为二分之一
         */

        //定义数组
        int[] arr = {1,2,3,4,5,6,7,8,9,10};

        //遍历数组,判断奇偶数
        for (int i = 0; i < arr.length; i++) {

            if (arr[i] % 2 == 0) {
                arr[i] = arr[i] / 2;
            } else {
                arr[i] = arr[i] * 2;
            }

        }
        //尽量一个循环只干一件事情，所以重新定义一个循环输出数组元素
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
            
        }

    }
}

5.数组动态初始化

直接指定数组的长度，由虚拟机给定默认的初始化值（知道元素个数）

与静态初始化不同的是

静态初始化已经知道数组的元素，自动计算出数组的个数（知道元素值）

package cn.bwl.array;

public class Demo4 {
    public static void main(String[] args) {
        //动态初始化数组（暂时不知道数组里面的元素，先给出数组的长度）

        //格式：数据类型[] 数组名 = new 数据类型[数组长度]；
        //特点：在创建的时候，由我们给定数组的长度，由虚拟机给出默认的初始化值

        //创建
        String[] arr = new String[50];

        //添加
        arr[0] = "zhangsan";
        arr[1] = "lisi";

        //获取
        System.out.println(arr[0]);//zhangsan
        System.out.println(arr[1]);//lisi
        System.out.println(arr[2]);//输出默认初始化的值null

        //数据初始化默认值规律
        //类型      默认值

        //整形      0
        //小数      0.0
        //字符      '\u0000'也就是 空格
        //布尔      false
        //引用      null
        //引用数据类型就是除八种数据类型之外的类型，这里是string

        int[] arr1 =  new int[3];
        System.out.println(arr1[0]);//0
        System.out.println(arr1[1]);//0
        System.out.println(arr1[2]);//0
    }
}

6.注意

数组访问越界

7.应用

1.求最值

package cn.bwl.array;

public class Practice4 {
    public static void main(String[] args) {
        //求数组中最大值 {22，7，19，33 ，49}

        //1.创建数组，知道元素，静态初始化数组
        int[] arr = {22,7,19,33,49};

        //2.定义最大值，只要数组中的元素即可
        int max = arr[0];

        //3.遍历数组
        for (int i = 0; i < arr.length; i++) {
            //i 索引   arr[i]元素
            if (arr[i] > arr[0]) { //当元素值大于先定义的最大值时，更新最大值
                max = arr[i];
            }
        }
        //4.输出最大值
        System.out.println(max);


        //注意：
        //1.可以根据最大值求最小值
        //将涵义 max 改为 min, > 改为 <
        //2.定义的最大值不能为0，因为 若数组中的元素都为负数，此时最大值将是0，不再为数组中的元素
        //所以，最大值是数组中的任意一个元素均可，最好是arr[0]，因为便于后面代码的修改
        //3.当for (int i = 0; i < arr.length; i++)，循环中arr[0]与arr[0]多比较了一次
        //为提高效率，改为int i = 1
    }
}

2.求和并统计个数

package cn.bwl.array;

import java.util.Random;

public class Practice5 {
    public static void main(String[] args) {
        //在1~100之间生成10个随机数，并求出有多少个比平均数小的值
        //思路
        //1.先求10个随机数的和
        //2.求出10个数的平均数
        //3.再求有多少个比平均数小的值


        //1.定义数组,动态初始化，因为只知道元素个数
        int[] arr = new int[10];

        //2.定义随机数
        Random r = new Random();
        //3.遍历数组求随机数
        int num;
        for (int i = 0; i < arr.length; i++) {
            //定义变量存随机数
            num = r.nextInt(100)+1;//bound的范围是0~99,所以要加1
            //****要把随机数添加到数组当中
            arr[i] = num;
        }

        //4.求10个随机数的和
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum+= arr[i];
        }
        System.out.println("10个随机数的和为"+sum);

        //5.求出10个数的平均数
        int avg;
        avg = sum / 10;
        System.out.println("10个随机数的平均值为"+avg);

        //6.求有多少个比平均数小的值
        int count =0;//计数
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] < avg){
                count++;
            }
        }
        System.out.println("10个随机数中有"+count+"个数比平均值小");

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

3.交换数组中的元素

package cn.bwl.array;

public class Practice6 {
    public static void main(String[] args) {
        //交换数组数据
        //定义一个数组，存入1,2,3,4,5，
        //交换前：1,2,3,4,5
        //交换后：5,4,3,2,1

        //1.先交换两个变量的值
        int a = 10;
        int b = 10;
        //临时变量temp
        int temp = a;
        a = b;
        b = temp;
        System.out.println(a);
        System.out.println(b);

        //2.交换数组中最小索引和最大索引的的值
        //定义数组
        int[] arr = {1,2,3,4,5};
        int temp2 = arr[0];
        arr[0] = arr[4];
        arr[4] = temp2;
        System.out.println(arr[0]);
        System.out.println(arr[4]);

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

        //3.交换数组数据,用到两个变量指向最小索引和最大索引
        //定义
        int[] arr1 = {1,2,3,4,5};
        //遍历交换
        for (int i = 0, j = arr1.length - 1; i < j; i++, j--) {
            int temp3 = arr1[i];
            arr1[i] = arr1[j];
            arr1[j] = temp3;

        }
        //遍历输出
        for (int i = 0; i < arr1.length; i++) {
            System.out.print(arr1[i]+" ");
        }

    }
}

4.打乱数组中的值

package cn.bwl.array;

import java.util.Random;

public class Practice7 {
    public static void main(String[] args) {
        //定义一个数组存入1,2,3,4,5，
        //要求打乱数组中所有元素
        //难点：
        /*int[] arr = {1,2,3,4,5};
        //获取随机索引
        Random r = new Random();
        int randomindex = r.nextInt();*/

        //1.定义数组
        int[] arr = {1,2,3,4,5};
        //获取随机索引
        Random r = new Random();
        //2.遍历数组
        for (int i = 0; i < arr.length; i++) {
            //生成一个随机索引
            int randomIndex = r.nextInt(arr.length);
            //int randomIndex = r.nextInt(5);
            int temp = arr[i];
            arr[i] = arr[randomIndex];
            arr[randomIndex] = temp;

        }

        //3.遍历输出数组
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

8.数组的内存图

new 出来的就是在堆里开辟了一个小空间

new的多次就是开辟了不同的小空间

.ccl

关注

13
点赞
踩
6

收藏

觉得还不错? 一键收藏
1
评论
java学习笔记

变量名：首字母小写，驼峰，int studyVariable = 89;类名：驼峰一种容器，同种数据类型的多个值不要简单的认为是打印，而是取出数据的过程，利用循环，结束条件为arr.length//数组的遍历//定义一个数组//输出数组中的元素//格式：数组名[索引]//重复进行一件事，利用循环i < 5;i++) {//当数组内元素个数未知时，此时，循环的结束条件很难求//求得，此时需要用数组名.length 求数组长度（arr.length.fori）
复制链接

扫一扫