Java on JokemeBlog

kmp算法Java版

Fri, 05 Nov 2021 23:31:27 +0800

KMP查找算法

import java.util.Arrays;

public class getstr {
    public static void main(String[] args) {
        String txt = "qwertyqwertyuisdgfsdnhjt";
        String gol = "sdgfsdn";
        int i = kmp(txt,gol);
        System.out.println("matchPoint: " + i);
    }
    static int kmp(String str1, String str2){
        int [] ary =getnext(str2);
        System.out.println(Arrays.toString(ary));

        for(int i =0,j = 0; i < str1.length();i++){
            while(j > 0 && str1.charAt(i) != str2.charAt(j) ){
                j = ary[j-1];
            }
            if(str1.charAt(i) == str2.charAt(j)){
                j++;
            }
            if(j == str2.length()){
//                System.out.println("i = "+i+"\nj = "+j);
                return i-j+1;
            }
        }
        return -1;
    }
    static int [] getnext(String str2){
        int [] ary = new int[str2.length()];
        ary[0] = 0;
        for(int i = 1, y = 0; i < str2.length(); i++ ){

            while(y > 0 && str2.charAt(i) != str2.charAt(y)){
                y-=1;
            }
            if(str2.charAt(i) == str2.charAt(y)){
                y++;
            }
            ary[i] = y;
        }

        return ary;
    }
}

其实一开始我也没有咋明白,但是后来我找到了下面这个文章 smoke_zl_图解kmp算法-通俗易懂kmp算法我就一下捂了,这个查找算法太妙了,就靠这一个数组,就可以实现快速查找不回溯

B/S分层简介

Fri, 10 Sep 2021 20:35:28 +0800

B/S分层

分层介绍

dto层

大概就是 MVC 中的 model 层,主要是用来写与数据库相对应的实体类的,并且需要有 get/set 方法

dao层

dao 层的文件习惯用 Mapper 来表示 dao 层会调用 dto层 ,并且在这一层主要就是 crud 操作

service层

service层会调用dao层和dto层,service层也会对数据进行一定的处理,比如条件判断和数据筛选等等；

controller层

最后，是controller层，controller层会调用前面三层，controller层一般会和前台的js文件进行数据的交互， controller层是前台数据的接收器，后台处理好的数据也是通过controller层传递到前台显示的。

SpringBoot中的分层

SpringBoot 分为四层：controller层、service层、dao层、entity层。

entity层：

和 model 层一样，存放的是实体类，属性值与数据库值保持一致，实现 setter 和 getter 方法。

dao层：

即 mapper层，对数据库进行持久化操作，他的方法使针对数据库操作的，基本上用的就是增删改查，他就是个接口，只有方法名，具体实现在mapper.xml中实现。

service层：

业务层，存放业务逻辑处理，不直接对数据库进行操作，有接口和接口实现类，提供 controller 层调用方法。

controller层：

控制层，导入 service层，调用你service方法，controller通过接受前端传来的参数进行业务操作，在返回一个制定的路径或数据表。

各层介绍

model层

model层即数据库实体层，也被称为entity层，pojo层。
一般数据库一张表对应一个实体类，类属性同表字段一一对应。

dao层

dao层即数据持久层，也被称为mapper层。
dao层的作用为访问数据库，向数据库发送sql语句，完成数据的增删改查任务。

service层

service层即业务逻辑层。
service层的作用为完成功能设计。
service层调用dao层接口，接收dao层返回的数据，完成项目的基本功能设计。

controller层

controller层即控制层。
controller层的功能为请求和响应控制。
controller层负责前后端交互，接受前端请求，调用service层，接收service层返回的数据，最后返回具体的页面和数据到客户端。

各模块简介

Java
- bean 实体类，对应数据库中的表(model)
  - 构造方法
  - 属性
  - getter setter
  - toString()
- dao 持久层数据库增删改查
- service 业务层
- controller 控制层跳转哪里
- resources
  - mapper dao实现类
  - applicationContext.xml Spring的配置文
  - db.properties 数据库连接信息
  - log4j.properties 日志配置文件
  - springmvc.xml 配置springmvc
- webapp
  - jsp等页面
  - web-inf
    - web.xml 加载过滤器拦截

各种命名介绍

PO

(persistant object) 持久对象

在 o/r 映射的时候出现的概念，如果没有 o/r 映射，没有这个概念存在了。通常对应数据模型 ( 数据库 ), 本身还有部分业务逻辑的处理。可以看成是与数据库中的表相映射的 java 对象。最简单的 PO 就是对应数据库中某个表中的一条记录，多个记录可以用 PO 的集合。 PO 中应该不包含任何对数据库的操作。

DO

（Domain Object）领域对象

就是从现实世界中抽象出来的有形或无形的业务实体。

TO

(Transfer Object) ，数据传输对象

在应用程序不同 tie( 关系 ) 之间传输的对象

DTO

（Data Transfer Object）数据传输对象

这个概念来源于J2EE的设计模式，原来的目的是为了EJB的分布式应用提供粗粒度的数据实体，以减少分布式调用的次数，从而提高分布式调用的性能和降低网络负载，但在这里，我泛指用于展示层与服务层之间的数据传输对象。

VO

(value object) 值对象

通常用于业务层之间的数据传递，和 PO 一样也是仅仅包含数据而已。但应是抽象出的业务对象 , 可以和表对应 , 也可以不 , 这根据业务的需要。用 new 关键字创建，由 GC 回收的。

BO

(business object) 业务对象

从业务模型的角度看 , 见 UML 元件领域模型中的领域对象。封装业务逻辑的 java 对象 , 通过调用 DAO 方法 , 结合 PO,VO 进行业务操作。 business object: 业务对象主要作用是把业务逻辑封装为一个对象。这个对象可以包括一个或多个其它的对象。比如一个简历，有教育经历、工作经历、社会关系等等。我们可以把教育经历对应一个 PO ，工作经历对应一个 PO ，社会关系对应一个 PO 。建立一个对应简历的 BO 对象处理简历，每个 BO 包含这些 PO 。这样处理业务逻辑时，我们就可以针对 BO 去处理。

POJO

(plain ordinary java object) 简单无规则 java 对象

纯的传统意义的 java 对象。就是说在一些 Object/Relation Mapping 工具中，能够做到维护数据库表记录的 persisent object 完全是一个符合 Java Bean 规范的纯 Java 对象，没有增加别的属性和方法。我的理解就是最基本的 Java Bean ，只有属性字段及 setter 和 getter 方法！。

DAO

(data access object) 数据访问对象

是一个 sun 的一个标准 j2ee 设计模式，这个模式中有个接口就是 DAO ，它负持久层的操作。为业务层提供接口。此对象用于访问数据库。通常和 PO 结合使用， DAO 中包含了各种数据库的操作方法。通过它的方法 , 结合 PO 对数据库进行相关的操作。夹在业务逻辑与数据库资源中间。配合 VO, 提供数据库的 CRUD 操作.

VO

vo就是我们在web的controller层返回的Object，在接口中这个VO都会被转成Json对象输出，view object。

DO

DO就是一个业务实体对象

DTO

DTO就是一个复合的DO对象，由于业务需要我们需要调用业务A查询数据得到业务对象A，再调用业务B查询数据得到业务对象B然后一系列封装转化得到复合的对象C此时他就是一个DTO，data transfer object 它是一个服务层和服务层以上之间转换的对象。

PO

po持久化对象一般放在domain 或者 Entry中是一个与数据库表关联的对象，每一个属性都是表中的一个字段。当业务过于简单时，po ，do，dto，vo并没有什么区别的时候我们也可以直接复用PO

model = dto

dao = mapper

controller = 除了上面两个所有的

Model是模型一般而言，会有人分的更细，VO，DTO 等等。我并不推荐分的更细，这个Model常常和持久化的数据一一对应，如Mysql和MongoDB。

Service的概念很大，它的重点是在于提供一个服务。这个服务可能包括一系列的数据处理，也有可能会调用多个Util，或者是调用别的服务。总归一句话，就是，有什么事情，你来找我。

Dao一般而言，都是用来和底层数据库通信，负责对数据库的增删改查。Dao最好都是要独立出来。到现在为止，最佳实践就是一个Service只对应一个Dao。Service会做一些额外的检查，如货物是否损坏，入库单是否完整，等等等等。

SpringBoot 集成MyBatis 中的@MapperScan注解

在SpringBoot中集成MyBatis，可以在mapper接口上添加@Mapper注解，将mapper注入到Spring,但是如果每一给mapper都添加@mapper注解会很麻烦，这时可以使用@MapperScan注解来扫描包。

经测试发现，@MapperScan注解只会扫描包中的接口，不会扫描类，所以可以在包中写Provider类。

@MapperScan(“com.demo.mapper”)：扫描指定包中的接口

@MapperScan(“com.demo..mapper”)：一个代表任意字符串，但只代表一级包,比如可以扫到com.demo.aaa.mapper,不能扫到com.demo.aaa.bbb.mapper

@MapperScan(“com.demo.**.mapper”)：两个*代表任意个包,比如可以扫到com.demo.aaa.mapper,也可以扫到com.demo.aaa.bbb.mapper

可以扫描到跨模块的包

Spring IOC DI 学习

Thu, 03 Jun 2021 17:27:33 +0000

Spring IOC DI 学习

最近在海底捞上班搞运维，但是我也没有放下我的Java开发学习，今天下班早点，我就又开始学习Springboot啦

因为去年写的wh项目太拉胯啦，有好多东西都是一知半解，只是知道某一个方法应该怎么用，但是为什么要这么使用，其中的道理我还是不太明白，虽然之前我也是写过两篇Springboot开发中的知识，但是现在显而易见，我已经把他们给忘记啦。所以现在再拉出来鞭尸一遍巩固学习的知识。

IOC简介

ioc [Inversion of Control] 控制反转，具体的官话我也说不出来，反正我个人的理解就是：

不需要我这个小垃圾来管理Java bean啦，我不需要亲自的new对象了，这些事情都交给Springboot来做。总的来说就是我解放了。

IOC是什么用？

众所周知，Springboot是注解式开发，那么IOC肯定是配合着注解来使用的。

假如，现在我有一个项目，里面有一个pojo package，里面有一个unix类如下：

package top.jokeme.funny.pojo;

import org.springframework.stereotype.Component;

@Component
public class unix {
    private Integer year;
    private String name;
    private Boolean unix;
  
    @Override
    public String toString() {return "unix{" +"year=" + year +", name='" + name + '\'' +", unix=" + unix +'}';
    }

