1.Lambda
1.1函数式编程思想概述
参数,箭头(->)以及一个表达式{代码块}
Lambda表达式的使用前提
- 一个接口
- 接口中有且仅有一个抽象方法
//创建接口抽象方法没有参数
public interface Eatable {
void eat();
}
public static void main(String[] args) {
//在主方法中调用 useEatable方法
Eatable e = new EatableImpl();
useEatable(e);
//匿名内部类
useEatable(new Eatable() {
@Override
public void eat() {
System.out.println("一天一苹果医生远离我");
}
});
//使用lambda表达式
useEatable(() ->{
System.out.println("天天吃苹果");
});
}
private static void useEatable(Eatable e){
e.eat();
}
//创建接口抽象方法有参数
public interface Flyable {
void fly(String s);
}
public static void main(String[] args) {
//匿名内部类
useFlyable(new Flyable() {
@Override
public void fly(String s) {
System.out.println(s);
System.out.println("我能开飞机");
}
});
//使用lambda表达式
useFlyable((String s) -> {
System.out.println(s);
System.out.println("we can fly");
});
}
private static void useFlyable(Flyable f){
f.fly("我可以飞");
}
面向对象的思想:必须通过对象的形式来做事情
函数式思想:强调做什么,而不是以什么形式去做
* * Lambad表达式的标准格式
* * 由三部分组成
* * 1.一线参数
* * 2.一个箭头
* * 3.一段代码
* * 格式:
* * (参数列表) -> {一些重写的方法的代码}
* * 解释说明格式
* * ():接口中抽象方法的参数列表,没有参数,就空着,有参数就写出参数,多个参数就使用逗号分开
* * ->:传递的意思,把参数传递给方法体{}
* * {}:重写接口的抽象方法的方法体
* lambda表达式 可推到可以省略
* 凡是根据上下文推到出来的内容,都可以省略书写
* 可以省略的内容
* 1.(参数列表):括号中的参数列表的数据类型,可以省略不写
* 2.(参数列表):括号中的参数如果只有一个,那么类型和()都可以省略
* 3.(一些代码):如果{}中的代码只有一行,无论是否有返回值,都可以省略({},return,分号)
* 注意:要省略({},return,分号),必须一起省略
*
*
* 使用Lambda的使用前提
* 必须有接口,接口中仅有一个抽象方法
即使是lambda表达式没有参数的时候,也需要提供括号,就像无参函数方法一样
() -> {for ( int i =100; i>=0;i–) System.out.println(i);}
无序知道lambda表达式的返回类型
Lambda表达式的注意事项
- 使用lambda必须要有接口,并且要求接口中有且仅有一个抽象方法
- 必须有上下文环境, 才能推导出lambda对应的接口
- 根据局部变量的赋值得知lambda对应的接口 : Runnable r = () ->System.out.printin(“Lambda表达式”);
- 根据调用方法的参数 得知lambda对应的接口 new Thread(() ->System.out.printin(“Lambda表达式”) ).start();
2.日期类
2.1 date
Date代表了一个特定的时间,精确到毫秒
// public Date() 分配了一个Date对象, 并将其初始化,表示从标准时间到now()的毫秒数
//public Date(long date) 分配了一个Date对象,并且将其初始化 从标准时间到指定时间的毫秒数
//常用方法
//getTime 获取日期对象从1970年1月1日 00:00:00 到现在毫秒数
//setTime(long time) 设置 时间, 给的是毫秒值
2.2 SimpleDateFormat
用于设置敏感的方法格式化和解析日期
2.2.1格式化(从Date到String)
public void String format(Date date) 将日期格式化成为日期/时间字符串
2.2.2解析(从Sring到Date)
public Date parse(String source): 从定字符串的开始解析文本生成日期
2.2.3日期工具类
1.定义日期工具类(DateUtils)
2.定义一个方法dateToString , 用于把日期转换为 指定格式的字符串
1. 返回值类型 Stirng
2. 参数 Date date , String format
3.定义一个方法stringToDate , 用于把字符串解析为 指定的日期格式
1. 返回值类型 Date
2. 参数 String s ,String format
4.定义测试类DateDemo, 调用日期工具类中的方法
3.Calendar类
Calender为某一时刻和一组日历字段之间的转换提供了一些方法,并为操作日历字段提供了一些方法
Calender 提供了 getInstance 用于获取Calender对象,其日期字段已使用当前日期和时间初始化
//public int get(int field)
// int year = instance.get(Calendar.YEAR);
// int month = instance.get(Calendar.MONTH) + 1;
// int day = instance.get(Calendar.DATE);
// System.out.println(year+"年"+month+"月"+day+"日");
// public abstract void add(int field,int amout); 根据日历的规则 将指定的时间量添加或减去给定的日历字段
//需求 1.3年前的今天
// instance.add(Calendar.YEAR,-3);
// int year = instance.get(Calendar.YEAR);
// int month = instance.get(Calendar.MONTH) + 1;
// int day = instance.get(Calendar.DATE);
// System.out.println(year+"年"+month+"月"+day+"日");
//需求2. 10年后的5天前
// instance.add(Calendar.YEAR,10);
// instance.add(Calendar.DATE,-5);
// int year = instance.get(Calendar.YEAR);
// int month = instance.get(Calendar.MONTH) + 1;
// int day = instance.get(Calendar.DATE);
// System.out.println(year+"年"+month+"月"+day+"日");
// public final void set (int year , int month , int date) 设置当前日历的年月日
instance.set(2020,5,1);
int year = instance.get(Calendar.YEAR);
int month = instance.get(Calendar.MONTH) + 1;
int day = instance.get(Calendar.DATE);
System.out.println(year+"年"+month+"月"+day+"日");
二月天
- 键盘录入任意的年份
- 设置日历对象的年,月,日
- 年 键盘录入
- 月 设置为3月 月份是从0开始的 所以设置的值是2
- 日 设置的为1日
- 3月1日往前推一天就是2月的最后一天
- 取出这一天
4.Stream流
Stream流的生成方式
1.Collection体系的集合可以使用默认的方法Stream()生成流
List<String> list = new ArrayList<>();
Stream<String> stream = list.stream();
Set<String> set = new HashSet<>();
Stream<String> stream1 = set.stream();
2.Map体系的集合间接生成流
Map<String,Integer> map = new HashMap<>();
Stream<String> stream2 = map.keySet().stream();
Stream<Integer> stream3 = map.values().stream();
Stream<Map.Entry<String, Integer>> stream4 = map.entrySet().stream();
3.数组可以通过Stream接口的静态方法of(T…values) 生成流
String[] strarray = {"hello","world"};
Stream<String> strarray1 = Stream.of(strarray);
Stream<String> hello = Stream.of("hello", "world");
Stream<Integer> integerStream = Stream.of(10, 20, 30);
filter :用于对流中的数据进行过滤
//创建一个集合
ArrayList<String> List = new ArrayList<>();
List.add("林青霞");
List.add("张曼玉");
List.add("王祖贤");
List.add("柳岩");
List.add("张敏");
List.add("张无忌");
//需求1: 把list集合以开头的在控制台中输出
List.stream().filter(s -> s.startsWith("张")).forEach(System.out::println);
//需求2:把集合中长度为3的元素在控制台中输出
List.stream().filter(s -> s.length() == 3).forEach(System.out::println);
//需求3: 把集合中以张开头的而且长度为3的元素在控制台中输出
List.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3 ).forEach(System.out::println);
limit: 返回此流中的元素组成的流,截取前指定参数个数的元素
//需求1: 取前三个数据在控制台中输出
List.stream().limit(3).forEach(System.out::println);
skip跳过 指定参数个数的数据,返回由该流的剩余元素组成的流
//需求2:跳过上元素,把剩下的元素在控制台中输出
List.stream().skip(3).forEach(System.out::println);
concat(Stream a , Stream b): 合并a和b两个流为同一个流
//取前四个数据组成一个流
Stream<String> s1 = List.stream().limit(4);
//跳过两个元素组成一个流
Stream<String> s2 = List.stream().skip(2);
//合并两个流
//Stream.concat(s1,s2).forEach(System.out::println);
distinct() 去重
//合并两个流,在控制台中输出,去重
Stream.concat(s1,s2).distinct().forEach(System.out::println);
sorted() 返回由此流的元素组成的流,根据自然顺序排序
// //需求1 : 按照字母顺序把数据在控制台中输出
// list.stream().sorted().forEach(System.out::println);
sorted(Comparator comparator) 返回由此流的元素组成的流,根据提供的Comparator进行排序
//需求2: 按照字符串长度把数据在控制台中输出
list.stream().sorted((s1,s2) ->{
int num = s1.length() -s2.length();
int num2 = num==0? s1.compareTo(s2) :num;
return num2;
}).forEach(System.out::println);
map 返回由给定函数应用与此流元素的结果组成的流
mapToInt 返回一个IntStream其中包含将给定函数应用与此流的元素的结果
ArrayList<String> list = new ArrayList<>();
list.add("10");
list.add("20");
list.add("30");
list.add("40");
list.add("50");
// 需求1: 将 集合中的字符串数据转换为整数后在控制台中输出
list.stream().map(Integer::parseInt).forEach(System.out::println);
//计算 流中的总和
int result = list.stream().mapToInt(Integer::parseInt).sum();
System.out.println(result);
}
Stream流终结操作方法
forEach() 对此流的每个元素执行操作
//遍历流中的所有元素
List.stream().forEach(System.out::println);
long count() 返回此流中的元素数
//计算流中元素的个数
long count = List.stream().filter(s -> s.startsWith("张")).count();
System.out.println(count);
Stream流的收集
Collecoter toList() 把元素收集到list集合中
// 创建list 集合对象
ArrayList<String> list = new ArrayList<>();
list.add("林青霞");
list.add("张曼玉");
list.add("王祖贤");
list.add("柳岩");
//需求1: 得到名字为3个字的流
Stream<String> s1 = list.stream().filter(s -> s.length() == 3);
//将数据收集到list集合中,遍历
List<String> names = s1.collect(Collectors.toList());
for (String s: names
) {
System.out.println(s);
}
Collecoter toSet() 把元素收集到Set集合中
// 创建set集合对象
Set<Integer> set = new HashSet<>();
set.add(10);
set.add(20);
set.add(30);
set.add(40);
set.add(50);
//大于25的数
Stream<Integer> s2 = set.stream().filter(s -> s > 25);
//将数据收集到set集合中,遍历
Set<Integer> ages = s2.collect(Collectors.toSet());
for (Integer age: ages
) {
System.out.println(age);
}
Collecoter toMap(Function key , Function value) 把元素收集到Map集合中
//定义一个字符串数组
String[] strArray = {"张三,23","李四,24","王五,25"};
//得到年龄大于18的流
Stream<String> stringStream = Stream.of(strArray).filter(s -> Integer.parseInt(s.split(",")[1]) > 18);
Map<String, Integer> map = stringStream.collect(Collectors.toMap(
s -> s.split(",")[0],
s -> Integer.parseInt(s.split(",")[1]))
);
Set<String> keySet = map.keySet();
for (String key: keySet
) {
Integer value = map.get(key);
System.out.println(key +"," + value);
}
"};
//得到年龄大于18的流
Stream<String> stringStream = Stream.of(strArray).filter(s -> Integer.parseInt(s.split(",")[1]) > 18);
Map<String, Integer> map = stringStream.collect(Collectors.toMap(
s -> s.split(",")[0],
s -> Integer.parseInt(s.split(",")[1]))
);
Set<String> keySet = map.keySet();
for (String key: keySet
) {
Integer value = map.get(key);
System.out.println(key +"," + value);
}