2023年之我拿起“java“ java基础进阶2

已于 2023-09-17 11:03:53 修改
阅读量167 收藏
点赞数
分类专栏： Java 文章标签： java 开发语言
于 2023-09-10 23:01:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63112274/article/details/132795154
版权

文章目录

java基础进阶2

日志框架 \color{red}{日志框架} 日志框架

  系统在开发阶段或者上线后，一旦业务出现问题，需要有信息定位，记录程序的运行信息就需要使用日志框架。

什么是日志

生活中的日志

  生活中的日志就好比日记，可以记录你生活中的点点滴滴。

程序中地日志

  程序中的日志可以用来记录程序运行过程中的信息，并可以永杰存储。

日志技术具备的优势

  1.可以将系统执行的信息选择性的记录到指定的位置（控制台、文件中、数据库中）。
  2.可以随时以开关的形式控制是否记录日志，无需修改源代码。

日志的规范

  1.日志规范大多是一些接口，提供给实现框架去设计。
  2.常见的规范是：

    Commons Logging

    Simple Logging Facade for Java

日志的实现框架

  1.Log4J
  2.Logback

Logback快速入门

  1.在项目下新建文件夹lib,导入Logback的相关jar包到该文件下，并添加到项目依赖库中去，
  2.将Logback的核心配置文件logback.xml直接拷贝到src目录下（必须是src下）。
  3.在代码中获取日志的对象。
  4.使用日志对象LOGGER调用其方法输出不能的日志对象。

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class LoggerDemo {
    //获取日志对象
    public static final Logger LOGGER = LoggerFactory.getLogger("LoggerDemo类");

    public static void main(String[] args) {
        LOGGER.trace("trace级别的日志");
        //打印结果 2023-09-10 22:10:30.992 [TRACE] LoggerDemo类 [main] : trace级别的日志
        
    }
}

函数式编程思想 \color{red}{函数式编程思想} 函数式编程思想

体验Lambda表达式

public class LambdaDemo {
    public static void main(String[] args) {
        useSwimming(new Swimming() {
            @Override
            public void swim() {
                System.out.println("匿名内部类");
            }
        });

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

        //lambda表达式
        useSwimming(()->{
            System.out.println("lambda");
        });
    }
    //方法的参数为接口，调用此方法要传入实现类对象
    public static void useSwimming(Swimming swimming){
        swimming.swim();
    }
}

interface Swimming{
    //抽象方法
    public abstract void swim();
}

函数式接口

函数式接口的介绍

  1.只有一个抽象方法需要重写的接口，函数式接口。函数式接口是允许其他的非抽象方法的存在例如静态方法，默认方法，私有方法。
  2.为了标识接口是一个函数式接口，可以在接口之上加上一个注解：@FunctionalInterface以示区别。

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

    }
}

//函数式接口里面要包含一个抽象方法
@FunctionalInterface
interface Swim{
    public abstract void show();

    //注意 Object类中的方法如果作为抽线方法，那么子类可以不重写
    public abstract String toString();
}

Lambda表达式

格式

(形式参数) -> {代码块}

  1.()：括号里面没有内容，可以看成方法形式参数为空。
  2.->：用箭头指向后面要做的事情。
  3.{}:包含一段代码，我们称之为代码块，可以看成是方法中的内容。
  4.如果有多个参数。参数之间用逗号隔开；如果没有参数，留空即可。

无参数无返回值的类型
//省略规则：
/*
    参数类型可以省略，但是有多个参数的情况下，不能只省略一个
    如果参数有且仅有一个，那么小括号可以省略
    如果代码块的语句只有一个，可以省略大括号和分号，甚至是return
 */
public class Test {
    public static void main(String[] args) {

        //无参所以小括号里面不需要写什么东西
        useShowHandler(()-> System.out.println("lambda"));
    }

    public static void useShowHandler(ShowHandler showHandler){
        showHandler.show();
    }
}