    public Integer getYear() {return year;}

    public void setYear(Integer year) {this.year = year;}

    public String getName() {return name;}

    public void setName(String name) {this.name = name;}

    public Boolean getUnix() {return unix;}

    public void setUnix(Boolean unix) {this.unix = unix;}
}

可以看到我加了一个注解：@Component

然后我的server package下面有：interface ：halo 、 package：impl 、impl下面有一个halo的实现类：haloimpl

halo内容如下：

package top.jokeme.funny.service;

public interface halo {
    public String sayhalo ();
}

haloimpl内容如下：

package top.jokeme.funny.service.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import top.jokeme.funny.pojo.unix;
import top.jokeme.funny.service.halo;

@Service
public class haloimpl implements halo {

    @Autowired
    private unix unix;

    @Override
    public String sayhalo() {
        unix.setUnix(true);
        unix.setYear(1973);
        unix.setName("Unix_like Linux_Ubuntu_20.04 Build 2021 03 06 13:09:35");
        return unix.toString();
    }
}

可以看的出来，这里最重要的注解就是@Autowired ，我们没有new对象，但是在加了注解以后就可以直接调用方法了。

如果你愿意加上一个controller，那你就可以在网页上查看你写的数据！

controller如下：

package top.jokeme.funny.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import top.jokeme.funny.service.halo;

@Controller
public class retUnix {
    @Autowired
    private halo haloimpl;

    @ResponseBody
    @RequestMapping("getunix")
    public String getunix (){
        return haloimpl.sayhalo();
    }
}

可以看到，万众瞩目的注解 @Autowired 依然在这里发光发热，我们只需要调用接口halo，就有一个实现类被实例化了。

如果此时，你再一不小心运行啦该代码，并且又一不小心的访问web页面，你就会发现，你写的东西已经被成功的返回啦！

我的疑惑

问题一

为什么同样在/下面，unix类需要加上注解 @Component 才能被Springboot接管，而haloimpl没有加 @Component 就可以被Springboot接管呢？或者通俗的说就是haloimpl可以通过 @Autowired获取unix类的原因我知道，是因为unix加了 @Component 注解，但是 haliimpl 没有加注解为什么没有加 @Component 也可以被retUnix 获取到呢？

我个人现在也觉得这个问题很无聊，因为haloimpl 有一个 @Service 注解。

再来给自己解释一下注解：

@Component：加上该注解就表示当前类需要被Spring的容器管理； @Service：加上该注解就表示当前类需要在业务逻辑类当中使用。 @Repositorty：加上该注解就表示当前类在数据访问层使用 @Controller：加上该注解就表示当前类在展现层（MVC）使用

问题二

为什么加了 @Autowired 参数以后就可以直接调用方法了？

其实吧加注解这一步就是叫 DI 也就是依赖注入，@Component 和 @Autowired 是成对出现的，除非你让Spring管理你的类，你自己再手动new。我想正常开发没个十年脑血栓不会这么干吧！

文章部分内容参考：所念皆山海

关于 Maven 下载插件缓慢的问题

Thu, 23 Jul 2020 03:48:26 +0000

关于 Maven 下载插件缓慢的问题

众所周知,咱们大天朝由于各种原因,只能活在局域网里面.这可能对那些不深度使用网络的人来说不痛不痒,但是你要是搞开发,搞运维,那才是各种烦呢

就拿 maven来说,我™下载一个几kb得依赖都要好几个小时,甚至还要看运气

网上也给了各种各样得解决方案~~特指 CSDN~~,但是我去尝试后,他妈的怎么弄都不行!!!我就搞不明白了,有些作者~~特指那种只会复制粘贴别人文章的~~,连别人文章的有效性都不去验证一下,就直接拿过来当作自己的了,太恶心了??

好嘞废话不多说了,还是说 maven 吧以前阿里源还是 http ,所以用网上的方法还是有效的,但是当阿里把 http 升级为https 后,原来的方法就失效了

idea编辑器:忽略ssl的配置,Maven -> Runner -> VM Options添加

`1`	`-Dmaven.wagon.http.ssl.insecure=true -Dmaven.wagon.http.ssl.allowall=true -Dmaven.wagon.http.ssl.ignore.validity.dates=true`

Eclipse操作大致同上,忽略 ssl即可

另外想屏蔽CSDN得话可以用 Tampermonkey 脚本来屏蔽一下 p.s. 需要先安装 Tampermonkey 再安装 百度搜索结果屏蔽csdn博客

文章转自博客园作者:lisongyu 原文链接:关于maven使用阿里源无法生效问题

SpringBoot学习笔记(1)

Fri, 29 May 2020 17:27:33 +0000

Spring学习

提醒⏰:在开始之前,我们需要配置以下基本环境(还有文件的编码方式也要注意)

File »> Project Structcture(CTRL+ALT+Shift+S) »> Project »> Project SDK:
File »> Project Structcture(CTRL+ALT+Shift+S) »> Project »> Project language level
File »> Project Structcture(CTRL+ALT+Shift+S) »> Modules »> Sources »> Languages level
File »> Settings(CTRL+ALT+S) »> Build,Execution,Deployment »> Compiler »> Java Compiler »> Project bytecode version
File »> Settings(CTRL+ALT+S) »> Build,Execution,Deployment »> Compiler »> Java Compiler »>Per-module bytecode version

配置文件 <pom.xml>

<properties>
  <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  <java.version>1.8</java.version>
</properties>
<!-- 首先配置一下基本的文件编码和Java版本 -->

<dependencies>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>2.2.2.RELEASE</version>
        </dependency>
<!-- 提供一些 mvc，aop 的依赖包，这是玩Spring-boot必备的依赖包 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.2.2.RELEASE</version>
            <type>pom</type>
        </dependency>
<!--  这个依赖是帮助我们自动选择一些依赖最合适的版本，这个是玩Spring-Boot必备的 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <version>2.1.7.RELEASE</version>
        </dependency>
<!--该插件是将Springboot项目打包为可执行的jar包 -->
</dependencies>

spring-boot-starter-parent 是版本仲裁者,所以我们在导入依赖时,可以省略一些依赖的版本号

spring-boot-starter-web web 模块的场景启动器组件,还有别的一些 starter 都是被 Sprint boot 抽取出来的,以后在项目里只需导入这些启动器就可以开箱即用

建立Controller & Starter

package top.jokeme;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Starter {
    public static void main(String[] args) {
        SpringApplication.run(Starter.class,args);
    }
}
#~~~~~~~~~~~~~~~~
package top.jokeme;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class Controller {
    @RequestMapping("/word")
    public String restr(){
        return "<p style='color:red;text-align:center'>Awesome Java</p>";
    }
}

这就是一个最简单的 SpringBoot 应用程序

package top.jokeme;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@ComponentScan("top.jokeme.ayibe")
@SpringBootApplication
public class Starter {
    public static void main(String[] args) {
        SpringApplication.run(Starter.class,args);
    }
}

@SpringBootApplication 该注解就标识着 Springboot 的主配置类,启动类,从这里的 main 方法开始执行

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(
    excludeFilters = {@Filter(
    type = FilterType.CUSTOM,
    classes = {TypeExcludeFilter.class}
), @Filter(
    type = FilterType.CUSTOM,
    classes = {AutoConfigurationExcludeFilter.class}
)}
)
public @interface SpringBootApplication {
    ......
}

注: @import 是 SpringBoot の底层注解.其作用就是给容器导入组件

需要注意两个比较重要的注解

Registrar.class

@SpringBootApplication 中的 
@EnableAutoConfiguration 中的 
@AutoConfigurationPackage 中的
@Import({Registrar.class})

其中 Registrar.clss就是

static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
        Registrar() {
        }

        public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
            AutoConfigurationPackages.register(registry, (new AutoConfigurationPackages.PackageImport(metadata)).getPackageName());
        }
//这个方法就是将标记了@SpringBootApplication的类,及其子包的所有组件扫描到Spring容器里面去
    
        public Set<Object> determineImports(AnnotationMetadata metadata) {
            return Collections.singleton(new AutoConfigurationPackages.PackageImport(metadata));
        }

AutoConfigurationImportSelector

1
2
3

@SpringBootApplication 中的 
@EnableAutoConfiguration 中的 
@Import({AutoConfigurationImportSelector.class})

AutoConfigurationImportSelector 就是导入哪些组件的选择器,并且会将需要导入的组件以全类名の方式返回,然后这些组件就会被添加到容器之中;

在这个过程中,会导入非常多的自动配置类诸如 [ xxxAutoConfiguration ] 等,目的就是给容器导入这些场景所需的所有组件,并自动配置好

上 AutoConfigurationImportSelector 代码片段:

    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        if (!this.isEnabled(annotationMetadata)) {
            return NO_IMPORTS;
        } else {
            AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader.loadMetadata(this.beanClassLoader);
            AutoConfigurationImportSelector.AutoConfigurationEntry autoConfigurationEntry = this.getAutoConfigurationEntry(autoConfigurationMetadata, annotationMetadata);
            return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
        }
    }
    protected AutoConfigurationImportSelector.AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata, AnnotationMetadata annotationMetadata) {
        if (!this.isEnabled(annotationMetadata)) {
            return EMPTY_ENTRY;
        } else {
            AnnotationAttributes attributes = this.getAttributes(annotationMetadata);
            List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes);
            configurations = this.removeDuplicates(configurations);
            Set<String> exclusions = this.getExclusions(annotationMetadata, attributes);
            this.checkExcludedClasses(configurations, exclusions);
            configurations.removeAll(exclusions);
            configurations = this.filter(configurations, autoConfigurationMetadata);
            this.fireAutoConfigurationImportEvents(configurations, exclusions);
            return new AutoConfigurationImportSelector.AutoConfigurationEntry(configurations, exclusions);
        }
    }

    protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
        List<String> configurations = SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader());
        Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you are using a custom packaging, make sure that file is correct.");
        return configurations;
    }

