自增 list

  • 采用 Collections.sort() 方法的 list，不管是添加时 sort 还是添加完后再 sort，都很慢
    • 但是遍历时被如果被其他线程修改，可能会导致 modCount 异常
  • 采用 Collections.BinarySearch() 方法的 list，速度快一点
    • 但是遍历时被如果被其他线程修改，可能会导致 modCount 异常
  • CopyOnWriteArray 提供快照读功能，即迭代时 modCount 使用的是旧数组的；但是会写时复制，大量单独插入不适用

  • treeSet **同样数据量，treeSet 添加在 0.05m 左右; **add 时间效率高，且查找元素，是基于类似二分搜索树的结构，效率更高 ```java static List sortList = new ArrayList() {

    1.   @Override
    2.   public boolean add(Long o) {
    3.       boolean ret = super.add(o);
    4.       if (ret) {
    5.           this.sort(Comparator.comparing(AdvancedMail::getId));
    6.       }
    7.       return ret;
    8.   }

    };

    static List binaryList = new ArrayList() {

    1.   @Override
    2.   public boolean add(Long o) {
    3.       int index = Collections.binarySearch(
    4.           this, mail, Comparator.comparing(AdvancedMail::getId));
    5.       if (index < 0) {
    6.           index = ~index;
    7.       }
    8.       super.add(index, o);
    9.       return true;
    11.   }

    };

    static List arrayList = new ArrayList<>();

    static Set treeSet = new TreeSet<>();

    public static void main(String[] args) throws RunnerException {

    1.   int size = 100000;
    2.   List<Long> longs = readFromFile(new File("data.txt"), size);
    3.   Stopwatch stopwatch = Stopwatch.createStarted();
    5.   for (int i = 0; i < size; i++) {
    6.       // 13s
    7.       // sortList.add(longs.get(i));
    8.       // 0.5s
    9.       binaryList.add(longs.get(i));
    10.       // 0.06s
    11.       treeSet.add(longs.get(i));
    12.       // 0.008s + 排序 约等于 13s
    13.       arrayList.add(longs.get(i));
    14.       arrayList.sort(Comparator.comparing(AdvancedMail::getId));
    15.   }
    17.   stopwatch.stop();
    18.   System.out.println(stopwatch.elapsed(TimeUnit.MILLISECONDS));

    }

    public static boolean checkSame(List beforeList, List afterList) {

    1.   beforeList.sort(Comparator.comparing(AdvancedMail::getId));
    3.  if (afterList instanceof List) {
    4.       List<Long> tempList = (ArrayList<Long>) afterList;
    5.       for (int i = 0; i < beforeList.size(); i++) {
    6.           if (!(beforeList.get(i).equals(tempList.get(i)))) {
    7.               return false;
    8.           }
    9.       }
    10.   } else if (afterList instanceof Set) {
    11.       Set<Long> tempSet = (TreeSet<Long>) afterList;
    12.       int i = 0;
    13.       for (Long aLong : tempSet) {
    14.           if (!beforeList.get(i).equals(aLong)) {
    15.               return false;
    16.           }
    17.           i++;
    18.       }
    19.   }
    21.   return true;

    }

  1. public static void writeText(File file, int size) {
  2.     try (OutputStream outputStream = new FileOutputStream(file)) {
  3.         for (int i = 0; i < size; i++) {
  4.             outputStream.write(String.valueOf(ThreadLocalRandom.current().nextLong()).getBytes());
  5.             if (i != size - 1) {
  6.                 outputStream.write(",".getBytes());
  7.             }
  8.         }
  9.     } catch (Exception e) {
  10.         e.printStackTrace();
  11.     }
  12. }
  14. public static List<Long> readFromFile(File file, int size) {
  15.     List<Long> dataList = new ArrayList<>(size);
  16.     try {
  17.         List<String> contentList = Files.readAllLines(Paths.get(file.getName()));
  18.         String str = contentList.get(0);
  19.         String[] split = str.split(",");
  20.         for (int i = 0; i < size; i++) {
  21.             dataList.add(Long.parseLong(split[i]));
  22.         }
  23.     } catch (IOException e) {
  24.         e.printStackTrace();
  25.     }
  26.     return dataList;
  27. }
  3. ---
  6. <a name="yID9D"></a>
  7. ## 比较器创建
  9. - java8 提供比较器创建，下面是其中之一
  10. > public static _<_T, U extends Comparable_<_? super U_>> _Comparator_<_T_> _comparing (
  11. > _ _Function_<_? super T, ? extends U_> _keyExtractor) {}
  14. `Comparator.comparing(AdvancedMail::getId)` 表示按照 AdvancedMail#getId() 自然排序，类似生成了下面的 lambda
  15. ```java
  16. ((o1, o2) -> {
  17.     if (o1.getId() > o2.getId()) {
  18.         return 1;
  19.     } else if (o1.getId().equals(o2.getId())) {
  20.         return 0;
  21.     } else {
  22.         return -1;
  23.     }
  24. })

如果需要自定义排序，则使用下面这个重载方法

public static <_T, U> Comparator<_T_> comparing( Function<_? super T, ? extends U_> keyExtractor, Comparator<_? super U_> _keyComparator)

将排序 lambda 进行书写类似

list分组

  • groupingBy 返回一个map，key 是 分组标志，value 是分组结果
    1. Map<String, List<Entrance>> collect = entrances.stream().collect(Collectors.groupingBy(Entrance::getFlag));
    2.       collect.forEach((k,v)->{
    3.           for (Entrance entrance1 : v) {
    4.               if (entrance1.lock) {
    5.                   entrance1.needShow = true;
    6.                   return;
    7.               }
    8.           }
    9.       });