黑马java学习笔记3(阶段一 第一章1-5 08~1-7)第一章完结

已于 2024-08-18 23:00:53 修改
阅读量479 收藏 5
点赞数 5
分类专栏： 黑马程序员Java学习笔记 文章标签： java 学习 笔记
于 2024-07-24 09:35:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaozhuzhu__/article/details/140653590
版权

以下学习笔记记录于：2024.07.17-2024.07.23

文章目录

阶段一 JavaSE基础

第一章 Java基本语法

1-5 数组

08 数组在计算机中的执行原理，Java内存分配

image-20240717114510302
在这里插入图片描述

09 多个变量指向同一个数组

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

10 数组案例：求最值

在这里插入图片描述

// 求取数组中的最大值
public class ArrayMax {
    public static void main(String[] args) {
        // 1.把颜值数据存在数组中
        int[] faceScores = {15, 900, 100, 888, 66, -5};

        // 2.定义一个变量来记住当前最大值
        int max = faceScores[0];    // 建议使用数组第一个值当作参考值

        // 3.从数组第二个位置开始遍历
        for (int i = 1; i < faceScores.length; i++) {
            // 将当前遍历到的数据与参考值进行比较
            if (faceScores[i] > max){
                max = faceScores[i];
            }
        }
        System.out.println("最高颜值为：" + max);
    }
}
11 数组案例：数组反转

在这里插入图片描述

// 完成数组反转
public class ArrayInversion {
    public static void main(String[] args) {
        int[] arr = {10, 20, 30, 40, 50, 60};
        // 定义一个循环，设计2个变量，一个在前，一个在后
        for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
            int temp = 0;
            temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

运行结果：
在这里插入图片描述

12 数组案例：随机排名

在这里插入图片描述

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

// 随机排名
public class ArrayRandom {
    public static void main(String[] args) {
         // 1.定义一个动态初始化数组来存储5名员工的工号
        int[] numbers = new int[5];

        // 2.提示用户录入对应5名员工的工号
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < numbers.length; i++) {
            System.out.println("请输入第" + (i+1) + "位员工的工号：");
            numbers[i] = sc.nextInt();
        }

        // 3.打乱数组中的元素顺序
        // 每遍历到一个数据，都随机生成一个数组索引范围内的值，然后将当前遍历到的数据与该索引对应位置处的值进行互换
        Random r = new Random();
        for (int i = 0; i < numbers.length; i++) {
            int index = r.nextInt(5);
            int temp = numbers[i];
            numbers[i] = numbers[index];
            numbers[index] = temp;
        }

        // 4.输出已打乱的工号
        for (int i = 0; i < numbers.length; i++) {
            System.out.print(numbers[i] + " ");
        }
    }
}

运行结果：
在这里插入图片描述

1-6 方法

01 方法概述

在这里插入图片描述

image-20240718162929448

注：

  • 方法修饰符此处暂时都使用 public static 修饰；

