javalambdasort

㈠ JDK1.8对List指定字段进行排序

import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

import java.util.List;

import com.wubei.demo.bean.Order;

/**

* List根据指定字段进行排序

*

*/

public class ListStreamTest {

public static void main(String[] args) {

String orderId1 = "2321837281372913";

String userId1 = "20180701001";

String orderId2 = "2321837281372914";

String userId2 = "20180701002";

String orderId3 = "2321837281372912";

String userId3 = "20180701003";

String orderId4 = "2321837281372918";

String userId4 = "20180701005";

String orderId5 = "2321837281372918";

String userId5 = "20180701004";

Order order = new Order();

order.setUserId(userId1);

order.setOrderId(orderId1);

Order order1 = new Order();

order1.setOrderId(orderId2);

order1.setUserId(userId2);

Order order2 = new Order();

order2.setOrderId(orderId3);

order2.setUserId(userId3);

Order order3 = new Order();

order3.setOrderId(orderId4);

order3.setUserId(userId4);

Order order4 = new Order();

order4.setOrderId(orderId5);

order4.setUserId(userId5);

List<Order> orderList = new ArrayList<Order>();

orderList.add(order);

orderList.add(order1);

orderList.add(order2);

orderList.add(order3);

orderList.add(order4);

//1.jdk8 lambda排序，带参数类型

orderList.sort(( Order ord1, Order ord2) -> ord2.getOrderId().compareTo(ord1.getOrderId()));

//2.jdk8 lambda排序，不带参数类型

orderList.sort(( ord1, ord2) -> ord2.getOrderId().compareTo(ord1.getOrderId()));

//3.jdk8 升序排序，Comparator提供的静态方法

Collections.sort(orderList, Comparator.comparing(Order::getOrderId));

//4.jdk8 降序排序，Comparator提供的静态方法

Collections.sort(orderList, Comparator.comparing(Order::getOrderId).reversed());

//5.jdk8 组合排序，Comparator提供的静态方法，先按orderId排序，orderId相同的按userId排序

Collections.sort(orderList, Comparator.comparing(Order::getOrderId).reversed().thenComparing(Order::getUserId));

orderList.stream().forEach(str -> System.out.println(str.getOrderId()+"/" + str.getUserId()));

}

}

㈡ java图中代码改用Lambda表达式实现Comparator接口

JDK1.8开始，才支持Lambda表达式的使用，也是JDK1.8的一个重要特性。

Lambda表达式两种使用语法：

1. (参数列表)->表达式

2. (参数列表)->{语句块}

当只有一个参数时候，可以省略圆括号()，多个参数必须使用括号。

参数类型可以不用声明，编译器会自动识别参数类型。

当箭头指向的是一个表达式或者一条语句，则可以省略花括号，如果有return关键字，也可以省略。

Java中能够使用的Lambda表达式的接口，在该接口中只能有一个方法。

Arrays.sort(shapes, (s0, s1) -> {

double difference=s0.area()-s1.area();

return difference==0?0:(difference<0?-1:1);

}
);

㈢ 编写java程序，输入10个成绩，计算最高分、最低分、平均分，并按从小到大排序，统计高于平均分的人数。

Java 8 以上（包含java8） Lambda 方式，这种方式比较简洁，代码如下：

importjava.util.ArrayList;
importjava.util.List;
importjava.util.Scanner;

