blocks|key|1018758|text|可以这样做的一种方法是将原始索引和国家名称包装到一个单独的类中。然后根据名称对数组进行排序。这样，您的原始索引将被保留。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1018759|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

One way you could do this is to Wrap the original index and country name into a separate Class. Then sort the Array based on the names. This way, your original indexes will be preserved.

blocks|key|1018795|text|TreeMap<String,Int>+map+=+new+TreeMap<String,Int>();
for(+int+i+:+indexes+)+{
++++map.put(+stringarray[i],+i+);
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1018796|现在，在map.values()上迭代以按排序顺序检索索引，在map.keySet()上迭代以获取字符串，或者在map.entrySet()上迭代以获得字符串索引对。|unstyled|1018797|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>TreeMap&lt;String,Int&gt; map = new TreeMap&lt;String,Int&gt;();
for( int i : indexes ) {
 map.put( stringarray[i], i );
}
</code></pre>

Now iterator over map.values() to retrieve the indexes in sort order, and over map.keySet() to get the strings, or over map.entrySet() to get the String-index-Pairs.

blocks|key|804118|text|乍一看，是这样映射它们的|type|unstyled|depth|inlineStyleRanges|entityRanges|data|804119|Map+<Integer,+String>+map+=+new+HashMap<Integer,+String>();
map.put(0,+"France");
map.put(1,+"Spain");
map.put(2,+"France");|code-block|syntax|javascript|804120|然后按值like+that对它们进行排序，然后您就可以知道它们的索引和值(键、值)，只需打印地图即可|offset|length|804121|Iterator+mapIterator+=+map.keySet().iterator();++

while+(mapIterator+.hasNext())+{++
+++++String+key+=+mapIterator.next().toString();++
+++++String+value+=+map.get(key).toString();++

+++++System.out.println(key+%2B+"+"+%2B+value);++
}|804122|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/109383/how-to-sort-a-mapkey-value-on-the-values-in-java^0|0|0|4|9|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@$I|X|J|Y|1|Z]]|A|$]]|$1|K|3|L|5|D|7|10|8|@]|9|@]|A|$E|F]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

What Comes at first Glance is Map them like that

<pre><code>Map &lt;Integer, String&gt; map = new HashMap&lt;Integer, String&gt;();
map.put(0, "France");
map.put(1, "Spain");
map.put(2, "France");
</code></pre>

and then sort them by value <a href="https://stackoverflow.com/questions/109383/how-to-sort-a-mapkey-value-on-the-values-in-java">like that</a> and then you can know their indexes and values (key, values) just print the map

<pre><code>Iterator mapIterator = map.keySet().iterator(); 

while (mapIterator .hasNext()) { 
 String key = mapIterator.next().toString(); 
 String value = map.get(key).toString(); 

 System.out.println(key + " " + value); 
}
</code></pre>

blocks|key|804168|text|Java+8+Stream+API实现这一点的简明方法，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|804169|final+String[]+strArr+=+{"France",+"Spain",+"France"};
int[]+sortedIndices+=+IntStream.range(0,+strArr.length)
++++++++++++++++.boxed().sorted((i,+j)+->+strArr[i].compareTo(strArr[j])+)
++++++++++++++++.mapToInt(ele+->+ele).toArray();|code-block|syntax|javascript|804170|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Concise way of achieving this with Java 8 Stream API,

<pre><code>final String[] strArr = {"France", "Spain", "France"};
int[] sortedIndices = IntStream.range(0, strArr.length)
 .boxed().sorted((i, j) -&gt; strArr[i].compareTo(strArr[j]) )
 .mapToInt(ele -&gt; ele).toArray();
</code></pre>

