标签: java

2023-10-13发表2024-08-11更新 Xiamu JavaSE3 分钟读完 (大约489个字)

JavaSE-日志文件

日志接口有两类，

Commons Logging (JCL)
Simple Logging Facade for Java (SLF4J)

热门的Logback是基于SLF4J实现的。

所以要使用Logback首先需要添加3个依赖，去maven仓库搜一下，用maven加载就好。

= = = = = = = = = = = = = = = = = = =
= = = = = = Maven仓库 = = = = = = =
= = = = = = = = = = = = = = = = = = =

然后我们可以通过一个logback.xml文件来配置logback一些东西，文件放在/src/main/resources下，这是一份样例。

language-xml

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <!--
        CONSOLE ：表示当前的日志信息是可以输出到控制台的。
    -->
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <!--输出流对象 默认 System.out 改为 System.err-->
        <target>System.out</target>
        <encoder>
            <!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度
                %msg：日志消息，%n是换行符-->
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%-5level]  %c [%thread] : %msg%n</pattern>
            <charset>utf-8</charset>
        </encoder>
    </appender>

    <!-- File是输出的方向通向文件的 -->
    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
            <charset>utf-8</charset>
        </encoder>
        <!--日志输出路径-->
        <file>C:/Users/kmo/IdeaProjects/JAVA-DataSt/DataSt/src/main/resources/Log/data.log</file>
<!--        指定日志文件拆分和压缩规则-->
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <!--通过指定压缩文件名称，来确定分割文件方式-->
            <fileNamePattern>C:/Users/kmo/IdeaProjects/JAVA-DataSt/DataSt/src/main/resources/Log/log-%d{yyyy-MM-dd}.log%i.gz</fileNamePattern>
            <!--文件拆分大小-->
            <maxFileSize>1MB</maxFileSize>
        </rollingPolicy>
    </appender>

    <!--
    level:用来设置打印级别，大小写无关：TRACE, DEBUG, INFO, WARN, ERROR(只有大于等于这个级别的才会被记录)    |    ALL 和 OFF
   ， 默认debug
    <root>可以包含零个或多个<appender-ref>元素，标识这个输出位置将会被本日志级别控制。
    -->
    <root level="ALL">
        <!-- 注意：如果这里不配置关联打印位置，该位置将不会记录日志-->
        <appender-ref ref = "CONSOLE"/>
        <appender-ref ref="FILE" />
    </root>
</configuration>

接着这样在代码中引入logback日志输出器

language-java

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class Test{
   
    public static void main(String[] args) {
   
        Logger logger = LoggerFactory.getLogger("");
        logger.info("This a info message");
        logger.warn("This a warning message");
    }
}

2023-10-13发表2024-08-11更新 Xiamu JavaSE2 分钟读完 (大约312个字)

JavaSE-IO

IO流总体来看有四大类

字节输入流
字节输出流
字符输入流
字符输出流

IO的体系如下图

需要注意的是字节流适合完整的复制文件之类的操作，而字符流尤其适合纯文本文件。

第一行实现类，都是原始流，性能并不高。

第二行是Buffer缓冲流，自带8KB缓冲池，相当于缓存之于cpu和硬盘的感觉。

第三行是打印流，符合平常的println习惯。

第四行是数据流，适合保存读取基本类型数据，保存后的文件打开是乱码很正常。

第五行是序列流，适合保存读取对象，对象需实现Serializable接口，transient关键字可以设置某变量不参加序列化。

除了原始流，其他的都是高级流，高级流都封装了原始流，并且性能都比较好。

IO框架

Commons-IO This is an example image https://www.w3schools.cn/apache_commons_io/同时Java自己后来也提供了IO框架库。

2023-10-13发表2024-08-11更新 Xiamu JavaSE4 分钟读完 (大约566个字)

JavaSE-Stream流

从流的出生，经过过滤，排序，去重等各种方法，变成最后的结果，就像水流一样，在代码层面也类似地简单明了，最大的优点是不用自己去保存中间状态，而是可以一直往后操作，直到遇到Stream的终结方法，也像水流一样，Stream流使用后就会改变，一般只用一遍。

1.获取Stream流

一般集合都提供了stream方法，只需要.stream()就可以获取。比如

1 2	Set<String> set = new HashSet<>(); Stream<String> stream = set.stream();

但Map除外，Map用以下方法获取流：

keySet()获取Key的Set后stream或者values()获取Value的Set后stream
entrySet()转化为包含Map.Entry的Set后stream

一般建议用第二种，毕竟Key+Value才是Map的精髓，下面代码里的Entry可以理解为Pair(一对)。

1 2	Map<String, Double> map = new HashMap<>(); Stream<Map.Entry<String, Double>> stream = map.entrySet().stream();

Arrays数组可以通过以下方式获得Stream