publicclassApp20{

	publicstaticvoidmain(String[]args){
		
		Scannerscanner=newScanner(System.in);
		
		List<Float>scores=newArrayList<>();
		
		System.out.println("请输入10个人的成绩：");
		
		for(inti=0;i<10;i++){
			scores.add(scanner.nextFloat());
		}
		
		floatmax=scores.stream().max((x,y)->Float.compare(x,y)).get();
		System.out.println("最高分："+max);
		
		floatmin=scores.stream().min((x,y)->Float.compare(x,y)).get();
		System.out.println("最低分："+min);
		
		floataverage=scores.stream().rece(0.0f,Float::sum)/scores.size();
		System.out.println("平均分："+average);
		
		scores.sort((x,y)->Float.compare(x,y));
	
		System.out.println("从小到大分数排序：");
		scores.forEach(s->System.out.print(s+""));
		
		longn=scores.stream().filter(r->r>average).count();
		System.out.println("
高于平均分的有"+n+"个");
	}
}

传统方式，如下：

importjava.util.Arrays;

publicclassApp21{

	publicstaticvoidmain(String[]args){
		
		float[]scores=newfloat[]{10f,9f,8f,7f,6f,5f,4f,3f,2f,1f};
		
		floatmax=Float.MIN_VALUE;
		
		for(floatscore:scores){
			if(score>max){
				max=score;
			}
		}
		
		System.out.println("最高分："+max);
		
		floatmin=Float.MAX_VALUE;
		
		for(floatscore:scores){
			if(score<min){
				min=score;
			}
		}
		
		System.out.println("最低分："+min);
		
		floatsum=0;
		
		for(floatscore:scores){
			sum+=score;
		}
		
		floataverage=sum/scores.length;
		
		
		System.out.println("平均分："+average);
		
		//从小到大排序
		Arrays.sort(scores);
		System.out.println("从小到大分数排序：");
		for(floatscore:scores){
			System.out.print(score+"");
		}
		
		intn=0;
		for(floatscore:scores){
			if(score>average)
				n++;
		}
		
		System.out.println("
高于平均分的有"+n+"个");
	}

}

㈣ java8 函数式编程和lambda的区别

很多编程语言早就引入了Lambda表达式而java语法又比较繁琐,被很多人嫌弃.于是java8新增了特性支持Lambda表达式.例如:不用Lambda表达式写的匿名内部类List names = Arrays.asList("jack", "tom", "jerry");Collections.sort(names, new Comparator() { @Override public int compare(String s1, String s2) { return s2.compareTo(s1); }});采用Lambda表达式简化上面的代码List names = Arrays.asList("jack", "tom", "jerry");Collections.sort(names, (s1, s2) -> s2.compareTo(s1));当然了java8中Lambda表达式还有其他用法,但我比较喜欢它的简洁

㈤ java的lambda表达式应用在哪些场合

例1、用lambda表达式实现Runnable
我开始使用Java 8时，首先做的就是使用lambda表达式替换匿名类，而实现Runnable接口是匿名类的最好示例。看一下Java 8之前的runnable实现方法，需要4行代码，而使用lambda表达式只需要一行代码。我们在这里做了什么呢？那就是用() -> {}代码块替代了整个匿名类。
// Java 8之前：
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("Before Java8, too much code for too little to do");
}
}).start();
//Java 8方式：
new Thread( () -> System.out.println("In Java8, Lambda expression rocks !!") ).start();

输出：
too much code, for too little to do
Lambda expression rocks !!

这个例子向我们展示了Java 8 lambda表达式的语法。你可以使用lambda写出如下代码：
(params) -> expression
(params) -> statement
(params) -> { statements }

例如，如果你的方法不对参数进行修改、重写，只是在控制台打印点东西的话，那么可以这样写：
() -> System.out.println("Hello Lambda Expressions");

如果你的方法接收两个参数，那么可以写成如下这样：
(int even, int odd) -> even + odd

顺便提一句，通常都会把lambda表达式内部变量的名字起得短一些。这样能使代码更简短，放在同一行。所以，在上述代码中，变量名选用a、b或者x、y会比even、odd要好。
例2、使用Java 8 lambda表达式进行事件处理
如果你用过Swing API编程，你就会记得怎样写事件监听代码。这又是一个旧版本简单匿名类的经典用例，但现在可以不这样了。你可以用lambda表达式写出更好的事件监听代码，如下所示：
// Java 8之前：
JButton show = new JButton("Show");
show.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
System.out.println("Event handling without lambda expression is boring");
}
});

// Java 8方式：
show.addActionListener((e) -> {
System.out.println("Light, Camera, Action !! Lambda expressions Rocks");
});

Java开发者经常使用匿名类的另一个地方是为 Collections.sort() 定制 Comparator。在Java 8中，你可以用更可读的lambda表达式换掉丑陋的匿名类。我把这个留做练习，应该不难，可以按照我在使用lambda表达式实现 Runnable 和 ActionListener 的过程中的套路来做。
例3、使用lambda表达式对列表进行迭代

㈥ Java8新特性lambda表达式有什么用

Java 8终于引进了lambda表达式，这标志着Java往函数式编程又迈进了一小步。

