Java学习

Bwywb_3

已于 2024-06-29 19:01:15 修改

阅读量320

点赞数 4

分类专栏： Java后端文章标签： java 学习开发语言

于 2024-06-14 21:21:48 首次发布

本文链接：https://blog.csdn.net/qq_46143063/article/details/139690322

版权

Java后端专栏收录该内容

3 篇文章 0 订阅

订阅专栏

最新笔记：https://www.yuque.com/g/bwywb/yg8g4f/kxe24ckin6osw0it/collaborator/join?token=KmDDobfEb7i7EDGp&source=doc_collaborator# 《Java学习(补漏版)》

仓库地址：https://github.com/Shmily33/javaSEPro

0 IDEA使用

0.1 导入模块

导入已有的新模块时，选择路径下的.iml文件（.iml 文件通常不需要手动编辑，而是由 IDEA 自动生成和管理。它们以 XML 格式存储，并包含了项目和模块的各种配置信息，如源码目录、依赖库、输出路径等。）
ps：先把文件复制到自己的工程文件里去，再导入，这样不会关联原来路径

0.2 代码surround：ctrl+alt+T

0.3 多行光标选中：shift+alt+左键

0.4 自动.var生成：ctrl+alt+v

1 Java基础

1.1 标识符

概念、要求、建议

1.2 自动类型转换

1.3 逻辑运算符

1.4 运算符优先级

1.5 switch分支注意事项

1.6 数组

1.6.1 静态初识化与动态初识化

1.6.2 java内存分配

1.6.3 数组执行原理

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

1.7 方法

1.7.1 Java参数传递机制：值传递

基本类型

引用类型

1.7.2 方法的重载

概念及注意事项

1.8 面向对象基础

1.8.1 如何识别引用类型的变量–存对象的地址

1.8.2 类和对象的注意事项

1.8.3 this

概念

this的应用场景

1.8.4 构造器

概念、特点、应用场景及注意事项

写完有参构造器就没有无参构造器了，记得补上无参构造器

1.8.5 封装

1.8.6 JavaBean(实体类)

概念及应用场景–仅负责数据存取

1.8.7 成员变量与局部变量的区别

1.9 常用API

1.9.1 包

idea自动快速导包

1.9.2 String：字符串

封装方式

常用方法

注意事项

1.9.3 ArrayList：集合

常用方法

从集合删元素tips

2 基础进阶

2.1 面向对象进阶

三大特征：封装、继承、多态

2.1.1 static

概念1-修饰成员变量

类变量应用场景

概念2-修饰成员方法

类方法应用场景

注意事项

应用知识

代码块

单例设计模式

设计模式–解决什么问题、怎么写

概念

上述为饿汉式

懒汉式单例

2.1.2 继承

概念

好处：减少代码的编写，提高代码的复用性

权限修饰符

方法重写–申明不变，重新实现

概念及注意事项

子类中访问其他成员的特点

子类构造器

this()调用兄弟

this和super

2.1.3 多态

概念–编译看左边，运行看右边

好处

问题、解决及注意事项

instanceof

2.1.4 final

概念及注意

常量

2.1.5 抽象类

概念

注意事项、特点

应用场景、好处

模板方法设计模式

解决的问题

写法

final修饰

2.1.6 接口

概念

好处

示例

新方法

其他注意事项

2.1.7 内部类

概念

成员内部类（了解）

静态内部类（了解）

局部内部类（了解）

匿名内部类（重点）

2.1.8 枚举

概念及特点

枚举类实现单例设计模式

应用场景

2.1.9 泛型

概念

方法、通配符、上下限

问题、注意事项

2.2 常用API

2.2.1 Object类

克隆（拷贝）–深浅

2.2.2 Objects类

2.2.3 包装类

2.2.4 StringBuilder、StringBuffer

与String

与StringBuffer

2.2.5 Stringjoiner

2.2.6 Math

2.2.7 System

2.2.8 Runtime

2.2.9 BigDecimal

double a = 0.1
BigDecimal a1 = BigDecimal.valueOf(a);

2.2.10 jdk8之前的日期、时间

2.2.11 jdk8之后的日期、时间

LocalDate

2.2.12 Arrays

2.1.13 Lambda表达式

public class LambdaTest2 {
    public static void main(String[] args) {
        // 目标：使用Lambda简化函数式接口。
        double[] prices = {99.8, 128, 100};

//        Arrays.setAll(prices, new IntToDoubleFunction() {
//            @Override
//            public double applyAsDouble(int value) {
//                // value = 0  1  2
//                return prices[value] * 0.8;
//            }
//        });

//        Arrays.setAll(prices, (int value) -> {
//                return prices[value] * 0.8;
//        });

//        Arrays.setAll(prices, (value) -> {
//            return prices[value] * 0.8;
//        });

//        Arrays.setAll(prices, value -> {
//            return prices[value] * 0.8;
//        });

        Arrays.setAll(prices, value -> prices[value] * 0.8 );

        System.out.println(Arrays.toString(prices));
        System.out.println("----------------------------------------------------------");

        Student[] students = new Student[4];
        students[0] = new Student("蜘蛛精", 169.5, 23);
        students[1] = new Student("紫霞", 163.8, 26);
        students[2] = new Student("紫霞", 163.8, 26);
        students[3] = new Student("至尊宝", 167.5, 24);

//        Arrays.sort(students, new Comparator<Student>() {
//            @Override
//            public int compare(Student o1, Student o2) {
//                return Double.compare(o1.getHeight(), o2.getHeight()); // 升序
//            }
//        });

//        Arrays.sort(students, (Student o1, Student o2) -> {
//                return Double.compare(o1.getHeight(), o2.getHeight()); // 升序
//        });

//        Arrays.sort(students, ( o1,  o2) -> {
//            return Double.compare(o1.getHeight(), o2.getHeight()); // 升序
//        });

        Arrays.sort(students, ( o1,  o2) -> Double.compare(o1.getHeight(), o2.getHeight()));


        System.out.println(Arrays.toString(students));
    }
}