blocks|key|804244|text|我根据@Skeet的代码做了以下工作。我觉得这有点像OOPie。我不知道。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|804245|public+static+<T+extends+Comparable<T>>+List<Integer>+sortIndex(List<T>+in)+{
++++ArrayList<Integer>+index+=+new+ArrayList<>();
++++for+(int+i+=+0;+i+<+in.size();+i%2B%2B)+{
++++++++index.add(i);
++++}

++++Collections.sort(index,+new+Comparator<Integer>()+{
++++++++@Override
++++++++public+int+compare(Integer+idx1,+Integer+idx2)+{
++++++++++++return+in.get(idx1).compareTo(in.get(idx2));
++++++++}
++++});

++++return+index;
}|code-block|syntax|javascript|804246|原始数组中的对象必须实现可比较接口，而不是具有传入的不同对象的比较器代码的实现排序和索引的类。似乎许多感兴趣的对象都有一个自然的顺序，并且已经实现了可比较的接口。|804247|public+static+void+main(String[]+args)+{

++++List<Integer>+a1+=+new+ArrayList<>(Arrays.asList(2,+3,+9,+4,+1));
++++//+Just+pass+in+the+list+to+have+its+indexes+sorted+by+the+natural+ordering
++++List<Integer>+idx+=+sortIndex(a1);

++++List<Double>+a2+=+new+ArrayList<>(Arrays.asList(1.0,+5.3,+5.2,+-3.1,+0.3));
++++idx+=+sortIndex(a2);

++++List<numBits>+a3+=+new+ArrayList<>();
++++for+(int+i+=+0;+i+<+10;+i%2B%2B)+{
++++++++a3.add(new+numBits(i));
++++}

++++//+If+you+need+to+sort+the+indexes+of+your+own+object,+you+must+implement
++++//+the+Comparable+Interface.
++++idx+=+sortIndex(a3);
}

static+class+numBits+implements+Comparable<numBits>+{
++++private+int+a;

++++public+numBits(int+i)+{
++++++++a+=+i;
++++}

++++public+String+toString()+{
++++++++return+Integer.toString(a);
++++}

++++//+Sort+by+the+total+number+of+bits+in+the+number.
++++@Override
++++public+int+compareTo(numBits+that)+{
++++++++if+(Integer.bitCount(this.a)+<+Integer.bitCount(that.a))
++++++++++++return+-1;
++++++++if+(Integer.bitCount(this.a)+>+Integer.bitCount(that.a))
++++++++++++return+1;
++++++++return+0;
++++}
}|804248|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I made the following based on @Skeet's code. I think it is a little more OOPie. I dunno.

<pre><code>public static &lt;T extends Comparable&lt;T&gt;&gt; List&lt;Integer&gt; sortIndex(List&lt;T&gt; in) {
 ArrayList&lt;Integer&gt; index = new ArrayList&lt;&gt;();
 for (int i = 0; i &lt; in.size(); i++) {
 index.add(i);
 }

 Collections.sort(index, new Comparator&lt;Integer&gt;() {
 @Override
 public int compare(Integer idx1, Integer idx2) {
 return in.get(idx1).compareTo(in.get(idx2));
 }
 });

 return index;
}
</code></pre>

Instead of the class that implements the sorting and indexing having the Comparator code for the different objects coming in, the objects in the original array must implement the Comparable interface. It seems many objects of interest have a natural ordering and have the Comparable interface implemented already.

<pre><code>public static void main(String[] args) {

 List&lt;Integer&gt; a1 = new ArrayList&lt;&gt;(Arrays.asList(2, 3, 9, 4, 1));
 // Just pass in the list to have its indexes sorted by the natural ordering
 List&lt;Integer&gt; idx = sortIndex(a1);

 List&lt;Double&gt; a2 = new ArrayList&lt;&gt;(Arrays.asList(1.0, 5.3, 5.2, -3.1, 0.3));
 idx = sortIndex(a2);

 List&lt;numBits&gt; a3 = new ArrayList&lt;&gt;();
 for (int i = 0; i &lt; 10; i++) {
 a3.add(new numBits(i));
 }

 // If you need to sort the indexes of your own object, you must implement
 // the Comparable Interface.
 idx = sortIndex(a3);
}

static class numBits implements Comparable&lt;numBits&gt; {
 private int a;

 public numBits(int i) {
 a = i;
 }

 public String toString() {
 return Integer.toString(a);
 }

 // Sort by the total number of bits in the number.
 @Override
 public int compareTo(numBits that) {
 if (Integer.bitCount(this.a) &lt; Integer.bitCount(that.a))
 return -1;
 if (Integer.bitCount(this.a) &gt; Integer.bitCount(that.a))
 return 1;
 return 0;
 }
}
</code></pre>

blocks|key|804284|text|如果有一个场景，重复地对具有正值的原始浮点数组或整型数组进行排序，那么与使用任何比较器相比，下面这样的方法会产生更快的(x3~x4)速度：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|804285|long+time+=+System.currentTimeMillis();
for+(int+i+=+0;+i+<+iters;+i%2B%2B)+{+++++++++++
++++float[]+array+=+RandomUtils.randomFloatArray(-1,++1,+3000);
++++long[]+valueKeyPairs+=+new+long[array.length];+
++++for+(int+j+=+0;+j+<+array.length;+%2B%2Bj)+{
++++++++valueKeyPairs[j]+=+(((long)+Float.floatToIntBits(array[j]))+<<+32)+%7C+(j+&+0xffffffffL);
++++}
++++Arrays.sort(valueKeyPairs);
++++/**Then+use+this+to+retrieve+the+original+value+and+index*/
++++//long+l+=+valueKeyPairs[j];
++++//float+value+=+Float.intBitsToFloat((int)+(l+>>+32));
++++//int+index+=+(int)+(l);
}
long+millis+=+System.currentTimeMillis()+-+time;|code-block|syntax|javascript|804286|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