  • 在形参列表中不能给初始化值。

03 方法使用时的常见问题
  • 一个方法不能定义在另一个方法里面；
  • void：无返回申明，不需要return返回数据；
  • return语句下面不能编写代码，若有则为无效代码，执行不到return后面去（报错内容：Unreachable statement）；
  • 调用无返回值的方法只有1种方式：直接调用。
public class MethodProblem {
    public static void printHelloWorld(){
        for (int i = 0; i < 3; i++) {
            System.out.println("Hello World!");
        }
    }
    public static int sum(int a, int b){
        return a + b;
    }
    public static void main(String[] args) {
        // 调用有返回值的方式有以下3种
        // 1.定义变量来接收结果
        int r = sum(10, 9);
        System.out.println(r);
        // 2.直接输出调用
        System.out.println(sum(3, 3));
        // 3.直接调用
        sum(3, 4);

        // 调用无返回值的方法只有1种方式：直接调用
        printHelloWorld();
    }
}

运行结果：
image-20240718162332063

06 Java的参数传递机制：基本类型的参数传递（值传递）

image-20240718163903730

// 理解方法的参数传递机制：值传递
public class MethodDemo {
    public static void main(String[] args) {
        int a = 10;
        change(a);  // 相当于change(10);
        System.out.println("main:" + a);
    }
    public static void change(int a){
        System.out.println("change1:" + a);
        a = 20;
        System.out.println("change2:" + a);
    }
}

运行结果：
image-20240718164221786

07 Java的参数传递机制：引用类型的参数传递（值传递）
// 理解方法的参数传递机制：值传递
public class MethodDemo1 {
    public static void main(String[] args) {
        int[] arrs = new int[]{10, 20, 30};
        change(arrs);   // change(arrs中存储的地址)
        System.out.println("main：" + arrs[1]);
    }
    public static void change(int[] arrs){  // 同样也是值传递，传入的是实参变量中存储的值的副本（也就是地址），而同一地址所指向的是同一个位置
        System.out.println("方法内1：" + arrs[1]);
        arrs[1] = 100;  // 修改arrs所指地址中第2个位置的值
        System.out.println("方法内2：" + arrs[1]);
    }
}

执行原理：
image-20240718164711557

运行结果：
image-20240718165655686

基本类型和引用类型在参数传递方面：
image-20240718165315564

08 参数传递的案例1：打印数组内容

image-20240718170400840

// 打印数组内容
public class ArrayPrintDemo {
    public static void main(String[] args) {
        int[] arrs = {10, 20, 30};
        printArray(arrs);
        int[] arrs1 = null;
        printArray(arrs1);
        int[] arrs2 = {};
        printArray(arrs2);
    }
    public static void printArray(int[] arrs){
        // 防止传入数组为空
        if(arrs == null){
            System.out.println(arrs);
            return; // 立即跳出并结束当前方法的执行
        }
        System.out.print("[");
        for (int i = 0; i < arrs.length; i++) {
//            if (i == arrs.length - 1){
//                System.out.print(arrs[i]);
//            }else {
//                System.out.print(arrs[i] + ", ");
//            }
            System.out.print(i == arrs.length - 1 ? arrs[i] : arrs[i] + ", ");	// 优化写法
        }
        System.out.println("]");
    }
}

运行结果：
image-20240718171638764

09 参数传递的案例2：判断两个数组是否相同

image-20240718195105301

// 判断两个数组是否相同
public class ArrayEqual {
    public static void main(String[] args) {
        int[] arrs1 = {10, 20, 30, 40};
        int[] arrs2 = {10, 20, 30};
        System.out.println(Equals(arrs1, arrs2));
    }
    public static boolean Equals(int[] arrs1, int[] arrs2){
        // 要预测一些非法状况

        // 两者均为null则相同
        if (arrs1 == null && arrs2 == null){
            return true;
        }
        // 其中一者为空，另一个非空则不相等
        if (arrs1 == null || arrs2 == null){
            return false;
        }
        // 两者长度不同也不想等
        if (arrs1.length != arrs2.length){
            return false;
        }
        //两者长度一样则进行值对比
        for (int i = 0; i < arrs1.length; i++) {
            if (arrs1[i] != arrs2[i]){
                return false;
            }
        }
        return true;
    }
}
10 方法重载

image-20240718200000423

1-7 案例

02 买飞机票

image-20240718204339798

// 目标：完成买飞机票的案例
public class planeTicketDemo {
    public static void main(String[] args) {
        double price = calculate(1000, 8, "经济舱");
        System.out.printf("优惠价为：%.2f元%n", price);
    }
    // 计算飞机票价格的方法
    // 此处month和type不用担心有特殊情况，之后的业务场景中在设计页面时会控制用户的输入范围
    public static double calculate(double price, int month, String type){
        // 1.判断当前月份的情况
        if (month >= 5 && month <= 10){
            // 旺季
            // 2.判断仓位类型
            switch (type){
                case "头等舱":
                    price *= 0.9;
                    break;
                case "经济舱":
                    price *= 0.85;
                    break;
            }
        }else {
            // 淡季
            switch (type){
                case "头等舱":
                    price *= 0.7;
                    break;
                case "经济舱":
                    price *= 0.65;
                    break;
            }
        }
        return price;
    }
}

运行结果：
image-20240718204241697

总结：
image-20240718204157232

03 生成随机验证码

image-20240718204533405

import java.util.Random;

// 目标：生成随机验证码
public class captchaDemo {
    public static void main(String[] args) {
        System.out.println("生成的随机验证码为：" + createCode(5));
    }
    public static String createCode(int n){
        Random r =new Random();
        // 3.定义一个String变量来连接产生的每位随机字符
        String code = "";
        // 1.定义一个for循环用于控制产生多少位的随机字符
        for (int i = 1; i <= n; i++) {
            // 2.每个位置均可能是数字、大写字母、小写字母之一，用0、1、2来分别代表不同的字符
            int type = r.nextInt(3);    // 通过type来确定该位置上是什么字符
            switch (type){
                case 0:     // 0代表生成数字字符0~9
                    code += r.nextInt(10);
                    break;
                case 1:     // 1代表是大写字母（其中ASCII码分别为A：65，Z：65+25 ➡ (0-25) + 65），需要转换成char类型才是字母形式呈现
                    char ch = (char)(r.nextInt(26) + 65);
                    code += ch;
                    break;
                case 2:     // 2代表是小写字母（其中ASCII码分别为a：95，z：95+25 ➡ (0-25) + 95），需要转换成char类型才是字母形式呈现
                    char ch1 = (char)(r.nextInt(26) + 95);
                    code += ch1;
                    break;
            }
        }
        return code;
    }
}

运行结果：
image-20240718211042739

04 评委打分

在这里插入图片描述

import java.util.Scanner;
// 目标：评委打分
public class averageScoreDemo {
    public static void main(String[] args) {
        System.out.println("最终得分为：" + getAverageScore(6));
    }
    public static double getAverageScore(int n){    // 传入评委位数
        // 1.定义一个动态初始化数组来存储评委打分情况
        int[] scores = new int[n];      // scores = [0, 0, 0, 0, ……]
        // 2.输入评委所给分数
        Scanner sc= new Scanner(System.in);
        for (int i = 0; i < scores.length; i++) {
            // 评委打分范围为[0, 100]
            System.out.println("请输入第" + (i+1) + "位评委的打分情况：");
            scores[i] = sc.nextInt();
        }
        // 3.找出最高分、最低分，以及计算出总分
        int sum = 0;
        int max = scores[0];    //max、min均以数组第一位作为参考
        int min = scores[0];
        for (int i = 0; i < scores.length; i++) {
            sum += scores[i];
            if (max < scores[i]){
                max = scores[i];
            }
            if (min > scores[i]){
                min = scores[i];
            }
        }
        return 1.0 * (sum - max - min) / (n - 2);   // 评委所给为int，但平均分要保留小数，所以*1.0
    }
}

运行结果：
在这里插入图片描述

05 数组加密

image-20240719111441278

import java.util.Scanner;

// 目标：数组加密
public class arrayEncryptionDemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入4位数的密码：");
        int password = sc.nextInt();
        System.out.println("加密后的密码为：" + encrypt(password));
    }
    // 将加密后的数据再传入一次便是解密
    public static String encrypt(int password) {
        // 1.将传入的密码拆分为一位一位的数字存储在数组中
        int[] passwords = split(password);  // 拆分为 passwords = [?, ?, ?, ?]

        // 2.对每位数字进行对应的加密处理
        for (int i = 0; i < passwords.length; i++) {
            passwords[i] = (passwords[i] + 5) % 10;
        }

        // 3.对数组进行反转操作
        reverse(passwords);

        // 4.对最终结果进行输出返回
        String data = "";
        for (int i = 0; i < passwords.length; i++) {
            data += passwords[i];
        }
        return data;
    }

    // 数组反转，此处选择方式2（方式1：从后往前遍历数组即可；方式2：将数组前后位置数据进行对调，然后顺序遍历数组）
    public static void reverse(int[] passwords) {
        for (int i = 0, j = passwords.length - 1; i < j; i++, j--) {
            int temp = passwords[j];
            passwords[j] = passwords[i];
            passwords[i] = temp;
        }
    }

    // 拆分密码
    public static int[] split(int password) {
        int[] passwords = new int[4];
        passwords[0] = password / 1000;
        passwords[1] = (password / 100) % 10;
        passwords[2] = (password / 10) % 10;
        passwords[3] = password % 10;
        return passwords;
    }
}

