文章目录
1 Jdk1.8 64位下载 安装 配置
1-1 JDK资源下载
如下图：
1-2 JDK 配置：
- 右键我的电脑 → 属性 → 高级系统配置 → 环境变量 → 系统变量：
新建 → JAVA_HOME → C:\Java\jdk1.8.0_201 ； - 新建 → CLASSPATH → .;%JAVA_HOME%\lib;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar
→ 注意前面有一个点和分号，别漏了 - Path → 编辑 → 新建两个：%JAVA_HOME%\bin 和 %JAVA_HOME%\jre\bin
- 打开 cmd 命令行，输入：java -version 查看Jdk版本是否正确即可；
2 java在线反编译class文件
3 指定jdk版本，运行jar包
3-1 自己使用的实例，可参考直接使用
@echo off
@REM 批处理显示的名称
title 外配处方7107Pdf调度服务
@REM 安装多个版本的Jdk时，指定固定的Jdk版本运行当前的Jar，其中 @REM 表示注释，如需指定Jdk，则删除@REM 即可； 若电脑配置了环境变量，且Jdk与Jar运行所需环境一致，这块保留无需变动即可；
@REM set JAVA_HOME=D:\softwares\jdk1.8
@REM set Path=%JAVA_HOME%\\bin;
@REM 运行当前目录下的Jar包
@REM %~dp0 -- 表示当前的路径,最后会自带\， 直接拼接jar包即可
java -jar %~dp0MediInfoWaiPeiCfPdfService.jar
@REM 悬停 无需暂停，启动直接运行服务了
@REM pause
4. Java中去掉字符串中的回车、换行、制表符
/**
* 测试移除代码中的换行符
*/
public class TestReturn {
public static void main(String[] args) {
String s1 = "i am china\n\r";
String s2 = "i am china";
//移除
Info info1 = new Info();
info1.setName(removeRNT(s1)+"a");
Info info2 = new Info();
info2.setName(s2+"a");
System.out.println(info1.getName());
System.out.println(info2.getName());
System.out.println(info1.getName().equals(info2.getName()));
}
@Data
public static class Info {
private String name;
}
/**
* 在正则表达式中\s表示所有的空格： 匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。注意 Unicode 正则表达式会匹配全角空格符。
* 使用正则表达式,移除换行符（且不移除空格）
*
* @param originalStr 原始字符串
* @return 移除换行\r、回车\n、制表\t符的字符串
*/
public static String removeRNT(String originalStr) {
if (originalStr == null || originalStr.isEmpty()) {
return originalStr;
}
return originalStr.replaceAll("[\t\n\r]","");
}
/**
* 移除字符串中所有的空白格（包含换行\r、回车\n、制表\t符）
*
* @param str 原始串
* @return 无空格后的串
*/
public static String trimAllWhitespace(String str) {
if (str == null || str.isEmpty()) {
return str;
}
int len = str.length();
StringBuilder sb = new StringBuilder(str.length());
for (int i = 0; i < len; i++) {
char c = str.charAt(i);
if (!Character.isWhitespace(c)) {
sb.append(c);
}
}
return sb.toString();
}
}
5. Jar包下载_Maven_Repository（中央仓库）
6. Lambda表达式 详解
-
Lambda 是一个匿名函数，可以把 Lambda表达式 理解为是一段可以传递的代码 (将代码像数据一样进行传递)
-
Lambda 表达式的基础语法 : Java8 中引入了一个新的操作符 “->” 该操作符称为箭头操作符或 Lambda 操作符，箭头操作符将 Lambda 表达式拆分成两部分 :
左侧 : Lambda 表达式的参数列表
右侧 : Lambda 表达式中所需执行的功能， 即 Lambda 体
6-1 Lambda表达式格式
括号的省略技巧：
上联 : 左右遇一括号省
下联 : 左侧推断类型省
横批 : 能省则省
语法格式一 : 无参数，无返回值
() -> System.out.println("Hello Lambda!");
语法格式二 : 有一个参数，并且无返回值
(x) -> System.out.println(x)
语法格式三 : 若只有一个参数，小括号可以省略不写
x -> System.out.println(x)
// 实例
Consumer<String> con = (x) -> System. out .println(x);
con.accept( "啦啦啦，哈哈哈" );
语法格式四 : 有两个以上的参数，有返回值，并且 Lambda 体中有多条语句
Comparator <Integer> com = (x, y) -> {
System.out.println("函数式接口");
return Integer.compare(x, y);
};
语法格式五 : 若 Lambda 体中只有一条语句， return 和 大括号都可以省略不写
Comparator <Integer> com = (x, y) -> Integer.compare(x, y);
语法格式六 : Lambda 表达式的参数列表的数据类型可以省略不写，因为JVM编译器通过上下文推断出，数据类型，即“类型推断”
(Integer x, Integer y) -> Integer.compare(x, y);
注 : Lambda 表达式中的参数类型都是由编译器推断得出的。 就是 “类型推断”
6-2 Lambda表达式说明
Lambda 表达式需要 “函数式接口” 的支持
函数式接口 : 接口中只有一个抽象方法的接口，称为函数式接口，可以通过 Lambda 表达式来创建该接口的对象 (若 Lambda表达式抛出一个受检异常，那么该异常需要在目标接口的抽象方法上进行声明) 可以使用注解 @FunctionalInterface 修饰可以检查是否是函数式接口，同时 javadoc 也会包含一条声明，说明这个接口是一个函数式接口；
// 比如下方两个接口
@FunctionalInterface
public interface MyFun {
Integer getValue(Integer num);
}
函数式接口中使用泛型 :
@FunctionalInterface
public interface MyFun< T > {
T getValue( T t);
}
6-3 匿名类到 Lambda 的转换
// 1. 匿名内部类作为参数传递
Comparator<Integer> comparator = new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return Integer. compare (o1, o2);
}
};
TreeSet<Integer> treeSet = new TreeSet<>(comparator);
// 2. Lambda 表达式作为参数传递
Comparator<Integer> comparator = (o1, o2) -> Integer. compare (o1, o2);
TreeSet<Integer> treeSet = new TreeSet<>(comparator);
说明： 作为参数传递 Lambda 表达式 :
为了将 Lambda 表达式作为参数传递，接收Lambda 表达式的参数类型，
必须是与该 Lambda 表达式兼容的函数式接口的类型
6-4 实例：
需求 : 雇员对象如下，有一个包含许多员工信息的对象 employees，
要求获取当前公司中员工年龄大于 35 的员工信息
public class Employee {
private String name ;
private int age ;
public Employee() {
}
public Employee(String name, int age ) {
this . name = name;
this . age = age;
}
// ...
@Override
public String toString() {
return "Employee{" + "name='" + name + ' \' ' + ", age=" + age + '}' ;
}
}
1. 最简单的方式是采用 foreach 循环遍历，以下是各种优化方式
2. 优化方式一 : 策略设计模式
@FunctionalInterface
public interface MyPredicate< T > {
boolean test( T t);
}
public class FilterEmployeeByAge implements MyPredicate<Employee> {
@Override
public boolean test(Employee employee) {
return employee.getAge() >= 35 ;
}
}
public List<Employee> filterEmployees3(List<Employee> employees, MyPredicate<Employee> myPredicate) {
List<Employee> emps = new ArrayList<>();
for (Employee employee : employees) {
if (myPredicate.test(employee)) {
emps.add(employee);
}
}
return emps;
}
List<Employee> emps = filterEmployees3( employees , new FilterEmployeeByAge());
for (Employee employee : emps) {
System. out .println(employee.toString());
}
优化方式二 : 匿名内部类
List<Employee> emps = filterEmployees3( employees , new MyPredicate<Employee>() {
@Override
public boolean test(Employee employee) {
return employee.getAge() >= 35 ;
}
});
for (Employee employee : emps) {
System. out .println(employee.toString());
}
优化方式三 : Lambda
filterEmployees3( employees , employee -> employee.getAge() >= 35 ).forEach(System. out ::println);
优化方式四 : Stream API
employees .stream().filter((employee) -> employee.getAge() >= 35 ).limit( 5 ).forEach(System. out ::println);
6-5 Java8 内置的四大核心函数式接口
Consumer<T> 消费型接口 :
public void happy( double money, Consumer<Double> con) {
con.accept(money);
}
happy( 10000 , (m) -> System. out .println( "吃大餐，每次消费：" + m + "元" ));
Supplier<T> 供给型接口 :
// 需求 : 产生指定个数的整数，并放入集合中
public List<Integer> getNumList( int num, Supplier<Integer> sup) {
List<Integer> list = new ArrayList<>();
for ( int i = 0 ; i < num; i++) {
Integer n = sup.get();
list.add(n);
}
return list;
}
getNumList( 10 , () -> ( int ) (Math. random () * 100 )).forEach(System. out ::println);
Function<T, R> 函数型接口 :
// 需求：用于处理字符串
public String strHandler(String str, Function<String, String> fun) {
return fun.apply(str);
}
String newStr = strHandler( " \t\t\t Good Good Study,Day Day up. " , (str) -> str.trim());
System. out .println(newStr);
Predicate<T> 断言型接口 :
// 需求：将满足条件的字符串，放入集合中
public List<String> filterStr(List<String> list, Predicate<String> pre) {
List<String> strList = new ArrayList<>();
for (String str : list) {
if (pre.test(str)) {
strList.add(str);
}
}
return strList;
}
List<String> list = Arrays. asList ( "Hello" , "atguigu" , "Lambda" , "www" , "ok" );
filterStr(list, (s) -> s.length() > 3 ).forEach(System. out ::println);
6-6 方法引用 _可利用Idea中Alter+Enter快捷键自动互转
若 Lambda 体中的功能，已经有方法提供实现，可以使用方法引用 (可以将方法引用理解为 Lambda 表达式的另外一种表现形式)
1> 对象的引用 :: 实例方法名
2> 类名 :: 静态方法名
3> 类名 :: 实例方法名
注 : 1> 方法引用所引用的方法的参数列表与返回值类型，需要与函数式接口中抽象方法的参数列表和返回值类型保持一致(就是函数签名和返回值一致)
2> 若Lambda 的参数列表的第一个参数，是实例方法的调用者，第二个参数(或无参)是实例方法的参数时，格式 : ClassName::MethodName
PrintStream ps = System. out ;
Consumer<String> con1 = (str) -> ps .println(str);
Consumer<String> con2 = ps::println;
Consumer<String> con3 = System. out::println;
对象的引用 :: 实例方法名
Employee emp = new Employee( 101 , "张三" , 18 , 9999.99 );
Supplier<String> sup = () -> emp .getName();
System. out .println(sup.get());
Supplier<String> sup2 = emp::getName;
System. out .println(sup2.get());
类名 :: 静态方法名
Comparator<Integer> comparator1 = (x, y) -> Integer. compare (x, y);
Comparator<Integer> comparator2 = Integer:: compare ;
BiFunction<Double, Double, Double> fun = (x, y) -> Math. max (x, y);
System. out .println(fun.apply( 1.5 , 22.2 ));
BiFunction<Double, Double, Double> fun2 = Math:: max ;
System. out .println(fun2.apply( 1.2 , 1.5 ));
类名 :: 实例方法名
BiPredicate<String, String> bp = (x, y) -> x.equals(y);
System. out .println(bp.test( "abcde" , "abcde" ));
BiPredicate<String, String> bp2 = String::equals;
System. out.println(bp2.test( "abc", "abc"));
Function<Employee, String> fun = (e) -> e.show();
System. out .println(fun.apply( new Employee()));
Function<Employee, String> fun2 = Employee::show;
System. out.println(fun2.apply( new Employee()));
注 : 当需要引用方法的第一个参数是调用对象，并且第二个参数是需要引用方法的第二个参数 (或无参数) 时 : ClassName::methodName
构造器引用
构造器的参数列表，需要与函数式接口中参数列表保持一致 (就是函数签名一致)
1> 类名 :: new
Supplier<Employee> sup = () -> new Employee();
System. out .println(sup.get());
Supplier<Employee> sup2 = Employee:: new ;
System. out .println(sup2.get());
Function<String, Employee> fun = Employee:: new ;
BiFunction<String, Integer, Employee> fun2 = Employee:: new ;
数组引用
1> 类型[] :: new
Function<Integer, String[]> fun = (args) -> new String[args];
String[] strs = fun.apply( 10 );
System. out .println(strs. length );
Function<Integer, Employee[]> fun2 = Employee[]:: new ;
Employee[] emps = fun2.apply( 20 );
System. out .println(emps. length );
扫一扫
19万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