Arrays.stream(YourArrays)
Stream.of(YourArrays)

2.常用的Stream的中间方法

filter使用lambda式判断条件作为过滤，例如：

List<Double> scores = new ArrayList<>();
Collections.addAll(scores, 88.5, 108.8, 60.0, 99.0, 9.5, 99.6, 25.0);
//需求1:找出成绩人于等于60分的数据,并升序后,可输出。
List<Double> list1 = scores.stream()
    .filter(s -> s > 60)
    .sorted()
    .collect(Collectors.toList());
System.out.println(list1);

sorted排序，limit限制数量，skip跳过，distinct去重，都比较简单。其中sorted需要重写排序规则，在集合体系已经讲过，distinct需要重写hashCode和equals，如果是Java自带的基础集合，都不用管这些。

map操作接收一个函数作为参数，支持lambda，比如

List<Integer> numList = Arrays.asList(1, 2, 3, 4, 5); 
List<String> strList = numList.stream()
                            .map(n -> n.toString())
                            .collect(Collectors.toList());

concat合并流，后者接在前者后面，比如

Stream<String> stream1 = Stream.of("张三", "李四");
Stream<String> stream2 = Stream.of("张三2", "李四2", "王五");
Stream<String> streamAll = Stream.concat(stream1, stream2);
streamAll.forEach(s -> System.out.println(s));

3.常用的终结方法

collect里面填诸如Collectors.toList()，Collectors.toSet()，to什么就用什么接收结果。

1 2	.collect(Collectors.toList()); .collect(Collectors.toMap(Student::getName, Student::getHeight))

2023-10-13发表2024-08-11更新 Xiamu JavaSE12 分钟读完 (大约1809个字)

JavaSE-集合

Java基础集合分为两大类，Collection和Map，前者单列集合，后者双列集合。

Collection

下图为Collection集合体系树

Collection下有List和Set两小类集合，List和Set都只是接口。

List的具体实现有ArrayList和LinkedList，Set的具体实现有HashSet，LinkedHashSet，TreeSet。

它们的特点如下表

Map

下图为Map集合体系树

其中具体的实现分别是HashMap，LinkedHashMap，TreeMap，特点如下表

|—–|—————|————|
| | | |
| Map | HashMap | 无序，不重复，无索引 |
| Map | LinkedHashMap | 有序，不重复，无索引 |
| Map | TreeMap | 排序，不重复，无索引 |

需要注意的是Map的”序”都是基于Key的

性能

ArrayList

ArrayList行为和数组无异，插入删除会设计复制覆盖，性能不高，但是因为索引所以涉及索引的操作性能格外的好，比如读取，末尾增删改。同时内存占用很小，除了数据本身没有太多其他的东西。

LinkedList

LinkedList在ArrayList基础上，使用”链”链接前后元素，取缔了ArrayList因为复制覆盖造成的低效行为，在增删改性能都很好，但是因为使用了链所以数据在内存中不是连续的，故而失去了索引一步读取的优势，需要遍历才能锁定元素，因此涉及索引的操作都受到一定性能下滑。内存占用比ArrayList多了”链”。

请使用Iterator迭代器，通过Iterator迭代List永远是效率最高的

1
2
3

List<String> list = new ArrayList<String>();
//后期还可直接替换成LinkedList
list = new LinkedList<String>();

HashSet

HashSet是基于哈希表实现的，哈希表是一种增删改查性能都较好的数据结构

目前的（jdk8+）哈希表是基于数组+链表+红黑树实现的。

我们可以肯定LinkedList的链能够一步增删元素的优势，但是却没法一步定位到元素，但是Hash可以逼近，Hash将元素的哈希值取余后的到的结果作为索引放入数组对应位置，如果多个元素位置相同就用链连接，这就是哈希表的雏形=数组+链表，虽然看起来漏洞百出。使用哈希表定位元素只需对哈希值取余得到索引，锁定数组位置，然后遍历链表，锁定元素。只需要保证哈希表取余和遍历都不会花上太多时间，那么哈希表在锁定元素上就也是成功的。

庆幸的是，哈希表的取余操作十分高效，这得益于它的设计，哈希表的数组长度保持为2的幂，用二进制数表示就是一个1+多个0，比如10=2，100=4，1000=8，那么对于随便一个二进制数，和这个2幂进行”按位与”运算就可以得到余数的二进制数。

如果我们保证一个数组位置上的元素不会太多，那么遍历链表也是开销极小的。哈希表默认的加载因子为0.75，意味着元素数超过数组长度*0.75时，哈希表会进行扩容，也就是将数组长度*2 ，这就保证了一个数组位置上的链表不会太长。此时又会产生一个问题，扩容后所有元素都需要重新取余计算位置吗？不用，哈希表也有巧妙的办法，基本上只需要移动一半的元素就可以。