运行结果：
image-20240719111215679

07 抢红包

image-20240719185050850

image-20240719184955931

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

// 目标：抢红包
// 方案1：将抽中的红包金额置为0
public class grabRedEnvelopeDemo {
    public static void main(String[] args) {
        int[] money = {9, 666, 188, 520, 99999};
        Scanner sc = new Scanner(System.in);
        Random r =new Random();
        for (int i = 0; i < money.length; i++) {
            System.out.println("请输入任意内容进行抽奖：");
            sc.next();      // 等待用户输入内容并按下回车继续执行
            // 设置一个死循环来随机抽取不同的红包金额
            while (true) {
                int index = r.nextInt(money.length);   // 生成0-4的随机索引值来抽取不同红包金额
                // 判断红包金额是否为0，若为0则继续抽取红包金额非零
                if (money[index] != 0){
                    System.out.println("恭喜您抽中了红包：" + money[index]);
                    money[index] = 0;
                    break;
                }
            }
        }
        System.out.println("活动结束！");
    }
}

// 方案2：将数组内容随机打乱，然后顺序输出
//public class grabRedEnvelopeDemo {
//    public static void main(String[] args) {
//        int[] money = {9, 666, 188, 520, 99999};
//        Scanner sc = new Scanner(System.in);
//        Random r =new Random();
//        for (int i = 0; i < money.length; i++) {
//            int index = r.nextInt(5);
//            int temp = money[i];
//            money[i] = money[index];
//            money[index] = temp;
//        }
//        // 顺序抽取已打乱的红包
//        for (int i = 0; i < money.length; i++) {
//            System.out.println("请输入任意内容进行抽奖：");
//            sc.next();      // 等待用户输入内容并按下回车继续执行
//            System.out.println("恭喜您抽中了红包：" + money[i]);
//        }
//        System.out.println("活动结束！");
//    }
//}

