int tmp1 = 1; //包围类的成员变量
static int tmp2 = 2; //包围类的静态成员变量 //https://blog.csdn.net/chengwangbaiko/article/details/73477551 https://www.cnblogs.com/newflydd/p/4948575.html
public static void main(String[] args) throws Exception {
List<Integer> list = Arrays.asList(100, 200, 300, 400, 500); list.forEach(o -> {System.out.println(o);}); //forEach函数实现内部迭代 System.out.println("1、给出一个String类型的数组，找出其中所有不重复的素数:");
distinctPrimary("2", "3", "4", "5", "6", "7", "8", "9", "2", "3", "4", "5", "6", "7", "8", "9"); System.out.println("2、给出一个String类型的数组，找出其中各个素数，并统计其出现次数:");
primaryOccurrence("2", "3", "4", "5", "6", "7", "8", "9", "2", "3", "4", "5", "6", "7", "8", "9"); System.out.println("3、给出一个String类型的数组，求其中所有不重复素数的和（预定义的reduce操作: 如sum()，max()，min()等。）:");
distinctPrimarySum("2", "3", "4", "5", "6", "7", "8", "9", "2", "3", "4", "5", "6", "7", "8", "9");
distinctPrimarySum2("2", "3", "4", "5", "6", "7", "8", "9", "2", "3", "4", "5", "6", "7", "8", "9"); System.out.println("4、生成器函数（Generator function）:");
Stream.generate(Math::random).limit(5).forEach(System.out::println); System.out.println("5、//3.1、λ表达式的更多用法:");
// 嵌套的λ表达式
Callable<Runnable> c1 = () -> () -> { System.out.println("Nested lambda"); };
c1.call().run(); // 用在条件表达式中
Callable<Integer> c2 = true ? (() -> 42) : (() -> 24);
System.out.println(c2.call()); // 定义一个递归函数
// private UnaryOperator<Integer> factorial = i -> { return i == 0 ? 1 : i * factorial.apply( i - 1 ); };
// //...
// System.out.println(factorial.apply(3));
System.out.println("6、方法引用（Method reference）:");
/*
Integer::parseInt //静态方法引用
System.out::print //实例方法引用
Person::new //构造器引用 super::toString //引用某个对象的父类方法
String[]::new //引用一个数组的构造器 //c1 与 c2 是一样的（静态方法引用）
Comparator<Integer> c2 = (x, y) -> Integer.compare(x, y);
Comparator<Integer> c1 = Integer::compare;
List<UserT> persons = new ArrayList<>();
//下面两句是一样的（实例方法引用1）
persons.forEach(e -> System.out.println(e));
persons.forEach(System.out::println); //下面两句是一样的（实例方法引用2）
persons.forEach(person -> person.eat());
persons.forEach(Person::eat); //下面两句是一样的（构造器引用）
strList.stream().map(s -> new Integer(s));
strList.stream().map(Integer::new); */ } //5、捕获（Capture）
/*
public void testCapture() {
int tmp3 = 3; //没有声明为final，但是effectively final的本地变量
final int tmp4 = 4; //声明为final的本地变量
int tmp5 = 5; //普通本地变量 Function<Integer, Integer> f1 = i -> i + tmp1;
Function<Integer, Integer> f2 = i -> i + tmp2;
Function<Integer, Integer> f3 = i -> i + tmp3;
Function<Integer, Integer> f4 = i -> i + tmp4;
Function<Integer, Integer> f5 = i -> {
tmp5 += i; // 编译错！对tmp5赋值导致它不是effectively final的
return tmp5;
};
//...
tmp5 = 9; // 编译错！对tmp5赋值导致它不是effectively final的
} */ //1、给出一个String类型的数组，找出其中所有不重复的素数
/**
* 你可能会觉得在这个例子里，List list被迭代了好多次，
* map，filter，distinct都分别是一次循环，效率会不好。
* 实际并非如此。这些返回另一个Stream的方法都是“lazy”的，而最后返回最终结果的collect方法则是“eager”的。
* 在遇到eager方法之前，lazy的方法不会执行。
*
* 当遇到eager方法时，前面的lazy方法才会被依次执行。
* 而且是管道贯通式执行。这意味着每一个元素依次通过这些管道。
* 例如有个元素“3”，首先它被map成整数型3；
* 然后通过filter，发现是素数，被保留下来；又通过distinct，
* 如果已经有一个3了，那么就直接丢弃，如果还没有则保留。这样，3个操作其实只经过了一次循环。
*
* 除collect外其它的eager操作还有forEach，toArray，reduce等
*/
public static void distinctPrimary(String... numbers) {
List<String> l = Arrays.asList(numbers);
List<Integer> r = l.stream()
.map(e -> new Integer(e))
// .map(e -> Integer.parseInt(e)) // 将集合流中的元素一一映射为一个新的元素，并生成到新的输出流中
.filter(e -> isPrime(e)) // 过滤，lambda表达式 .filter(e -> Primes.isPrime(e))
.distinct() // stream的高级方法，去除重复
.collect(Collectors.toList()); // 将整理好的输出流收集到新的listInt集合中
System.out.println("distinctPrimary result is: " + r);
} //2、给出一个String类型的数组，找出其中各个素数，并统计其出现次数
public static void primaryOccurrence(String... numbers) {
List<String> l = Arrays.asList(numbers);
Map<Integer, Integer> r = l.stream()
.map(e -> new Integer(e))
// .filter(e -> Primes.isPrime(e))
.filter(e -> isPrime(e))
.collect( Collectors.groupingBy(p->p, Collectors.summingInt(p->1)) ); //把结果收集到一个Map中，用统计到的各个素数自身作为键，其出现次数作为值。
System.out.println("primaryOccurrence result is: " + r);
} //3、给出一个String类型的数组，求其中所有不重复素数的和（预定义的reduce操作: 如sum()，max()，min()等。）
public static void distinctPrimarySum(String... numbers) {
List<String> l = Arrays.asList(numbers);
int sum = l.stream()
.map(e -> new Integer(e))
// .filter(e -> Primes.isPrime(e))
.filter(e -> isPrime(e))
.distinct()
.reduce(0, (x,y) -> x+y); // equivalent to .sum() reduce方法用来产生单一的一个最终结果。
System.out.println("distinctPrimarySum result is: " + sum);
}
public static void distinctPrimarySum2(String... numbers) {
List<String> l = Arrays.asList(numbers);
int sum = l.stream().map(Integer::new)
// .filter(Primes::isPrime)
.filter(e -> isPrime(e))
.distinct()
.mapToInt(item -> item)
.sum()
;
System.out.println("distinctPrimarySum2 result is: " + sum);
} //3.1、统计年龄在25-35岁的男女人数、比例 (预定义的reduce操作)
public void boysAndGirls(List<UserT> persons) {
Map<Integer, Integer> result = persons.parallelStream().filter(p -> p.getAge()>=25 && p.getAge()<=35).
collect(
Collectors.groupingBy(p->p.getSex(), Collectors.summingInt(p->1))
);
System.out.print("boysAndGirls result is " + result);
System.out.println(", ratio (male : female) is " + (float)result.get(UserT.Sex.MALE)/result.get(UserT.Sex.FEMAILE));
} static class UserT { public enum Sex {
MALE("男"),
FEMAILE("女"); private String description; Sex(String description) {
this.description = description;
} public String getDescription() {
return description;
} public void setDescription(String description) {
this.description = description;
} public static Sex fromName(String name) {
for (Sex model : Sex.values()) {
if (StringUtils.equals(model.name(), name)) {
return model;
}
}
return null;
}
} String name;
Integer age;
Integer sex; public Integer getSex() {
return sex;
} public void setSex(Integer sex) {
this.sex = sex;
} public Integer getAge() {
return age;
} public void setAge(Integer age) {
this.age = age;
} public UserT(String zm) {
this.name=zm;
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
}
}
★、根据条件生成新的 array：
public static void main(String[] args){
String[] ids={"11","12","13"};
String[] contents={"a"};
String[] z1 = new String[0];
if(ids.length != contents.length){
int diff = ids.length - contents.length;
int z0 = diff + contents.length;
z1 = new String[z0];
for (int i = 0; i < contents.length; i++) {
z1[i] = contents[i];
}
}
String[] z3 = Arrays.stream(z1).map(i -> {
return i == null ? "" : i;
}).toArray(String[]::new);
Arrays.stream(z3).forEach(System.out::println);
}