你们好，最近小活发现有诸多的小伙伴们对于jdk1.8新特性有哪些，jdk1 8新特性这个问题都颇为感兴趣的，今天小活为大家梳理了下，一起往下看看吧。

1、1. Create a stream

2、package com.stream.api1;

(资料图片)

3、import java.util.ArrayList;

4、import java.util.Arrays;

5、import java.util.List;

6、import java.util.stream.Stream;

7、import org.junit.Test;

8、/**

9、*一、流程1的三个操作步骤。创建流2。中级操作3。终止操作(终端操作)。

10、*

11、* @author Administrator

12、*

13、*/

14、public class TestStreamAPI1 {

15、//Create a stream

16、@Test

17、public void test1() {

18、//1.可以通过集合系列集合提供的stream()或parallelStream()。

19、ListString list=new ArrayListString();

20、StreamString stream1=list.stream();

21、//2.通过数组中的静态方法stream()获取数组流。

22、Employee[] ems=new Employee[10];

23、StreamEmployee stream2=Arrays.stream(ems);

24、//3.通过Stream类中()的静态方法。

25、StreamString stream3=Stream.of("aa", "bb", "cc", "dd");

26、//4.创造无限的流动

27、StreamInteger stream4=Stream.iterate(0, x - x + 2);

28、//stream4.forEach(System.out:println);

29、stream4.limit(10).forEach(System.out:println);

30、//生成

31、Stream.generate(() - Math.random()).limit(5).forEach(System.out:println);

32、}

33、}

34、2.流过滤和切片

35、package com.stream.api2;

36、import java.util.Arrays;

37、import java.util.Iterator;

38、import java.util.List;

39、import java.util.stream.Stream;

40、import org.junit.Test;

41、import com.stream.api1.Employee;

42、/**

43、*一、流程1的三个操作步骤。创建流2。中级操作3。终止操作(终端操作)。

44、*

45、* @author Administrator

46、*

47、*/