运行结果：
image-20240721161712553

image-20240719185208973

方案1需要判断是否金额为0，若多次随机抽取到的位置金额均为0，则在查找非零红包上会花费一些时间。所以，在性能方面方案2会好一些。

08 找素数

image-20240721170821019

public class findPrimeNumberDemo {
    public static void main(String[] args) {
        System.out.printf("%n当前区间素数个数为：%d", search(101, 200));
    }
    // 返回素数数量，输出素数
    public static int search(int start, int end) {
        int count = 0;
        for (int i = start; i <= end ; i++) {
            // 定义一个信号标志位（信号位思想）
            boolean flag = true;    //默认为素数
            // 判断2到该数一半的数据中是否有可以整除它的数，若存在则非素数
            for (int j = 2; j <= i / 2; j++) {
                if (i % j ==0){
                    flag = false;
                    break;      //不是素数
                }
            }
            if (flag){  //  是素数
                count++;
                if (count % 10 == 0){   // 每10个为一行
                    System.out.println(i);
                }else {
                    System.out.print(i + " ");
                }
            }
        }
        return count;
    }
}

运行结果：
image-20240721170638755

09 双色球

image-20240722161350594

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

// 目标：完成双色球系统
public class unionLottoDemo {
    public static void main(String[] args) {
        int[] userNumbers = userSelectNumbers();    // 将用户所投注的号码存储成数组
        System.out.println("投注的号码是");
        printArray(userNumbers);                    // 输出用户投注的号码组
        int[] luckNumbers = createNumbers();        // 将随机生成的中奖号码存储入数组
        System.out.println("中奖的号码是");
        printArray(luckNumbers);                    // 输出中奖号码组
        judge(userNumbers, luckNumbers);            // 判断中奖情况
    }

    // userSelectNumbers方法用于记录用户投注的号码并进行返回
    public static int[] userSelectNumbers(){
        // 创建一个数组存储用户投注的 6+1 个号码（6红，1蓝）
        int[] numbers = new int[7];     // numbers = [0, 0, 0, 0, 0, 0, 0];
        Scanner sc =new Scanner(System.in);
        // 用户先输入所要投注的6个红球号码（1-33之间，球号不能重复）
        for (int i = 0; i < numbers.length - 1; i++) {
            // 直到用户输入正确的号码组后退出死循环
            while (true) {
                System.out.println("请输入第" + (i+1) + "个红球号码（1-33之间，球号不能重复）：");
                int number = sc.nextInt();
                // 判断用户所投注的号码是否合理（1-33之间，球号不能重复）
                if (number < 1 || number > 33){
                    System.out.println("对不起，您输入的红球号码不在规则内，请确认号码是否在1-33之间！");
                }else {
                    // 判断号码是否输入重复，若不重复才可以正式存入数组中
                    if (exist(numbers, number)){
                        System.out.println("您输入的号码有重复，请重新输入新的号码！");
                    }else{
                        numbers[i] = number;
                        break;
                    }
                }
            }
        }

        // 用户投注篮球号码
        while (true) {
            System.out.println("请输入1个蓝球号码（1-16之间）：");
            int number = sc.nextInt();
            // 判断用户所投注的号码是否合理（1-33之间，球号不能重复）
            if (number < 1 || number > 16){
                System.out.println("对不起，您输入的蓝球号码不在规则内，请确认号码是否在1-16之间！");
            }else {
                numbers[6] = number;
                break;
            }
        }

        return numbers;
    }

