Java 如何按字母顺序对字符串数组列表进行插入排序

所以在一个类比赛中，我有一个数组列表，它包含（字符串名，int-disability）

有一个方法alphalcsort（）可以按姓名的字母顺序对玩家列表进行排序。我必须使用插入排序

下面，我尝试采用我知道的插入排序算法使其工作，但两行

players.add(j+1) 

给我一个错误，说“赋值的左边必须是一个变量。”我理解这意味着什么，但我无法找到解决方案

    public void alphabeticSort() {

    for(int i = 1; i < players.size(); i++)  {
        String key = players.get(i).getName();
        int j = i - 1;
        while (j >= 0 && key.compareTo(players.get(i).getName()) < 0) {
            players.add(j+1) = players.get(j);

            j--;
        }
        players.add(j+1) = key;
    }

到

对于第二个实例（最后一行），我是否也这样做

我还发现，这条线

 while (j >= 0 && key.compareTo(players.get(i).getName()) < 0)

但我不知道如何用字符串实现，因为不能在字符串上使用运算符。帮助

编辑2：

JUnit测试，应该测试它是否工作

public void testAlphabeticSort() {
    int [] par = {3,4,5,4,5,3,4,3,5,3,4,5,4,3,4,5,4,3};
    int [] scores1 = {3,4,3,5,3,4,4,3,5,3,3,4,3,4,3,4,3,4};
    int [] scores2 = {4,4,3,5,3,4,4,3,5,3,3,4,3,4,3,4,3,4};
    int [] scores3 = {3,4,3,5,3,4,4,3,5,3,3,4,3,4,3,4,3,5};
    Tournament T = new Tournament(par);
    T.enter("Scott",  1, scores3);
    T.enter("Norman",  2, scores1);
    T.enter("Palmer",  4, scores2);
    T.alphabeticSort();
    ArrayList<Player> sortedPlayers = T.getPlayers();
    Player player1 = new Player("Norman", 2, scores1);
    Player player2 = new Player("Palmer", 4, scores2);
    Player player3 = new Player("Scott", 1, scores3);
    assertTrue(sortedPlayers.get(0).equals(player1));
    assertTrue(sortedPlayers.get(1).equals(player2));
    assertTrue(sortedPlayers.get(2).equals(player3));
}

public void testAlphabeticSort（）{
INT[] PAR= {3，4，5，4，5，3，4，3，5，3，4，5，4，3，4，5，4，3}；
int[]分数1={3,4,3,5,3,4,4,3,5,3,3,4,3,4,4,3,4}；
int[]分数2={4,4,3,5,3,4,4,3,5,3,3,4,3,4,4,3,4}；
int[]得分3={3,4,3,5,3,4,4,3,5,3,3,4,3,4,4,3,4,3,5}；
锦标赛T=新锦标赛（标准杆）；
T.输入（“斯科特”，1分，3分）；
T.enter（“诺曼”，2分，1分）；
T.enter（“帕尔默”，4分，2分）；
字母排序法（）；
ArrayList sortedPlayers=T.getPlayers（）；
玩家玩家1=新玩家（“诺曼”，2，得分1）；
player2=新玩家（“帕尔默”，4，得分2）；
玩家玩家3=新玩家（“斯科特”，1，得分3）；
assertTrue（sortedPlayers.get（0）.equals（player1））；
assertTrue（sortedPlayers.get（1.equals）（player2））；
assertTrue（sortedPlayers.get（2.equals）（player3））；
}

对于特定错误，您的行应修改为：

players.add(j+1, players.get(j));

它将移动列表中的后续元素

如果使用set函数，它将替换索引j+1处的实体

观察这些变化，并按如下方式更换功能体：

for(int i = 1; i < players.size(); i++)  {
    Player key = players.get(i);
    int j = i - 1;
    while (j >= 0 && key.getName().compareTo(players.get(j).getName()) < 0) {
        players.set(j+1, players.get(j));

        j--;
    }
    players.set(j+1, key);
}

for（inti=1；i=0&&key.getName（）.compareTo（players.get（j.getName（））<0）{
players.set（j+1，players.get（j））；
j--；
}
玩家。设置（j+1，键）；
}

对于特定错误，您的行应修改为：

players.add(j+1, players.get(j));

它将移动列表中的后续元素

如果使用set函数，它将替换索引j+1处的实体

观察这些变化，并按如下方式更换功能体：

for(int i = 1; i < players.size(); i++)  {
    Player key = players.get(i);
    int j = i - 1;
    while (j >= 0 && key.getName().compareTo(players.get(j).getName()) < 0) {
        players.set(j+1, players.get(j));

        j--;
    }
    players.set(j+1, key);
}