然后就用到了 SpringFactoriesLoader.loadFactoryNames

    public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
        String factoryTypeName = factoryType.getName();
        return (List)loadSpringFactories(classLoader).getOrDefault(factoryTypeName, Collections.emptyList());
    }
    private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
        MultiValueMap<String, String> result = (MultiValueMap)cache.get(classLoader);
        if (result != null) {
            return result;
        } else {
            try {
                Enumeration<URL> urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");
                LinkedMultiValueMap result = new LinkedMultiValueMap();

                while(urls.hasMoreElements()) {
                    URL url = (URL)urls.nextElement();
                    UrlResource resource = new UrlResource(url);
                    Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                    Iterator var6 = properties.entrySet().iterator();

                    while(var6.hasNext()) {
                        Entry<?, ?> entry = (Entry)var6.next();
                        String factoryTypeName = ((String)entry.getKey()).trim();
                        String[] var9 = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
                        int var10 = var9.length;

                        for(int var11 = 0; var11 < var10; ++var11) {
                            String factoryImplementationName = var9[var11];
                            result.add(factoryTypeName, factoryImplementationName.trim());
                        }
                    }
                }

                cache.put(classLoader, result);
                return result;
            } catch (IOException var13) {
                throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var13);
            }
        }
    }

SpringBoot 在启动的时候,主要就是从类路径下的 META-INF/factories 里获取 EnableAutoConfiguration 指定的值,并将这些值作为自动配置类导入容器中,然后自动配置类生效,帮我们实现自动配置的工作

这些都归功于:

spring-boot-autoconfigure-2.2.2.RELEASE.jar

注: Part 2.1的一些内容可能与 Part 3 的内容有冲突,以 Part 3 为准,Part 2.1有点老

自动配置原理

application.properties 配置文件里面都可以配置什么内容?

SpringBoot在启动的时候会加载主配置类,这个主配置类就是我们添加了注解 [ @SpringBootApplication ]的类

并且为这个类开启了自动配置功能 (继承至注解:@SpringBootApplication の注解 @EnableAutoConfiguration)

小技巧 :在使用Idea的时候,我们想要看导入的一些第三方代码的源码可以按 ALT+CTRL+鼠标点击你要看源码的类/接口/注解…

package org.springframework.boot.autoconfigure;

import ......;

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(
    excludeFilters = {@Filter(
    type = FilterType.CUSTOM,
    classes = {TypeExcludeFilter.class}
), @Filter(
    type = FilterType.CUSTOM,
    classes = {AutoConfigurationExcludeFilter.class}
)}
)
public @interface SpringBootApplication {
......
}

EnableAutoConfigurationの作用:

使用 AutoConfigurationImportSelector 给容器导入相关组件
虽然没太看懂 selectImports 代码,但是我猜大概的意思是:
依赖 AutoConfigurationMetadataLoader 来导入 META-INF 下面的 properties 文件

详细解释可以看这个 Other+ 的文章