    // 判断用户输入的号码是否重复，重复返回true，反之为false
    private static boolean exist(int[] numbers, int number) {
        for (int i = 0; i < numbers.length; i++) {
            // 若遍历到数组为0处，则说明后面还没有存入用户输入的数据，不必继续往后查看是否有重复号码
            if (numbers[i] == 0){
                break;
            }

            if (numbers[i] == number){
                return true;
            }
        }
        return false;
    }

    //  printArray方法用于输出用户投注的号码组
    private static void printArray(int[] arrs) {
        System.out.print("[");
        for (int i = 0; i < arrs.length; i++) {
            System.out.print(i == arrs.length - 1 ? arrs[i] : arrs[i] + ", ");	// 优化写法
        }
        System.out.println("]");
    }

    // createNumbers方法用于生成一组中奖号码并进行输出（6红，1蓝）
    public static int[] createNumbers(){
        int[] numbers = new int[7];
        Random r = new Random();
        // 生成红球中奖号码，1-33
        for (int i = 0; i < numbers.length - 1; i++) {
            while (true) {
                int number = r.nextInt(33) + 1;   // 生成1-33的红球中奖号码
                // 判断随机生成的红球号码是否合理（1-33之间，球号不能重复）
                if (!exist(numbers, number)){   //号码不重复才会进来
                    numbers[i] = number;
                    break;
                }
            }
        }
        // 生成蓝球中奖号码，1-16
        numbers[6] = r.nextInt(16) + 1;
        return numbers;
    }

    // judge方法用来判断用户的中奖情况并进行输出
    public static void judge(int[] userNumbers, int[] luckNumbers){ // 数组前6个为红球号码，最后一个为蓝球号码
        // 定义两个变量来记录用户的中奖号码个数
        int redCount = 0;
        int blueCount = 0;

        // 判断红球命中数量，数组前6个
        for (int i = 0; i < userNumbers.length - 1; i++) {
            for (int j = 0; j < luckNumbers.length - 1; j++) {
                if (userNumbers[i] == luckNumbers[j]){
                    redCount++;
                    break;      // 因为中奖号码每个不重复，所以一旦匹配到则退出内部循环
                }
            }
        }
        // 判断蓝球是否命中
        blueCount = userNumbers[6] == luckNumbers[6] ? 1 : 0;

        System.out.println("您命中的红球数量是：" + redCount);
        System.out.println("您命中的蓝球数量是：" + blueCount);

        // 判断中奖金额
        if (redCount == 6 && blueCount == 1){
            System.out.println("恭喜中奖1000万，今天实现了十分之一的小小目标！！！😊");
        }else if (redCount == 6 && blueCount == 0){
            System.out.println("恭喜中奖500万，可以开始稍微享受人生喽！！！o(*￣▽￣*)ブ");
        }else if (redCount == 5 && blueCount == 1){
            System.out.println("恭喜中奖3000元，可以出去吃顿好的哈哈哈！");
        }else if (redCount == 5 && blueCount == 0 || redCount == 4 && blueCount == 1){
            System.out.println("200元到手，可以少加班一会");
        }else if (redCount == 4 && blueCount == 0 || redCount == 3 && blueCount == 1){
            System.out.println("中了10元，来自一杯蜜雪冰城的爱~~~");
        }else if (redCount < 3 && blueCount == 1){
            System.out.println("中了5元，天气热可以买支雪糕吃，雪糕也是爱~");
        }else {
            System.out.println("感谢您对福利事业做出的巨大贡献/(ㄒoㄒ)/~~");
        }
    }
}

运行结果：
image-20240722194621784