2.1.14 方法引用

2.3 正则表达式

package com.javase.regex;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @Author: gs_wang
 * @Date: 2024/06/16/下午3:23
 * @Description: 使用正则表达式查找一段文本中的内容
 */
public class RegexTest {
    public static void main(String[] args) {
        String data = "来黑马程序员学习Java，\n" +
                "      电话：18666688888，18699997777\n" +
                "      或者联系邮箱：boniu@itcast.cn，\n" +
                "      座机电话：01036517895，010-98951256\n" +
                "      邮箱：bozai@itcast.cn，\n" +
                "      邮箱2：dlei0009@163.com，\n" +
                "      热线电话：400-618-9090 ，400-618-4000，4006184000，4006189090";
        // 1.定义爬取规则
        String regex = "(1[3-9]\\d{9})|(0\\d{2,7}-?[1-9]\\d{4,19})|" +
                "(\\w{2,}@(\\w{2,10}\\.){1,2})|(400-?\\d{3,7}-?\\d{3,7})";
        // 2.封装成Pattern对象
        Pattern pattern = Pattern.compile(regex);
        // 3.通过Pattern对象去获取查找内容的匹配器对象
        Matcher matcher = pattern.matcher(data);
        while (matcher.find()) {
            System.out.println(matcher.group());
        }

        String s2 = "我我我们喜喜喜喜喜喜欢欢欢欢欢欢欢欢欢编编编编编编编编编编编编程程程程程程程程程程程啊";
        /**
         * (.)一组： .匹配任意字符
         * \\1： 为这个组声明一个组号
         * + ：声明必须是重复的字
         * $1：可以取到第一组代表的那个重复的字
         * 在正则表达式中，使用 \\1 表示引用第一个捕获组的内容，而 \\2 则表示引用第二个捕获组的内容，以此类推。在给定的代码中，只使用了一个捕获组 (.)，因此只能使用 \\1 来引用它。
         * 捕获组是通过圆括号来创建的，每个圆括号内的内容都会被视为一个捕获组。在正则表达式替换的时候，可以使用这些捕获组的引用来进行替换操作。
         * 如果在正则表达式中有多个捕获组，并且需要引用它们，可以使用 \\1、\\2、\\3 等来分别引用第一、第二、第三个捕获组的内容
         */
        System.out.println(s2.replaceAll("(.)\\1+", "$1"));

    }
}

2.4 异常

异常的体系

处理异常

自定义异常

2.5 集合进阶

体系

2.5.1 Collection

常见方法

遍历方式

（1）迭代器

(2) 增强for

问题

（3）Lambda表达式

2.5.2 List

ArrayList

底层原理

应用场景

LinkedList

底层原理

常用方法

应用场景：设计队列、栈

2.5.3 Set

HashSet

前置知识：哈希值

去重复机制

LinkedHashSet

底层原理

TreeSet

特点、注意事项

自定义排序

2.5.4 总结（一）

2.5.5 可变参数

2.5.6 Collections

2.5.7 Map

集合体系

常用方法

遍历方式

（1）键找值

（2）键值对

（3）lambda

package com.javase.map;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.function.BiConsumer;

/**
 * @Author: gs_wang
 * @Date: 2024/06/17/下午4:55
 * @Description:
 */
public class MapTest {
    public static void main(String[] args) {
        Map<String, Double> map = new HashMap<>();
        map.put("1", 123.2);
        map.put("2", 1565.5);
        map.put("3", 445.1);

        // 1、键找值
        Set<String> keySet = map.keySet();
        for (String key : keySet) {
            System.out.println(key + "=>" + map.get(key));
        }
        // 2、键值对	-- 以他可以对map排序
        Set<Map.Entry<String, Double>> entries = map.entrySet();
        for (Map.Entry<String, Double> entry : entries) {
            System.out.println(entry.getKey() + "=>" + entry.getValue());
        }
        // 3、lambda
        map.forEach(new BiConsumer<String, Double>() {
            @Override
            public void accept(String k, Double v) { // 实际上还是以2方式实现
                System.out.println(k + "=>" + v); 
            }
        });
        map.forEach((k, v) -> { // 简写
            System.out.println(k + "=>" + v);
        });

    }
}

HahMap

LinkedHashMap

TreeMap

2.5.8 Stream流

概念

使用步骤

常用方法

（1）获取Stream流

（2）Stream流常用方法

ps: 关于distinct去重

distinct去重复自定义类型的对象，希望内容一样就认为重复，需要重写hashCode、equals两个方法

（3）终结方法

Bwywb_3

关注

4
点赞
踩
6

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java学习

导入已有的新模块时，选择路径下的.iml文件（.iml 文件通常不需要手动编辑，而是由 IDEA 自动生成和管理。它们以 XML 格式存储，并包含了项目和模块的各种配置信息，如源码目录、依赖库、输出路径等。ps：先把文件复制到自己的工程文件里去，再导入，这样不会关联原来路径。写完有参构造器就没有无参构造器了，记得补上无参构造器。好处：减少代码的编写，提高代码的复用性。
复制链接

扫一扫