Java8新特性学习

admin管理员组

文章数量:1794759

Java8新特性学习

目录

■代码 (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.文件的 Flush

46.java中的常量

47.引用传值，方法中new时，传递进来的值会失效

48.使用javap，查看类中的 常量  和 方法

49.年金计算  （平方函数）

50.加密

51.XXX

52.XXX

53.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方法。 // 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(); }

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】） （私密文章）

blog.csdn/sxzlc/article/details/123563903

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

blog.csdn/sxzlc/article/details/123195147

5.TreeMap

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类

blog.csdn/sxzlc/article/details/123946309

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

工作中使用到的单词（软件开发）_sun0322的博客-CSDN博客_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】

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][];)

blog.csdn/sxzlc/article/details/124070892

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

blog.csdn/sxzlc/article/details/124077379

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

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）

blog.csdn/sxzlc/article/details/124621551

----

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

​​​​​​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】）

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各种考试题

blog.csdn/sxzlc/article/details/124956082

41.String.format()

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

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

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>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 * * 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.文件的 Flush package com.sxz.test2; import java.io.FileWriter; import java.io.IOException; public class FlushTest { public static void main(String[] args) throws IOException { // 文件大小是0size，里面什么也没有 FileWriter fileWriter1 = new FileWriter("C:\\\\test\\\\Hello1.txt"); fileWriter1.write("123\\r\\n" + "456"); // 不调用flush()方法你会发现，文件是空白的，没有把数据写进来，也是因为数据在内存中而不是落盘到磁盘了。 // 所以为了实时性和安全性，IO在写操作的时候，需要调用flush()或者close() // close() 和flush()的区别：关close()是闭流对象，但是会先刷新一次缓冲区，关闭之后，流对象不可以继续再使用了，否则报空指针异常。 // flush()仅仅是刷新缓冲区，准确的说是"强制写出缓冲区的数据"，流对象还可以继续使用。 // 文件有内容 try (FileWriter fileWriter2 = new FileWriter("C:\\\\test\\\\Hello2.txt");){ fileWriter2.write("12345\\r\\n" + "456789"); } // public class FileWriter extends OutputStreamWriter { // public class OutputStreamWriter extends Writer { // public abstract class Writer implements Appendable, Closeable, Flushable { } } 46.java中的常量

・项目在经javac编译成class文件后、常量在应用中（编译后的class中）不是以常量名的形式存在的、而是以常量值的形式存在。 ・因此、即使我们修改了一个常量类、 其他的编译好的仍然使用原值。 ・也就是说无论我怎么替换这个常量类的class文件、其他文件只要指向这个class文件里面的常量、都会加载之前的值（原值）

＝＝＝

遇到的问题：

想直接替换发布的Web工程的class文件，结果发现直接替换被引用的常量类无效。

解决：

引用常量的类的class，也要作为替换对象，重新编译，替换。

47.引用传值，方法中new时，传递进来的值会失效

下面代码运行结果是aaa

package com.sxz.reference; public class Test { public static void main(String[] args) { // TODO Auto-generated method stub TestAAA aaa = new TestAAA(); aaa.setAaa("aaa"); setAAAInfo(aaa); System.out.println(aaa.getAaa()); } public static void setAAAInfo(TestAAA aaa){ aaa = new TestAAA(); aaa.setAaa("bbb"); } } class TestAAA{ private String aaa; public String getAaa() { return aaa; } public void setAaa(String aaa) { this.aaa = aaa; } } 48.使用javap，查看类中的 常量  和 方法

java

package com.sxz.constants; public class TestConstant { private String testAbc; public final String TEST_AAA = "12345"; public static final String TEST_STATIC_AAA = "1223456"; public String getTestAbc() { return testAbc; } public void setTestAbc(String testAbc) { this.testAbc = testAbc; } }

javap

javap -constants .\\TestConstant.class

49.年金计算  （平方函数）

==

package com.sxz.calc; public class Test { public static void main(String[] args){ double result; double rate = 0.1; double money =2000; int year =5; result=money*rate/(Math.pow((1+rate), year)-1); System.out.println(result); } } 50.加密

AES加密、MD5、SHA256等散列生成（java代码）_md5密钥生成_sun0322的博客-CSDN博客

51.XXX

xxx

52.XXX

xxx

53.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 （经过的各个类以及方法） （私密）

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  （私密）

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学习

blog.csdn/sxzlc/article/details/124183805

Oracle学习

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

===

本文标签： 新特性