同时，在红黑树的加持下，如果太过幸运，数组某位置上的链表过长（>8），那么哈希表会把这个链表变成红黑树，进一步为遍历加速。

因此，HashSet的性能是均衡地较好。

LinkedHashSet

就是在HashSet的基础上，给元素间加上了链，确定了它们的顺序。

TreeSet

底层不是哈希表了，而是红黑树，一种自平衡二叉树。性能感觉起来是更优雅的均衡较好。

随着元素数量增加，二叉树优势越为明显，如果数组+链表的结构能在低量元素时能比红黑树快，那么哈希表就比单纯的红黑树快。

Map

Map和Set是一样的，更准确地说，Set底层用的就是Map，忽略了value只保留key而已。

其他问题

HashSet不能对内容一样的两个不同对象去重，为什么？怎么办？

比如自定义Student类

public class Student {
    private String name;
    private int age;
    private double height;
}

1 2	Student s1 = new Student("张三", 22, 189.5); Student s2 = new Student("张三", 22, 189.5);

因为第一，哈希表需要对象的哈希值确定位置，而hashCode()默认是地址的比较，两个不同对象地址明显不同，使用哈希表会错误地把两个对象也放进去。解决办法是重写对象地hashCode()方法。

因为第二，如果两个对象hashCode()一致，在数组同一位置，此时会进行equals比较，如果是false，后者就会当作新元素。解决办法就是重写equals方法。

在Java中==对基本数据类型是值的比较，对对象是地址比较。

equals方法（一般不对基本数据类型比较），对对象是地址比较，但是对象的equals方法可以重写。这很常见，就像String一样是重写过的，使用equals实际上是在对值进行比较。

所以想要去重，就要重写对象的hashCode和equals方法。

idea可以快捷插入hashCode和equals，默认是值一样就相等。

@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    StudentComp student = (StudentComp) o;
    return age == student.age && Double.compare(height, student.height) == 0 && Objects.equals(name, student.name);
}

@Override
public int hashCode() {
    return Objects.hash(name, age, height);
}

如果TreeSet的键是自定义对象，怎么定义排序规则？

两个办法

Student类继承Comparable接口，重写compareTo方法

public class Student implements Comparable<Student> {
    private String name;
    @Override
    public int compareTo(Student o) {
        if (this.age!=o.age){
            return Integer.compare(this.age, o.age);
        }else if (this.height!=o.height){
            return Double.compare(this.height, o.height);
        }else{
            return this.name.compareTo(o.name);
        }
    }
}

使用TreeSet时提供参数构造器的Comparator

Set<Student> set2 = new TreeSet<>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                if (o1.age!=o2.age){
                    return Integer.compare(o1.age, o2.age);
                }else if (o1.height!=o2.height){
                    return Double.compare(o1.height, o2.height);
                }else{
                    return o1.name.compareTo(o2.name);
                }
            }
        });

Set<Student> set2 = new TreeSet<>((o1, o2)->{
            if (o1.age!=o2.age){
                return Integer.compare(o1.age, o2.age);
            }else if (o1.height!=o2.height){
                return Double.compare(o1.height, o2.height);
            }else{
                return o1.name.compareTo(o2.name);
            }
        });

2023-06-12发表2024-08-11更新 Xiamu SpringBoot3 / Docker2 分钟读完 (大约354个字)

优雅地给Docker容器添加新端口

一共分为三步，停止容器和docker服务，修改配置文件，重启服务和容器。

这里只讲如何修改配置文件。

如果你是Linux环境

容器配置文件hostconfig.json 通常位于 /var/lib/docker/containers/[hash_of_the_container]/hostconfig.json 或者 /var/snap/docker/common/var-lib-docker/containers/[hash_of_the_container]/hostconfig.json

找到PortBindings字段，以下是一个端口的格式例子

"PortBindings": {
                "8080/tcp": [
                    {
                        "HostIp": "",
                        "HostPort": "8080"
                    }
                ],
                "8088/tcp": [
                    {
                        "HostIp": "",
                        "HostPort": "8088"
                    }
                ]
            },

如果不起作用，建议同时修改下面提到的config.v2.json 。

如果你是windws+wsl2环境

那么你需要修改两个文件，hostconfig.json和config.v2.json，它们都位于/mnt/wsl/docker-desktop-data/data/docker/<containerID>下。

hostconfig.json文件修改和linux的一样。

config.v2.json需要修改以下两个字段

1
2
3

"ExposedPorts":{"8080/tcp":{},"8088/tcp":{}}

"Ports":{"8080/tcp":[{"HostIp":"0.0.0.0","HostPort":"8080"}],"8088/tcp":[{"HostIp":"0.0.0.0","HostPort":"8088"}]}