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"。只有當整理完成後，線程邏輯才可以繼續運行。