1 枚举语法特点
-
枚举是jdk1.5提供的一个特性
-
枚举是一个特殊的类,这个类的对象的数量是有限的。在定义枚举类的同时就已经确定了类对象及类对象的数量。
-
枚举使用
enum
关键字定义 -
在枚举类中的第一行,就需要提供枚举类的对象(名字)
多个对象名之间使用逗号隔开。
最后一个对象可以使用分号,也可以不用。强烈建议使用分号结束
每一个对象都相当于public static final A a ; (编码规范:常量的名字都大写)
enum A{
//public static final A a1 = new A();
a1 , a2 , a3 , a4 ;
}
-
枚举类中也可以有属性,方法和构造方法,其中属性和方法与普通类没有任何区别。
-
构造方法可以是无参,也可以是有参。但必须是private
-
在声明枚举对象时,可以指定调用的构造方法及为构造方法传递的参数。
enum B{
B1, //new B()
B2(), //new B()
B3(10,20), //new B(10,20);
B4(100,200), //new B(100,200);
B5 ;
private B(){}
private B(int i , int j){
this.i = i ;
this.j = j ;
}
int i ;
int j ;
}
-
枚举不能继承
-
枚举中可以定义抽象方法
enum C{
c1(){
public void t1(){
System.out.println("----------------------------");
}
} ,
c2(){
public void t1(){
System.out.println("=============================");
}
} ;
public abstract void t1() ;
}
2 枚举的使用
获得枚举对象
-
B b = B.B1;
-
枚举对象可以作为switch的判断条件
public void test(B b){
switch(b){
case B1:break ;
case B2:break ;
case B3:break ;
case B4:break ;
}
}
使用枚举对象
-
就是调用枚举对象的属性和方法。 包括两部分
-
定义枚举时,我们根据需求自定义的属性和方法
-
所有的枚举类都默认继承Enum父类。 类似于所有的注解都继承Annotation。 所以枚举 对象中还包含一些Enum父类中提供的方法
-
e.getName();//获得枚举对象的名字,也就是变量名
e.ordinal();//获得当前枚举对象在所有枚举对象列表中的位置(下标 0开始)
e.compareTo(Enum e1); //默认比较两个枚举对象的索引位置
Enum.valueOf(B.class,"B2"); //获得指定名字的枚举对象
B.values(); //获得B这个枚举类的所有枚举对象,以数组的形式返回
3 什么Stream流
-
jdk1.8提供的一个新特性
-
与IO没有任何关系。
-
是对集合数据操作的一个增强。 一般指的是数组, Set , List , Collection
-
Stream的使用需要配合lambda
4 Stream流分类
-
Stream中提供了很多流操作(一个一个的方法)
-
流中的数据每经过一个方法(每经过一个流),就会对数据进行一些处理(过滤,排序,分组等)
-
根据流的作用不同,分成2大类
-
终端流 : 流数据经过终端流的处理,就完成了最终的处理,就不会再经过其他流处理了。
在众多终端流中,流数据只会经过一个终端流
-
过程流:流数据可以经过多个过程流,依次进行处理。
每个过程流处理的都是上一个过程流处理后的结果
在程序运行时,遇见过程流,不会立刻执行,只会提前做好准备
直到遇见终端流,整个流操作才会开启。
-
-
在数据流操作的过程中,不会对集合中的原始数据造成影响。
5 产生Stream流
通过集合直接获得对应的流
Stream<String> stream = list.stream();
Stream<String> stream = set.stream();
通过数组获得对应的流
Stream<String> stream = Arrays.stream(names);
直接使用Streams工具产生流
Stream<String> stream2 = Stream.of("dongmingyu", "cuijunhe", "luzhipeng", "panshuai");
Stream<Integer> stream3 = Stream.iterate(1, (i) -> i += 2).limit(10);
6 流的使用
6.1 终端流
foreach()
-
循环遍历流中的每一个元素,对其进行消费,一般会配合输出打印
Stream<String> s = list.stream();
s.forEach( (name)->{
System.out.println(name);
} );
s.forEach(System.out::println);
count()
-
获得流中数据的数量
### count()
* 获得流中数据的数量
max() & min()
-
获得流管道中最大或最小的数据。
-
由于流中是对象数据,也就需要对象比较大小
-
对象如何比较大小? 自身比较 或 比较器比较
Stream<String> s = list.stream();
Optional<String> max = s.max((name1, name2) -> name1.compareTo(name2) );
String name = max.get();
System.out.println(name);
-
注意:返回的不直接是最终的结果,而是将其包装成了Optional对象
可以通过调用Optional.get()获得最终的结果
collect()
-
会将数据收集到一起,再做一些综合性的整理
-
需要配合
Collectors
类,完成具体的收集操作
s.collect(Collectors.toSet());
s.collect(Collectors.toList());
s.collect(Collectors.toMap((v)->key? , (v)->value? ));
//使用流中数据的某一个属性进行求和统计
Integer r = s.collect(Collectors.summingInt((user) ->user.getSalary() ));
Double r = s.collect(Collectors.averagingInt((user) -> user.getSalary()));
//使用流中数据的某一个属性进行求和统计
Integer r = s.collect(Collectors.summingInt((user) ->user.getSalary() ));
Double r = s.collect(Collectors.averagingInt((user) -> user.getSalary()));
6.2 过程流
filter()
-
对流中的数据进行过滤,复合条件的保留,不符合条件的被筛掉
-
filter中需要提供一个Predicted断言
Stream<Car> s = cars.stream();
s = s.filter( car->car.getPrice() > 350000 ) ;
s.forEach(System.out::println);
map()
-
重新处理流中的每一个数据,在原结构的基础上,构建新的结构
对有n个属性的数据,可以重新设置其具有的属性(可以增加属性,可以减少属性,可以更换属性)
public static void main(String[] args) {
String[] colors = new String[]{"red","green","blue","yellow","pink"};
List< Map<String,String> > list = new ArrayList<>() ;
for(int i=1;i<=10;i++){
Map<String,String> car = new LinkedHashMap<>();
car.put("cno",1000+i+"");
car.put("cname","bmw"+i);
int index = (int)(Math.random() * colors.length);
car.put("color",colors[index]);
car.put("price",150000 + (int)(Math.random()*300000) + "");
list.add(car);
}
Stream<Map<String, String>> s = list.stream();
//old代表流中的原始数据,当前是一个Map
//对old数据处理后,返回一个新的结构的数据。不一定还是Map,可能是Car
s = s.map( (old)->{
String price = old.get("price");
int _price = Integer.parseInt(price);
if(_price < 200000){
old.put("flag","便宜");
}else if(_price < 400000){
old.put("flag","一般");
}else{
old.put("flag","昂贵");
}
return old ;
} ) ;
s.forEach(System.out::println);
}
sorted()
-
对容器中的元素进行排序。排序需要对象大小比较。比较需要自身比较或比较器
java
s = s.sorted( (car1,car2)-> {
int price1 = Integer.parseInt(car1.get("price")) ;
int price2 = Integer.parseInt( car2.get("price")) ;
return price2 - price1 ;
});
skip() & limit()
-
可以实现数据的分页处理
-
假设有105条件,准备每页显示10条记录,请问需要多少页?11页
-
第1页,显示哪10条? 前10条 ,从0开始,显示10条,也就是0~9条
-
第2页,显示哪10条?从10开始,显示10条,也就是10~19条
-
第3页,显示哪10条?从20开始,显示10条,也就是20~29条
-
第n页,显示哪10条?从10n-10开始,显示10条,也就是10n-10~(10n-1)
//跳过6个数据,从下标为6的第7个数据开始,找3条记录。
s = s.skip(6).limit(3);
7 串行流和并行流
-
串行流,就是使用单线程,一个数据一个数据的处理
默认使用的就是串行流
-
并行流,就是使用多线程,同时对各自的数据进行处理
如何获得并行流?
public static void main(String[] args) {
Stream<Integer> s = Stream.iterate(1, i -> ++i).limit(10);
s = s.parallel();
s.forEach(System.out::println);
}
标签:10,stream,Stream,对象,int,枚举,详解 From: https://blog.csdn.net/weixin_53755148/article/details/141804292