■代码 (Lambda表达式，函数式接口，方法引用等等)

■代码运行结果 (Lambda表达式，函数式接口，方法引用等等)

■代码说明 (Lambda表达式，函数式接口，方法引用等等)

・４４行：Stream的、foreach方法ー参数类型：函数式接口

・82行：Interface中，default方法

・92行 Stream的、max方法的ー参数类型：函数式接口

・Stream的优点（特性）

■四种常见的【函数式接口】以及【运用】

・Function （T -> R）(函数描述符， T：参数列表；R返回值) apply

・Consumer （() -> T）(函数描述符，无需参数；T返回值) accpect

・Supplier （T -> void）(函数描述符， T：参数列表；无返回值) get

・ Predicate （T -> boolean） boolean test （T t）

■更多代码

■更多代码1（Stream，Optional）

■更多代码2（Java8 文件操作）

42行：①Files类 ②Files类的lines方法　　③try-with-resource

①Files类 // since 1.7

②lines方法 // since 1.8

③try-with-resource since 1.7

■更多代码3：传统内部类

■更多Java知识

■更多学习总结

1.Java8新特性

2.线程相关（Java.util.concurrent.XXXXX）

3.Java8新特性学习_002_（Stream的各种方法：【map】【reduce】【limit】【skip】【collect】）（私密文章）

4.Junit (Mock) （私密文章） ⇒　【Mockito】

5.TreeMap

6.循环处理（数学公式【（1+1+2+1+2+3+1+2+3+4。。。）⇒n*(n+1)*(n+2)/6】）

7.正则表达式

8.文件处理（和7链接相同，里面含有文件处理的内容）、try-with-resource

9. Comparator 与 Comparable

10.数组变成ArrayList

11.Spring + AspectJ

11.1. Spring XML 配置时【aop:aspect】与【aop:advisor】

12.Spring、SF4J、Logback、Log4j

12.1.AOP术语

13.Optional类

14.【代理模式】与【装饰者】的区别

15.【JDK静态代理，AspectJ】、　【JDK动态代理、CGLIB动态代理】

16.SpringBoot + Thymeleaf

17.SpringBoot + Thymeleaf + MyBatis

17.1.★★★　SpringBoot工程，Package构造笔记　 ★★★

18.java中的【强引用】，【软引用】，【弱引用】，【虚引用】 ⇒与 GC 相关；应用【ThreadLocal】

19. finall Return

20. Map的4中遍历方式

21. Java 二维数组 (String s[][] = new String[2][];)

22.Java格式化字符串输出（System.out.printf(String str, String[] args)）

23.java基础之------访问控制之----protected

24.IO操作

25.网络编程

26.transient 修饰的变量，不会被序列化。

27.Oracle：Case when

28.Java：Case、break

29.普通Maven工程配置Log4j，并使用（无Spring）

30.反射（reflect），Junit中反射的使用　 ⇒　【JMockit】

31.Spring Bean 的别名 :两种方式

31.Java Web容器加载顺序

32.Collections.rotate(Arrays.asList(arr), 2);

33.使用工具类复制文件 (FileUtils)

34.ER图生成工具（Eclipse中：【ERMaster】）

35.Mysql同时删除多个表的数据

36.Oracle 更新查询

37.List list = new ArrayList<>(20); 中的list扩充几次

38.@Autowired

39.MD5

40. ★★★　java各种考试题

41.String.format()

42.java基础（自增，日期格式化）

43.注解 Target

44.javax.inject 需要下载额外的 javax.inject-1.jar

45.XXX

46.XXX

47.XXX

■SpringBoot 与 Spring

●1.@SpringBootApplication注解背后

1.ComponentScan

2.@EnableAutoConfiguration

●2. Spring的@import

代码1：SpringBoot中的使用（@EnableAutoConfiguration中，就使用了这个标注）

代码1的补充说明：AutoConfigurationImportSelector.class

代码２： AspecJ中的使用

●３．组件的注册方式

1.Spring的核心：都是一种设计模式（工厂，代理）

２.BeanFactory 是 Spring的根容器

●４．使用SpringBoot，启动SpringBatch

●５．SpringBoot配置多个数据源

■Spring框架源码分析

1.SpringBoot的jar传递参数时，使用两个「--」横线来标记参数

2.SpringBoot 数据源自动配置

3.使用SpringBoot，启动SpringBatch （经过的各个类以及方法）（私密）

4.配置Log时，【logging.file.name】,【logging.file】

■Java中的标注

1.@PostConstruct // javax.annotation.PostConstruct

2.XX

3.XXX

■Java工具应用

1.打包Jar

2.使用Log4J （私密）

3.使用VBA调用Jar

■更多学习笔记（大篇幅整理的笔记）

Java学习

Spring Boot学习

Spring Batch学习

Oracle学习

■代码 (Lambda表达式，函数式接口，方法引用等等)

package com.sxz.test;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Optional;
import java.util.function.Consumer;
import java.util.stream.Stream;

public class TestStreamAPI {