If having a scenario of repeatedly sorting primitive float or int arrays with positive values, then a method like below yields much better (x3~x4) speed compared to using any comparators:

<pre><code>long time = System.currentTimeMillis();
for (int i = 0; i &lt; iters; i++) { 
 float[] array = RandomUtils.randomFloatArray(-1, 1, 3000);
 long[] valueKeyPairs = new long[array.length]; 
 for (int j = 0; j &lt; array.length; ++j) {
 valueKeyPairs[j] = (((long) Float.floatToIntBits(array[j])) &lt;&lt; 32) | (j &amp; 0xffffffffL);
 }
 Arrays.sort(valueKeyPairs);
 /**Then use this to retrieve the original value and index*/
 //long l = valueKeyPairs[j];
 //float value = Float.intBitsToFloat((int) (l &gt;&gt; 32));
 //int index = (int) (l);
}
long millis = System.currentTimeMillis() - time;
</code></pre>

blocks|key|804319|text|我找到了解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|804320|List<String>+a+=+{b,+a,+d,+c};
List<Integer>+b+=+{2,+1,+4,+3};|code-block|syntax|javascript|804321|如果a排序|offset|length|style|CODE|804322|private+void+setsortb()+{
List<String>+beforeA+=+new+ArrayList<>();
List<Integer>+beforeB+=+new+ArrayList<>();
beforeA.addAll(a);
beforeB.addAll(b);
a.sort();//change+like+this+{a,+b,+c,+d}

for(int+i+=+0;+i+<+beforeA.size();+i%2B%2B)+{
int+index+=+beforeA.indexOf(a.get(i));
b.set(i,+beforeB.get(i));
}
}|804323|像这样|804324|结果|804325|a+=+{a,+b,+c,+d}
b+=+{1,+2,+3,+4}|804326|entityMap^0|0|0|2|1|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@$I|Z|J|10|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|12|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|13|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|14|8|@]|9|@]|A|$E|F]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

i found solution.
<pre><code>List&lt;String&gt; a = {b, a, d, c};
List&lt;Integer&gt; b = {2, 1, 4, 3};
</code></pre>
and if <code>a</code> sort
<pre><code>private void setsortb() {
List&lt;String&gt; beforeA = new ArrayList&lt;&gt;();
List&lt;Integer&gt; beforeB = new ArrayList&lt;&gt;();
beforeA.addAll(a);
beforeB.addAll(b);
a.sort();//change like this {a, b, c, d}

for(int i = 0; i &lt; beforeA.size(); i++) {
int index = beforeA.indexOf(a.get(i));
b.set(i, beforeB.get(i));
}
}
</code></pre>
like this
result
<pre><code>a = {a, b, c, d}
b = {1, 2, 3, 4}
</code></pre>

Suppose the user enter an array, for example:

<pre><code>Array = {France, Spain, France, France, Italy, Spain, Spain, Italy}
</code></pre>

which I did know the length of it

the <code>index</code> array would be:

<pre><code>index = {0, 1, 2, 3, 4, 5, 6, 7}
</code></pre>

Now, after sorting it using <code>Arrays.sort(Array);</code>

<code>newArray</code> will be like:

<pre><code>newArray = {France, France, France, Italy, Italy, Spain, Spain, Spain}
</code></pre>

and the <code>newIndex</code> will be:

<pre><code>newIndex = {0, 2, 3, 4, 7, 1, 5, 6}
</code></pre>

The problem is: how can I find the <code>newIndex</code> from the input Array?

Thanks in advance

Get the indices of an array after sorting?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

假设用户输入一个数组，例如：Array = {France, Spain, France, France, Italy, Spain, Spain, Italy}我确实知道它的长度index数组将为：index = {0, 1, 2, 3, 4, 5, 6, 7}现在，在使用Arrays.sort(Array);对其进...

问排序后获取数组的索引？
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问排序后获取数组的索引？EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问排序后获取数组的索引？
EN