@FunctionalInterface
interface ShowHandler{
    public abstract void show();
}
有参无返回值
public class Test2 {
    public static void main(String[] args) {

        useStringHandler(a-> System.out.println(a));

        //lambda表达式最简式
        useStringHandler(System.out::println);
    }
    public static void useStringHandler(StringHandler stringHandler){
        stringHandler.printMessage(5);
    }
}

@FunctionalInterface
interface StringHandler{
    public abstract void printMessage(int a);
}
有参有返回值
public class Test4 {
    public static void main(String[] args) {

        useCalculator(new Calculator() {
            @Override
            public double calc(double a, double b) {
                //想要精确运算要加字符串
                BigDecimal bigDecimal1 = new BigDecimal(a+"");
                BigDecimal bigDecimal2 = new BigDecimal(b+"");
                BigDecimal sum = bigDecimal1.add(bigDecimal2);
                //将BigDecimal进行转换为double类型
                return sum.doubleValue();
            }
        });

        useCalculator((a, b)->{
            BigDecimal bigDecimal1 = new BigDecimal(a+"");
            BigDecimal bigDecimal2 = new BigDecimal(b+"");
            BigDecimal sum = bigDecimal1.add(bigDecimal2);
            return sum.doubleValue();
        });

    }
    public static void useCalculator(Calculator calculator){
        double result = calculator.calc(0.1,0.2);
        System.out.println(result);
    }
}

@FunctionalInterface
interface Calculator{
    public abstract double calc(double a,double b);
}

Lambda表达式的省略模式

  1.参数类型可以省略，但是有多个参数的情况下，不能只省略一个。
  2.如果有参数有且仅有一个，那么小括号可以省略。
  3.如果代码块的语句只有一条，可以省略大括号和分号，甚至是return。

Lambda表达式和匿名内部类的区别

所需类型不同

  1.匿名内部类：可以是接口，也可以是抽象类，还可以是具体类。
  2.Lambda表达式：只能是函数式接口。

使用限制不同

  1.如果接口中仅有一个抽象方法需要重写，可以使用Lambda表达式，也可以使用匿名内部类。
  2.如果接口中多于一个抽象方法，只能使用匿名内部类，而不能使用Lambda表达式。

使用原理不同

  1.匿名内部类：编译之后，产生一个单独的class字节码文件。
  2.Lambda表达式：编译之后，没有一个单独的class字节码文件，对应的字节码会在运行的时候动态生成。

S t r e a m 流 \color{red}{Stream流} Stream流

Stream流思想

1.获取Stream流。

  创建一条流水线，并把数据放到流水线准备进行操作。

2.中间方法

  流水线上的操作。
  一次操作完毕之后，还可以继续进行其他操作。

3.终结方法

  一个Stream流只能有一个终结方法。
  是流水线上的左后一个操作。

public class StreamDemo {
    public static void main(String[] args) {
        /*
            单列集合
         */
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"张三丰","张飞","曹操","孙尚香");

        list.stream().forEach(s -> System.out.println(s));

        /*
            双列集合
         */
        HashMap<Integer,String> hm = new HashMap<>();

        hm.put(1,"张三丰");
        hm.put(2,"张飞");
        hm.put(3,"曹操");
        hm.put(4,"孙尚香");

        Set<Integer> set = hm.keySet();

        set.stream().forEach(s-> System.out.println(hm.get(s)));

        /*
            数组
         */

        Integer[] arr = {1,2,3};
        Arrays.stream(arr).forEach(s-> System.out.println(s));



        //可变参数
        Stream.of(1,2,3,4,5,6,7).forEach(s-> System.out.println(s));
    }
}

Stream中间方法

filter

用于对流中的数据进行过滤。

//1.Stream<T> filter(Predicate predicate) 用于对流中的数据进行过滤
    //Predicate接口中的方法：boolean test(T t):对指定的参数进行判断，返回一个布尔值