	public static void main(String[] args) {
		
		List<Integer> list= new ArrayList<>();
		
		list.add(1);
		list.add(2);
		list.add(3);
		list.add(4);
		list.add(5);
		list.add(6);
		
		
		// 例子001
		System.out.println("---Java5 For");
		for (int i: list){
			System.out.println("item="+i);
		}
		
		// 例子002
		System.out.println("---匿名内部类 ");
		Stream<Integer> streamInt= list.stream();
		streamInt.forEach(new Consumer<Integer>() {
			@Override
			public void accept(Integer item) {
				System.out.println("item="+item);
			}
		});
		
		// 例子003
		System.out.println("---Lambda ");
		streamInt= list.stream();
		// forEach函数，Consumer——消费型接口（只有输入，无返回）
		streamInt.forEach(item -> {
			System.out.println("item="+item);
		});
		
//		list.stream().forEach(item -> {
//			System.out.println("item="+item);
//		});
		
		// 例子004
		// 当lambda表达式只是调用了某个方法时，可以用【方法引用】代替Lambda
		System.out.println("---Method Referance");
		list.stream().forEach(System.out::println);

//		■函数式接口(Functional Interface)就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。
//		函数式接口可以被隐式转换为 lambda 表达式。
		
//		■四大函数式接口--（位置：java.util.function） // 1.8
//		Function——函数型接口（有输入、有返回）
//		Predicate——断定型接口（有输入，返回boolean）
//		Consumer——消费型接口（只有输入，无返回）
//		Supplier——供给型接口（无入参，只有返回值）
		
//		■.1.8之前的接口特性：
//		 
//		1.接口中的变量都是静态常量，必须显示初始化
//		 
//		2.接口中的所有方法默认都是public abstract，方法不能有方法体。
//		 
//		3.接口中没有构造方法，不可以被实例化，可以被实现
//		 
//		4.实现类必须实现接口的所有方法
//		 
//		5.实现类可以实现多个接口
				
		
//		■JDK8及以后，允许我们在接口中定义static方法和default方法。
//		https://blog.csdn/sxzlc/article/details/108139670
//		比如，Comparator这个接口
        Comparator com;
        
        
		// 例子101
//        ■Java 8中提供了java.util.Optional<T> 类，是一个容器类，
//        避免java.lang.NullPointerException
        System.out.println("---Optional---Max ");
        streamInt = list.stream();
//        Optional<Integer> one = streamInt.max(Comparatorparing( item -> item)); // 返回值 6
//        Optional<Integer> one = streamInt.max((item1,item2) -> item2 - item1);  // 返回值 1
        Optional<Integer> one = streamInt.max((item1,item2) -> item1 - item2);  // 返回值 6
        System.out.println(one.get());

		// 例子102
        System.out.println("---Optional---Greater Then Three ");
        streamInt = list.stream();
        Stream<Integer> greateThanThree = streamInt.filter(item -> item >3);
        greateThanThree.forEach(System.out::println); 
        
		// 例子102_1
        System.out.println("---Optional---Greater Then Three  And Get Any ");
        streamInt = list.stream();
        Optional<Integer>  greateThanThree2 = streamInt.filter(item -> item >3).findAny();
        System.out.println(greateThanThree2.get());
        
		// 例子103
        System.out.println("---Optional---Greater Then Seven ");
        streamInt = list.stream();
        Stream<Integer> greateThanSeven = streamInt.filter(item -> item >7);
        greateThanSeven.forEach(System.out::println);
        
		// 例子103_1
        System.out.println("---Optional---Greater Then Seven And Get Any ");
        streamInt = list.stream();
        Optional<Integer>  greateThanSeven2 = streamInt.filter(item -> item >7).findAny();
        if (greateThanSeven2.isPresent()){
            System.out.println(greateThanSeven2.get());
            
//          如果不加判断，会出下面的错误   
//            Exception in thread "main" java.util.NoSuchElementException: No value present
//        	at java.util.Optional.get(Optional.java:135)
//        	at com.sxz.test.TestStreamAPI.main(TestStreamAPI.java:118)

        }
        	
	}

}

■代码运行结果 (Lambda表达式，函数式接口，方法引用等等)

---Java5 For
item=1
item=2
item=3
item=4
item=5
item=6
---匿名内部类 
item=1
item=2
item=3
item=4
item=5
item=6
---Lambda 
item=1
item=2
item=3
item=4
item=5
item=6
---Method Referance
1
2
3
4
5
6
---Optional---Max 
6
---Optional---Greater Then Three 
4
5
6
---Optional---Greater Then Three  And Get Any 
4
---Optional---Greater Then Seven 
---Optional---Greater Then Seven And Get Any

■代码说明 (Lambda表达式，函数式接口，方法引用等等)

・４４行：Stream的、foreach方法ー参数类型：函数式接口

---

・82行：Interface中，default方法

在Java中可以为接口定义一个默认方法的实现，使用的关键字就是default，有了默认方法，实现类就可以不对接口中的默认方法进行重写。

---

・92行 Stream的、max方法的ー参数类型：函数式接口

参数（Comparator）是一个函数式接口

---

・Stream的优点（特性）

・无存储。stream不是一种数据结构，它只是某种数据源的一个视图，数据源可以是一个数组，Java容器或I/O channel等。
・为函数式编程而生。
・对stream的任何修改都不会修改背后的数据源
比如对stream执行过滤操作并不会删除被过滤的元素，而是会产生一个不包含被过滤元素的新stream。
・可消费性。stream只能被“消费”一次，一旦遍历过就会失效，要再次遍历必须重新生成。

比如代码的42行：【streamInt= list.stream(); 】再次使用时，需重新生成

直接使用有两个参数的Lambda表达式

---

■四种常见的【函数式接口】以及【运用】

・Function （T -> R）(函数描述符， T：参数列表；R返回值) apply

