Java 在数组中对字符串和双类类型进行排序

我正试图根据销售数字对我的表格进行排序。
例如：
Names Figures
A 400
B 200
C 500 姓名和数字
A 400
B200
C 500 将 姓名和数字
c500
A 400
B200
经过整理。这是我的密码。我是初学者请原谅我的密码呵呵

Scanner input = new Scanner(System.in);
int numAsso;
System.out.print("Enter the Number of Associates: ");
numAsso = input.nextInt();

String[] names = new String[numAsso];
String line;

for (int i = 0; i < numAsso; i++)
{
System.out.print("Enter the name of the Associate: ");
names[i] = input.next();
}

 final Double[][] sales = new Double [numAsso][2];
double sum= 0;
for(int j = 0; j < numAsso; j++)
{
System.out.print("Enter Total Figures for "+ names[j]+": ");
sales[j][0] = input.nextDouble();
sum+=sales[j][0];
}
double average = sum/numAsso;



System.out.println("Names\t\t"+"Figures\t\t"+"Average");

for(int x = 0; x < numAsso; x++)
{
System.out.println(names[x] + "\t\t" + sales[x][0] + "\t\t" + average);

}

扫描仪输入=新扫描仪（System.in）；
努马索国际酒店；
系统输出打印（“输入员工人数：”）；
numAsso=input.nextInt（）；
字符串[]名称=新字符串[numAsso]；
弦线；
对于（int i=0；i

您应该将数据存储在

地图中

并按值排序，您可以查看以下链接：

效用类方法 当条目添加到地图时，您可以使用此实用程序类对条目进行排序，而不是使用静态分类器方法：

public class ValueSortedMap<K extends Comparable<K> ,V extends Comparable<V> > extends TreeMap<K,V> {

        private TreeMap<K,V> sortedMap;

        private ValueComparator comparator;

        private boolean reverseOrder = false;

        public ValueSortedMap() {
                this.comparator = new ValueComparator();
                this.sortedMap = new TreeMap<K, V>(comparator);
        }




        public ValueSortedMap(boolean reverseOrder) {
                this();
                this.reverseOrder = reverseOrder;


        }

        @Override
        public String toString() {
                return sortedMap.toString();
        }

        @Override
        public V put(K key, V value) {
        if(sortedMap.containsKey(key)){
            //remove the key in the sorted set before adding the key again
            remove(key);
        }               
                comparator.unsortedMap.put(key, value);
                return sortedMap.put(key, value);
        }


        @Override
        public Map.Entry<K, V> firstEntry() {
                return sortedMap.firstEntry();
        }       



        @Override
        public void clear() {
                sortedMap.clear();
                comparator.unsortedMap.clear();
        }

        @Override
        public boolean containsKey(Object key) {
                return sortedMap.containsKey(key);
        }

        @Override
        public boolean containsValue(Object value) {
                return sortedMap.containsValue(value);
        }


        @Override
        public Set<Map.Entry<K, V>> entrySet() {
                return sortedMap.entrySet();
        }

        @Override
        public V get(Object key) {
                return sortedMap.get(key);
        }


        /**
         * 0-based position
         * @param position
         * @return
         */
        public Map.Entry<K, V> getEntryInPosition(int position) {
                Iterator<Map.Entry<K,V>> iterator = sortedMap.entrySet().iterator();
                int i = 0;
                while(iterator.hasNext()){
                         if(i == position){
                                 return iterator.next(); 
                         }else{
                                 i++;
                         }
                }

                return null;

        }       

        @Override
        public boolean isEmpty() {
                return sortedMap.isEmpty();
        }



        @Override
        public Set<K> keySet() {
                return sortedMap.keySet();
        }



        @Override
        public void putAll(Map<? extends K, ? extends V> map) {
                for(Map.Entry<? extends K, ? extends V> entry : map.entrySet()){
                        put(entry.getKey(), entry.getValue());
                }
        }       