在Java 8以前的代码中，为了实现带一个方法的接口，往往需要定义一个匿名类并复写接口方法，代码显得很臃肿。比如常见的Comparator接口：

String[]oldWay="".split("");
Arrays.sort(oldWay,newComparator<String>(){
@Override
publicintcompare(Strings1,Strings2){
//忽略大小写排序:
returns1.toLowerCase().compareTo(s2.toLowerCase());
}
});
System.out.println(String.join(",",oldWay));

对于只有一个方法的接口，在Java 8中，现在可以把它视为一个函数，用lambda表示式简化如下：

String[]newWay="".split("");
Arrays.sort(newWay,(s1,s2)->{
returns1.toLowerCase().compareTo(s2.toLowerCase());
});
System.out.println(String.join(",",newWay));

Java 8没有引入新的关键字lambda，而是用()->{}这个奇怪的符号表示lambda函数。函数类型不需要申明，可以由接口的方法签名自动推导出来，对于上面的lambda函数：

(s1,s2)->{
returns1.toLowerCase().compareTo(s2.toLowerCase());
});

参数由Comparator<String>自动推导出String类型，返回值也必须符合接口的方法签名。

实际上，lambda表达式最终也被编译为一个实现类，不过语法上做了简化。

对于Java自带的标准库里的大量单一方法接口，很多都已经标记为@FunctionalInterface，表明该接口可以作为函数使用。

以Runnable接口为例，很多时候干活的代码还没有定义class的代码多，现在可以用lambda实现：

publicstaticvoidmain(String[]args){
//oldway:
RunnableoldRunnable=newRunnable(){
@Override
publicvoidrun(){
System.out.println(Thread.currentThread().getName()+":OldRunnable");
}
};
RunnablenewRunnable=()->{
System.out.println(Thread.currentThread().getName()+":NewLambdaRunnable");
};
newThread(oldRunnable).start();
newThread(newRunnable).start();
}

在未来的Java代码中，会出现越来越多的()->{}表达式。

㈦ 匿名内部类与lambda表达式

有自定义类就不需要lambda，有lambda就不需要自定义类 humans.sort( (Human h1, Human h2) -> h1.getName().compareTo(h2.getName()));

㈧ java编程：输入某个班学生的成绩，输入-1时，表示输入结束。计算该班的学生人数、最高分、最低分和平均分

1、题目描述：

/*java编程：输入某个班学生的成绩，输入-1时，表示输入结束。计算该班的学生人数、最高分、最低分和平均分*/

分析：

根据题目可知，①需要连续输入数据，并将连续输入的数据保存，②记录输入的数据个数③需要有输入数据内容判断，如果输入-1则停止输入，执行计算。

2、代码如下

	publicstaticvoidmain(String[]args){

		ArrayList<Float>gList=newArrayList<>();//定义浮点型动态数组，用作记录成绩，也可以取数组长度作为人数
		Scannerinput=newScanner(System.in);
		floatgrade=0;
		for(;grade!=-1;){//当输入-1时结束
			System.out.println("请输入学生成绩（-1结束输入）：");
			grade=input.nextFloat();
			if(grade!=-1){//避免最后一次录入-1
				gList.add(grade);
			}
			
		}
			//当输入-1时停止记录数据
		
		
		//求最高分		
		//最低分
		floatmax=0,sum=0,aveg=0;
		floatmin=gList.get(0);//取第一项作为最低分初始值
		for(inti=0;i<gList.size();i++){
		
			if(max<gList.get(i)){
				max=gList.get(i);
			}
			if(min>gList.get(i)){
				min=gList.get(i);
			}
			sum+=gList.get(i);//求总分
		}
		
		//平均分
		aveg=sum/gList.size();
		System.out.println("共有"+gList.size()+"人，"+"最高分："+max
				+",最低分："+min+"，平均分："+aveg);
	
	}

3、运行效果

㈨ java ->是什么意思

java中的不等于，数字之间可以用！=表示，字符串可以用equals方法做比较，如下：

public class TestA {

public static void main(String[] args){
int a=5;
int b=4;
//数字或者对象地址之间不等于可以用！=符号来比较
System.out.println(a!=b);

String str1="hello";
String str2="hi";
String str3="hello";
//字符串之间可以用equals方法来比较
System.out.println(str1.equals(str2));
//true表示相等，false表示不等
System.out.println(str1.equals(str3));

}
}
结果：
true
false
true