public class test {
    public static void main(String[] args) {
        //新建集合
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"白起","鲁班","貂蝉","吕布");

        /*
             filter方法会拿到流中的每一个数据
             把每一个数据传递给Lambda表达式的形参s
             如果返回false就丢弃，如果返回true就保留。
         */
        list.stream().filter(s -> {return true;}).forEach(s-> System.out.println(s));
        //return true;
        //打印结果全部打印

        //return false;
        //打印结果全部不打印
    }
}
limit

limit拿到前面多少位元素。

public class test {
    public static void main(String[] args) {
        //新建集合
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"白起","鲁班","貂蝉","吕布");

        //limit拿到前面多少位元素，这里拿到前面3个元素
        list.stream().limit(3).forEach(s -> System.out.println(s));
    }
}
skip

skip跳过指定参数个数的元素。

public class test {
    public static void main(String[] args) {
        //新建集合
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"白起","鲁班","貂蝉","吕布");

        //skip跳过指定参数个数的元素,这里跳过前三个元素
        list.stream().skip(3).forEach(s -> System.out.println(s));
    }
}
concat

concat合并a和b两个流成为一个流。

public class test {
    public static void main(String[] args) {
        //新建集合
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"白起","鲁班","貂蝉","吕布");

        //concat合并a和b两个流成为一个流
            //只有前三个元素
        Stream a = list.stream().limit(3); //"白起","鲁班","貂蝉"

            //跳过前三个元素
        Stream b = list.stream().skip(3);  //"吕布"

        Stream.concat(a,b).forEach(s-> System.out.println(s));
    }
}
distinct

去重，保证唯一性

public class test {
    public static void main(String[] args) {
        //新建集合
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"白起","鲁班","貂蝉","吕布");

        //去重,保证唯一型
        list.stream().distinct().forEach(s -> System.out.println());
    }
}
sorted

默认升序排序。

public class test {
    public static void main(String[] args) {
        //新建集合
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"白起","鲁班","貂蝉","吕布");

        Stream.of(1,2,3,7,64,3,5).sorted().forEach(s-> System.out.println(s));
        //打印结果 1 2 3 3 5 7 64

        Stream.of(1,2,3,7,64,3,5).sorted(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        }).forEach(s-> System.out.println(s));
        //打印结果 降序排序
    }
}

Stream终结方法

count

返回流中的元素个数。

public class test {
    public static void main(String[] args) {
        //新建集合
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list, "白起", "鲁班", "貂蝉", "吕布");

        //返回流中的元素个数
        long result = list.stream().count();
        System.out.println(result);
    }
}

Stream流收集方法

/*
    过滤元素并遍历集合
    定义一个集合，并添加一些整数1，2，3，4，5，6，7，8，9，10
    将集合中的奇数删除，只保留偶数
 */

public class test {
    public static void main(String[] args) {
        //新建集合
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list, "白起", "鲁班", "貂蝉", "吕布");

        Stream.of(1,2,3,4,5,6,7,8,9,10).filter(s->{return s%2==0;}).forEach(s-> System.out.println(s));
    }
}


public class test {
    public static void main(String[] args) {
        //新建集合
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list, "白起", "鲁班", "貂蝉", "吕布","吕布","吕布","孙尚香","马儿扎哈");

        List<String> newList = list.stream().filter(s -> {
            return s.length() >= 3;
        }).collect(Collectors.toList());
        System.out.println(newList);
        //打印结果 [孙尚香, 马儿扎哈]

        Set<String> set = list.stream().filter(s -> {
            return s.length() >= 2;
        }).collect(Collectors.toSet());
        System.out.println(set);
        //打印结果 [马儿扎哈, 白起, 吕布, 貂蝉, 孙尚香, 鲁班]
    }
}