for（inti=1；i=0&&key.getName（）.compareTo（players.get（j.getName（））<0）{
players.set（j+1，players.get（j））；
j--；
}
玩家。设置（j+1，键）；
}
你错了：
players.add（j+1）=players.get（j）

不能为方法指定值

类
ArrayList
提供了两种方法来添加对象

在您的例子中：您使用
add（Object）
-它将在参数中的最后一个位置将对象添加到ArrayList中，并返回true或false

要解决您的问题：让我们使用add方法（int-index，Object）。此方法将使用索引位置将对象插入ArrayList

代码示例：

players.add（j+1，players.get（j））

你错了：
players.add（j+1）=players.get（j）

不能为方法指定值

类
ArrayList
提供了两种方法来添加对象

在您的例子中：您使用
add（Object）
-它将在参数中的最后一个位置将对象添加到ArrayList中，并返回true或false

要解决您的问题：让我们使用add方法（int-index，Object）。此方法将使用索引位置将对象插入ArrayList

代码示例：

players.add（j+1，players.get（j））

<>代码>清单> <代码> S/P >
ArrayList
，用于允许快速随机读取
LinkedList
允许固定时间的插入或删除
如果你的程序有很多插入和删除，那么你应该考虑使用<代码> LIKEDList而不是<代码>
players.set(j+1, players.get(j));

另见：


代码中的问题是在
players.add（j+1）=players.get（j）。只能对变量使用赋值运算符，而不能对方法使用赋值运算符

但是，如果您愿意设置
列表
玩家
的
j+1
值，则可以使用
set（）
方法，该方法可用于
LinkedList
和
ArrayList

players.set(j+1, players.get(j));

<>代码>清单> <代码> S/P >
ArrayList
，用于允许快速随机读取
LinkedList
允许固定时间的插入或删除
如果你的程序有很多插入和删除，那么你应该考虑使用<代码> LIKEDList而不是<代码>
players.set(j+1, players.get(j));

另见：


代码中的问题是在
players.add（j+1）=players.get（j）。只能对变量使用赋值运算符，而不能对方法使用赋值运算符

但是，如果您愿意设置
列表
玩家
的
j+1
值，则可以使用
set（）
方法，该方法可用于
LinkedList
和
ArrayList

players.set(j+1, players.get(j));

您也可以实现自己的比较器来保持干净，我制作了一个小程序，这样您就可以轻松地测试它