public String[] selectImports(AnnotationMetadata annotationMetadata) {
        if (!this.isEnabled(annotationMetadata)) {
            return NO_IMPORTS;
        } else {
            AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader.loadMetadata(this.beanClassLoader);
            AutoConfigurationImportSelector.AutoConfigurationEntry autoConfigurationEntry = this.getAutoConfigurationEntry(autoConfigurationMetadata, annotationMetadata);
            return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
        }

所有可以在配置文件中配置的属性,都在xxxProperties类中

由于**@SpringBootApplication** 有一个默认的ComponentScan注解指定了扫描包の方式,所以在我们需要DIY扫包方式的时候就需要用 @ComponentScan 来指定我们需要扫描的包

eg: @ComponentScan(“top.jokeme.ayibe”) 指定扫描 ayibe 这个包….如果指定以后就不会使用默认的扫描方式,只会扫描指定の包

YAML & Properties

yaml基本语法:

K: V
##############
K:
    V1: 443
    V2: sew

yaml是大小写敏感的,并且需要注意缩进和空格

注意:yaml里面

`1`	`" " & ' ' 作用不一样`

" “会转义字符串,比如 \n 等

’ ’ 不会转义字符串,输入啥,输出啥

yamlの对象

food:
    name: apple
    tasty: true
####################
food: {name: apple,tasty: true}

yamlの数组

interesting:
 - 13
 - 14
 - 15
#####################
interesting: [13,14,15]

yaml文件 & 数据绑定

person:
  sname: zhangsan
  sage: 18
  Sod: 'AnHui Provience'
  Lovelydog: {age: 13,name: lisi}

package top.day2_yaml;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@Component
@ConfigurationProperties(prefix = "person")
public class Person {
}

如果不出意外:

1
2
3

#localhost:8080/se 
#会出现以下效果
Person{sname='zhangsan', sage=18, Sod='AnHui Provience', Lovelydog=dog{age=13, name='lisi'}}

注意1:@Component 注解是帮助绑定值的一个注解,所以不能忘记添加该注解

注意2:这里可能需要导入以下依赖

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-configuration-processor</artifactId>
  <version>2.3.0.RELEASE</version>
</dependency>
<!-- 配置文件处理模块,配置文件的数据绑定就依赖该模块 -->

Properties

properties の用法大致与 yaml 差不多,但是比 yaml 费事一点点

person.sname=zhangsan
person.sage=18
person.Sod='AnHui Provience'
person.lovelydog.age=13
person.lovelydog.name=lisi
server.port=8088

∵ Properties 是大小写不敏感的

∴ person.age = person.Age

@Value

@Value 使用方法

package top.day3_atValue;

import org.springframework.beans.factory.annotation.Value;

public class human {
    @Value("Person")
    String Typeof;
}

@ConfigurationProperties & @Value の区别

	@ConfigurationProperties	@Value
特征	批量注入配置文件里的属性	一个个指定
松散语法	?YES	?NO
SpEL	?NO	?YES
JSR303	?YES	?NO
复杂类型封装	?YES	?NO

eg: 复杂类型封装就是指只, map/list/…

我们在何时使用他们

如果我们只是某项业务逻辑中需要获取某个属性,推荐使用

如果我们是需要进行大规模配置文件,就要使用 @ConfigurationProperties

@PropertySource & @ImportResource

@PropertySource使用方法

package top.day3_atValue;

import org.springframework.context.annotation.PropertySource;

@PropertySource(value={"classpath:per.properties"})
public class human {
    
}

@PropertySource 加载指定☞的配置文件

@ConfigurationProperties 默认获取全局の配置文件里的属性

⚠注意: @PropertySource 必须和 @ConfigurationProperties 一起使用才有效,单独使用没有效果

@ImportResource使用方法

其作用是导入 Spring 里面的配置文件并让其生效

`1`	`@ImportResource(locations = {classpath:"abc.xml"})`

配置文件占位符

先来一个实例:

person.sname=${random.uuid}
person.sage=${random.int}
person.Sod='AnHui Provience'
person.lovelydog.age=${person.lol:233}
person.lovelydog.name=lisi
server.port=8080

这就是用随机数 $random 来生成的,还有用占位符生成の

${person.lol:233} の意思就是有person.lol就用它,没有就用233

`1`	`Person{sname='d573e71a-f8b2-4a48-a688-10449b4b55fc', sage=-1817647899, Sod=''AnHui Provience'', Lovelydog=dog{age=233, name='lisi'}}`

Profile文件支持

多Profile文件

properties

可以用多个带有 application-{env}.properties 来切换环境

注: 默认的profile是 application.properties

如果需要切换生产环境,可以在 application.properties 里面配置

`1`	`spring.profiles.active=env`

dog2.SunDay=24
dog2.Example.k1=sim
dog2.Example.k2=sib
dog2.Friends={lisi,zhangsan}
dog2.soul.Weight=30
dog2.soul.Data=35
dog2.soul.Power=80
dog2.soul.Lovely=true
spring.profiles.active=ssr

person.sname=${random.uuid}
person.sage=${random.int}
person.Sod='AnHui Provience'
person.lovelydog.age=${person.lol:233}
person.lovelydog.name=lisi
server.port=8080
spring.profiles=ssr

yaml

如果配置文件是 yaml 我们还可以用更为简便の多文档块の方式

这里就涉及到了基本の yaml 语法 - - - 这种连续三个 - 就表示文本块,看操作:

person:
  sname: zhangsan
  sage: 18
  Sod: 'AnHui Provience'
  Lovelydog: {age: 13,name: lisi}
spring:
  profiles: 
    active: ssr
---
person:
  sname: ${random.uuid}
  sage: ${random.int}
  Sod: 'AnHui Provience'
  Lovelydog: {age: 13,name: lisi}
server.port: 8088
spring:
  profiles: ssr

SpringBoot配置文件の加载顺序

首先关心一下,配置文件放哪里才会被加载

1.file:./config	2.file:/
3.classpath:/config/	4.classpath:/

按照顺序,1-4按顺序扫描,然后1-4の优先级依次降低,当配置文件里的属性冲突时,以优先级高的配置文件为准

还有一点需要注意的就是,这些文件都会被加载,形成互补配置

外部配置文件加载顺序

1、命令行参数：所有的配置都可以在命令行参数中指定，每个配置项前使用--，多个配置间使用空格隔开，例如：

java -jar spring-boot-02-0.0.1-SNAPSHOT.jar --server.port=8088 --server.context-path=boot
2、来自java:comp/env的JNDI属性

3、java的系统属性(System.getProperties(""))

4、操作系统环境变量

5、RandomValuePropertySource配置的random.*属性值

6、jar包外部的application-{profile}.properties或application-{profile}.yml(带spring.profile配置)

7、jar包内部的application-{profile}.properties或application-{profile}.yml(带spring.profile配置)

8、jar包外部的application.properties或application.yml(不带spring.profile配置)

9、jar包内部的application.properties或application.yml(不带spring.profile配置)

10、@Configuration注解类上的@PropertySource

11、通过SpringApplication.setDefaultProperties()指定的默认属性

注：

    ①以上配置文件的优先级顺序由高到低，高优先级的覆盖低优先级的并形成互补

    ②6、8所指的jar包外指的是和jar包同一个文件夹下

Java 注解的简单学习

Sat, 15 Feb 2020 21:33:56 +0000

Java 注解（Annotation）

Java 注解其实并不难，从名字上你都知道注解是帮助 Java 代码执行的，它的形式跟接口很类似，不过前面多了一个 @ 符号

Java 元注解

@Retention

Retention 保留期，决定注解的生命时常，取值如下

SOURCE	只在源码阶段保留
CLASS	只被保留到编译进行的时候
RUNTIME	注解可以保留到程序运行的时候

eg：该注解被保留到运行时

1
2
3

@Retention(RetentionPolicy.RUNTIME)
public @interface Annotation {
}

- @Documented

它的作用是能够将注解中的元素包含到 Javadoc 中去

- @Target

Target 指定了注解运用的地方

ANNOTATION_TYPE	给一个注解进行注解
CONSTRUCTOR	给构造方法进行注解
FIELD	给属性进行注解
LOCAL_VARIABLE	给局部变量进行注解
METHOD	给方法进行注解
PACKAGE	给包进行注解
PARAMETER	给方法内的参数进行注解
TYPE	给一个类型进行注解，比如类、接口

- @Inherited

一个类被 @Inherited 注解过的注解进行注解的话，如果它的子类没有被任何注解应用的话，那么这个子类就继承了该类的注解。

- @Repeatable

是可重复的意思

Java 内置注解

@Deprecated 这个元素是用来标记过时的元素
@Override 子类要复写父类中的方法
@SuppressWarnings 忽略编辑器的警告 ⚠
@SafeVarargs 参数安全类型注解。它的目的是提醒开发者不要用参数做一些不安全的操作，它的存在会阻止编译器产生 unchecked 这样的警告。
@FunctionalInterface 函数式接口注解，函数式接口可以很容易转换为 Lambda 表达式

注解与反射。

注解通过反射获取。首先可以通过 Class 对象的 isAnnotationPresent() 方法判断它是否应用了某个注解

`1`	`public boolean isAnnotationPresent(Class<? extends Annotation> annotationClass) {}`

然后通过 getAnnotation() 方法来获取 Annotation 对象。

`1`	`public <A extends Annotation> A getAnnotation(Class<A> annotationClass) {}`

或者是 getAnnotations() 方法。

`1`	`public Annotation[] getAnnotations() {}`

前一种方法返回指定类型的注解，后一种方法返回注解到这个元素上的所有注解。

如果获取到的 Annotation 如果不为 null，则就可以调用它们的属性方法了

注解应用实例

JUnit

public class JUnitTest {
    @Test
    public void solo(){
        System.out.println("Awesome Junit");
    }
}

Java通过jdbc操作MySQL数据库

Sat, 01 Feb 2020 21:33:56 +0000

Java JDBC 操作 MySQL

Maven 导包

<dependency>
	<groupId>mysql</groupId>
	<artifactId>mysql-connector-java</artifactId>
	<version>5.1.48</version>
</dependency>
	<groupId>org.junit.jupiter</groupId>
	<artifactId>junit-jupiter</artifactId>
	<version>RELEASE</version>
    <scope>compile</scope>
</dependency>

填在 pom 文件里面即可，无难度

用代码连接数据库

import java.io.*;
import java.sql.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Fre{
    public static final String driver = "com.mysql.jdbc.Driver";
    public static final String uri = "jdbc:mysql://127.0.0.1:3306/solo";
    public static final String user = "root";
    public static final String passcode = "123456";
    final String sqlScript = "select * from b3_solo_article";
    Connection connection= null;

    public ResultSet StartCollection() throws SQLException {
        try{
            Class.forName(driver);
            connection = DriverManager.getConnection(uri,user,passcode);
            if(!connection.isClosed())
                System.out.println("connection successfully");
            Statement statement = connection.createStatement();
            ResultSet replyString = statement.executeQuery(sqlScript);
            return replyString;
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            return null;
        }
    }

    public static String toTheJson(List<Map> list){
        return list.toString().replace("{", "{\"").replace("}", "\"}").replace("=","\":\"").replace(", ", "\",\"").replace("}\",\"{", "},{").replace("{", "{\"").replace("}", "\"}").replace("=","\":\"").replace(", ", "\",\"").replace("}\",\"{", "},{").replace("\"\"","\"");
    }

    public void close(){
        try{

            this.connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
   @Test
   public void Solomon() throws SQLException, IOException {
       Map<String,Object> outer = new HashMap<String, Object>();
       List<Map> list = new ArrayList<Map>();
       Fre solo = new Fre();
       ResultSet so  = solo.StartCollection();
       while(so.next()){
           Map<String,Object>  map = new HashMap<String, Object>();
           map.put("User_ID",so.getString(1));
           map.put("User_Name",so.getString(2));
           map.put("User_Mod",so.getString(3));
           map.put("User_IDE",so.getString(4));
           list.add(map);
       }
       String Solo = toJson(list);
       System.out.println(Solo);
       FileOutputStream fos = new FileOutputStream("solo.json",true);
       OutputStreamWriter osw = new OutputStreamWriter(fos,"utf-8");
       osw.write(Solo);
       System.out.println("Write Over");
       osw.close();
   		}
    }
}

代码详解

public static final String driver = "com.mysql.jdbc.Driver";
public static final String uri = "jdbc:mysql://127.0.0.1:3306/solo";
public static final String user = "root";
public static final String passcode = "123456";
final String sqlScript = "select * from b3_solo_article";
Connection connection= null;

在定义这些常量的时候，最好不要直接定义 String ,而是 public static final String ,怎么安全，怎么来

而且对象尽量不要在方法里面 new ,如果发生异常就不能释放系统资源了

public ResultSet StartCollection() throws SQLException {
        try{
            Class.forName(driver);
            connection = DriverManager.getConnection(uri,user,passcode);
            if(!connection.isClosed())
                System.out.println("connection successfully");
            Statement statement = connection.createStatement();
            ResultSet replyString = statement.executeQuery(sqlScript);
            return replyString;
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            return null;
        }
}

如果从安全角度来考虑的话，那么我们不应该用 Statement 而是用 PreparedStatement ,我在自己电脑上也不怕什么 SQL注入，所以没有用

1
2
3

public static String toTheJson(List<Map> list){
        return list.toString().replace("{", "{\"").replace("}", "\"}").replace("=","\":\"").replace(", ", "\",\"").replace("}\",\"{", "},{").replace("{", "{\"").replace("}", "\"}").replace("=","\":\"").replace(", ", "\",\"").replace("}\",\"{", "},{").replace("\"\"","\"");
    }

主要是我没有导 JSON 相关的库，就这样简化 List<Map<String,String» »> JSON 主要就是字符串的替换，还有转义可能有点懵 ?,小心即可

public void close(){
        try{

            this.connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

使用完资源以后肯定也要释放的，没有什么好说的

@Test
public void Solomon() throws SQLException, IOException {
       Map<String,Object> outer = new HashMap<String, Object>();
       List<Map> list = new ArrayList<Map>();
       Fre solo = new Fre();
       ResultSet so  = solo.StartCollection();
       while(so.next()){
           Map<String,Object>  map = new HashMap<String, Object>();
           map.put("User_ID",so.getString(1));
           map.put("User_Name",so.getString(2));
           map.put("User_Mod",so.getString(3));
           map.put("User_IDE",so.getString(4));
           list.add(map);
       }
       String Solo = toTheJson(list);
       System.out.println(Solo);
       FileOutputStream fos = new FileOutputStream("solo.json",true);
       OutputStreamWriter osw = new OutputStreamWriter(fos,"utf-8");
       osw.write(Solo);
       System.out.println("Write Over");
       osw.close();
   		}
}

写完先测试一下

Java collections框架的工具类

Sat, 28 Dec 2019 21:33:56 +0000

Collection 框架的工具类

Collections

sort 按照自然顺序排序

package sourceCode;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Collections_utils {
	public static void main(String[] args) {
		List<String> se = new ArrayList<String>();
		se.add("fdw");
		se.add("jokeme");
		se.add("dfipo");
		se.add("daase");
		Collections.sort(se);
		System.out.println(se);
			}
}
~~~~~~~~~~~~~~~~~~~~
[daase, dfipo, fdw, jokeme]

用法很简单： Collections.sort(List)

reverse 倒序排列自然排序的 List

Collections.reverse(se);
System.out.println(se);
~~~~~~~~~~~~~~~
[jokeme, fdw, dfipo, daase]

用法也很简单： Collections.reverse(List)

如果单独使用时，其效果和 reverseOrder() 作用一样

自定义排序方法

`1`	`Collections.reverseOrder(Comparator<T> cmp())`

自定义排序方法时就需要使用 reverseOrder() 并且需要自定义一个比较方法 ? 传进去

Collections.sort(se, Collections.reverseOrder(new compareByLength()));
System.out.println(se);
~~~~~~~~~~~~~~~
[fdw, daase, dfipo, jokeme]
~~~~~~~~~~~~~~~
package sourceCode;

import java.util.Comparator;

public class compareByLength implements Comparator<String> {
	@Override
	public int compare(String str1,String str2) {
		int temp = str2.length() - str1.length();
		return temp==0?str2.compareTo(str1):temp;
	}
}

**上面我们可以看出 reverseOrder() 就是万金油，不传参就是倒序排列自然排序的 List , 而传参就可以自定义我们需要的比较方法 < 注意 reverseOrder 要联合 sort 使用，只有 reverse 可以单独使用 > **

将非同步集合转为同步集合

Java IO简单操作文件

Sat, 28 Dec 2019 21:33:56 +0000

Java-IO

Java Input-Output 主要是用于文件的存储和读取，相关操作一般都会放在 Java.io 包中

File 类

file 类的方法是我们操作文件必不可少的，是必须要学习的类

使用示例：

package Java_IO;

import java.io.File;
import java.io.IOException;

public class fileClass {
	public static void main(String[] args) throws IOException {
		
		File se = new File("D:\\Frelon.txt");
		File we = new File("D:\\","sda.py");
		System.out.println(se+"~~~~"+we);
		
		File dir = new File("D:\\KW"+File.separator);
		File sdCard = new File (dir,"a.java");
		if(sdCard.createNewFile()) {
			System.out.println("Create File Successfully ! "+sdCard);
		}else {
			System.out.println("Filed!");
		}
	}
}

File类常见方法

获取文件路径

package Java_IO;

import java.io.File;

public class filePath {
	public static void main(String[] args) {
		File file = new File("a.sh");
		String str = file.getAbsolutePath();
		String str1 = file.getPath();
		System.out.println(str+"~~~~~"+str1);
	}
}
~~~~~~~~~~~~~~~~~~
D:\github\Hadoop_build\JavaLearn\a.sh~~~~~a.sh

getPath()只是获取相对路径 < 程序在哪运行，路径就是那里 >

getAbsolutePath()表示获取绝对路径

获取文件修改时间

package Java_IO;

import java.io.File;
import java.text.DateFormat;
import java.util.Date;

public class filePath {
	public static void main(String[] args) {
		File file = new File(".classpath");
		Long lon = file.lastModified();
		Date date = new Date(lon);
		String mod_time = DateFormat.getDateTimeInstance(DateFormat.LONG,DateFormat.LONG).format(date);
		System.out.println(lon+" >>>>> "+mod_time);
	}
}

`1`	`1575876750643 >>>>> 2019年12月9日下午03时32分30秒`

该方法并不困难，稍稍有难度的是如何把获取到的 Long 类型的数字转化为具体的时间

Date date = new Date(1575876750643l);
DateFormat time = DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.LONG);
String str = time.format(date);
System.out.println(str);

常见操作

boolean boof = file.createNewFile();     
boolean boo  = file.canExecute();        
boolean booa = file.canRead();           
boolean bood = file.canWrite();          
boolean booh = file.exists();            
boolean booj = file.isAbsolute();        
boolean book = file.isDirectory();       
boolean bool = file.isFile();            
boolean booz = file.isHidden();

认识即可，没有难度

获取文件夹内容

当操作文件夹时，肯定要知道这个文件夹里面有什么东西，我们才好操作，常用的方法有两种 list() , listFile() 但是建议用后者，因为list() 有的它也有，他有的方法**list()**没有

package Java_IO;

import java.io.File;

public class visitFile {
	public static void main(String[] args) {
		File alean = new File("c:\\");
		if (alean.exists()) {
			String[] dd = alean.list();
			for (String ss : dd) {
				System.out.println(ss);
			}
System.out.println("~~~~~~~~~~~~~~~~~~~~~~");
			File[] fo = alean.listFiles();
			for (File fs : fo) {
				if(fs.getName().contains("Logs")) {
					System.out.println(fs+" ~~~ "+fs.getName());
				}
			}
System.out.println("~~~~~~~~~~~~~~~~~~~~~~");
			Long sis = alean.getFreeSpace();
			System.out.println(alean + " " + sis / Math.pow(1024, 3) + "Gb" + " free!");
		} else {
			System.out.println("No this file");
		}
	}
}

文件过滤器

File[] str1  =  dir.listFiles(new fileFilterByName());
for (File strr : str1) {
	System.out.println(strr);
}
~~~~
package Java_IO;

import java.io.File;
import java.io.FileFilter;

public class fileFilterByName implements FileFilter {
	@Override
	public boolean accept(File arg0) {
		return arg0.isDirectory();
	}
}

它可以过滤出该 ?内的 ?,还可以过滤出 ?内的 ?,只需要把 fileFilterByName の accept() 方法改一下即可

public boolean accept(File arg0) {
	return arg0.isDirectory();
//	return arg0.isFile();
//  return arg0.isFile();
//  return arg0.getName().endSWith(".java")
}

文件名过滤器

package Java_IO;

import java.io.File;
import java.io.FilenameFilter;

public class filterByName implements FilenameFilter {
	private String se="";
	
	public filterByName(String se) {
		super();
		this.se = se;
	}
	public filterByName() {
		super();
	}
	
	@Override
	public boolean accept(File arg0, String arg1) {
		
		return arg1.endsWith(se);
	}

}
~~~~~~~~~~~~~~~~~~~~~~
package Java_IO;

import java.io.File;

public class FileFilter {
	public static void main(String[] args) {
		File file = new File("D:\\hadoop-2.8.5");
		String[] str = file.list(new filterByName(".txt"));
		for (String name : str) {
			System.out.println(name);
		}
	}
}

这种过滤器不常用，因为需要一个过滤器实现FileNameFilter, 实际 coding 我们可以使用FileFilter 替代，它不仅仅可以过滤文件夹 ?还可以过滤文件 ?

递归获取 ?内的内容

package Java_IO;

import java.io.File;
import java.io.IOException;
import java.nio.file.NoSuchFileException;

public class getAllFiles {

	public static void main(String[] args) throws IOException {
		File dir = new File("D:\\github");
		getAllFile(dir);
	}

	public static void getAllFile(File se) throws IOException {
		File[] dir1 = se.listFiles();
		if(!se.exists()) {
			throw new NoSuchFileException("No such Path");
		}
		for (File der : dir1) {
			if (der.isDirectory()) {
				getAllFile(der);
			} else {
				System.out.println("Visited " + der);
			}
		}
	}
}

什么是递归？

其实递归就是在方法内部调用该方法，该方法不断地进栈，在使用递归时，一定要有判断条件，否则一直递归下去会导致内存溢出

public void met(){
	void show();
}

public void show(){
	void met();
}

这就是一种递归，但是它是错误 ❌的递归，两个方法相互调用会导致栈内存溢出，

1
2
3

public void show(){
	void show();
}

这也是一种错误 ❌的递归，方法内部无线调用自己 ✌会导致栈内存溢出

1.3.1 使用递归删除 ?

package Java_IO;

import java.io.File;
import java.nio.file.NoSuchFileException;

public class deleteFiles {
	public static void main(String[] args) throws NoSuchFileException {
		File dir = new File("D:\\KWS");
		removeFiles(dir);
	}
	public static void removeFiles(File se) throws NoSuchFileException {
		File [] wow = se.listFiles();
		for(File wo : wow) {
			if(!wo.exists()) {
				throw new NoSuchFileException(null);
			}
			if(wo.isDirectory()) {
				removeFiles(wo);
			}else {
				Boolean esc = wo.delete();
				System.out.println("delete the file "+wo+" "+esc);
			}
		}
		Boolean esc = se.delete();
		System.out.println("delete the file "+se+" "+esc);
	}
}

递归删除很简单，只是需要注意，这个删除是不经过回收站的，会被直接删除，不可找回

还有就是需要判断该 ?有没有权限访问，要不然会报 java.lang.NullPointerException 异常，甚至还需要我们自己来抛一些 IO 异常

前三 part 测试

需求：

1
2

获取某个?内所有文件的集合
获取该?内某个?内的.txt文件,并存储到集合中打印?出来

package Java_IO;

import java.io.File;
import java.io.FilenameFilter;
import java.util.ArrayList;
import java.util.List;

public class IO_Test1 {
	public static void main(String[] args) {
		File dir = new File("c:\\tempfile");

		List<String> list = new ArrayList<String>();

		fileFilterByName filter = new fileFilterByName(".txt");

		getFile(dir, filter, list);

		for (String ser : list) {
			System.out.println(ser);
		}
	}

	private static void getFile(File file, fileFilterByName filter, List<String> list) {
		File[] fileName = file.listFiles();
		for (File se : fileName) {
			if (se.isDirectory()) {
				getFile(se, filter, list);
			} else {
				if (filter.accept(se)) {
					list.add(se.getPath());
				}
			}
		}
	}
}
~~~~~~~~~~~~~~~~~~~~
package Java_IO;

import java.io.File;
import java.io.FileFilter;

public class fileFilterByName implements FileFilter {
	private String str;
    
	public fileFilterByName(String str) {
		super();
		this.str = str;
	}
    
	public fileFilterByName() {
		super();
	}
	
	
	@Override
	public boolean accept(File arg0) {
		return arg0.getName().endsWith(this.str);
	}

}

给自己点个赞 ?,我真厉害?

FileOutputStream 向 ?内写入内容

package Java_IO;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

public class writeIntoFile {
	private static final String Line_separator = System.getProperty("line.separator");

	public static void main(String[] args) throws IOException {
		File dir = new File("c:\\tempfile");
		if(!dir.exists()) {
			dir.mkdir();
		}
		String str ="i Love Java";
		FileOutputStream fops = null;
		try {
			fops = new FileOutputStream("c:\\tempfile\\fops.java",true);
			String ssr = Line_separator+"Hello World"+Line_separator;
			fops.write(ssr.getBytes());
			fops.write(str.getBytes());
			fops.write(ssr.getBytes());
			System.out.println("写入成功");
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if(fops!=null) {}
			fops.close();
		}
	}
}

写入内容很容易，只需要调用一下write()方法即可，但是难点就是处理各种Exception ,我们需要考虑到各种各样的异常

比如 FileNotFoundException,,,NullPointerException 等等等，因为一旦出现了这些问题我们的代码可能就占用了相关的系统资源，但是程序执行失败后，我们并没有释放该资源，如此循环往复就会导致系统的卡慢，甚至死机重启，这里我们经常使用try catch finally 方法来解决，需要执行的代码放在try 里面，在finally 里面放 close()方法，保证我们的代码在申请完资源以后，无论是否报错，都可以被释放掉，还有一点就是如果我们使用try catch finally 那我们一定不能在try里面 new 对象，因为到时候finally 关闭资源时会找不到对象 ?的

还有write() 方法是会覆盖掉文件内部的内容的，如果我们需要在当前内容上继续添加内容，那就需要在创建对象时加一个true 表示续写该文件，代码如下

`1`	`FileOutputStream fops = new FileOutputStream("c:\\tempfile\\fops.java",true);`

FileInputStream 读取 ?内容

FileInputStream 类和 FileOutputStream 类有许多的共同点，都需要传一个 File 类的对象(new 对象时要保证 Path✔无误，要不然很容易造成空指针异常) 还有就是在使用完资源以后要及时释放掉资源，还有要注意的是异常の处理，如果没有处理好异常也会导致我们无法释放掉资源，导致程序占用过多的系统资源，使系统卡慢

❌ read() 入门级读取

package Java_IO;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class readFile {
	private static final int LIMSize = 8192;

	public static void main(String[] args) throws IOException {
		File dir = new File("c:\\tempfile\\fops.java");

		FileInputStream fipts = new FileInputStream(dir);

		int byt;
		while ((byt = fipts.read()) != -1) {
			System.out.println(byt);
		}

		fipts.close();
	}
}

日常开发中，基本上用不上 PASS ❌

❌ read() 初级读取

package Java_IO;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class readFile {
	private static final int LIMSize = 8192;

	public static void main(String[] args) throws IOException {
		File dir = new File("c:\\tempfile\\fops.java");
		byte[] buf = new byte[2];

		FileInputStream fip = new FileInputStream(dir);

		int len = fip.read(buf);
		System.out.println(len + "~~~" + new String(buf));

		fip.close();
	}
}

日常开发中，基本上用不上 PASS ❌

✔ read() 进阶级读取

package Java_IO;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class readFile {
	private static final int LIMSize = 8192;

	public static void main(String[] args) throws IOException {
		File dir = new File("c:\\tempfile\\fops.java");
				FileInputStream fips = new FileInputStream(dir);
		byte[] by = new byte[LIMSize];

		int length = 0;

		while ((length = fips.read(by)) != -1) {
			System.out.println(new String(by, 0, length));
		}
		fips.close();

	}
}

日常开发中可以使用，✔建议根据需要改变缓冲区的大小，一般建议设置成 :8192

✔ read()高级读取

package Java_IO;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class readFileAdvantage {
	public static void main(String[] args) throws IOException {
		File dir = new File("c:\\tempfile\\fops.java");
		FileInputStream fips = new FileInputStream(dir);
		byte [] byt = new byte [fips.available()];
		fips.read(byt);
		System.out.println(new String(byt));
		fips.close();
	}
}

✔这种是我比较喜欢的一种方法，简洁好用，也不用考虑缓冲区大小 ?,而且一般 File 对象没有问题也就不会出错啊(相对于前面几个),这是重点 ✔,圈起来！下次会考！!!

但是！!但是！!但是！这种方法只是比较适合处理比较小的文件，如果处理好几个 G 的文件，当场挂..所以呢，还是进阶和高级一起用

FileOutputStream 和 FileInputStream 一起读写文件

低级写法

package Java_IO;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class IO_CopyFile {

	public static void main(String[] args) throws IOException {
		File dir = new File("C:\\tempfile\\fops.java");
		FileInputStream fis = new FileInputStream(dir);

		File dir1 = new File("C:\\tempfile\\fops.txt");
		FileOutputStream fos = new FileOutputStream(dir1);
		int len = 0;
		while ((len = fis.read()) != -1) {
			fos.write(len);
		}
		fis.close();
		fos.close();
	}
}

不推荐这种写法，因为效率比较低，读取一个写入一个，太浪费时间

高级写法

package Java_IO;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

import APICourceCode.dateAPI;

public class copyFileByBuf {
	public static void main(String[] args) throws IOException {
		dateAPI date = new dateAPI();
		date.getDate();
		File dir = new File("d:\\tempfile\\idea.exe");
		FileOutputStream fos = null;
		FileInputStream fis = null;
		try {
			fis = new FileInputStream(dir);
			fos = new FileOutputStream("d:\\tempfile\\idea.wilu");

			byte[] buf = new byte[10240];

			int len = 0;
			while ((len = fis.read(buf)) != -1) {
				fos.write(buf, 0, len);
			}
		} catch (IOException e) {
			throw new IOException();
		} finally {
			fis.close();
			fos.close();
			date.getDate();
			System.out.println("Copy Over");
		}

	}
}

我无聊就试了试，这个byte 数组の长度对IO の性能影响有多大，就把长度从 10,102,1024,2048,4096,8192,10240 都试了个遍，得出以下答案：

时间\byte 长度	10	102	1024	2048	4096	8192	10240	20480
Start	19:38:27	19:53:42	19:54:52	19:55:50	19:56:25	19:57:05	19:57:40	19:58:16
Stop	19:44:33	19:54:19	19:54:57	19:55:54	19:56:28	19:57:08	19:57:42	19:58:18
time	366s	37s	5s	4s	3s	3s	2s	2s

测试所使用的文件大小为： 584935KB 大约是 571MB

可以看出 byte 数组的长度也是越大越好的，只要你内存足够大，磁盘性能足够强，理论上是可以做到一秒内复制任何文件的，可是！! 科技日益发达的今天电脑内存和磁盘还依然是一个瓶颈，有待我们突破啊，So 为了适应各种大小的文件，还是选择大小为8192 或者10240 也是可以的

Buffer 缓冲区

buffer 原理就是调用一片内存，作为缓冲区，然后再为 FileInput/OutputStream 使用，原理和上面的相似

使用示例

package Java_IO;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class buffer {
	public static void main(String[] args) throws IOException {
				copyfile();
	}
	public static void copyfile() throws IOException {
		File dir  = new File("d:\\LinuxSoftware_VariedOS\\Python-3.8.0.tgz");
		
		FileInputStream pis = new FileInputStream(dir);
		FileOutputStream pos = new FileOutputStream("d:\\tempfile\\Python.wilu");
		
		BufferedInputStream bufpis = new BufferedInputStream(pis);
		BufferedOutputStream bufpos = new BufferedOutputStream(pos);
		
		byte [] buf = new byte[8192];
		int len = 0;
		while((len=bufpis.read(buf))!=-1) {
			bufpos.write(buf,0,len);
		}
		bufpis.close();
		bufpos.close();
		System.out.println("Copy over");
	}  
}

字符读写

使用 I/O-Stream-Reader/Writer

由于中文一个字符占两字节，所以我们不能像读写英文那样，直接操作数据了，

package Java_IO;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class StreamReader {
	public static void main(String[] args) throws IOException {
		FileInputStream fis = new FileInputStream("D:\\tempfile\\fpos.java");
		FileOutputStream fos = new FileOutputStream("D:\\tempfile\\pofs.c",true);
		
		InputStreamReader isr = new InputStreamReader(fis);
		OutputStreamWriter osw = new OutputStreamWriter(fos,"utf-8");
		
		int in ;
		while((in = isr.read()) != -1) {
			osw.write(in);
		}
		
		isr.close();
		osw.close();
		System.out.println("Copy over");
	}
}

中文处理时比较的麻烦，因为各种电脑支持的编码可能不一样，就导致乱码问题，这时候我们在new 对象的时候就需要指定我们所需要的编码方式，今天就因为编码就倒腾了半天的时间 ⏰

所以为了保险起见，在创建 FileOutputStream 的时候还是加上 UTF-8 好一点

FileReader/FileWriter 类

FileReader/FileWriter 其实就是简化了FileOutputStream ＆ FileOutputStream の使用过程，但是缺点( •̀ ω •́ )y 非常明显，就是不支持设置编码方式，默认的是 ISO-8859-1 or US-ASCII ,非常容易导致乱码 ~%?…,# *’☆&℃ $︿★?

处理乱码也不难，就是不用这个类 ?

way 1

`1`	`BufferedWriter writer = new BufferedWriter (new OutputStreamWriter (new FileOutputStream (filePath,true),"UTF-8"));`

虽然这也是一种解决办法吧，但是如果一点要用的话那就只能用下面这种方法了

way 2

`1`	`Writer writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream ("String"), "UTF-8"));`

让FileWriter 继承 Write の编码方式，不过也不好用

FileReader / FileWrite 初级写法

package Java_IO;

import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;

public class fileWriter {
	public static void main(String[] args) throws IOException {
		FileOutputStream fos = new FileOutputStream("D:\\tempfile\\pofs.c");
		OutputStreamWriter osw = new OutputStreamWriter(fos,"UTF-8");
		
		FileReader fr = new FileReader("D:\\tempfile\\fpos.java");
		FileWriter fw = new FileWriter("D:\\tempfile\\pofs.c");
		
		int in;
		while((in=fr.read())!=-1) {
			fw.write((char)in);
		}
		fr.close();
		System.out.println(fw.getEncoding());
		fw.close();
		osw.close();
		System.out.println("Copy over");
	}
}

FileReader / FileWrite 高级写法

package Java_IO;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class IO_SimplifyChinese {
	public static void main(String[] args) throws IOException {
		copyChineseChar();
	}
	public static void copyChineseChar() throws IOException {
		FileReader fr = new FileReader("D:\\LinuxSoftware_VariedOS\\jdk-8u231-linux-x64.tar.gz");
		FileWriter fw = new FileWriter("D:\\tempfile\\jdk8.wuli");
		
		char [] chara = new char[2048];
		int len ;
		while ((len=fr.read(chara))!= -1) {
			fw.write(chara,0,len);
		}
		fr.close();
		fw.close();
		System.out.println("copy over");
	}
}

BufferedReader / BufferedWriter

主要是利用缓冲区来提高读写效率，也没有啥难处，会用就可以了

package Java_IO;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class Buffered_IO {
	public static void main(String[] args) throws IOException {
		buff();
	}
	public static void buff() throws IOException {
		FileReader fr = new FileReader("D:\\tempfile\\fos.java");
		BufferedReader br = new BufferedReader(fr);
		
		FileWriter fw = new FileWriter("D:\\tempfile\\copyed_fos.wuli");
		BufferedWriter bw = new BufferedWriter(fw);
		
		char [] chara = new char[2048];
		
		int in ;
		while((in=fr.read(chara))!= -1) {
			bw.write(chara,0,in);
		}
		br.close();
		bw.close();
		System.out.println("Copy over");
	}
}

Final 写在最后：

在经过学习后，我发现字节流和字符流都用于复制文件，但字符流的出现主要是为了解决与字符相关的问题，所以不适合复制文件(编码原因),字符流复制文件时可能会出现莫名其妙的问题导致复制后的文件破损无法使用，但字节流就不存在这种问题所以得出

`1`	`复制文件时使用字节流:复制文本文件时使用字符流`

简单的Java泛型学习

Sat, 28 Dec 2019 21:33:56 +0000

泛型

泛型特性

百度得如下解释：

泛型是程序设计语言的一种特性,允许程序员在强类型程序设计语言中编写代码时定义一些可变部分，那些部分在使用前必须作出指明。各种程序设计语言和其编译器、运行环境对泛型的支持均不一样。将类型参数化以达到代码复用提高软件开发工作效率的一种数据类型。泛型类是引用类型，是堆对象，主要是引入了类型参数这个概念。

举个栗子

List Li = new ArrayList();
Li.add("sdn");
Li.add(90);

for (Object se :Li){
	System.out.println(se);   
}

`1`	`java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String`

典型的类型转换异常，Integer不能被转换成String

正确的写法如下：

`1`	`List<String> Li = new ArrayList<String>();`

泛型的使用

泛型有三种使用方式，分别为：泛型类、泛型接口、泛型方法

泛型类

泛型类型用于类的定义中，被称为泛型类。通过泛型可以完成对一组类的操作对外开放相同的接口。最典型的就是各种容器类，如：List、Set、Map。

一个最普通的泛型类：

public class examples<Human>{ 
    private Human key;
    public examples(Human key) { 
        this.key = key;
    }
    public Human getKey(){ 
        return key;
    }
}

注意事项

泛型的类型参数只能是类类型，不能是简单类型。

不能对确切的泛型类型使用instanceOf操作，编译时会出错。

泛型接口

泛型接口与泛型类的定义及使用基本相同

1
2
3

public interface killSky<Gun> {
    public Gun next();
}

实现泛型接口的类也必须要保证该类的泛型和接口保持一致

class Fun<Gun> implements killSky<Gun>{
    @Override
    public Gun next() {
        return null ;
    }
}

泛型通配符

在写代码时可能会遇到下面的情况，通配符就会统统匹配

public static void printCollection(Collection<?> coll) {
		for (Object obj:coll){
			System.out.println(obj);
		}

泛型方法

泛型类，是在实例化类的时候指明泛型的具体类型，那么泛型方法，就是在调用方法的时候指明泛型的具体类型。

静态方法与泛型

静态方法有一种情况需要注意一下，那就是在类中的静态方法使用泛型：静态方法无法访问类上定义的泛型；如果静态方法操作的引用数据类型不确定的时候，必须要将泛型定义在方法上。

即：如果静态方法要使用泛型的话，必须将静态方法也定义成泛型方法。

public class StaticGenerator<T> {
    ....
    ....
    public static <T> void show(T t){

    }
}

泛型上下边界

在使用泛型的时候，我们还可以为传入的泛型类型实参进行上下边界的限制，如：类型实参只准传入某种类型的父类或某种类型的子类。

为泛型添加上边界，即传入的类型实参必须是指定类型的子类型

public void showKeyValue1(Generic<? extends Number> obj){
    System.out.println(obj)
} 
public void showKeyValue1(Generic<? super Number> obj) {
    System.out.println(obj)
}

//在泛型方法中添加上下边界限制的时候，必须在权限声明与返回值之间的<T>上添加上下边界，即在泛型声明的时候添加
//public <T> T showKeyName(Generic<T extends Number> container)，编译器会报错："Unexpected bound"
public <T extends Number> T showKeyName(Generic<T> container){
    System.out.println("container key :" + container.getKey());
    T test = container.getKey();
    return test;
}

看到了很多文章中都会提起泛型数组，经过查看 sun 的说明文档，在 Java 中是”不能创建一个确切的泛型类型的数组”的。

也就是说下面的这个例子是不可以的：

`1`	`List<String>[] ls = new ArrayList<String>[10];`

而使用通配符创建泛型数组是可以的，如下面这个例子：

`1`	`List<?>[] ls = new ArrayList<?>[10];`

这样也是可以的：

`1`	`List<String>[] ls = new ArrayList[10];`

下面使用Sun 的一篇文档的一个例子来说明这个问题：

Java中的collections的map

Sat, 28 Dec 2019 21:17:12 +0000

Collection-Map

Map--|双列集合,一次存一对键值对,必须保证唯一性
	 --|HashMap:哈希表,不同步,允许空的Key,Value
	 --|TreeMap:二叉树,线程不同步,可以对Map集合的键?排序
	 --|Hashtable:哈希表,线程同步效率低下,不允许空的Key,Value

Map 集合共性功能

添加	V put(K,V) / putAll(Map<K,V> map)
删除	V remove(K) / void clear()
判断	Boolean containsKey / Value()
获取	V get(K) / int size()

注意：如果对同一个键多次存储会出现值被覆盖的现象

Map 集合取出键值对方法

迭代器取出法

package sourceCode;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class collMap {
	public static void main(String[] args) {
		Map<Integer,String> se = new HashMap<Integer,String>();
		se.put(1, "Now");
		se.put(5, "aset");
		se.put(6, "kEREd");
//		System.out.println(se);
		Set<Integer> keySet = se.keySet();
		for (Iterator<Integer> iter = keySet.iterator(); iter.hasNext();) {
			Integer ssr = (Integer) iter.next();
			System.out.println(se.get(ssr));
		}
	}
}

Map.Entry

		Set<Map.Entry<Integer, String>> Solo = se.entrySet();
		for (Iterator<Map.Entry<Integer, String>> itera = Solo.iterator(); itera.hasNext();) {
			Map.Entry<Integer, String> me = itera.next();
			Integer er =me.getKey();
			String  sun =me.getValue();
			System.out.println(er+"::::"+sun);			
		}

这里解释以下Map.Entry 其实，Entry就是Map接口内的一个接口

它随着Map的加载而加载

interface Map{
	public static interface Entry {
		
	}
}
class xxx implements Map.Entry{

}

Values 方法取出键值对

Collection<String> value = se.values();
for (Iterator<String> uuid = value.iterator(); uuid.hasNext();) {
	String dock =uuid.next();
	System.out.println(dock);
}

三种方法结果如下：

Now
aset
kEREd
~~~~~~~~~~~
1::::Now
5::::aset
6::::kEREd
~~~~~~~~~~~
Now
aset
kEREd

关于 Map.Entry 方法

其实Map.Entry可以直接写为Entry 方法，因为我在敲代码的时候偶然发现，不敲 Map. 程序依然可以正常运行

百度得：

1
2
3

Entry是Map中的一个静态内部类，用来表示Map中的每个键值对。除非使用了静态导入:import static java.util.Map.*
除了使用静态导入外，还可以直接导入这个类，因为它是public的。即:import java.util.Map.Entry。
导入后也可以在当前空间直接使用Entry。

Java时间类api

Sun, 22 Dec 2019 21:33:56 +0000

时间类 API

在日常学习生活中，我们经常遇到时间相关的问题，现在虽然 Date 类已经不是主流了，但任然有许多方法要学习

DateFormat

使用示例

package APICourceCode;

import java.text.DateFormat;
import java.util.Date;

public class dateAPI {
	public static void main(String[] args) {
		Date date = new Date();
		DateFormat ses = DateFormat.getDateTimeInstance(DateFormat.FULL, DateFormat.FULL);
		String sesa = ses.format(date);
		System.out.println(sesa);
	}
}

其常见的Style如下

FULL:2019年12月16日 星期一 下午06时38分17秒 CST
LONG:2019年12月16日 下午06时39分20秒
MEDIUM:2019-12-16 18:39:41 (默认方式)
SHORT:19-12-16 下午6:40

如果需要自定义的格式，就需要按照下面的表格自定义，自定义以后，系统自带的Style将不生效

字母	意义
y	年
M	月份
w	年份中的周数
W	月份中的周数
d	月份中的天数
D	年份中的天数
F	月份中的星期
E	星期中的天数
a	am/pm 表示上下午
H	一天中的小时数(0-23)
h	am/pm 中的一天小时数(1-12)
m	小时中的分钟数
s	分钟中的秒数
S	毫秒数
z	PST;GMT 时区

package APICourceCode;

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;

public class dateAPI {
	public static void main(String[] args) {
		Date date = new Date();
		DateFormat ses = DateFormat.getDateTimeInstance();
		ses = new SimpleDateFormat("yyyy/MM/dd HH-mm-ss-SS");
		String sesa = ses.format(date);
		System.out.println(sesa);
		
	}
}

总结：

DateFormat方法其实很简单，

① 首先new一个Date类对象，就不用管了

② 调用DateFormat方法对象(不需要 new),生成自定义的Style

③ 使用字符串接收DateFormat对象的Format方法，需要传Date类的对象

DateFormat 反解析

使用示例：

package APICourceCode;

import java.text.DateFormat;
import java.text.ParseException;
import java.util.Date;

public class ReverseDateFormat {
	public static void main(String[] args) throws ParseException {
		String str = "2019-07-02";
		DateFormat se = DateFormat.getDateInstance();
		Date date =se.parse(str);
		System.out.println(date);
	}
}

Calendar

使用示例：

package APICourceCode;

import java.util.Calendar;

public class CalenderL {
	public static void main(String[] args) {
		Calendar se = Calendar.getInstance();
		
		se.add(Calendar.YEAR, 1);
		
		int year = se.get(Calendar.YEAR);
		int month = se.get(Calendar.MONTH)+1;
		int day = se.get(Calendar.DAY_OF_MONTH);
		int hours = se.get(Calendar.HOUR_OF_DAY);
		int minute = se.get(Calendar.MINUTE);
		int sec = se.get(Calendar.SECOND);
		System.out.println(year + "-" + month + "-" + day + "-" + hours + "-" + minute + "-" + sec);
	}
}
----------
2020-12-16-20-16-53

常见的Calendar参数

java.util.GregorianCalendar[
time=1576496255445,
firstDayOfWeek=1,
YEAR=2019,
MONTH=11,
WEEK_OF_YEAR=51,
WEEK_OF_MONTH=3,
DAY_OF_MONTH=16,
DAY_OF_YEAR=350,
DAY_OF_WEEK=2,
DAY_OF_WEEK_IN_MONTH=3,
HOUR=7,
HOUR_OF_DAY=19,
MINUTE=37,
SECOND=35,
MILLISECOND=445]

日期的偏移

`1`	`se.add(Calendar.MONTH, 1);`

个人认为作用不是很大

Java collection

Fri, 20 Dec 2019 21:33:56 +0000

collection集合

1
2
3

collection--|
		   |--list:有序,有索引,允许重复元素
		   |--set:不允许重复元素,元素存取无序

共性功能

a.添加

1
2

Boolean add (Obj obj);//添加单个对象
Boolean addAll (Collection c);//添加一组的collection的对象

b.删除

1
2
3

void clear();//清空collection内所有对象/元素
Boolean remove (Object o);//删除collection里面某个对象
Boolean removeAll (Collection c);//删除一组的collection

c.获取长度

`1`	`int size();`

d.判断

1
2
3

Boolean isEmpty();
Boolean contains(Object o);
Boolean containsAll(Collection c)

e.集合转数组

1
2

toArray();
toArray([]);

f.迭代器

`1`	`Iterator iterator();`

List集合

list集合的具体子类

List----
	|-- Vector:数组数据结构,长度可变,线程同步<多线程安全>,但是速度比较慢(现在已经不常用-被ArrayList替代),长度按数组长度的100%延长
	|-- ArrayList:数组结构,长度可变,线程不同步<多线程不安全>.查,速度快,增 删 改速度慢,长度按数组长度的50%延长
	|-- LinkedList:链表结构,线程不同步<多线程不安全>,增,删,改,速度快,查 速度慢

迭代器使用注意

1
2
3

Exception in thread "main" java.util.ConcurrentModificationException
	at java.util.ArrayList$Itr.checkForComodification(Unknown Source)
	at java.util.ArrayList$Itr.next(Unknown Source)

遇到这种在使用迭代器时还修改迭代器内元素的时候，JVM会报错，这时候就需要用ListIterator

犯错实记:

package sourceCode;

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class listTest {
	public static void clean(ArrayList<person> jsr) {
		List<person> dot = new ArrayList<person>();

		for (ListIterator<person> lis = jsr.listIterator(); lis.hasNext();) {
			person pop = lis.next();
			if (!dot.contains(pop)) {
				dot.add(pop);
			}
		}
		jsr.clear();
		jsr.addAll(dot);
	}

	public static void main(String[] args) {
		ArrayList<person> jsr = new ArrayList<person>();
		jsr.add(new person(20, "frelon"));
		jsr.add(new person(21, "frelon"));
		jsr.add(new person(23, "frelon"));
		jsr.add(new person(21, "frelon"));
		clean(jsr);
		System.out.println(jsr);
	}

}

package sourceCode;

public class person {
	private int age;
	private String name;

	public person(int age, String name) {
		super();
		this.age = age;
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	@Override
	public String toString() {
		return "person [age=" + age + ", name=" + name + "]";
	}
	


	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		person other = (person) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}

	public boolean equals(person obj) {
		if (this==obj) {
			return true;
		}
			return this.name.equals(obj.name)&&this.age==obj.age;
	}
}

上面这个例子，是我用了两天时间得出Java面向接口编程的一个实例

为什么说用了两天时间呢？

因为我一直都不太明白 Java 面向对象编程的具体表现，所以在写代码的时候也比较呆板，再者就是我还没有搞明白接口里面的类有没有被子类所实现

`1`	`ArrayList<person> dot = new ArrayList<person>();`

这就是我犯错的一段代码，我总是用List的子类 ArrayList来new新对象，而我Overwrite的方法已经被ArrayList实现，使用无论我怎么调用都还是无法调用到我自己 Overwrite后的代码

`1`	`List<person> dot = new ArrayList<person>();`

这就是导致我卡了两天的细节，我用List new对象以后代码完美执行了

这就是因为没有掌握面向对象编程的思想，犯下的一个低级错误

重写 equals和hashcode

LinkedList

a.特有方法

addFirst()	removeFirst()	getFirst()
#添加到第一个	#删除第一个	#获取第一个
addlast()	removeLast()	getLast()
#添加到最后一个	#删除最后一个	#获取最后一个

JDK1.6以后推荐使用下列方法替代，这样在遇到空值时就不会报错而是返回null

offerFirst()	pollFirst()	peekFirst()
#添加到第一个	#删除第一个	#获取第一个
offerLast()	pollLast()	peekLast()
#添加到最后一个	#删除最后一个	#获取最后一个

b.实战演练

实现先进后出

package sourceCode;

import java.util.LinkedList;

public class linkedlist_test {
	public static void main(String[] args) {
		test loser = new test();
		loser.setKail("hello");
		loser.setKail("CNN");
		loser.setKail("Love China");
		while (loser.Kailisempty()) {
			System.out.println(loser.getKail());
		}
	}
}

class test {
	private LinkedList<Object> kail;

	public Object getKail() {
		return kail.pollLast();
	}

	public Boolean Kailisempty() {
		if (kail.isEmpty()) {
			return false;
		} else if (!kail.isEmpty()) {
			return true;
		}
		return false;
	}

	@Override
	public String toString() {
		return "test [kail=" + kail + "]";
	}

	public void setKail(Object obj) {
		this.kail.addLast(obj);
	}

	public test() {
		kail = new LinkedList<Object>();
	}
}

Set 集合

Set--:不允许重复元素,方法和collection相同.set集合只能用Iterator取出元素
	|--Hashset:不保证存入和取出的顺序一致,不允许重复,效率高 
			 |--LinkedHashSet:有序的HashSet表,不允许重复	
	|--Treeset:可以对元素进行排序,其排序方式需要元素具备比较功能,且实现CompareTo()方法,且不允许存储相同元素的方法是依据compareto()返回值是否为0,其数据结构为二叉树结构,

HashSet

HashSet主要就是靠hashcode()表来确定元素排列的，在使用时必须要重写hashCode()方法，而hashCode()方法内部又调用到了equals()方法来解决Hash 冲突,所以在使用时必须要Overwrite这两个方法

HashSet 使用示例

package sourceCode;

import java.util.HashSet;
import java.util.Set;

public class hashset {
	public static void main(String[] args) {
		Set doThat = new HashSet();
		
		doThat.add(new person(13,"coco"));
		doThat.add(new person(22,"peon"));
		doThat.add(new person(23,"frelon"));
		doThat.add(new person(23,"frelon"));
		
		System.out.println(doThat);
	}
}

person类同上,这里仅写出 Overwrite 部分
	@Override
	public boolean equals(Object obj) {
		if (this==obj) {
			return true;
		}	
			person se = (person) obj;
			return this.name.equals(se.name)&&this.age==se.age;
	}
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}

TreeSet

Comparable 接口的学习

Exception in thread "main" java.lang.ClassCastException: sourceCode.person cannot be cast to java.lang.Comparable
	at java.util.TreeMap.compare(Unknown Source)
	at java.util.TreeMap.put(Unknown Source)
	at java.util.TreeSet.add(Unknown Source)

这个异常对于学习 TreeSet 的我是一脸懵逼啊 ?,啥啥啥啊，就报了个异常，再看看我这代码没有错啊，编辑器也没有报错啊！

package sourceCode;

import java.util.Set;
import java.util.TreeSet;

public class treeSetLearn {
	public static void main(String[] args) {
		Set ssf = new TreeSet();
		ssf.add(new person(12, "hfh"));
		ssf.add(new person(19, "frelon"));
		ssf.add(new person(13, "jokoe"));

	}
}

遂百度，知，需要person 类 implements comparable 接口并 Overwrite 该接口的 CompareTo() 方法

package sourceCode;

public class person implements Comparable {
~~~
    略
~~~
    方法一:只能按年龄排序,忽略了姓名
	public int compareTo(Object osi) {
		person seao = (person) osi;
		if(this.age>seao.age) {
			return 1;
		}
		if(this.age<seao.age)
			return -1;
		return 0;
	}
    
~~~
    方法二:完美方案?
    public int compareTo(Object osi){
        int temp = this.age-seao.age;
        return temp==0?this.name.compareTo(osi.name):temp;
    }

按照方法二改完以后，成功按照年龄(从小到大)排序，并且同姓名，同年龄算一个人，不存进去

实现Comparator接口示例

当我们需要需要对没有比较功能的元素进行排序时or 自定义元素排序方式时，我们就不能再依赖通过实现Comparable接口的**CompareTo()**方法，而是要自定义一个新的比较器

使用自定义的比较器对TreeSet排序

package sourceCode;

import java.util.Set;
import java.util.TreeSet;

public class diySavePerson {
	public static void main(String[] args) {
		Set t1 = new TreeSet(new diyCompare());
		t1.add(new person(12,"frelon"));
		t1.add(new person(29,"lion"));
		t1.add(new person(29,"aion"));
		t1.add(new person(19,"zoco"));
		for(Object se : t1) {
			System.out.println(se);
		}
	}
}

package sourceCode;

import java.util.Comparator;

public class diyCompare implements Comparator<Object> {

	@Override
	public int compare(Object arg0, Object arg1) {

		person p1 = (person) arg0;
		person p2 = (person) arg1;

		int temp = p1.getName().compareTo(p2.getName());
		int temp2 = p1.getAge() - p2.getAge();

		return temp == 0 ? temp2 : temp;
	}

}

对根据字符长短排序

下面的方案主要是根据名字的长短来排序的，如长短相同则根据名字的hashCode决定谁在前面

package sourceCode;

import java.util.Set;
import java.util.TreeSet;

public class diySavePerson {
	public static void main(String[] args) {
		Set<String> set1 = new TreeSet<String>( new diyCompare()); 
		set1.add("jeAreF");
		set1.add("jpwdth");
		set1.add("jogeth");
		set1.add("jokeme");
		set1.add("jsrdds");
		for (Object se: set1) {
			System.out.println(se);
		}
	}
}

package sourceCode;

import java.util.Comparator;

public class diyCompare implements Comparator<Object> {

	@Override
	public int compare(Object arg0, Object arg1) {
		String str1 = (String)arg0;
		String str2 = (String)arg1;
		int temp1=str1.length()-str2.length();
		int sss = str1.hashCode();
		int ssd = str2.hashCode();
		return temp1==0?sss-ssd:temp1;
	}

}

三元运算符

语法为：条件表达式？表达式 1：表达式 2。

说明：问号前面的位置是判断的条件，判断结果为 boolean 型，为 true 时调用表达式 1，为 false 时调用表达式 2。

Java的equals和contains的一些区别

Fri, 20 Dec 2019 21:33:56 +0000

equals() && contains()

Java 中常见的比较有equals和hashcode

今天在学习的时候就遇到了一个头疼的问题(菜鸟级的我有大大疑问)

在比较两个对象内的元素时，无论是使用equals还是hashcode都始终得不到我想要的结果。遂百度，记此文

那么这两种方法到底有什么区别呢？

equals()方法是根类 Object 的默认方法，查看 Object 中 equals()的默认实现：

public boolean equals(Object obj) {
    return (this == obj);
    }
✅

可以看出没有重写过的 equals()方法和 == 是一样的，都是比较两个对象引用指向的内存地址是否一样判断两个对象是否相等。

也就是说，基本上每次都要Overwrite这个方法

hashCode是JDK根据对象的地址或者字符串或者数字计算该对象的哈希码值的方法。

hashcode 和 equals 两者必须同时重写。

注意在类中，有一些 equals 方法 OverWrite 时必须要传入 Object 类型

public boolean equals (person obj){
	return (this == obj);
	}	
❌
//这样写就是错误的,equals()方法不允许传入非 Object 类

Java on JokemeBlog

kmp算法Java版

KMP查找算法

B/S分层简介

B/S分层

分层介绍

dto层

dao层

service层

controller层

SpringBoot中的分层

entity层：

dao层：

service层：

controller层：

各层介绍

model层

dao层

service层

controller层

各模块简介

各种命名介绍

PO

DO

TO

DTO

VO

BO

POJO

DAO

VO

DO

DTO

PO

SpringBoot 集成MyBatis 中的@MapperScan注解

Spring IOC DI 学习

Spring IOC DI 学习

IOC简介

IOC是什么用？

我的疑惑

问题一

问题二

关于 Maven 下载插件缓慢的问题

关于 Maven 下载插件缓慢的问题

SpringBoot学习笔记(1)

Spring学习

配置文件 <pom.xml>

建立Controller & Starter

需要注意两个比较重要的注解

Registrar.class

AutoConfigurationImportSelector

自动配置原理

EnableAutoConfigurationの作用:

YAML & Properties

yaml基本语法:

yamlの 对象

yamlの数组

yaml文件 & 数据绑定

Properties

@Value

@Value 使用方法

@ConfigurationProperties & @Value の区别

我们在何时使用他们

@PropertySource & @ImportResource

@PropertySource使用方法

@ImportResource使用方法

配置文件占位符

Profile文件支持

多Profile文件

properties

yaml

SpringBoot配置文件の加载顺序

外部配置文件加载顺序

Java 注解的简单学习

Java 注解（Annotation）

Java 元注解

Java 内置注解

注解与反射。

注解应用实例

Java通过jdbc操作MySQL数据库

yamlの对象

递归获取 ?内的内容