java学习day8 -- 可变参数,collections,stream流，方法引用
·
可变参数
底层是一个数组，当传入的形参数量很庞大，不可能一个一个写上，就用可变参数的形式。
package myArg;
public class ArgsDemo {
public static void main(String[] args) {
System.out.println(gerSum(1, 2, 34, 5));
}
public static int gerSum(int...a){
int sum = 0;
for (int i : a) {
sum = sum + i;
}
return sum;
}
}
注意：
1.在方法的形参中最多写一个可变参数。
2.在方法中，除了可变参数外还有其他形参，可变参数要写在最后（因为可变参数会把所有数据都纳入到其中，若写在其他形参前，会把所有数据都当作可变参数中的数据）
Collections
collections是集合的工具类.为集合提供多种操作方法如：addAll()，shuffle()（打乱）,sort(),binarySearch(),copy(),fill(),max/min(),swap()。
不可变集合
不可以被修改的集合，长度和内容都不能修改。
使用 集合.of 方法获得一个不可变的集合。只能进行查询操作，使用增删改会报错。
当获取一个不可变Set集合时，要注意保证其中的数据唯一。
不可变Map集合，保证键不重复，且其中可传递的数据有上限为10个键值对。如果想要传递超过10个键值对对象，可以使用ofEntries方法（将键值看为一个整体）实现。若想用ofEntries方法，还需先将传入的数据转为集合，使用toArray（new Map.Entry[0]），指定集合存入参数的类型为entry。也可以用copyof()方法，可以直接创建一个不可变集合（jdk10出现）。
Stream流
package Stream;
import java.util.ArrayList;
public class StreamDemo1 {
public static void main(String[] args) {
ArrayList<String> list1 = new ArrayList<>();
list1.add("aaa");
list1.add("bbb");
list1.add("aaaa");
list1.add("ddd");
list1.add("aaaaa");
//这部分为不使用stream流的方式
// System.out.println(list1);
// System.out.println("----------------------");
//
// ArrayList<String> list2 = new ArrayList<>();
//
// for (String name : list1) {
// if (name.startsWith("a")){
// list2.add(name);
// }
// }
// System.out.println(list2);
// System.out.println("----------------------");
//
//
// ArrayList<String> list3 = new ArrayList<>();
// for (String name : list2) {
// if (name.length() <= 3){
// list3.add(name);
// }
// }
// System.out.println(list3);
list1.stream().filter(name->name.startsWith("a")).filter(name -> name.length()==3).forEach(name -> System.out.println(name));
}
}
使用步骤：
1.获得一条stream流，并放入数据。2.使用中间方法对流进行操作。3.使用终结方法进行操作
获得流
1.单列集合 使用Collection中的默认方法 stream()
package Stream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Consumer;
import java.util.stream.Stream;
public class StreamDemo2 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list,"a","b","c","d","e","f");
Stream<String> stream1 = list.stream();
// stream1.forEach(new Consumer<String>() {
// @Override
// public void accept(String s) {
// System.out.println(s);
// }
// });
stream1.forEach(s->System.out.println(s));
}
}
2.双列集合 无法直接使用，需先转化为单列集合才可用
package Stream;
import java.util.HashMap;
public class StreamDemo3 {
public static void main(String[] args) {
HashMap<String,Integer> hm = new HashMap<>();
hm.put("aaa",1);
hm.put("bbb",2);
hm.put("ccc",3);
hm.put("ddd",4);
//双列集合获取stream流方法：将键转化为单列集合
hm.keySet().stream().forEach(s -> System.out.println(s));
//也可以使用entryset，获得键值对的单列集合再使用
hm.entrySet().stream().forEach(stringIntegerEntry -> System.out.println(stringIntegerEntry));
}
}
3.数组 数组使用stream方法，会调用Arrays工具类中的Stream
4.零散数据 使用stream.of()实现.这个方法的形参是一个可变参数，可以传递零散数据和数组。但是传入的数组必须是引用数据类型。如果数组是一个基本数据类型，会把整个数组当作一个元素放入stream流中，因此会输出一个地址值。
package Stream;
import java.util.Arrays;
import java.util.stream.Stream;
public class StreamDemo4 {
public static void main(String[] args) {
int[] arr ={1,2,3,45,6,7,8,9};
Arrays.stream(arr).forEach(s-> System.out.print(s));
System.out.println();
Stream.of(1,2,3,4,5).forEach(s-> System.out.print(s));
}
}
Stream流中间方法
每个动作产生stream流只能使用一次，动作结束后会产生新的stream流，因此建议使用链式编程。
filiter() 过滤
limit() 获取前几个元素
skip() 跳过前几个元素
distinct() 元素去重
concat() 合并a和b两个流为一个
map() 转换流中的数据类型
package Stream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Predicate;
import java.util.stream.Stream;
public class StreamDemo5 {
public static void main(String[] args) {
ArrayList<String> list1 = new ArrayList<>();
Collections.addAll(list1,"aaa","ccc","bbb","ddd","aaaaa","aa");
// list.stream().filter(new Predicate<String>() {
// @Override
// public boolean test(String s) {
// //放回值为true，表示当前数据留下。为false则舍去
// return s.startsWith("a");
// }
// }).forEach(s -> System.out.println(s));
list1.stream().filter( s-> s.startsWith("a")).forEach(s -> System.out.println(s));
System.out.println("==========================");
//每个动作产生stream流只能使用一次，动作结束后会产生新的stream流，因此建议使用链式编程
//limit获得前几个
list1.stream().limit(3)
.forEach(s -> System.out.println(s));
System.out.println("==========================");
list1.stream().skip(4)
.forEach(s -> System.out.println(s));
System.out.println("==========================");
ArrayList<String> list2 = new ArrayList<>();
Collections.addAll(list2,"aaa","aaa","aaa","aaa","ccc","bbb","ddd","aaaaa","aa");
ArrayList<String> list3 = new ArrayList<>();
Collections.addAll(list3,"nnn","mmm","ppp","qqq");
//去重
list2.stream().distinct().forEach(s -> System.out.println(s));//使用hashSet进行的数据去重.
System.out.println("==========================");
Stream.concat(list1.stream(),list3.stream()).forEach(s -> System.out.println(s));
System.out.println("==========================");
}
}
Stream流终结方法
forEach() 遍历
count() 统计
toArray() 收集流中数据到数组
collect() 收集流中数据到集合
package Stream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.function.IntFunction;
public class StreamDemo6 {
public static void main(String[] args) {
ArrayList<String> list1 = new ArrayList<>();
Collections.addAll(list1,"aaa","ccc","bbb","ddd","aaaaa","aa");
list1.stream().forEach(s -> System.out.println(s));
System.out.println("==============================");
long count = list1.stream().count();
System.out.println(count);
System.out.println("==============================");
// String[] array = list1.stream().toArray(new IntFunction<String[]>() {
// @Override
// public String[] apply(int value) {
// return new String[value];
// }
// });
String[] array = list1.stream().toArray(value -> new String[value]);
System.out.println(Arrays.toString(array));
}
}
方法引用
方法+引用。引用的条件：
1.引用处必须是函数式接口
2.被引用方法必须已经存在
3.被引用方法的形参和返回值需要跟抽象方法保持一致
4.被引用方法的功能要满足当前需求
import java.util.Arrays;
import java.util.Comparator;
public class FunctionDemo1 {
public static void main(String[] args) {
Integer[] arr = {2,3,5,6,1,4};
Arrays.sort(arr, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o2-o1;
}
});
System.out.println(Arrays.toString(arr));
System.out.println("=============================");
Arrays.sort(arr,(o1, o2) -> o2 - o1);
System.out.println(Arrays.toString(arr));
System.out.println("=============================");
Arrays.sort(arr,FunctionDemo1::subtraction);//方法引用
System.out.println(Arrays.toString(arr));
}
//被引用的方法可以是java中已经写好的方法，也可以来自第三方工具类
public static int subtraction(int num1,int num2){
return num2 - num1;
}
}
方法引用的分类：
1.引用静态方法
格式：类名::静态方法
package Function;
import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Function;
public class FunctionDemo2 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list,"1","2","3","4","5","6");
list.stream().map(new Function<String, Integer>() {
@Override
public Integer apply(String s) {
int i = Integer.parseInt(s);
return i;
}
}).forEach(s-> System.out.println(s));
System.out.println("=======================");
list.stream().map(Integer::parseInt).forEach(s-> System.out.println(s));
}
}
2.引用成员方法
格式：对象::成员方法
（1）引用其他类的成员方法
其他类::方法名
package Function;
import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Predicate;
public class FunctionDemo3 {
public static void main(String[] args) {
ArrayList<String> list =new ArrayList<>();
Collections.addAll(list,"aaa","ccc","bbb","ddd","aaaaa","aa");
list.stream().filter(s -> s.startsWith("a"))
.filter(s -> s.length()==3)
.forEach(s -> System.out.println(s));
System.out.println("==============================");
list.stream().filter(new Predicate<String>() {
@Override
public boolean test(String s) {
return s.startsWith("a") && s.length() == 3;
}
}).forEach(s -> System.out.println(s));
System.out.println("==============================");
list.stream().filter(new StringOperation()::StringJudge)
.forEach(s -> System.out.println(s));
}
}
package Function;
public class StringOperation {
public boolean StringJudge(String s){
return s.startsWith("a") && s.length() == 3;
}
}
（2）引用本类的成员方法
this::方法名
（3）引用父类的成员方法
super::方法名
3.引用构造方法
类名引用成员变量. 类名::成员方法。特殊规则：在stream流中，第一个参数表示流里的每个数据，假设流里的数据是字符串，那么都只能用String这个类里的方法。
接下来从第二个参数到第三个参数跟引用方法的形参保持一致，若没有第二个参数，说明被引用的方法需要无参的成员方法。
引用数组的构造方法 数据类型[]::new
汇聚全球AI编程工具，助力开发者即刻编程。
更多推荐
15
0- 0
已为社区贡献17条内容
所有评论(0)