玩家：
比较层：
锦标赛：
import java.util.ArrayList；
公开课比赛
{
int[]分数；
ArrayList players=新的ArrayList（）；
int[]部分；
公开赛（INT[PAR）]
{
PARS＝PAR；
}
/**
*@还分数
*/
公共int[]获取分数（）
{
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Console
{

    public static void main ( String [ ] args )
    {
        List < Player > players = new ArrayList< Player >();
        List < Player > playersOrdered = new ArrayList < Player > ( );
        
        players.add ( new Player ( "Chris", 32222 ) );
        players.add ( new Player ( "John", 3 ) );
        players.add ( new Player ( "Zebra", 5 ) );
        players.add ( new Player ( "Albert", 333 ) );
        players.add ( new Player ( "Chris", 32222 ) );
        players.add ( new Player ( "Chris", 3 ) );

        
        
        Collections.sort ( players, new ComparatorPlayer ( ) );
        
        
        
        for ( Player player : players )
        {
            System.out.println ( player.getName ( ) +  " + " + player.getHandicap ( ) );
            playersOrdered.add ( player );
        }
        
    }

}

import java.util.ArrayList;

public class Console
{

    public static void main ( String [ ] args )
    {
        System.out.println ( "Starting" );
        ArrayList < Player > players = new ArrayList < Player > ( );
        players.add ( new Player ( "John" , 3 ) );
        players.add ( new Player ( "Chris" , 32222 ) );
        players.add ( new Player ( "Zebra" , 5 ) );
        players.add ( new Player ( "Albert" , 333 ) );
        players.add ( new Player ( "Christ" , 32222 ) );
        players.add ( new Player ( "Chris" , 3 ) );

        alphabeticSort ( players );

        for ( Player player : players )
        {
            System.out.println ( player.getName ( ) + " + " + player.getHandicap ( ) );
        }

        System.out.println ( "Finish" );
    }

    // alphabeticSort pass by parameter
    public static void  alphabeticSort ( ArrayList < Player > players )
    {
        int i = 1 , j;
        Player key = new Player ( );
        ArrayList < Player > inputArray = players;

        for ( j = 1 ; j < inputArray.size ( ) ; j ++ )
        {
            key = inputArray.get ( j );
            i = j - 1;
            
            while ( i >= 0 )
            {
                if ( key.getName ( ).compareTo ( inputArray.get ( i ).getName ( ) ) > 0 )
                {
                    break;
                }
                
                Player element = inputArray.get ( i + 1 );
                inputArray.set ( i + 1 , inputArray.get ( i ) );
                inputArray.set ( i , element );
                i -- ;
            }
        }
    }
}

import java.util.Arrays;

public class Player
{
    private String name;
    private int handicap;
    private int scores[];
    
    public Player( )
    {
        
    }
    
    public Player (String name, int handicap)
    {
        this.name = name;
        this.handicap = handicap;
    }
    
    public Player (String name, int handicap, int [] scores)
    {
        this.name = name;
        this.handicap = handicap;
        this.setScores ( scores ); 
    }
    
    /**
     * @return the name
     */
    public String getName ( )
    {
        return name;
    }
    /**
     * @param name the name to set
     */
    public void setName ( String name )
    {
        this.name = name;
    }
    /**
     * @return the handicap
     */
    public int getHandicap ( )
    {
        return handicap;
    }
    /**
     * @param handicap the handicap to set
     */
    public void setHandicap ( int handicap )
    {
        this.handicap = handicap;
    }

    /**
     * @return the scores
     */
    public int [] getScores ( )
    {
        return scores;
    }

    /**
     * @param scores the scores to set
     */
    public void setScores ( int scores[] )
    {
        this.scores = scores;
    }

    /* (non-Javadoc)
     * @see java.lang.Object#hashCode()
     */
    @Override
    public int hashCode ( )
    {
        // TODO Auto-generated method stub
        return super.hashCode ( );
    }

    /* (non-Javadoc)
     * @see java.lang.Object#equals(java.lang.Object)
     */
    @Override
    public boolean equals ( Object obj )
    {
        Player objToCompare = (Player) obj;
        if( this.handicap == objToCompare.getHandicap ( ) &&
                this.name.equals ( objToCompare.getName ( ) ) &&
                    Arrays.equals ( this.scores , objToCompare.scores ))
        {
            return true;
        }
        return false;
        
    }
    
}

import java.util.ArrayList;

public class Tournament
{

    int [] scores;
    ArrayList<Player> players = new ArrayList<Player> ( );
    int [] pars;
    
    public Tournament ( int [ ] par )
    {
        this.pars = par;
    }

    /**
     * @return the scores
     */
    public int [ ] getScores ( )
    {
        return scores;
    }

    /**
     * @param scores the scores to set
     */
    public void setScores ( int [ ] scores )
    {
        this.scores = scores;
    }

    /**
     * @return the players
     */
    public ArrayList < Player > getPlayers ( )
    {
        return players;
    }

    /**
     * @param players the players to set
     */
    public void setPlayers ( ArrayList < Player > players )
    {
        this.players = players;
    }

    /**
     * @return the pars
     */
    public int [ ] getPars ( )
    {
        return pars;
    }

    /**
     * @param pars the pars to set
     */
    public void setPars ( int [ ] pars )
    {
        this.pars = pars;
    }
    
    /**
     * Enter a player to a tournament
     * @param name
     * @param handicap
     * @param scores
     */
    public void enter ( String name , int handicap , int [ ] scores )
    {
        this.players.add ( new Player ( name, handicap, scores ));
    }

    
    /**
     * alphabeticSort by player name
     */
    public void alphabeticSort ()
    {
        int i = 1 , j;
        Player key = new Player ( );
        ArrayList < Player > inputArray = this.getPlayers ( );

        for ( j = 1 ; j < inputArray.size ( ) ; j ++ )
        {
            key = inputArray.get ( j );
            i = j - 1;
            
            while ( i >= 0 )
            {
                if ( key.getName ( ).compareTo ( inputArray.get ( i ).getName ( ) ) > 0 )
                {
                    break;
                }
                
                Player element = inputArray.get ( i + 1 );
                inputArray.set ( i + 1 , inputArray.get ( i ) );
                inputArray.set ( i , element );
                i -- ;
            }
        }
       this.players = inputArray;
    }

}

 for(int i = 1; i < players.size(); i++)  {
    String key = players.get(i).getName();
    int j = i - 1;
    while (j >= 0 && key.compareTo(players.get(j).getName()) < 0) {
        players.set(j+1, players.get(j));

        j--;
    }
      players.set(j+1,key);