JavaScript前端：识别数组连续重复属性并为元素追加指定前缀

实现思路 #

1. 遍历数组时跟踪当前连续相同TranslatedText的分组，记录分组的起始下标和对应值
2. 当遇到TranslatedText和当前分组值不同时，判断当前分组长度是否≥2：如果是，就给该分组内所有元素的展示字段追加Rep - 前缀
3. 遍历结束后单独判断最后一个分组是否符合条件，做相同处理

JavaScript 实现示例 #

const FinalArray = [
  {ColumnName:'Name',ID:6,TranslatedText:'Name',Category:'Assigned Employee'},
  {ColumnName:'Name',ID:7,TranslatedText:'Name',Category:'Requested Employee'},
  {ColumnName:'Designation',ID:8,TranslatedText:'Designation',Category:'Employee'},
  {ColumnName:'Occupation',ID:9,TranslatedText:'Occupation',Category:'Assigned Employee'},
  {ColumnName:'Occupation',ID:10,TranslatedText:'Occupation',Category:'Requested Employee'}
];

function addRepPrefix(arr) {
  if (arr.length < 2) return arr;
  let currentText = arr[0].TranslatedText;
  let startIndex = 0;
  
  for (let i = 1; i < arr.length; i++) {
    if (arr[i].TranslatedText !== currentText) {
      if (i - startIndex >= 2) {
        for (let j = startIndex; j < i; j++) {
          arr[j].showText = `Rep - ${arr[j].TranslatedText}`;
        }
      } else {
        arr[startIndex].showText = arr[startIndex].TranslatedText;
      }
      currentText = arr[i].TranslatedText;
      startIndex = i;
    }
  }
  
  // 处理最后一个分组
  if (arr.length - startIndex >= 2) {
    for (let j = startIndex; j < arr.length; j++) {
      arr[j].showText = `Rep - ${arr[j].TranslatedText}`;
    }
  } else {
    arr[startIndex].showText = arr[startIndex].TranslatedText;
  }
  return arr;
}

// 渲染时直接使用返回结果的showText字段即可
const processedArr = addRepPrefix(FinalArray);

Java 实现示例 #

首先定义实体类：

class EmployeeField {
    private String columnName;
    private Integer id;
    private String translatedText;
    private String category;
    // 新增展示用字段，也可以直接修改translatedText属性
    private String showText;

    // 构造方法、getter、setter自行补充
}

处理逻辑代码：

import java.util.ArrayList;
import java.util.List;

public class ProcessList {
    public static List<EmployeeField> addRepPrefix(List<EmployeeField> list) {
        int size = list.size();
        if (size < 2) {
            for (EmployeeField field : list) {
                field.setShowText(field.getTranslatedText());
            }
            return list;
        }
        
        String currentText = list.get(0).getTranslatedText();
        int startIndex = 0;
        
        for (int i = 1; i < size; i++) {
            String currentItemText = list.get(i).getTranslatedText();
            if (!currentItemText.equals(currentText)) {
                if (i - startIndex >= 2) {
                    for (int j = startIndex; j < i; j++) {
                        EmployeeField field = list.get(j);
                        field.setShowText("Rep - " + field.getTranslatedText());
                    }
                } else {
                    list.get(startIndex).setShowText(list.get(startIndex).getTranslatedText());
                }
                currentText = currentItemText;
                startIndex = i;
            }
        }
        
        // 处理最后一个分组
        if (size - startIndex >= 2) {
            for (int j = startIndex; j < size; j++) {
                EmployeeField field = list.get(j);
                field.setShowText("Rep - " + field.getTranslatedText());
            }
        } else {
            list.get(startIndex).setShowText(list.get(startIndex).getTranslatedText());
        }
        return list;
    }
}

两种实现都没有修改原始的TranslatedText属性，避免影响其他业务逻辑，如果需要直接修改原始属性，替换对应操作的字段名即可。逻辑严格适配连续重复的判断规则，非连续的重复值不会被误加前缀。

内容的提问来源于stack exchange，提问作者Neptune_Code