Question

我有List<Size> sizes = new ArrayList<>();。此列表是摄像机图片的质量。

以下是尺寸列表的结果：

我想要得到3xxx的第一个结果，2xxx的第一个结果和1xxx的第一个结果，如：

仅凭此结果我该怎么做才能删除或创建新数组？

最后，我找到了一个解决方案，问题只是j：

for (int j = 0; j < sizes.size(); j++){
    if ( j + 1 < sizes.size() ){
        if( String.valueOf(sizes.get(j).getWidth()).charAt(0) == String.valueOf(sizes.get(j + 1).getWidth()).charAt(0) ){
            sizes.remove(j+1);
            j = j-1;
        }
    }
    //Log.d(TAG, sizes.get(j).toString() );
}

结果是：

Answer 1

我用String代替了大小不明的大小

List<String> filtered = new ArrayList<>();
      List<Character> firstchar = new ArrayList<>();
      List<String> sizes = new ArrayList<>();

      for(String size:sizes){
          if(!firstchar.contains(size.charAt(0))){
              filtered.add(size);
              firstchar.add(size.charAt(0));
          }
      }
      for(String elem:filtered){
          System.out.println(elem);
      }

Answer 2

正如我在评论中提到的，我根据以下内容实施了此案。你可以测试一下。我的想法是根据第一个字符覆盖Size对象的equals和hashcode方法，并在遍历size列表的同时调用list的contains方法将其放在新列表中。如果列表包含方法返回false，则添加否则不添加。这样，您可以按首字符分组

 public class Size {
        private String dimension;

        public Size(String dimension) {
            this.dimension = dimension;
        }

        public String getDimension() {
            return dimension;
        }

        public void setDimension(String dimension) {
            this.dimension = dimension;
        }

        public String getDimensionFirstPart() {
            return this.dimension.split("x")[0];
        }
        @Override
        public int hashCode() {
            final int prime = 31;
            int result = 1;
            result = prime * result + ((dimension == null) ? 0 : dimension.hashCode());
            return result;
        }

        @Override
        public boolean equals(Object obj) {
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            Size other = (Size) obj;
            if (dimension == null) {
                if (other.dimension != null)
                    return false;
            } 
            else if (getDimensionFirstPart().length() == other.getDimensionFirstPart().length() && 
                    getDimensionFirstPart().charAt(0) == other.getDimensionFirstPart().charAt(0))
                return true;
            return false;
        }
        @Override
        public String toString() {
            return dimension;
        }
    }

测试类

public class Test {
    public static void main(String[] args) {
        Size size1 = new Size("3264x2448");
        Size size2 = new Size("3264x1836");
        Size size3 = new Size("2880x2160");
        Size size4 = new Size("2560x1440");
        Size size5 = new Size("2048x1152");
        Size size6 = new Size("1920x1080");
        Size size7 = new Size("1440x1080");
        Size size8 = new Size("1280x720");
        Size size9 = new Size("320x240");
        Size size10 = new Size("352x288");
        Size size11 = new Size("960x720");
        Size size12 = new Size("800x450");

        List<Size> sizes = new ArrayList<Size>();
        sizes.add(size1);sizes.add(size2);sizes.add(size3);sizes.add(size4);sizes.add(size5);sizes.add(size6);sizes.add(size7);sizes.add(size8);
        sizes.add(size9);sizes.add(size10);sizes.add(size11);sizes.add(size12);
        List<Size> newSizes = new ArrayList<Size>();
        for(Size size: sizes) {
            if(!newSizes.contains(size)) {
                newSizes.add(size);
            }
        }
        System.out.println(newSizes);
    }
}

Answer 3

保持极限值（多为1000），并且每次更改极限值时仅添加一个元素。

List<Size> selected = new ArrayList<>();
int limit = Integer.MAX_VALUE;

for (Size size : sizes) {
  if (limit == 0) { break; }
  int width = size.getWidth();
  if (width < limit && width >= 1000) {
    selected.add(size);
    limit = (width / 1000) * 1000;
  }
}

Answer 4

您可以使用regex和stream（Java 8及更高版本）来过滤项目并创建包含所需项目的新列表

假设您的Size对象为

public class Size {
    private String size;

    Size(String s) {
        this.size = s;
    }

    public String getSize() {
        return size;
    }
}

您可以编写以下逻辑

String threeSeries = "3[\\d]{3}x[\\d]{4}";
String twoSeries = "2[\\d]{3}x[\\d]{4}";
String oneSeries = "1[\\d]{3}x[\\d]{3,4}";

List<Size> result = new ArrayList<>();

result.add(sizes.stream().filter((s) -> s.getSize().matches(threeSeries)).findFirst().get());
result.add(sizes.stream().filter((s) -> s.getSize().matches(twoSeries)).findFirst().get());
result.add(sizes.stream().filter((s) -> s.getSize().matches(oneSeries)).findFirst().get());

result.addAll(sizes.stream().filter(
        (s) -> !s.getSize().matches(threeSeries) && !s.getSize().matches(twoSeries) && !s.getSize().matches(oneSeries))
        .collect(Collectors.toList()));

result.forEach((s) -> System.out.println(s.getSize()));

Answer 5

您可以浏览列表，并跟踪已经添加到列表中的Nxxx值，并且仅在尚未添加其相应掩码的情况下添加Size。遵循以下原则：

List<Size> resultList = new ArrayList<>();
List<String> maskAlreadyInList = new ArrayList<>();
int width;
String widthAsString, mask;
StringBuilder maskBuilder;
for(Size s : sizes) {
    width = s.getWidth();
    widthAsString = String.valueOf(width);
    maskBuilder = new StringBuilder(""+widthAsString.charAt(0));
    for(int i = 1; i < widthAsString.length(); i++) {
        maskBuilder.append("x");
    }
    mask = maskBuilder.toString();

    if (!maskAlreadyInList.contains(mask)) {
        resultList.add(s);
        maskAlreadyInList.add(mask);
    }
}

resultList.forEach(System.out::println);

输出

Size{width=3264, height=2448}
Size{width=2880, height=2160}
Size{width=1920, height=1080}
Size{width=960, height=720}
Size{width=800, height=450}
Size{width=720, height=480}
Size{width=640, height=480}
Size{width=352, height=288}

注意：

为Size对象使用toString的定义

@Override
public String toString() {
    return "Size{width="+width+", height="+height +"}";
}

解决了在数组列表java

5 个答案: