Concernant le traitement de certaines données de tableaux, certaines méthodes couramment utilisées sont enregistrées ici pour éviter de les oublier et de les rechercher.
De manière générale, le traitement de certaines listes implique le regroupement, le tri, la fusion, le positionnement, etc. il., Pour vous éviter d'avoir besoin d'utiliser des méthodes "spéciales" pour y parvenir n'est pas seulement gênant, mais pas non plus élégant.
1. Données par lots
Certains traitements de données par lots impliquent un regroupement de données.
List<Integer> list = Arrays.asList(23, 18, 20, 2, 12, 9, 6, 14, 1, 87, 15, 99);
//1、直接分组（推荐）
List<List<Integer>> partition = Lists.partition(list, 10); //10个一组，封装到partition中
//2、可以个人处理
int num = list.size()/10 + list.size()%10==0?0:1; //计算要切割成几份
// 然后使用循环截取。不过要注意的是要和list的大小比较，防止下标溢出
for (int i = 0; i < num; i++) {
if((i+1)*10<list.size()){
List<Integer> integerList = list.subList(i * 10, (i + 1) * 10);
// integerList to do sth
} else {
List<Integer> integerList = list.subList(i * 10, list.size());
// integerList to do sth
}
}
2. Sommation des données
List<Book> bookList = new ArrayList<>();
// BigDecimal类型求和
BigDecimal sum = bookList.stream().map(book -> book.getPrice()).reduce(BigDecimal.ZERO, BigDecimal::add);
// int、double、long类型求和
int sumInt = bookList.stream().mapToInt(book -> book.getWidth()).sum();
long sumLong = bookList.stream().mapToLong(book -> book.getLength()).sum();
double sumDouble = bookList.stream().mapToDouble(book -> book.getHight()).sum();3. Tri personnalisé
//定制排序，可以根据条件定义排序，一个或多个条件均可以，下面适示意的是从大到小排序
// 判断条件是自己写的，可以根据需要来，仿写的话没啥大问题哈
public class Book implements Comparable<Book> {
private String name;
private BigDecimal price ;
private Long length;
private Integer width;
private Double hight;
@Override
public int compareTo(Book o) {
if(o.getWidth()>this.getWidth()){
return 1;
} else if(o.getWidth()<this.getWidth()){
return -1;
}
return 0;
}
}4. Les données sont regroupées par conditions
Je ne sais pas si vous avez rencontré ce problème, mais il est également plus couramment utilisé. Par exemple, si vous trouvez des livres, vous pouvez les regrouper en fonction de la personne où se trouvent les livres. Bien sûr, cela peut également être fait dans la base de données, mais il doit parfois être traité dans le code. Il existe également un lot de sous-requêtes, puis lorsque les données correspondent, c'est un groupe de groupes correspondants.
List<Book> bookList = new ArrayList<>();
Book book = new Book();
book.setWidth(12);
book.setName("Ebook");
bookList.add(book);
Book book1 = new Book();
book1.setWidth(2);
book1.setName("java");
bookList.add(book1);
Book book2 = new Book();
book2.setWidth(17);
book2.setName("java");
bookList.add(book2);
Map<String, List<Book>> groupMap= bookList.stream().collect(Collectors.groupingBy(vo -> vo.getName()));
System.out.println(JSON.toJSONString(groupMap));
L'impression est groupée par nom:
{"java":[{"name":"java","width":2},{"name":"java","width":17}],"Ebook":[{"name":"Ebook","width":12}]}Le processus de regroupement utilise vo -> vo.getName (), vous pouvez implémenter votre propre logique en fonction de vos besoins
5. Les données sont traitées par clé et valeur
Il peut parfois être nécessaire de diviser un objet sous la forme d'une clé et d'une valeur pour faciliter les opérations ultérieures. Il existe également des moyens de résoudre ce problème.
List<Book> bookList = new ArrayList<>();
Book book = new Book();
book.setWidth(12);
book.setName("Ebook");
bookList.add(book);
Book book1 = new Book();
book1.setWidth(2);
book1.setName("java");
bookList.add(book1);
Book book2 = new Book();
book2.setWidth(17);
book2.setName("java");
bookList.add(book2);
// 这个是固定写法，后面的 (p1, p2) -> p2)是指如果有两个value相同，是选择前一个p1,还是选择后一个p2作为map的value,如下，名称java对应的就是后一个了（17），value覆盖
Map<String, Integer> map = bookList.stream().collect(Collectors.toMap(voKey -> voKey.getName(), voValue -> voValue.getWidth(), (p1, p2) -> p2));
System.out.println(JSON.toJSONString(map));Bien entendu, vous pouvez également accumuler ou concaténer des valeurs avec la même clé.
Map<String, Integer> map = bookList.stream().collect(Collectors.toMap(voKey -> voKey.getName(), voValue -> voValue.getWidth(), (p1, p2) -> p1+p2));Supplément: 6. Filtre pour supprimer la duplication
Déduplication selon un champ
List<Book> bookList = new ArrayList<>();
bookList.add(new Book("语文书", "12.3", "张三"));
bookList.add(new Book("语文书", "12.3", "李四"));
bookList.add(new Book("数学书", "16.3", "张三"));
bookList.add(new Book("英语书", "11.3", "王五"));
bookList.add(new Book("数学书", "16.3", "何柳"));
// 过滤掉bookList中 书籍相同的数据
List<Book> resultList = bookList.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() ->
new TreeSet<>(Comparator.comparing(Book::getName))), ArrayList::new));
System.out.println("结果：" + JSONArray.toJSONString(resultList));
Le résultat est imprimé:
结果：[{"author":"张三","name":"数学书","price":"16.3"},{"author":"王五","name":"英语书","price":"11.3"},{"author":"张三","name":"语文书","price":"12.3"}]
Cela dépend de vos propres besoins. Si vous avez besoin d'un autre traitement complexe, vous pouvez également l'implémenter, mais s'il est plus complexe, vous devriez considérer votre propre conception et voir si vous pouvez optimiser la conception ~
Il n'y a que tellement de traitement de liste auquel je pense temporairement, alors ajoutons-le plus tard quand j'y penserai!
Faites-moi un compliment si ça vous va ~
Pas de sacrifice, pas de victoire!