㈩ 上课要求jdk版本1.8.0而我的版本是jdk11，有什么区别

jdk版本迭代都是根据上一代进行增添新功能。djk11在1.8版本上只是添加了少许新内容以适应现在互联网技术节奏，除了新添加的内容，两者没有什么影响。也就是，如果不用到新添加的内容，运行不受影响。但是需要知道，有哪些内容是新的。

JDK1.8的新特性：

一、接口的默认方法Java 8允许我们给接口添加一个非抽象的方法实现，只需要使用 default关键字即可，这个特征又叫做扩展方法。

二、Lambda 表达式在Java 8 中你就没必要使用这种传统的匿名对象的方式了，Java 8提供了更简洁的语法，lambda表达式：

Collections.sort(names, (String a, String b) -> {return b.compareTo(a);});

三、函数式接口Lambda表达式是如何在java的类型系统中表示的，每一个lambda表达式都对应一个类型，通常是接口类型。

而“函数式接口”是指仅仅只包含一个抽象方法的接口，每一个该类型的lambda表达式都会被匹配到这个抽象方法。因为默认方法不算抽象方法，所以也可以函数式接口添加默认方法。

四、方法与构造函数引用Java 8 允许你使用 :: 关键字来传递方法或者构造函数引用，上面的代码展示了如何引用一个静态方法，我们也可以引用一个对象的方法：

converter = something::startsWith;

String converted = converter.convert("Java");

System.out.println(converted);

五、Lambda 作用域在lambda表达式中访问外层作用域和老版本的匿名对象中的方式很相似。你可以直接访问标记了final的外层局部变量，或者实例的字段以及静态变量。

六、访问局部变量可以直接在lambda表达式中访问外层的局部变量：

七、访问对象字段与静态变量 和本地变量不同的是，lambda内部对于实例的字段以及静态变量是即可读又可写。该行为和匿名对象是一致的：

八、访问接口的默认方法JDK 1.8 API包含了很多内建的函数式接口，在老Java中常用到的比如Comparator或者Runnable接口，这些接口都增加了@FunctionalInterface注解以便能用在lambda上。

Java 8 API同样还提供了很多全新的函数式接口来让工作更加方便，有一些接口是来自Google Guava库里的，即便你对这些很熟悉了，还是有必要看看这些是如何扩展到lambda上使用的。

(10)javalambdasort扩展阅读：

jdk11新特性：

1、字符串加强

// 判断字符串是否为空白" ".isBlank(); // true// 去除首尾空格" Javastack ".strip(); // "Javastack"// 去除尾部空格 " Javastack ".stripTrailing()。

// 去除首部空格 " Javastack ".stripLeading(); // "Javastack "// 复制字符串"Java".repeat(3); // "JavaJavaJava"// 行数统计"A B C".lines().count(); // 3

2、HttClient Api

这是 Java 9 开始引入的一个处理 HTTP 请求的的孵化 HTTP Client API，该 API 支持同步和异步，而在 Java 11 中已经为正式可用状态，你可以在java.net包中找到这个 Api

3、用于 Lambda 参数的局部变量语法

用于 Lambda 参数的局部变量语法简单来说就是支持类型推导：

var x = new A();for (var x : xs) { ... }try (var x = ...) { ... } catch ...

4、ZGC

从JDK 9开始，JDK使用G1作为默认的垃圾回收器。G1可以说是GC的一个里程碑，G1之前的GC回收，还是基于固定的内存区域，而G1采用了一种“细粒度”的内存管理策略，不在固定的区分内存区域属于surviors、eden、old。

而我们不需要再去对于年轻代使用一种回收策略，老年代使用一种回收策略，取而代之的是一种整体的内存回收策略。

这种回收策略在我们当下cpu、内存、服务规模都越来越大的情况下提供了更好的表现，而这一代ZGC更是有了突破性的进步。

从原理上来理解，ZGC可以看做是G1之上更细粒度的内存管理策略。由于内存的不断分配回收会产生大量的内存碎片空间，因此需要整理策略防止内存空间碎片化。

在整理期间需要将对于内存引用的线程逻辑暂停，这个过程被称为"Stop the world"。只有当整理完成后，线程逻辑才可以继续运行。