public class StreamDemo7 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();

        Collections.addAll(list,"zhangsan,23","lisi,24","wangwu,25");

        Map<String, Integer> map = list.stream().filter(s -> {
            String[] strings = s.split(",");

            int age = Integer.parseInt(strings[1]);

            return age >= 24;

            // }).collect(Collectors.toMap(Function类型的数据,Function类型的数据));
        }).collect(Collectors.toMap(
                (String s) -> {
                    return s.split(",")[0];
                },
                (String s) -> {
                    return Integer.parseInt(s.split(",")[1]);
                })
        );

        System.out.println(map) ;
        //打印结果 {lisi=24, wangwu=25}
    }
}
君生我老
关注
专栏目录
Java基础，Java进阶，Java数据结构，十大算法
04-04
Java是世界上最流行的编程语言之一，尤其在企业级应用开发领域占据主导地位。本教程涵盖了从基础到高级，再到数据结构和算法的全面Java知识体系，旨在帮助开发者深入理解和掌握这门语言。 首先，我们从“Java基础”...
【后端】java基础（3.1）java基础进阶之判断
03-29
看到这章，那么你已经掌握了java的基本的语法，现在可以来做点稍微高级的事情啦。判断，是编程的最基本的逻辑，因此本章我们来讲一讲java的条件判断。 在java中，最常用的条件判断无非是if判断语句，我们的if语句又...
Java基础知识到进阶知识
09-12
Java基础知识到进阶知识
由浅入深学Java-基础、进阶与必做
10-19
因此，我将直接根据标题《由浅入深学Java-基础、进阶与必做》中提及的知识点来撰写相关知识点。为了确保内容丰富且详细，我将覆盖Java基础、进阶知识和一些常用的Java实践技巧。 Java是目前世界上使用最广泛的编程...
Java零基础到大牛实战进阶指南
08-31
从Java语言基础语法讲起，逐步深入面向对象编程、集合框架、多线程、网络编程等核心知识，并结合实际项目案例，引导学习者将理论知识应用于实战中。此外，还涵盖了Java Web开发、Spring框架、数据库操作等进阶内容，...
JavaScript ArrayBuffer的读写与类型转换
白瑕 的博客
10-01 262
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
Spring Cloud全解析：服务调用之OpenFeign集成OkHttp
Lxn2zh的博客
09-30 583
HTTP连接需要进行TCP三次握手，是一个比较耗时的操作，一般我们不直接使用HttpURLConnection，而是使用HttpClient/okHttp等支持连接池的客户端工具，以Feign集成OkHttp为例。OpenFeign本质是HTTP来进行服务调用的，也就是需要集成一个Http客户端。默认是HttpURLConnection方式，也就是jdk中提供的最原始的那个。要开启OkHttp ,还需要在YML 中添加开启配置项，默认是关闭的。使用的是Client接口来进行请求的。
「Java开发指南」如何用MyEclipse为iPhone搭建Spring应用程序？
需要界面开发、IDE工具研发中文教程资料的小伙伴，记得私信我~
09-30 563
本教程将介绍如何用MyEclipse为iPhone搭建Spring应用程序，欢迎下载最新版IDE体验！
spring-boot 整合 mybatis
m0_72168501的博客
09-29 455
spring boot 整合 mybatis
Java内存布局
阿呆的专栏
10-01 703
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
C#基础：掌握控制流语句，构建灵活的程序逻辑
学习和分享
09-28 298
在C#中，控制流语句是用来控制程序执行流程的重要部分。它们允许你根据条件执行不同的代码块，或者重复执行某些代码块直到满足特定条件。
进程管理工具：非daemon进程管理工具supervisor
happy_king_zi的博客
09-29 1092
supervisor是一个 Client/Server模式的系统，允许用户在类unix操作系统上监视和控制多个进程，或者可以说是多个程序。supervisor与launchd，daemontools，runit等程序有着相同的功能，与其中某些程序不同的是，它并不作为“id 为 1的进程”而替代init。相反，它用于控制应用程序，像启动其它程序一样，通俗理解就是，把Supervisor服务管理的进程程序，它们作为supervisor的子进程来运行，而supervisor是父进程。
Java - LeetCode面试经典150题(二)
心如冰清，天塌不惊
09-28 851
否则，返回 false。给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那两个整数，并返回它们的数组下标。遍历字符串数组，将其中的字符串，进行排序，这样就形成一个唯一的字符串了，之后将原字符串追加到这个排序完的字符串映射的String列表中。这里的 遵循 指完全匹配，例如， pattern 里的每个字母和字符串 s 中的每个非空单词之间存在着双向连接的对应规律。将magazine中的每个字符的个数记录下来，用map映射成。
【RocketMQ】RocketMQ应用难点
记录一名在读研究生的学习笔记、感悟、开发产物
09-30 759
本文探讨了RocketMQ中消息重复消费的问题及其解决方案，尤其是在CLUSTERING模式下的扩容影响。文章分析了重复消费的原因，如广播模式、负载均衡模式下的多consumerGroup消费、消费者组内的动态变化及网络延迟等，并提出了利用唯一标识进行去重的方法。此外，还讨论了如何选择合适的存储机制以高效处理大量消息标识，如HashMap、MySQL、Redis以及推荐的布隆过滤器等方案。对于防止消息堆积与确保消息不丢失，也给出了相应的策略和技术措施。
第十三届蓝桥杯真题Java 斐波那契与7(持续更新)
音符犹如代码的博客
09-29 318
这是一道结果填空的题, 你只需要算出结果后提交即可。本题的结果为一 个整数, 在提交答案时只填写这个整数, 填写多余的内容将无法得分。斐波那契数列的递推公式为: Fn=Fn−1+Fn−2Fn​=Fn−1​+Fn−2​, 其中 F1=F2=1F1​=F2​=1。请问, 斐波那契数列的第 1 至 202202011200 项（含）中, 有多少项的个位 是 7。
【hot100-java】【合并两个有序链表】
m0_73629042的博客
09-30 364
记忆中，两个指针合并即可。
Java中ResultSet接口的详细介绍
2301_77032029的博客
09-28 442
ResultSet接口是Java JDBC API中的一个核心接口，用于表示从数据库查询返回的结果集。它允许用户遍历查询结果，并从中提取数据。ResultSet接口代表从数据库查询返回的结果集，它提供了以下功能：遍历结果集：允许用户向前或向后移动指针，以便访问结果集中的每一行。
JavaScript Set基础与实战应用
最新发布
软考鸭
10-01 297
Set是JavaScript中一个非常有用的数据结构，它提供了一种存储唯一值的方式。通过掌握Set的基本用法、特性以及高级操作，你可以在开发过程中更加灵活地处理集合数据。无论是去除数组中的重复元素，还是进行集合运算，Set都能提供简洁而高效的解决方案。
Dubbo快速入门（一）：分布式与微服务、Dubbo基本概念
TracyCoder的博客
09-26 1214
在互联网时代，随着用户基数的急剧增长和技术的不断进步，互联网项目与传统项目相比有了显著的区别。因此，互联网项目更加注重用户体验，包括界面的美观度、功能的丰富性、加载的速度以及系统的稳定性。在互联网架构中，为了实现上述目标，通常会采用集群和分布式计算的技术方案。例如，在一个分布式系统中，为了提高系统的可用性和性能，通常会采用集群技术来部署关键组件，如Web服务器、数据库和缓存等。集群技术主要用于解决单点故障问题，提高系统的可靠性和可用性，同时也能通过负载均衡来提升系统的处理能力。
"Java面向对象编程进阶，完整资源下载地址
本文介绍的是Java开发基础入门教程系列中的第八个课程——Java编程实训 Java开发基础入门教程1-08 面向对象编程进阶。该课程共有37页，主要内容包括对象的生命周期、静态方法和类变量、访问控制、String和类型转换、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

君生我老

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值