java获取值在数组中的索引

java获取2个数组中相同与不相同的元素

/**
     * 
     * 给对象授予角色权限
     * 
     * @param id 对象id
     * @param date 角色
     * 
     *
     * @date 2016年8月22日 上午11:08:51
     */
    public static void addObjectToRole(String id, String data) {
        Map<String, Object> map = new HashMap<String, Object>();
        if (StringUtils.isNotBlank(id)) {
            BasicDBList deteleIds = new BasicDBList();
            BasicDBList addIds = new BasicDBList();
            if (StringUtils.isNotBlank(data)) {
                List<String> oldIds = getRoleIds(id);// 旧的
                String[] codes = data.split(";");// 新的
                /**
                 * 比较新旧id,获取要添加的id和要移除的id
                 */
                Map<String, Object> all = compare(codes, oldIds);

                deteleIds=(BasicDBList) all.get("delete_arry");// 要移除的角色id
                addIds=(BasicDBList) all.get("add_arry");// 要添加的角色id

                if (oldIds == null || oldIds.size()==0) {// 之前未授权
                    addAtuh(id, addIds);// 添加权限
                }
                removeAtuh(id, deteleIds);// 移除权限
                addAtuh(id, addIds);// 添加权限
            } else {// 未选中
                removeAtuh(id, deteleIds);
            }
            map.put("code", "ok");
            map.put("mgs", "授权成功");
        } else {
            map.put("code", "error");
            map.put("mgs", "授权异常");
        }
        renderJSON(map);
    }

/**
     * 
     * 获取2个数组中相同与不相同的元素
     * 
     * @param t1 新的数组
     * @param t2 旧的数组
     * @return
     * 
     *
     * @date 2016年8月22日 下午3:26:07
     */
    public static Map<String, Object> compare(String[] t1, List<String> t2) {
        /**
         * 要移除的元素
         */
        BasicDBList deleteArry = new BasicDBList();
        List<String> list1 = Arrays.asList(t1);
        for (String t : t2) {//遍历新的数组元素
            if (!list1.contains(t)) {//新的数组中不包含旧的元素（即为要移除的元素）
                deleteArry.add(Integer.parseInt(t));
            }
        }

        /**
         * 要添加的元素
         */
        BasicDBList addArry = new BasicDBList();
        for(int j = 0; j < t1.length; j++){//遍历新的数组元素
            if( !t2.contains(t1[j])){//旧的数组中不包含新的数组（即为要添加的元素）
                addArry.add(Integer.parseInt(t1[j]));
            }
        }


        /**
         * 获取2个数组中相同的元素
         */
        Set<String> same = new HashSet<String>(); // 用来存放两个数组中相同的元素
        Set<String> temp = new HashSet<String>(); // 用来存放数组a中的元素

        for (int i = 0; i < t1.length; i++) {
            temp.add(t1[i]); // 把数组a中的元素放到Set中，可以去除重复的元素
        }

        for (int j = 0; j < t2.size(); j++) {
            if (!temp.add(t2.get(j))){// 把数组b中的元素添加到temp中
                same.add(t2.get(j));// 如果temp中已存在相同的元素，则temp.add（b[j]）返回false
            }
        }


        Map<String, Object> map=new HashMap<String, Object>();
        map.put("add_arry", addArry);
        map.put("delete_arry", deleteArry);
        map.put("same", same);

        return map;
    }

• 将数组的比较，抽成公共方法，比较规范和常用：
• 因为String [] 比较容易转成List(String),List<String> list1 = Arrays.asList(t1);
• 对此，我们可以规范成以下公共方法：

/**
     * 
     * 比较2个数组，获取相对于数组1相同的元素、相对于数组2相同的元素，2个数组相同的元素
     *
     * @param t1 旧的数组
     * @param t2 新的数组
     * 
     * @return 返回3种类型的集合
     * 
     * @date 2016年8月26日 下午5:34:49
     */
    public static Map<String, Object> compareArry(List<String> t1, List<String> t2) {
        /**
         * 集合A (新的数据有，旧的数据没有，即为要添加的数据)
         */
        List<Long> listA=new ArrayList<Long>();
        for (String str1:t2) {//遍历新的数组元素
            if (!t1.contains(str1)) {//旧的数组中不包含新的元素（即为要添加的元素）
                listA.add(Long.valueOf(str1));
            }
        }

        /**
         * 集合B (旧的数据中有，新的数据没有，即为要删除的数据)
         */
        List<Long> listB = new ArrayList<Long>();
        for(String str2:t1){//遍历旧的数组元素
            if( !t2.contains(str2)){//新的数组中不包含旧的数组（即为要删除的元素）
                listB.add(Long.valueOf(str2));
            }
        }

        /**
         * 集合C (旧的数据中有，新的数据有，即为共同的数据)
         */
        List<Long> listC = new ArrayList<Long>();
        for(String str3:t1){//遍历旧的数组元素
            if( t2.contains(str3)){//新的数组中包含旧的数组（即为共同的元素）
                listC.add(Long.valueOf(str3));
            }
        }


        Map<String, Object> map=new HashMap<String, Object>();
        map.put("add_arry", listA);
        map.put("delete_arry", listB);
        map.put("common_date", listC);
        return map;
    }