【java.util.stream.Stream】类中
    <R> Stream<R> map(Function<? super T, ? extends R> mapper);

・Consumer （() -> T）(函数描述符，无需参数；T返回值) accpect

【java.util.stream.Stream】类中
void forEach(Consumer<? super T> action);

・Supplier （T -> void）(函数描述符， T：参数列表；无返回值) get

【java.util.Optional】类中
    public T orElseGet(Supplier<? extends T> other) {
        return value != null ? value : other.get();
    }

https://blog.csdn/sxzlc/article/details/123946309

・ Predicate （T -> boolean） boolean test （T t）

【java.util.stream.Stream】类中
    Stream<T> filter(Predicate<? super T> predicate);

■更多代码

■更多代码1（Stream，Optional）

package com.sxz.test;

import java.util.Arrays;
import java.util.List;
import java.util.Optional;

public class TestStream {
	public static void main(String[] args) {
     List<Integer> list = Arrays.asList(7, 6, 9, 3, 8, 2, 1);

     // 遍历输出符合条件的元素
     list.stream().filter(x -> x > 6).forEach(System.out::println);
     // 匹配第一个
     Optional<Integer> findFirst = list.stream().filter(x -> x > 6).findFirst();
     // 匹配任意（适用于并行流）
     Optional<Integer> findAny = list.parallelStream().filter(x -> x > 6).findAny();
     Optional<Integer> findAny1 = list.stream().findAny();
     // 是否包含符合特定条件的元素
     boolean anyMatch = list.stream().anyMatch(x -> x < 6);
     System.out.println("---------------");
     // Stream也是支持类似集合的遍历和匹配元素的，
     // 只是Stream中的元素是以Optional类型存在的。Stream的遍历、匹配非常简单。
     System.out.println("匹配第一个值：" + findFirst.get());
     System.out.println("匹配任意一个值：" + findAny.get());
     System.out.println("匹配任意一个值1：" + findAny1.get());
     System.out.println("是否存在大于6的值：" + anyMatch);
 }
}

---

■更多代码2（Java8 文件操作）

java中，正则表达式的使用（最普通使用，Group，贪婪模式）_sun0322-CSDN博客_java正则表达式贪婪模式

package com.sxz.test;
 
import java.io.File;
import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.util.Arrays;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Stream;
 
public class TestFileOperate {
 
	private static String BATH_PATH = "C:\\test\\";
	private static String COLUMN_REGEX="<itemName>.*?</itemName>";
	public static int count;
	
	public static void main(String[] args) {
		getFileNameAndPrintColumnName("test001");
	}
	
	public static void getFileNameAndPrintColumnName(String folderName){
		
		File[] files = listFilesMatching(BATH_PATH + folderName, ".*\\.(txt|TXT)$");
		List<File> listFile = Arrays.asList(files);
		
		listFile.stream().forEach(readFileTxt -> process(readFileTxt));
	}
	
	private static File[] listFilesMatching(String path, String regex){
		final Pattern p = Patternpile(regex);
		return new File(path).listFiles(file -> p.matcher(file.getName()).matches());
		
	}
	
	private static void process(File readFileTxt){
 
		System.out.println("---" + readFileTxt.getName() + "------START");
		count = 0;
		final Pattern ptn = Patternpile(COLUMN_REGEX);
		try(Stream<String> lines = Files.lines(readFileTxt.toPath(),Charset.forName("UTF-8"))){
			
			lines.forEach(line->{
				Matcher match = ptn.matcher(line);
				if(match.find()){
					System.out.println(match.group());
					count = count + 1;
				}
			});
			
		} catch (IOException e) {
			e.printStackTrace();
		}
		
		System.out.println("---" + readFileTxt.getName() + " 项目数：" + count + "------END");
	}
 
}

---

42行：①Files类 ②Files类的lines方法　　③try-with-resource

①Files类 // since 1.7

②lines方法 // since 1.8

③try-with-resource since 1.7

旨在减轻开发人员释放try块中使用的资源的义务。 它最初是在Java 7中引入的，其背后的全部想法是，开发人员无需担心仅在一个try-catch-finally块中使用的资源的资源管理。

---

■更多代码3：传统内部类

//students是个list
Collections.sort(students, new Comparator<Student>() {
 
	@Override
	public int compare(Student s1, Student s2) {
		int num = s1.getAge() - s2.getAge();
		if(num == 0) {
			return s1.getName()pareTo(s2.getName());
		}
		return num;
	}	
});

---

■更多Java知识

Java面试题大全（2020版）_Java笔记-CSDN博客_java面试

---

2020 最新Spring面试题_duchaochen的博客-CSDN博客_spring的接口编程主要目的是

---

■更多学习总结

1.Java8新特性

Java8新特性学习_001_（Lambda表达式，函数式接口，方法引用，Stream类，Optional类）_sun0322的博客-CSDN博客

2.线程相关（Java.util.concurrent.XXXXX）

Java学习之Thread之【Monitor】与【wait】与【notify】与【sleep】_加【Callable】【Executor】【ExecutorService】【Future】_sun0322的博客-CSDN博客

3.Java8新特性学习_002_（Stream的各种方法：【map】【reduce】【limit】【skip】【collect】）（私密文章）

https://blog.csdn/sxzlc/article/details/123563903

4.Junit (Mock) （私密文章） ⇒　【Mockito】

https://blog.csdn/sxzlc/article/details/123195147

5.TreeMap

https://blog.csdn/sxzlc/article/details/123920981