        @Override
        public int size() {
                return sortedMap.size();
        }

        @Override
        public Collection<V> values() {
                return sortedMap.values();
        }


        @Override
        public V remove(Object key) {
                sortedMap.remove(key);
                return comparator.unsortedMap.remove(key);
        }


        public class ValueComparator implements Comparator<K>{

                public Map<K,V> unsortedMap = new HashMap<K,V>();


                @Override
                public int compare(K k1, K k2) {
                        Comparable<V> v1 = unsortedMap.get(k1);
                        Comparable<V> v2 = unsortedMap.get(k2);
                        if(Objects.equal(v1,v2)){
                                return k1.compareTo(k2); //not using reverseOrder comparing keys
                        }else{
                                if(reverseOrder){
                                     return ComparisonChain.start().compare(v2, v1, Ordering.natural().nullsFirst()).result();
                                }else{
                                        return ComparisonChain.start().compare(v1, v2, Ordering.natural().nullsFirst()).result();
                                }
                        }
                }

        }       

}

public类ValueSortedMap扩展树映射{
私有树形图分类图；
私人价值比较人；
私有布尔反向顺序=false；
公共价值分类地图（）{
this.comparator=新的ValueComparator（）；
this.sortedMap=新树映射（比较器）；
}
public ValueSortedMap（布尔反向排序）{
这个（）；
this.reverseOrder=reverseOrder；
}
@凌驾
公共字符串toString（）{
返回sortedMap.toString（）；
}
@凌驾
公共V输入（K键，V值）{
if（分拣地图集装箱箱（钥匙））{
//在再次添加密钥之前，请删除已排序集中的密钥
取下（钥匙）；
}               
比较器.未排序映射.put（键，值）；
返回已分类的地图放置（键、值）；
}
@凌驾
public Map.Entry firstEntry（）的{
返回sortedMap.firstEntry（）；
}       
@凌驾
公共空间清除（）{
sortedMap.clear（）；
comparator.unsortedMap.clear（）；
}
@凌驾
公共布尔containsKey（对象键）{
返回分拣地图集装箱箱（钥匙）；
}
@凌驾
公共布尔包含值（对象值）{
返回sortedMap.containsValue（值）；
}
@凌驾
公共集入口集（）{
返回sortedMap.entrySet（）；
}
@凌驾
public V get（对象键）{
返回已分类的地图。获取（键）；
}
/**
*基于0的位置
*@param位置
*@返回
*/
公共地图。条目getEntryInPosition（int位置）{
迭代器迭代器=sortedMap.entrySet（）.Iterator（）；
int i=0；
while（iterator.hasNext（））{
if（i==位置）{
返回iterator.next（）；
}否则{
i++；
}
}
返回null；
}       
@凌驾
公共布尔值为空（）{
返回sortedMap.isEmpty（）；
}
@凌驾
公共集密钥集（）{
返回sortedMap.keySet（）；
}
@凌驾
public void putAll（Map您应该将数据存储在
Map
中并按值排序，您可以查看以下链接：





效用类方法
当条目添加到地图时，您可以使用此实用程序类对条目进行排序，而不是使用静态分类器方法：

public class ValueSortedMap<K extends Comparable<K> ,V extends Comparable<V> > extends TreeMap<K,V> {

        private TreeMap<K,V> sortedMap;

        private ValueComparator comparator;

        private boolean reverseOrder = false;

        public ValueSortedMap() {
                this.comparator = new ValueComparator();
                this.sortedMap = new TreeMap<K, V>(comparator);
        }




        public ValueSortedMap(boolean reverseOrder) {
                this();
                this.reverseOrder = reverseOrder;


        }

        @Override
        public String toString() {
                return sortedMap.toString();
        }

        @Override
        public V put(K key, V value) {
        if(sortedMap.containsKey(key)){
            //remove the key in the sorted set before adding the key again
            remove(key);
        }               
                comparator.unsortedMap.put(key, value);
                return sortedMap.put(key, value);
        }


        @Override
        public Map.Entry<K, V> firstEntry() {
                return sortedMap.firstEntry();
        }       



        @Override
        public void clear() {
                sortedMap.clear();
                comparator.unsortedMap.clear();
        }

        @Override
        public boolean containsKey(Object key) {
                return sortedMap.containsKey(key);
        }

        @Override
        public boolean containsValue(Object value) {
                return sortedMap.containsValue(value);
        }


        @Override
        public Set<Map.Entry<K, V>> entrySet() {
                return sortedMap.entrySet();
        }

        @Override
        public V get(Object key) {
                return sortedMap.get(key);
        }


        /**
         * 0-based position
         * @param position
         * @return
         */
        public Map.Entry<K, V> getEntryInPosition(int position) {
                Iterator<Map.Entry<K,V>> iterator = sortedMap.entrySet().iterator();
                int i = 0;
                while(iterator.hasNext()){
                         if(i == position){
                                 return iterator.next(); 
                         }else{
                                 i++;
                         }
                }

                return null;

        }       

        @Override
        public boolean isEmpty() {
                return sortedMap.isEmpty();
        }



        @Override
        public Set<K> keySet() {
                return sortedMap.keySet();
        }



        @Override
        public void putAll(Map<? extends K, ? extends V> map) {
                for(Map.Entry<? extends K, ? extends V> entry : map.entrySet()){
                        put(entry.getKey(), entry.getValue());
                }
        }       



        @Override
        public int size() {
                return sortedMap.size();
        }

        @Override
        public Collection<V> values() {
                return sortedMap.values();
        }


        @Override
        public V remove(Object key) {
                sortedMap.remove(key);
                return comparator.unsortedMap.remove(key);
        }


        public class ValueComparator implements Comparator<K>{

                public Map<K,V> unsortedMap = new HashMap<K,V>();


                @Override
                public int compare(K k1, K k2) {
                        Comparable<V> v1 = unsortedMap.get(k1);
                        Comparable<V> v2 = unsortedMap.get(k2);
                        if(Objects.equal(v1,v2)){
                                return k1.compareTo(k2); //not using reverseOrder comparing keys
                        }else{
                                if(reverseOrder){
                                     return ComparisonChain.start().compare(v2, v1, Ordering.natural().nullsFirst()).result();
                                }else{
                                        return ComparisonChain.start().compare(v1, v2, Ordering.natural().nullsFirst()).result();
                                }
                        }
                }

        }       

}

public类ValueSortedMap扩展树映射{
私有树形图分类图；
私人价值比较人；
私有布尔反向顺序=false；
公共价值分类地图（）{
this.comparator=新的ValueComparator（）；
this.sortedMap=新树映射（比较器）；
}
public ValueSortedMap（布尔反向排序）{
这个（）；
this.reverseOrder=reverseOrder；
}
@凌驾
公共字符串toString（）{
返回sortedMap.toString（）；
}
@凌驾
公共V输入（K键，V值）{
if（分拣地图集装箱箱（钥匙））{
//在再次添加密钥之前，请删除已排序集中的密钥
取下（钥匙）；
}               
比较器.未排序映射.put（键，值）；
返回已分类的地图放置（键、值）；
}
@凌驾
public Map.Entry firstEntry（）的{
返回sortedMap.firstEntry（）；
}       
@凌驾
公共空间清除（）{
sortedMap.clear（）；
comparator.unsortedMap.clear（）；
}
@凌驾
公共布尔containsKey（对象键）{
返回分拣地图集装箱箱（钥匙）；
}
@凌驾
公共布尔包含值（对象值）{
返回sortedMap.containsValue（值）；
}
@凌驾
公共集入口集（）{
返回sortedMap.entrySet（）；
}
@凌驾
public V get（对象键）{
返回已分类的地图。获取（键）；
}
/**
*基于0的位置
*@param位置
*@返回
*/
公共映射。条目GetEntryInputPosition（int posit