lsm/hutool
1
0
Fork 0
mirror of https://gitee.com/dromara/hutool.git synced 2025-05-03 12:18:01 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

!1240 优化 IndexedComparator性能，它在ExcelWriter带别名写入存在性能问题

Browse Source 
Merge pull request !1240 from mochouZero555/v5-dev
This commit is contained in:
Looly 2024-07-30 03:03:00 +00:00 committed by Gitee
commit f7fa704d6c
No known key found for this signature in database
GPG Key ID: 173E9B9CA92EEF8F
3 changed files with 179 additions and 10 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
hutool-core/src/main/java/cn/hutool/core/comparator/IndexedComparator.java
View File

@ -1,9 +1,10 @@
package cn.hutool.core.comparator;
import cn.hutool.core.lang.Assert;
import cn.hutool.core.util.ArrayUtil;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
/**
* 按照数组的顺序正序排列，数组的元素位置决定了对象的排序先后<br>
@ -16,7 +17,10 @@ import java.util.Comparator;
public class IndexedComparator<T> implements Comparator<T> {
private final boolean atEndIfMiss;
private final T[] array;
/**
* map存储对象类型所在列表的位置,k为对象，v为位置
*/
private final Map<? super T, Integer> map;
/**
* 构造
@ -28,6 +32,19 @@ public class IndexedComparator<T> implements Comparator<T> {
this(false, objs);
}
/**
* 构造
*
* @param atEndIfMiss 如果不在列表中是否排在后边
* @param map 参与排序的map，map中的value值大小决定了对象的排序先后
*/
@SuppressWarnings("unchecked")
private IndexedComparator(boolean atEndIfMiss, Map<? super T, Integer> map) {
this.atEndIfMiss = atEndIfMiss;
this.map = map;
}
/**
* 构造
*
@ -38,7 +55,10 @@ public class IndexedComparator<T> implements Comparator<T> {
public IndexedComparator(boolean atEndIfMiss, T... objs) {
Assert.notNull(objs, "'objs' array must not be null");
this.atEndIfMiss = atEndIfMiss;
this.array = objs;
map = new HashMap<>(1 + (int) (objs.length / 0.75));
for (int i = 0; i < objs.length; i++) {
map.put(objs[i], i);
}
}
@Override
@ -47,8 +67,8 @@ public class IndexedComparator<T> implements Comparator<T> {
final int index2 = getOrder(o2);
if (index1 == index2) {
if (index1 < 0 || index1 == this.array.length) {
// 任意一个元素不在列表中, 返回原顺序
if (index1 < 0 || index1 == this.map.size()) {
// 任意一个元素不在map中, 返回原顺序
return 1;
}
@ -60,15 +80,15 @@ public class IndexedComparator<T> implements Comparator<T> {
}
/**
* 查找对象类型所在列表的位置
* 查找对象类型所对应的顺序值,即在原列表中的顺序
*
* @param object 对象
* @return 位置，未找到位置根据{@link #atEndIfMiss}取不同值，false返回-1，否则返回列表长度
* @return 位置，未找到位置根据{@link #atEndIfMiss}取不同值，false返回-1，否则返回map长度
*/
private int getOrder(T object) {
int order = ArrayUtil.indexOf(array, object);
if (order < 0) {
order = this.atEndIfMiss ? this.array.length : -1;
Integer order = map.get(object);
if (order == null) {
order = this.atEndIfMiss ? this.map.size() : -1;
}
return order;
}

75
hutool-core/src/test/java/cn/hutool/core/comparator/ArrayIndexedComparator.java Normal file
View File

@ -0,0 +1,75 @@
package cn.hutool.core.comparator;
import cn.hutool.core.lang.Assert;
import cn.hutool.core.util.ArrayUtil;
import java.util.Comparator;
/**
* 按照数组的顺序正序排列，数组的元素位置决定了对象的排序先后<br>
* 默认的，如果参与排序的元素并不在数组中，则排序在前（可以通过atEndIfMiss设置)
*
* @param <T> 被排序元素类型
* @author looly
* @since 4.1.5
*/
public class ArrayIndexedComparator<T> implements Comparator<T> {
private final boolean atEndIfMiss;
private final T[] array;
/**
* 构造
*
* @param objs 参与排序的数组，数组的元素位置决定了对象的排序先后
*/
@SuppressWarnings("unchecked")
public ArrayIndexedComparator(T... objs) {
this(false, objs);
}
/**
* 构造
*
* @param atEndIfMiss 如果不在列表中是否排在后边
* @param objs 参与排序的数组，数组的元素位置决定了对象的排序先后
*/
@SuppressWarnings("unchecked")
public ArrayIndexedComparator(boolean atEndIfMiss, T... objs) {
Assert.notNull(objs, "'objs' array must not be null");
this.atEndIfMiss = atEndIfMiss;
this.array = objs;
}
@Override
public int compare(T o1, T o2) {
final int index1 = getOrder(o1);
final int index2 = getOrder(o2);
if (index1 == index2) {
if (index1 < 0 || index1 == this.array.length) {
// 任意一个元素不在列表中, 返回原顺序
return 1;
}
// 位置一样，认为是同一个元素
return 0;
}
return Integer.compare(index1, index2);
}
/**
* 查找对象类型所在列表的位置
*
* @param object 对象
* @return 位置，未找到位置根据{@link #atEndIfMiss}取不同值，false返回-1，否则返回列表长度
*/
private int getOrder(T object) {
int order = ArrayUtil.indexOf(array, object);
if (order < 0) {
order = this.atEndIfMiss ? this.array.length : -1;
}
return order;
}
}

74
hutool-core/src/test/java/cn/hutool/core/comparator/IndexedComparatorTest.java Normal file
View File

@ -0,0 +1,74 @@
package cn.hutool.core.comparator;
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.date.StopWatch;
import cn.hutool.core.lang.Console;
import lombok.AllArgsConstructor;
import lombok.Data;
import org.junit.Assert;
import org.junit.Ignore;
import org.junit.Test;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
public class IndexedComparatorTest {
@Test
public void sortTest() {
final Object[] arr ={"a", "b", new User("9", null), "1",3,null,"2"};
final Collection<Object> set = new HashSet<>(Arrays.asList(arr));
final List<Object> sortSet = CollectionUtil.sort(set, new ArrayIndexedComparator<>(arr));
Assert.assertEquals("a", sortSet.get(0));
Assert.assertEquals( new User("9", null), sortSet.get(2));
Assert.assertEquals(3, sortSet.get(4));
Assert.assertNull(sortSet.get(5));
}
@Test
public void reversedTest() {
final Object[] arr ={"a", "b", new User("9", null), "1",3,null,"2"};
final Collection<Object> set = new HashSet<>(Arrays.asList(arr));
final List<Object> sortSet = CollectionUtil.sort(set, new ArrayIndexedComparator<>(arr).reversed());
Assert.assertEquals("a", sortSet.get(6));
Assert.assertNull(sortSet.get(1));
Assert.assertEquals( new User("9", null), sortSet.get(4));
Assert.assertEquals(3, sortSet.get(2));
}
@Test
@Ignore
public void benchmarkSortTest() {
final Object[] arr ={"a", "b", new User("9", null), "1",3,null,"2"};
final Collection<Object> set = new HashSet<>(Arrays.asList(arr));
final StopWatch stopWatch = new StopWatch();
stopWatch.start();
for (int i = 0; i < 10_000_000; i++) {
final List<Object> sortSet = CollectionUtil.sort(set, new IndexedComparator<>(arr));
}
stopWatch.stop();
stopWatch.start();
for (int i = 0; i < 10_000_000; i++) {
final List<Object> sortSet = CollectionUtil.sort(set, new ArrayIndexedComparator<>(arr));
}
stopWatch.stop();
Console.log(stopWatch.prettyPrint());
}
@Data
@AllArgsConstructor
static class User{
private String a;
private String b;
}
}