6.循环处理（数学公式【（1+1+2+1+2+3+1+2+3+4。。。）⇒n(n+1)(n+2)/6】）

数学公式【（1+1+2+1+2+3+1+2+3+4。。。）⇒n*(n+1)*(n+2)/6】_sun0322的博客-CSDN博客

7.正则表达式

java中，正则表达式的使用（最普通使用，Group，贪婪模式）_sun0322的博客-CSDN博客_java正则贪婪模式

以下是部分代码：

        String checkRE = "^([a-zA-Z0-9])+@([a-zA-Z0-9\\.]+)$";
        Pattern ptn = Patternpile(checkRE);
        Matcher matStr = ptn.matcher("sxz@csnd");
 
        System.out.println(matStr.find());

8.文件处理（和7链接相同，里面含有文件处理的内容）、try-with-resource

java中，正则表达式的使用（最普通使用，Group，贪婪模式）_sun0322的博客-CSDN博客_java正则贪婪模式

以下是部分代码：

		try(Stream<String> lines = Files.lines(readFileTxt.toPath(),Charset.forName("UTF-8"))){
			
			lines.forEach(line->{
				Matcher match = ptn.matcher(line);
				if(match.find()){
					System.out.println(match.group());
					count = count + 1;
				}
			});
			
		} catch (IOException e) {
			e.printStackTrace();

---

【try-with-resource】中声明的变量，会隐式的加上【final】关键字，无法在进行赋值操作。

---

9. Comparator 与 Comparable

Comparator的使用，一般使用匿名的内部类

Collections.sort(studentList, new Comparator<Student>(){

});

重写 compare（Object o1, Object o2）方法

return st1.age-st2.age // 升序

Comparable的使用，一般实现这个接口，实现 compareTo（Object o）方法

// Object is Student

return（this.age > st.age）?1:-1  // 升序

(String类，就实现了，Comparable接口，所以String对象，可用直接比较)

negatice 负数；否点；拒绝， positive 正数；正面；积极

10.数组变成ArrayList

Arrays.AsList(String...)

11.Spring + AspectJ

Java学习之「Spring + AspectJ 」_sun0322的博客-CSDN博客

11.1. Spring XML 配置时【aop:aspect】与【aop:advisor】

<aop:aspect>与<aop:advisor>的区别_爱上香锅的麻辣的博客-CSDN博客_aop:advisor

<aop:aspect> 【定义切面】多用于日志

//定义切面
public class SleepHelperAspect{
    public void beforeSleep(){
        System.out.println("睡觉前要脱衣服！");
    }

    public void afterSleep(){
        System.out.println("起床后要穿衣服！");
    }
}

//aop配置
<bean id="sleepHelperAspect" class="com.ghs.aop.SleepHelperAspect"></bean>

<aop:config>
    <aop:pointcut expression="execution(* *.sleep(..))" id="sleepPointcut"/>
    <aop:aspect ref="sleepHelperAspect">
        <!--前置通知-->
        <aop:before method="beforeSleep" pointcut-ref="sleepPointcut"/>
        <!--后置通知-->
        <aop:after method="afterSleep" pointcut-ref="sleepPointcut"/>
    </aop:aspect>
</aop:config>

<bean id="human" class="com.ghs.aop.Human"/>

<aop:advisor> 【定义通知器】多用于事物

//定义通知
public class SleepHelper implements MethodBeforeAdvice,AfterReturningAdvice{
    @Override
    public void before(Method arg0, Object[] arg1, Object arg2)
            throws Throwable {
        System.out.println("睡觉前要脱衣服！");
    }

    @Override
    public void afterReturning(Object arg0, Method arg1, Object[] arg2,
            Object arg3) throws Throwable {
        System.out.println("起床后要穿衣服！");
    }
}

//aop配置
<bean id="sleepHelper" class="com.ghs.aop.SleepHelper"></bean>

<aop:config>
    <aop:pointcut expression="execution(* *.sleep(..))" id="sleepPointcut"/>
    <aop:advisor advice-ref="sleepHelper" pointcut-ref="sleepPointcut"/>
</aop:config>

<bean id="human" class="com.ghs.aop.Human"/>

12.Spring、SF4J、Logback、Log4j

JNDI RMI 注入（Log4j2漏洞）_sun0322的博客-CSDN博客_jndi注入

12.1.AOP术语

一 概念理解
■　 1     AOP的术语重在理解。  ＝＝＝＝＝＝＝   
Join Point:(连接点) Spring AOP中，join point就是一个方法。（通俗来讲就是起作用的那个方法，具体执行的方法）
 
Pointcut:(切入点)  用来指定join point（通俗来讲就是描述的一组符合某个条件的join point）。通常使用pointcut表达式来限定joint point，Spring默认使用AspectJ pointcut expression language。
 
Advice: 在join point上特定的时刻执行的操作，Advice有几种不同类型，下文将会讨论（通俗地来讲就是起作用的内容和时间点）。
 
Introduction：给对象增加方法或者属性。
 
Target object: Advice起作用的那个对象。
 
AOP proxy: 为实现AOP所生成的代理。在Spring中有两种方式生成代理:JDK代理和CGLIB代理。
 
Aspect: 组合了Pointcut与Advice，在Spring中有时候也称为Advisor。某些资料说Advisor是一种特殊的Aspect，其区别是Advisor只能包含一对pointcut和advice，但是aspect可以包含多对。AOP中的aspect可以类比于OOP中的class。
 
Weaving：将Advice织入join point的这个过程。

切面（Aspect）: 切面是通知和切点的结合。
 
■　2  Advice的类型 ＝＝＝＝＝＝＝  
Before advice:  执行在join point之前的advice,但是它不能阻止joint point的执行流程，除非抛出了一个异常（exception）。
 
After returning advice: 执行在join point这个方法返回之后的advice。
 
After throwing advice: 执行在join point抛出异常之后的advice。
 
After(finally) advice: 执行在join point返回之后或者抛出异常之后的advice，通常用来释放所使用的资源。
 
Around advice: 执行在join point这个方法执行之前与之后的advice。
 
■　3 两种代理 ＝＝＝＝＝＝＝  
Spring AOP是基于代理机制的。上文说到，Spring AOP通过JDK Proxy和CGLIB Proxy两种方法实现代理。
 
如果target object没有实现任何接口，那么Spring将使用CGLIB来实现代理。CGLIB是一个开源项目,它是一个强大的,高性能,高质量的Code生成类库,它可以在运行期扩展Java类与实现Java接口。
 
如果target object实现了一个以上的接口，那么Spring将使用JDK Proxy来实现代理，因为Spring默认使用的就是JDK Proxy，并且JDK Proxy是基于接口的。这也是Spring提倡的面向接口编程。当然，你也可以强制使用CGLIB来进行代理，但是这样可能会造成性能上的下降。

Aop动态代理如下遵从如下规则, 如果bean有接口, 则默认使用Jdk动态代理, 否则使用CGlib动态代理

CGLib Code Generation Library

13.Optional类

https://blog.csdn/sxzlc/article/details/123946309

14.【代理模式】与【装饰者】的区别

工作中使用到的单词（软件开发）_sun0322的博客-CSDN博客_https://10.59.142.4/integration

■相同点

对装饰器模式来说，装饰者（Decorator）和被装饰者（Decoratee）都实现一个接口。对代理模式来说，代理类（Proxy Class）和真实处理的类（Real Class）都实现同一个接口。此外，不论我们使用哪一个模式，都可以很容易地在真实对象的方法前面或者后面加上自定义的方法。

■不同点

在上面的例子中，

【装饰器模式】是使用的调用者从外部传入的被装饰对象（coffee），调用者只想要你把他给你的对象装饰（加强）一下。

而【代理模式】使用的是代理对象在自己的构造方法里面new的一个被代理的对象，不是调用者传入的。调用者不知道你找了其他人，他也不关心这些事，只要你把事情做对了即可。

15.【JDK静态代理，AspectJ】、　【JDK动态代理、CGLIB动态代理】

・JDK动态代理，需要实现接口

16.SpringBoot + Thymeleaf

SpringBoot + Thymeleaf 之 HelloWorld_sun0322的博客-CSDN博客

17.SpringBoot + Thymeleaf + MyBatis

SpringBoot + MyBatis + Thymeleaf 之 HelloWorld_sun0322的博客-CSDN博客

17.1.★★★　SpringBoot工程，Package构造笔记　 ★★★

Spring工程，Package构造_sun0322的博客-CSDN博客

18.java中的【强引用】，【软引用】，【弱引用】，【虚引用】 ⇒与 GC 相关；应用【ThreadLocal】

https://blog.csdn/sxzlc/article/details/123988666

19. finall Return

java中有return 的情况，return以及try,finally代码块的执行顺序_sun0322的博客-CSDN博客

20. Map的4中遍历方式

Map的四种遍历方式_sun0322的博客-CSDN博客_map四种遍历

21. Java 二维数组 (String s[][] = new String[2][];)

https://blog.csdn/sxzlc/article/details/124070892

22.Java格式化字符串输出（System.out.printf(String str, String[] args)）

https://blog.csdn/sxzlc/article/details/124077379

23.java基础之------访问控制之----protected

https://blog.csdn/sxzlc/article/details/124079131

24.IO操作

InputStream和Reader的区别（OutputStream和Writer的区别）

Java 流(Stream)、文件(File)和IO | 菜鸟教程

序列化/反序列化的定义

Java 序列化 | 菜鸟教程

25.网络编程

Socket通信的原理及用法（Socket 基于网络操作的 IO）

Java 网络编程 | 菜鸟教程

RESTful Web services的原理

RESTful 架构详解 | 菜鸟教程

Web Services

JAX-WS Tutorial - javatpoint

26.transient 修饰的变量，不会被序列化。

transient 英[ˈtrænziənt]

n. 过往旅客；临时旅客；候鸟；瞬变现象

adj. 短暂的；路过的；临时的

对于transient 修饰的成员变量,在类的实例对象的序列化处理过程中会被忽略。因此,transient变量不会贯穿对象的序列化和反序列化,生命周期仅存于调用者的内存中而不会写到磁

 public final class StringBuffer
    extends AbstractStringBuilder
    implements java.io.Serializable, CharSequence
{

    /**
     * A cache of the last value returned by toString. Cleared
     * whenever the StringBuffer is modified.
     */
    private transient char[] toStringCache;

27.Oracle：Case when

Case when的用法，一旦满足了某一个WHEN ，则这一条数据就会退出CASE WHEN，而不再考虑其他CASE

Oracle：Case when 没有 Break

28.Java：Case、break

break;语句"不是必须的"。
如果不写，如果一旦case相应的值成功，但内部没有break语句，
那么将会无条件(不再进行case匹配)的继续向下执行其它case中的语句，
直到遇到break;语句或者到达switch语句结束。

29.普通Maven工程配置Log4j，并使用（无Spring）

https://blog.csdn/sxzlc/article/details/124621551

----

30.反射（reflect），Junit中反射的使用　 ⇒　【JMockit】

https://blog.csdn/sxzlc/article/details/124655686

---

31.Spring Bean 的别名 :两种方式

1.使用alias

 <bean id="studentAdd" class="...">
    <alias name="studentAdd" alias="add"/>
    <alias name="studentAdd" alias="doAdd"/>
  </bean>

使用alias设置别名，alias的name要和bean的ID相同。可以设置多个别名

2.使用name

  <bean id="studentAdd" class="..." name="add,doAdd;myAdd"">
	<property name="id" value="1"/>
	<property name="name" value="constxiong"/>
  </bean>

多个别名用、英文逗号(,)、英文分号(;) 分隔

===

31.Java Web容器加载顺序

ServletContext -> context-param -> listener-> filter -> servlet

启动web项目后，web容器首先回去找web.xml文件，读取这个文	件。
容器会创建一个 ServletContext （ servlet 上下文），整个 web 项目的所有部分都将共享这个上下文。
容器将 转换为键值对，并交给 servletContext
容器创建 中的类实例，创建监听器。
容器加载filter，创建过滤器， 要注意对应的filter-mapping一定要放在filter的后面。
容器加载servlet，加载顺序按照 Load-on-startup 来执行

java web的初始化加载顺序，以及servlet的运行过程_douya_bb的博客-CSDN博客_servlet初始化加载类

32.Collections.rotate(Arrays.asList(arr), 2);

代码

package com.sxz.test;

import java.util.Arrays;
import java.util.Collections;

public class CollectionRotate {
	
    public static void main(String[] args) 
    { 
        Integer arr[] = {10, 20, 30, 40, 50}; 
   
        System.out.println("Original Array:" + Arrays.toString(arr)); 
           
        // rotating an array by distance 2 
        System.out.println("rotating an array by distance 2 ");
        Collections.rotate(Arrays.asList(arr), 2); 
           
        System.out.println("Modified Array:" +  Arrays.toString(arr)); 
    } 

}

结果

Original Array:[10, 20, 30, 40, 50]
rotating an array by distance 2 
Modified Array:[40, 50, 10, 20, 30]

===

33.使用工具类复制文件 (FileUtils)

FileUtils走读笔记 - - ITeye博客

java

package com.sxz.study;

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

import org.apachemons.io.FileUtils;

public class FileUtilsTest {
	
    public static void main(String[] args) { 
        
		File from = new File("C:\\test\\from\\test001\\sss.txt");
		File to = new File("C:\\test\\to");
    	
    	 try {
			FileUtils.copyFileToDirectory(from ,to);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
    	
    } 

}

pom引用第三方jar

    <dependency>
      <groupId>commons-io</groupId>
      <artifactId>commons-io</artifactId>
      <version>2.8.0</version>
    </dependency>

34.ER图生成工具（Eclipse中：【ERMaster】）

https://blog.csdn/sxzlc/article/details/124738001

35.Mysql同时删除多个表的数据

DELET 
    t1, t2
FROM
    TABLEA t1
INNER JOIN TABLEB t2 ON t1.id = t2.id
WHERE
    DATEDIFF(CURRENT_DATE(), t1.create_time) > 2;

36.Oracle 更新查询

根据条件，更新全部执行：
update   tableName   set   (a,b,c)=(select   a,b,c   from   ida   where   ida.id=tableName.id);

update   tableName t1   set   a=(select   t2.a   from   ida   t2   where   t1.id=t2.id),b=(select   t2.b   from   ida   t2   where   t1.id=t2.id),c=(select   t2.c   from   ida   t2   where   t1.id=t2.id)

每条数据执行：
UPDATEtableName SET (A,B,C)=(select A,B,C from tableName where id=''xxxxxx)  WHERE id='xxxxxxx'

37.List<String> list = new ArrayList<>(20); 中的list扩充几次

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

0次

面试题|集合ArrayList list = new ArrayList(20) 中的list扩充几次？_赵先生-的博客-CSDN博客_list扩充了几次

ArrayList list=new ArrayList();
这种是默认创建大小为10的数组，每次扩容大小为1.5倍

ArrayList list=new ArrayList(20);
使用的ArrayList的有参构造函数

===

38.@Autowired

@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Autowired {

	/**
	 * Declares whether the annotated dependency is required.
	 * <p>Defaults to {@code true}.
	 */
	boolean required() default true;

}

39.MD5

MD5 与 Base64一起使用加密，计算原理_sun0322的博客-CSDN博客_md5加密base64

40. ★★★　java各种考试题

https://blog.csdn/sxzlc/article/details/124956082

41.String.format()

string.format()详解 - 双间 - 博客园 (cnblogs)

42.java基础（自增，日期格式化）

https://blog.csdn/sxzlc/article/details/124767861

43.注解 Target

@Target({ElementType.TYPE, ElementType
TYPE	类、接口（包括注释类型）或枚举声明
FIELD	字段声明（包括枚举常量）
METHOD	方法声明
PARAMETER	参数声明
CONSTRUCTOR	构造方法声明
LOCAL_VARIABLE	局部变量声明
ANNOTATION_TYPE	注释类型声明
PACKAGE	包声明

44.javax.inject 需要下载额外的 javax.inject-1.jar

<dependencies>	

。。。

   <dependency>
	    <groupId>javax.inject</groupId>
	    <artifactId>javax.inject</artifactId>
	    <version>1</version>
	</dependency>

</dependencies>
   
<repositories>
  <repository>
    <id>repo1</id>
    <name>repo1</name>
    <url>https://repo1.maven/maven2</url>
  </repository>
</repositories>

===

/*
 * Copyright (C) 2009 The JSR-330 Expert Group
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package javax.inject;

import java.lang.annotation.Retention;
import java.lang.annotation.Documented;
import static java.lang.annotation.RetentionPolicy.RUNTIME;

/**
 * String-based {@linkplain Qualifier qualifier}.
 *
 * <p>Example usage:
 *
 * <pre>
 *   public class Car {
 *     &#064;Inject <b>@Named("driver")</b> Seat driverSeat;
 *     &#064;Inject <b>@Named("passenger")</b> Seat passengerSeat;
 *     ...
 *   }</pre>
 */
@Qualifier
@Documented
@Retention(RUNTIME)
public @interface Named {

    /** The name. */
    String value() default "";
}

45.XXX

xxx

46.XXX

xxx

47.XXX

xxx

===

■SpringBoot 与 Spring

●1.@SpringBootApplication注解背后

@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 {




---
但其实，最主要的是以下这三个
@Configuration
@EnableAutoConfiguration
@ComponentScan

1.ComponentScan

常用的几个属性【basePackages】、【includeFilters】，【excludeFilters】

2.@EnableAutoConfiguration

・@EnableAutoConfiguration 中，有【exclude】、【excludeName】这两个属性；

当不想某个特定配置类生效时使用。

●2. Spring的@import

借助@import，将符合自动配置条件的bean，加载到IOC容器中。

代码1：SpringBoot中的使用（@EnableAutoConfiguration中，就使用了这个标注）

// SpringBoot中的 @EnableAutoConfiguration中，就使用了这个标注

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {

代码1的补充说明：AutoConfigurationImportSelector.class

    （@EnableAutoConfiguration中，@Import（AutoConfigurationImportSelector.class））
该组件内部调用SpringFactoriesLoader
加载autoconfigure.jar包中的spring.factories文件，
根据文件定义列表载入各个配置类

代码２： AspecJ中的使用

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {

●３．组件的注册方式

@Bean
@ConmponetScan
@import
@FactoryBean

1.Spring的核心：都是一种设计模式（工厂，代理）

　 IoC的思想基于工厂模式 // FactoryBean：以Bean结尾，表示它是个Bean，它并不是简单的Bean，而是一个能生产对象或者修饰对象的工厂Bean
　　AOP的思想则是基于代理模式。

AspectJ是一个面向切面的框架，是目前最好用，最方便的AOP框架

２.BeanFactory 是 Spring的根容器

BeanFactory：它是Spring IoC容器的一种形式，提供完整的IoC服务支持，也可以看出主语是Factory，即是一个管理Bean的工厂

---

●４．使用SpringBoot，启动SpringBatch

使用SpringBoot启动SpringBatch_sun0322的博客-CSDN博客

----

●５．SpringBoot配置多个数据源

SpringBoot + MyBatis 配置多个数据源_sun0322的博客-CSDN博客

■Spring框架源码分析

1.SpringBoot的jar传递参数时，使用两个「--」横线来标记参数

SpringBoot的jar传递参数时，使用两个「--」横线来标记参数_sun0322的博客-CSDN博客_springboot 两个参数

2.SpringBoot 数据源自动配置

SpringBoot 数据源自动配置_sun0322的博客-CSDN博客_springboot 自动配置数据源

3.使用SpringBoot，启动SpringBatch （经过的各个类以及方法）（私密）

https://blog.csdn/sxzlc/article/details/124323644

4.配置Log时，【logging.file.name】,【logging.file】

Springboot，log文件配置时，logging.file.name与logging.file_sun0322的博客-CSDN博客

===

■Java中的标注

1.@PostConstruct // javax.annotation.PostConstruct

Core Technologies (spring.io)

2.XX

xxx

3.XXX

xxxx

■Java工具应用

1.打包Jar

POM 打包 Jar，指定Main方法的类，指定使用的JDK_sun0322的博客-CSDN博客_pom打包指定main

2.使用Log4J （私密）

https://blog.csdn/sxzlc/article/details/124621551

3.使用VBA调用Jar

下面文章的 No.14

VBA中各种数据类型的使用（自定义数据类型Type，数组，数据字典）、读写文件_sun0322的博客-CSDN博客_vba数据类型

===

■更多学习笔记（大篇幅整理的笔记）

Java学习

Java学习（更新中）_sun0322的博客-CSDN博客_javajava学习

Spring Boot学习

Spring Boot，Sprint Batch 学习_sun0322的博客-CSDN博客

Spring Batch学习

https://blog.csdn/sxzlc/article/details/124183805

Oracle学习

数据库学习（Oracle）_sun0322的博客-CSDN博客_oracle数据库学习

===

更多推荐

Java8新特性学习_001_（Lambda表达式,函数式接口,方法引用,Stream类,Optional类）

Java8新特性学习_001_（Lambda表达式，函数式接口，方法引用，Stream类，Optional类）

■代码 (Lambda表达式，函数式接口，方法引用 等等)

■代码运行结果 (Lambda表达式，函数式接口，方法引用 等等)

■代码说明 (Lambda表达式，函数式接口，方法引用 等等)

・４４行：Stream的、foreach方法ー参数类型：函数式接口

・82行：Interface中，default方法

・92行 Stream的、max方法的ー参数类型：函数式接口

・Stream的优点（特性）

■四种常见的【函数式接口】以及【运用】

・Function （T -> R）(函数描述符， T：参数列表；R返回值) apply

・Consumer （() -> T）(函数描述符， 无需参数；T返回值) accpect

・Supplier （T -> void）(函数描述符， T：参数列表；无返回值) get

・ Predicate （T -> boolean） boolean test （T t）

■更多代码

■更多代码1（Stream，Optional）

■更多代码2（Java8 文件操作）

42行：①Files类 ②Files类的lines方法 ③try-with-resource

①Files类 // since 1.7

②lines方法 // since 1.8

③try-with-resource since 1.7

■更多代码3：传统内部类

■更多Java知识

■更多学习总结

1.Java8新特性

2.线程相关 （Java.util.concurrent.XXXXX）

3.Java8新特性学习_002_（Stream的各种方法：【map】【reduce】【limit】【skip】【collect】） （私密文章）

4.Junit (Mock) （私密文章） ⇒ 【Mockito】

5.TreeMap

6.循环处理 （数学公式【（1+1+2+1+2+3+1+2+3+4。。。）⇒n*(n+1)*(n+2)/6】）

7.正则表达式

8.文件处理 （和7链接相同，里面含有文件处理的内容）、try-with-resource

9. Comparator 与 Comparable

10.数组变成ArrayList

11.Spring + AspectJ

11.1. Spring XML 配置时【aop:aspect】与 【aop:advisor】

12.Spring、SF4J、Logback、Log4j

12.1.AOP术语

13.Optional类

14.【代理模式】 与【装饰者】的区别

15.【JDK静态代理，AspectJ】、 【JDK动态代理、CGLIB动态代理】

16.SpringBoot + Thymeleaf

17.SpringBoot + Thymeleaf + MyBatis

17.1.★★★ SpringBoot工程，Package构造笔记 ★★★

18.java中的【强引用】，【软引用】，【弱引用】，【虚引用】 ⇒与 GC 相关 ；应用【ThreadLocal】

19. finall Return

20. Map的4中遍历方式

21. Java 二维数组 (String s[][] = new String[2][];)

22.Java格式化字符串输出 （System.out.printf(String str, String[] args)）

23.java基础 之------访问控制 之----protected

24.IO操作

25.网络编程

26.transient 修饰的变量，不会被 序列化。

27.Oracle：Case when

28.Java：Case、break

29.普通Maven工程配置Log4j，并使用（无Spring）

30.反射（reflect），Junit中反射的使用 ⇒ 【JMockit】

31.Spring Bean 的别名 :两种方式

31.Java Web容器加载顺序

32.Collections.rotate(Arrays.asList(arr), 2);

33.使用工具类复制文件 (FileUtils)

34.ER图生成工具（Eclipse中：【ERMaster】）

35.Mysql同时删除多个表的数据

36.Oracle 更新查询

37.List<String> list = new ArrayList<>(20); 中的list扩充几次

38.@Autowired

39.MD5

40. ★★★ java各种考试题

41.String.format()

42.java基础 （自增，日期格式化）

43.注解 Target

44.javax.inject 需要下载额外的 javax.inject-1.jar

45.XXX

46.XXX

47.XXX

■SpringBoot 与 Spring

●1.@SpringBootApplication注解背后

1.ComponentScan

2.@EnableAutoConfiguration

●2. Spring的@import

代码1：SpringBoot中的使用（@EnableAutoConfiguration中，就使用了这个标注）

■代码 (Lambda表达式，函数式接口，方法引用等等)

■代码运行结果 (Lambda表达式，函数式接口，方法引用等等)

■代码说明 (Lambda表达式，函数式接口，方法引用等等)

・Consumer （() -> T）(函数描述符，无需参数；T返回值) accpect

42行：①Files类 ②Files类的lines方法　　③try-with-resource

2.线程相关（Java.util.concurrent.XXXXX）

3.Java8新特性学习_002_（Stream的各种方法：【map】【reduce】【limit】【skip】【collect】）（私密文章）

4.Junit (Mock) （私密文章） ⇒　【Mockito】

6.循环处理（数学公式【（1+1+2+1+2+3+1+2+3+4。。。）⇒n(n+1)(n+2)/6】）

8.文件处理（和7链接相同，里面含有文件处理的内容）、try-with-resource

11.1. Spring XML 配置时【aop:aspect】与【aop:advisor】

14.【代理模式】与【装饰者】的区别

15.【JDK静态代理，AspectJ】、　【JDK动态代理、CGLIB动态代理】

17.1.★★★　SpringBoot工程，Package构造笔记　 ★★★

18.java中的【强引用】，【软引用】，【弱引用】，【虚引用】 ⇒与 GC 相关；应用【ThreadLocal】

22.Java格式化字符串输出（System.out.printf(String str, String[] args)）

23.java基础之------访问控制之----protected

26.transient 修饰的变量，不会被序列化。

30.反射（reflect），Junit中反射的使用　 ⇒　【JMockit】

40. ★★★　java各种考试题

42.java基础（自增，日期格式化）

２.BeanFactory 是 Spring的根容器

3.使用SpringBoot，启动SpringBatch （经过的各个类以及方法）（私密）

■更多学习笔记（大篇幅整理的笔记）