海盐之冬
关注
专栏目录
JAVA 黑马学习笔记记录 Java基本语法
wifiuuu的博客
07-20 285
运算符对常量或者变量进行操作的符号表达式用运算符把常量或者变量连接起来符合java语法的式子就可以称为表达式。不同运算符连接的表达式体现的是不同类型的表达式。
Java学习 - 黑马 - 随堂笔记 - 第一部分总目录
qq_43104872的博客
04-17 937
Java学习 - 黑马 - 随堂笔记 - 第一部分总目录 本内容仅为个人看视频记录的随手笔记，部分内容可能不全面，，可以作为学习黑马程序员Java基础视频参考使用或者看完之后进行复习巩固使用。 Java学习 - 黑马 - 随堂笔记 - 01_ Java概述 Java学习 - 黑马 - 随堂笔记 - 02_第一个程序 Java学习 - 黑马 - 随堂笔记 - 03_基础语法 Java学习 - 黑马 - 随堂笔记 - 04_运算符 Java学习 - 黑马 - 随堂笔记 - 05_数据输入 Java学习 - 黑马
java黑马学习笔记
02-21
是我从黑马资源中抓出来的每天教师上课的笔记,对于基础学习者帮助还是很大的,毕竟视频太多了,不可能全部看完,但是笔记就不一样.
黑马训练营java学习笔记:集合
Vabp4的博客
09-01 444
集合概述： 在编程时，常常需要存放多个数据，可以用数组来保存多个对象，但数组长度不好变化，一旦初始化数组时就指定了数组的长度，这个数组长度就是不可改变的，如果需要保存数量变化的数据时，数组就显得比较无能为力了；而且数组无法保存具有映射关系的数据，例如成绩表：数学-80，语文-90，英语-100，这种数组看上去像两个数组，但其实这个两个数据有一定的关系。 为了保存数量不确定的数组，以及保存像成绩
黑马程序员 Java 入门 笔记
m0_46554918的博客
03-25 487
一、基础概念。
《后端》黑马-Hibernate框架学习笔记-第1章 -2020年12月23日
BelleDiao的博客
12-23 393
1.1 Hibernate框架的学习路线 第一天：Hibernate的入门（Hibernate的环境搭建、Hibernate的API、Hibernate的CRUD） 第二天：Hibernate的一级缓存、其他的API 第三天：Hibernate的一对多配置、Hibernate的多对多的配置 第四天：Hibernate的查询方式、抓取策略 1.2 CRM的案例 1.2.1.1 什么是CRM 客户关系管理 1.2.1.2 CRM有哪些模块 1.3 Hibernate的框架的概述 1.3.1 EE的三层架构 1
数据清洗黑马程序员 第3章Kettle工具的基本使用 --学习笔记
m0_53823329的博客
09-18 1592
3.1 Kettle简介 3.1.1 Kettle概述 Kettle是一款国外免费开源的轻量级ETL工具，是基于Java语言开发的，可以在Windows、Linux、UNIX系统上运行。 Kettle工具主要由4个组件组成，分别是Spoon、Pan、Kitchen及Carte组件，具体功能介绍如下。 > Spoon是Kettle集成开发环境，它会提供一个基于SWT的图形用户界面，主要用于构建ETL Jobs（作业）和Transformations（转换），也可用于执...
黑马程序员《数据清洗》学习笔记第八章综合案例（1）
qq_45744760的博客
11-21 5737
第八章综合案例（1） 案例【8.3.28.3.38.3.4】 8.3.2 加载日期数据至日期维度表 1.打开Kettle工具，创建转换 打开Kettle工具创建转换load_dim_date，并添加“生成记录”控件、“增加序列”控件、“JavaScript代码”控件、“表输出”控件以及Hop跳连接线，如图8-1。 图 8-1 2.配置生成记录控件 双击“生成记录”控件，进入“生成记录”配置界面；在“限制”处...
java面试大全-黑马
01-10
**第一章 内容介绍** 这部分通常会概述整个面试宝典的结构和目标，包括各个章节的分布和重点内容。例如，它可能包含了Java基础、面向对象编程、异常处理、集合框架、多线程、I/O流、网络编程、反射、内存管理等核心...
第一章 Redis基础(简介+下载和安装+基本操作)----黑马
无
05-03 379
目标1：能够说出NoSQL的概念，redis的应用场景，能够完成redis的下载安装与启动以及一些常用的配置 目标2：能够说出redis常用的5种数据类型，对应这些数据类型的基本操作，应用场景及对应的解决方案 目标3：能够说出redis中常用的一些基本指令 目标4：能够使用jedis完成客户端应用程序的开发 目标5：能够说出redis数据持久化的两种方式，各自相关的操作配置及指令，以及两种方式的优缺点比较......
黑马Java基础笔记
03-18
非常详细的黑马Java基础核心笔记，非常适合自学的人看！
黑马java教程知识点笔记整理
02-04
之前收藏的一个大牛的知识点总结，结合黑马java视频看效果较好，希望能帮助到需要的人
黑马程序员——Java学习笔记--java基础
a121552497的博客
10-02 764
java数据类型划分 分为两大类型：                1）基本数据类型：类似于普通的值。                2）引用数据类型：传递的是内存的地址。 浮点类型实际上就是表示小数。   java基本数据类型   数据的溢出 当整数的数据大小超出了可以表示的范围，而程序中又没有做数值范围的检查时，这个整型变量
黑马java基础笔记
m0_49808352的博客
03-15 829
List(接口,有序、可重复、有索引,for循环) set(接口，无序、不可重复、无索引，对象不重复(若认为两个内容一样的对象重复，即重写equals()和hashCode()))数据源(集合、数组)[获取stream流] ---> 常见的中间方法(过滤，去重，排序) ---> 获取结果(常见的终结方法，遍历，统计，收集)乐观锁：一开始不上锁，认为是没有问题的，大家一起跑，等要出现线程安全问题的时候才开始控制。
黑马java笔记-java部分-java基础
qq_52649952的博客
02-18 1354
黑马java课程中关于java基础部分-java部分的内容
黑马学习笔记_java基础知识总结
dddlinux的博客
08-24 588
——- android培训、java培训、期待与您交流！ ———-逻辑运算符&(并且) , |(或者) , !(非) , ^(异或) , &&(短路与) , ||(短路或)注意事项： a:逻辑运算符一般用于连接boolean类型的表达式或者值。 在Java中我们要表示一个数大于3并且小于6 ， 不可以写成3<x<6，应该写成 x>3 & x<6 。 b
Java-JVM-黑马程序员学习笔记＜一＞
weixin_45532984的博客
08-03 404
JVM是JavaVirtualMachine（Java虚拟机）的缩写，JVM是一种用于计算设备的规范，它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的. Java的虚拟机机比较出名的有HotSpot，J9等。 了解JVM有助于更加清除java程序的执行过程。...
黑马程序员Java笔记
m0_68735537的博客
03-14 2384
输出打印、参与运算、修改记录的值。
传智播客黑马Java学习笔记_09
weixin_41285610的博客
09-28 324
在子类创建对象时，发现父类的构造方法也运行了，为什么呢？ 在子类的构造函数中第一行有一个隐式语句super(); class Fu{ Fu(){ System.out.println("Fu is running"); } } class Zi extends Fu(){ Zi(){ //super(); 隐式语句 空参数构造函数 Syste...
黑马程序员java第一章
最新发布
06-07
《黑马程序员Java从入门到精通》是一本非常经典的Java学习教材，通常作为初学者的入门教程。第一章可能会涵盖Java基础，包括以下几个部分： 1. **Java概述**：介绍了Java语言的历史、平台无关性（JVM）、版本变迁和主要特点。 2. **安装与配置**：指导读者如何下载并安装Java开发工具包（JDK），设置开发环境如集成开发环境（IDE）如Eclipse或IntelliJ IDEA。 3. **Java基本数据类型和变量**：讲解基本的数据类型（如int, char, boolean等），以及变量的声明、赋值和作用域。 4. **控制结构**：包括顺序结构、选择结构（if-else，switch）、循环结构（for, while）等。 5. **运算符**：介绍了Java中的算术、关系、逻辑等运算符。 6. **数组和集合**：可能涉及一维数组的概念，以及ArrayList、LinkedList、HashMap等集合框架的基础使用。 7. **方法**：讲解方法的定义、调用、重载和递归等概念。 8. **类和对象**：讲解面向对象编程的基本概念，如类的定义、构造函数、实例化对象等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值