在Java中更改数组中的值而不遍历整个数组？

例如：如果我的数组是

arr[5]={5,2,1,5,8}

因此，如果我必须将所有5都更改为-1，可能的方法是检查每个元素，
如果value==5，则将其更改为-1

在JAVA中有其他方法吗

我在C中找到了使用指针数组的解决方案，但在JAVA中没有

下面是c代码：

#include <stdio.h>

 void main()

{
int i ;

int a[7] = {0,1,2,3,4,5,6};

int *ptr[5] = { &a[2] , &a[5] , &a[1] , &a[5] , &a[5] } ;


printf("The value of array is :\n");
for(i = 0 ; i < 5 ; i++)
{

    printf("%d  ",*ptr[i]);

}printf("\n");

//////Now changing 5 ot -1 I require only one step , not to traverse entire    ///array , Here the step is : 

a[5] = -1 ;

///final array is :
for(i = 0 ; i < 5 ; i++)
{

    printf("%d  ",*ptr[i]);

}

#包括
void main（）
{
int i；
int a[7]={0,1,2,3,4,5,6}；
int*ptr[5]={&a[2]、&a[5]、&a[1]、&a[5]、&a[5]}；
printf（“数组的值为：\n”）；
对于（i=0；i<5；i++）
{
printf（“%d”，*ptr[i]）；
}printf（“\n”）；
//////现在更改5OT-1只需要一个步骤，而不是遍历整个///数组，这里的步骤是：
a[5]=-1；
///最后一个数组是：
对于（i=0；i<5；i++）
{
printf（“%d”，*ptr[i]）；
}

}
如果希望在不遍历的情况下执行此操作，则可能不是合适的数据结构。按以下方式使用
Map
：

Map<Integer, Integer> map = new HashMap<Integer, Integer>();  

正如您所说的，不需要。您必须对数组进行排序或使用其他结构，以便能够轻松找到所有5并对其进行更改

指针数组揭示了您的想法：如果您的数组不是
int
s，而是封装
int
s的可变对象，那么您就可以实现这一点。然后，如果所有
5
s由同一个对象表示，则可以对该对象进行变异，以对列表中的所有
5
s进行变异。但是，如果您真正想要的是
int
s数组，那么这不是正确的解决方案，因为要确保所有
5
s都是相同的对象，而且封装它们的效率低下

基于问题更新的更新：

我猜你在做什么完全正确。我建议的对象相当于您使用的
int
指针（实际上，所有对象都是指针，尽管它们指向的不仅仅是
int
）。你可以在你的C代码中看到我为这个解决方案指出的相同问题：它只在你指向
a
的元素，如果
a
包含数组中所有可能的数字，并且如果你不需要在数组中插入任何
5
时才起作用（因为尝试转到
5
会将您发送到
-1
）。实际上，您并没有像您认为的那样解决问题。在某些情况下，这种类型的解决方案可能很有用，但修改任意的
int[]
不是其中之一。
使用一种数据结构，它将值按降序排序。然后遍历，直到找到5为止。更改这些值。Viola，你没有遍历整个数组，尽管你可能会做更多的工作

我建议使用最大堆。在Java中，
PriorityQueue
可以满足您的需要

虽然我知道这不会比只遍历一次数组更有效。保持一个有序的数据结构并对其执行操作非常耗时。
Java只使用指针，但您看不到。为此，您需要对所有数组进行版本转换或进行其他操作。
决定投入我的两分钱。当然不是更有效，但如果询问者正在寻找替代解决方案，你就来吧

public static void main(String[] args){
    //52158
    int[] arr = {5,2,1,5,8};
    String strArr = Arrays.toString(arr);
    strArr = strArr.replaceAll("5", "-1");
    strArr = strArr.replaceAll("\\[", "");
    strArr = strArr.replaceAll("\\]", "");
    strArr = strArr.replaceAll(",", "");
    strArr = strArr.replaceAll(" ", "");
    ArrayList<Integer> endArr = new ArrayList<Integer>();
    for (int i = 0; i < strArr.length(); i++){
        if (strArr.substring(i, i + 1).equals("-")) {
            endArr.add(Integer.parseInt(strArr.substring(i, i + 2)));
            i++;
        }
        else endArr.add(Integer.parseInt(strArr.substring(i, i + 1)));
    }   
}

publicstaticvoidmain（字符串[]args）{
//52158
int[]arr={5,2,1,5,8}；
String strArr=Arrays.toString（arr）；
strArr=strArr.replaceAll（“5”和“-1”）；
strArr=strArr.replaceAll（“\\[”，”）；
strArr=strArr.replaceAll（“\\]”，“”）；
strArr=strArr.replaceAll（“，”，”）；
strArr=strArr.replaceAll（“，”）；
ArrayList endArr=新的ArrayList（）；
对于（int i=0；i

我只是转换成一个字符串，然后将它们全部替换，然后将其转换回来。是的，几乎完全没有用，而且您必须非常天真地实现此解决方案，但它不同，因为我使用了字符串操纵和数组操纵。我知道没有太多不同，但是，它是。
如果您想比循环所有索引更快地执行此操作，您需要额外的数据。一个示例是使用。但是创建该数据所需的时间比遍历整个数组所需的时间要长

反向索引将值映射到索引，即对于
arr={5,2,1,5,8}
：

1 -> {2}
2 -> {1}
5 -> {0, 3}
8 -> {4}

创建索引
Map invertedIndex=new HashMap（）；
对于（int i=0；i

替换值
int numToReplace=5；
int newValue=-1；
//--------------------
列表l=逆变器索引移除（numToReplace）；
如果（l！=null）{
//替换arr中的数字
for（整数索引：l）{
arr[索引]=新值；
}
//更新倒排索引
列表l2=invertedIndex.get（newValue）；
如果（l2！=null）{
l2.addAll（l）；
}否则{
反相器索引put（新值，l）；
}
}

改变单一元素
int索引=。。。；
int newValue=。。。；
//-------------------
int oldValue=arr[index]；
List oldList=invertedIndex.get（oldValue）；
删除（索引）；
if（oldList.isEmpty（））{
逆变器索引移除（旧值）；
}
列表l=invertedIndex.get（newValue）；
if（l==null）{
l=新链接列表（）；
反相器索引put（新值，l）；
}
l、 添加（索引）；
为什么需要使用另一种方法？在C中如何“使用指针”？指针数组仍然需要完全扫描。C中的解决方案是如何做到的？请链接。我很感兴趣。算法理论说你做得再好不过了。你必须遍历整个数组，以确保每5个指针变为-1。不！我
1 -> {2}
2 -> {1}
5 -> {0, 3}
8 -> {4}

Map<Integer, List<Integer>> invertedIndex = new HashMap<>();
for (int i = 0; i < arr.length; i++) {
    int val = arr[i];
    List<Integer> l = invertedIndex.get(val);
    if (l == null) {
        l = new LinkedList<>();
        invertedIndex.put(val, l);
    }
    l.add(i);
}

int numToReplace = 5;
int newValue = -1;
//--------------------
List<Integer> l = invertedIndex.remove(numToReplace);
if (l != null) {
    // replace numbers in arr
    for (int index : l) {
        arr[index] = newValue;
    }
    // update inverted index
    List<Integer> l2 = invertedIndex.get(newValue);
    if (l2 != null) {
        l2.addAll(l);
    } else {
        invertedIndex.put(newValue, l);
    }
}

int index = ...;
int newValue = ...;
//-------------------
int oldValue = arr[index];
List<Integer> oldList = invertedIndex.get(oldValue);
oldList.remove(index);
if (oldList.isEmpty()) {
    invertedIndex.remove(oldValue);
}
List<Integer> l = invertedIndex.get(newValue);
if (l == null) {
    l = new LinkedList<>();
    invertedIndex.put(newValue, l);
}
l.add(index);