48、public class TestStreamAPI2 {

49、列出雇员雇员=数组。阿斯利斯特(新雇员("张三，12,1200.99),新员工("小明" 15, 4500.99),

50、New employees ("Xiaoli, 16,5500.99), new employees ("Wang Er, 32,1100.99), new employees ("Erhu" 22, 9825.99),

51、New employees ("Li Jing, 18,4502.99), new employees ("Xiaosan, 17, 1469.99), new employees ("Xiaosan" 17,1469.99),

52、New employees ("Little Three, 17, 1469.99), new employees ("Little Three" 17,1469.99));

53、//中间操作

54、/**

55、*过滤和切片过滤器——接收Lambda并从流中排除一些元素。limit ——截断流，使其元素不超过给定的数目。跳过(n) ——

56、*跳过元素并返回一个流，其中前n个元素被丢弃。如果流中的元素少于n个，则返回一个空流。不同的——与极限(n)互补

57、*过滤，通过流生成的元素的hashCode()和equals()去除重复元素。

58、*

59、*

60、*注意：使用distinct进行复制需要重写hashcode和equals方法。

61、*/

62、//内部迭代：迭代操作由Stream API完成。

63、@Test

64、public void test1() {

65、//中间操作：不执行任何操作。

66、StreamEmployee stream1=employees.stream().filter((e) - {

67、Stream API intermediate operation");

68、return e.getAge() 17;

69、});

70、//终止操作：一次性执行所有内容，即“懒求值”。

71、stream1.forEach(System.out:println);

72、}

73、//外部迭代

74、@Test

75、public void test2() {

76、IteratorEmployee it=employees.iterator();

77、while (it.hasNext()) {

78、System.out.println(it.next());

79、}

80、}

81、//短路，limit一旦找到合适的数据将不再继续执行，一定程度上提高了性能

82、@Test

83、public void test3() {

84、employees.stream().filter((e) - {

85、System.out.println("短路！");

86、return e.getSalary() 5000;

87、}).limit(2).forEach(System.out:println);

88、;

89、}

90、@Test

91、public void test4() {

92、employees.stream().filter((e) - e.getSalary() 1000).skip(2).limit(2).forEach(System.out:println);

93、;

94、}

95、@Test

96、public void test5() {

97、employees.stream().filter((e) - e.getSalary() 1000).skip(2).distinct().forEach(System.out:println);

98、;

99、}

100、}

101、/3、Stream映射

102、package com.stream.api3;

103、import java.util.ArrayList;

104、import java.util.Arrays;

105、import java.util.List;

106、import java.util.stream.Stream;

107、import org.junit.Test;

108、import com.stream.api1.Employee;

109、public class TestStreamAPI3 {

110、ListEmployee employees=Arrays.asList(new Employee("张三", 12, 1200.99), new Employee("小明", 15, 4500.99),

111、new Employee("小丽", 16, 5500.99), new Employee("王二", 32, 1100.99), new Employee("二虎", 22, 9825.99),

112、new Employee("李静", 18, 4502.99), new Employee("小三", 17, 1469.99), new Employee("小三", 17, 1469.99),

113、new Employee("小三", 17, 1469.99), new Employee("小三", 17, 1469.99));

114、/**

115、*

116、* 映射map —— Lambda，将元素转换成其它形式或提取信息，接收一个函数作为参数，改函数会被应用到每个元素上， 并将其映射成一个新的元素。

117、* flatMap —— 接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有的流连城一个流。

118、*/

119、@Test

120、public void test6() {

121、ListString list=Arrays.asList("aaa", "bbb", "bbb", "ddd");

122、list.stream().map((str) - str.toUpperCase()).forEach(System.out:println);

123、System.out.println("---------------------------");

124、employees.stream().map(Employee:getName).forEach(System.out:println);

125、System.out.println("---------------------------");

126、StreamStreamCharacter stream=list.stream().map(TestStreamAPI3:filterCharacter);

127、stream.forEach((sm) - {

128、sm.forEach(System.out:println);

129、});

130、System.out.println("---------------------------");

131、StreamCharacter stream2=list.stream().flatMap(TestStreamAPI3:filterCharacter);

132、stream2.forEach(System.out:println);

133、}

134、public static StreamCharacter filterCharacter(String str) {//add(Object obj) addAll(collection coll)

135、ListCharacter list=new ArrayList();

136、for (Character character : str.toCharArray()) {

137、list.add(character);

138、}

139、return list.stream();

140、}

141、}

142、4、Stream排序

143、package com.stream.api4;

144、import java.util.Arrays;

145、import java.util.List;

146、import org.junit.Test;

147、import com.stream.api1.Employee;

148、public class TestStreamAPI4 {

149、ListEmployee employees=Arrays.asList(new Employee("张三", 12, 1200.99), new Employee("小明", 15, 4500.99),

150、new Employee("小丽", 16, 5500.99), new Employee("王二", 32, 1100.99), new Employee("二虎", 22, 9825.99),

151、new Employee("李静", 18, 4502.99), new Employee("小三", 17, 1469.99), new Employee("小三", 17, 1469.99),

152、new Employee("小三", 17, 1469.99), new Employee("小三", 17, 1469.99));

153、/**

154、* 排序sorted() —— 自然排序(Comparable) sorted(Comparater com) —— 定制排序(Comparater)

155、*/

156、@Test

157、public void test1() {

158、ListString list=Arrays.asList("ccc", "aaa", "bbb", "ddd", "eee");

159、list.stream().sorted().forEach(System.out:println);

160、System.out.println("--------------------------------------------");

161、employees.stream().sorted((e1, e2) - {

162、if (e1.getAge()==e2.getAge()) {

163、return e1.getName().compareTo(e2.getName());

164、} else {

165、return Integer.compare(e1.getAge(), e2.getAge());

166、}

167、}).forEach(System.out:println);

168、}

169、}

170、5、Stream查找与匹配

171、package com.stream.api5;

172、import java.util.Arrays;

173、import java.util.List;

174、import java.util.Optional;

175、import org.junit.Test;

176、import com.stream.api1.Employee;

177、import com.stream.api1.Employee.Status;

178、public class TestStreamAPI5 {

179、ListEmployee employees=Arrays.asList(new Employee("张三", 12, 1200.99, Status.BUSY),

180、new Employee("小明", 15, 4500.99, Status.BUSY), new Employee("小丽", 16, 5500.99, Status.BUSY),

181、new Employee("王二", 32, 1100.99, Status.FREE), new Employee("二虎", 22, 9825.99, Status.FREE),

182、new Employee("李静", 18, 4502.99, Status.FREE), new Employee("小三", 17, 1469.99, Status.VOCATION),

183、new Employee("小三", 17, 1469.99, Status.VOCATION), new Employee("小三", 17, 1469.99, Status.VOCATION),

184、new Employee("小三", 17, 1469.99, Status.VOCATION));

185、/**

186、* 查找与匹配allMatch —— 检查是否平匹配所有元素anyMatch —— 检查是否至少匹配一个元素noneMatch ——

187、* 检查是否没有匹配的元素findFirst —— 返回第一个元素findAny —— 返回当前流中的任意元素count —— 返回流中元素的总个数

188、* max —— 返回流中最大值min —— 返回流中最小值

189、*/

190、@Test

191、public void test1() {

192、boolean b1=employees.stream().allMatch(e - e.getStatus().equals(Status.BUSY));

193、System.out.println(b1);

194、boolean b2=employees.stream().anyMatch((e) - e.getStatus().equals(Status.BUSY));

195、System.out.println(b2);

196、boolean b3=employees.stream().noneMatch((e) - e.getStatus().equals(Status.BUSY));

197、System.out.println(b3);

198、OptionalEmployee op1=employees.stream().sorted((e1, e2) - -Double.compare(e1.getSalary(), e2.getSalary()))

199、.findFirst();

200、System.out.println(op1.get());

201、OptionalEmployee op2=employees.stream().filter((e) - e.getStatus().equals(Status.FREE)).findAny();

202、System.out.println(op2.get());

203、OptionalEmployee op3=employees.parallelStream().filter((e) - e.getStatus().equals(Status.FREE)).findAny();

204、System.out.println(op3.get());

205、}

206、@Test

207、public void test2() {

208、Long count=employees.stream().count();

209、System.out.println(count);

210、OptionalEmployee op1=employees.stream().max((e1, e2) - Double.compare(e1.getSalary(), e2.getSalary()));

211、System.out.println(op1.get());

212、OptionalDouble op2=employees.stream().map(Employee:getSalary).max(Double:compare);

213、System.out.println(op2.get());

214、}

215、}

216、6、Stream约与收集归

217、package com.stream.api6;

218、import java.util.Arrays;

219、import java.util.DoubleSummaryStatistics;

220、import java.util.HashSet;

221、import java.util.List;

222、import java.util.Map;

223、import java.util.Optional;

224、import java.util.Set;

225、import java.util.stream.Collectors;

226、import org.junit.Test;

227、import com.stream.api1.Employee;

228、import com.stream.api1.Employee.Status;

229、public class TestStreamAPI6 {

230、ListEmployee employees=Arrays.asList(new Employee("张三", 12, 1200.99, Status.BUSY),

231、new Employee("小明", 15, 4500.99, Status.BUSY), new Employee("小丽", 16, 5500.99, Status.BUSY),

232、new Employee("王二", 32, 1100.99, Status.FREE), new Employee("二虎", 22, 9825.99, Status.FREE),

233、new Employee("李静", 18, 4502.99, Status.FREE), new Employee("小三", 17, 1469.99, Status.VOCATION),

234、new Employee("小三", 17, 1469.99, Status.VOCATION), new Employee("小三", 17, 1469.99, Status.VOCATION),

235、new Employee("小三", 17, 1469.99, Status.VOCATION));

236、/**

237、* 归约reduce(T identity,BinaryOperator)/reduce(BinaryOperator) ——

238、* 可以将流中元素反复结合起来，得到一个值

239、*/

240、@Test

241、public void test1() {

242、ListInteger list=Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

243、Integer sum=list.stream().reduce(0, (x, y) - x + y);

244、System.out.println(sum);

245、System.out.println("-------------------------------------------");

246、OptionalDouble op1=employees.stream().map(Employee:getSalary).reduce(Double:sum);

247、System.out.println(op1.get());

248、}

249、/**

250、* 收集collect —— 将流转换为其它形式，接收一个Collector接口的实现，用于给Stream中元素做汇总的方法

251、*/

252、@Test

253、public void test2() {

254、ListString list=employees.stream().map(Employee:getName).collect(Collectors.toList());

255、list.forEach(System.out:println);

256、System.out.println("-----------------------");

257、SetString set=employees.stream().map(Employee:getName).collect(Collectors.toSet());

258、set.forEach(System.out:println);

259、System.out.println("-----------------------");

260、HashSetString hashSet=employees.stream().map(Employee:getName)

261、.collect(Collectors.toCollection(HashSet:new));

262、hashSet.forEach(System.out:println);

263、}

264、@Test

265、public void test3() {

266、//总数

267、Long count=employees.stream().collect(Collectors.counting());

268、System.out.println(count);

269、System.out.println("-----------------------");

270、//平均值

271、Double avg=employees.stream().collect(Collectors.averagingDouble(Employee:getSalary));

272、System.out.println(avg);

273、System.out.println("-----------------------");

274、//总和

275、Double sum=employees.stream().collect(Collectors.summingDouble(Employee:getSalary));

276、System.out.println(sum);

277、System.out.println("-----------------------");

278、//最大值

279、OptionalEmployee max=employees.stream()

280、.collect(Collectors.maxBy((e1, e2) - Double.compare(e1.getSalary(), e2.getSalary())));

281、System.out.println(max.get());

282、System.out.println("-----------------------");

283、//最大值

284、OptionalEmployee min=employees.stream()

285、.collect(Collectors.minBy((e1, e2) - Double.compare(e1.getSalary(), e2.getSalary())));

286、System.out.println(min.get());

287、}

288、//分组

289、@Test

290、public void test4() {

291、MapStatus, ListEmployee map=employees.stream().collect(Collectors.groupingBy(Employee:getStatus));

292、System.out.println(map);

293、}

294、//多级分组

295、@Test

296、public void test5() {

297、MapStatus, MapString, ListEmployee map=employees.stream()

298、.collect(Collectors.groupingBy(Employee:getStatus, Collectors.groupingBy((e) - {

299、if (e.getAge() 16) {

300、return "青年";

301、} else if (e.getAge() 18) {

302、return "中年";

303、} else {

304、return "老年";

305、}

306、})));

307、System.out.println(map);

308、}

309、//分区

310、@Test

311、public void test6() {

312、MapBoolean, ListEmployee map=employees.stream()

313、.collect(Collectors.partitioningBy(e - e.getSalary() 5000));

314、System.out.println(map);

315、}

316、@Test

317、public void test7() {

318、DoubleSummaryStatistics collect=employees.stream().collect(Collectors.summarizingDouble(Employee:getSalary));

319、System.out.println(collect.getAverage());

320、System.out.println(collect.getCount());

321、System.out.println(collect.getMax());

322、System.out.println(collect.getMin());

323、System.out.println(collect.getSum());

324、}

325、@Test

326、public void test8() {

327、String str1=employees.stream().map(Employee:getName).collect(Collectors.joining());

328、System.out.println(str1);

329、System.out.println("---------------------------------");

330、String str2=employees.stream().map(Employee:getName).collect(Collectors.joining(","));

331、System.out.println(str2);

332、System.out.println("---------------------------------");

333、String str3=employees.stream().map(Employee:getName).collect(Collectors.joining(",", "===", "==="));

334、System.out.println(str3);

335、}

336、}

337、7、Stream约练习

以上就是jdk1 8新特性这篇文章的一些介绍，希望对大家有所帮助。