Java 从字符串数组的ArrayList中删除字符串的可能逻辑？

有人能透露从字符串数组的ArrayList中删除字符串的任何可能逻辑吗

ArrayList

测试=新建ArrayList（）

test.remove（i）[k]；不行。
其中“i”和“k”是可能的循环。

实际上，我正在尝试制作集成求解器。我已经通过split方法拆分了一个关于“+”的完整字符串输入，然后将整个字符串更改为arraylist，依此类推。代码可以看作： 请考虑<代码> /删除负面最终< <代码>注释< /p>

import java.util.ArrayList;
import java.util.Arrays;


public class IntegrationClass {

public static final String calculate(String input)
{
    String rawPositive[];
    String rawNegInitial[];
    String[] rawNeg=null;
    String SplitPosArray[] = null;
    String SplitNegArray[]=null;

    ArrayList<String[]> rawNeg1= new ArrayList<>();
    ArrayList <String> DataNeg = new ArrayList<>();
    ArrayList <String> DataPos = new ArrayList<>();
    ArrayList <String> SplitPos =  new ArrayList<>();
    ArrayList <String> SplitNeg =  new ArrayList<>();
    ArrayList <ArrayList> PosPower= new ArrayList<>();
    ArrayList <ArrayList> NegPower= new ArrayList<>();


    ArrayList <String> tempX = new ArrayList<>();       

    if (input.contains("+")==true||input.contains("-")==true)
    {

        rawPositive= input.split("\\+");
        //casting raw positive into array list
        DataPos = new ArrayList<>(Arrays.asList(rawPositive));

        //putting positive final data into raw initial data

            rawNegInitial= DataPos.toArray(new String[DataPos.size()]);


        // deleting negative value from positive final
        for(int i =0;i<DataPos.size();i++)
        {
        if(DataPos.get(i).contains("-"))
        {
            String temp[];
            temp=DataPos.get(i).split("\\-");
            DataPos.set(i, temp[0]);
        }
        }


            //putting initial data in raw of negative from positive data

            for(int i =0;i<rawNegInitial.length;i++)
            {
                //System.out.println(rawNegInitial[i]);
                if(rawNegInitial[i].contains("-")==true)
                {
                    rawNeg=rawNegInitial[i].split("\\-");
                    rawNeg1.add(rawNeg);
                }
            }

            //casting negative raw into final negative data
            try{
            //  DataNeg = new ArrayList<>(Arrays.asList(rawNeg1));

            //deleting positive data from negative final
            for(int j=0;j<rawNeg1.size();j++)
            {
                for(int k=0;k<2;k++)
                {
            for(int i =0;i<DataPos.size();i++)
            {

                    String a=rawNeg1.get(j)[k];
                    System.out.println(DataPos.get(i) +" "+ a);
                    if(DataPos.get(i).contains(a))
                    {

                        //x^1+x^2-x^3+x^4-x^5
                        System.out.println("here");
                        try{
                        rawNeg1.get(j)[k-1]=rawNeg1.get(j)[k];
                        }
                        catch(ArrayIndexOutOfBoundsException ex)
                        {

                            rawNeg1.get(j)[k]=rawNeg1.get(j)[k+1];
                        }
                        //rawNeg1.get(j)[k]= null;
                    }
                    else
                    {
                        tempX.add(a);
                    }

                    System.out.println(rawNeg1.get(j)[k]+ " yoy ");
            }
                }
            }
            //  DataNeg = new ArrayList<>(tempX);

            //adding minus sign with negative array.
            for(int i=0;i<DataNeg.size();i++)
            {
                String x=DataNeg.get(i);
                x="-"+x;
                DataNeg.set(i, x);
            }
            }
            catch(NullPointerException np)
            {

            }
            //splitting ^ from PosArrayList
            for(int i =0;i<DataPos.size();i++)
            {
                if(DataPos.get(i).contains("^"))
                {
                    SplitPosArray=DataPos.get(i).split("\\^");
                    SplitPos = new ArrayList<>(Arrays.asList(SplitPosArray));
                    PosPower.add(SplitPos);
                }
            }

            //splitting ^ from NegArrayList
            for(int i =0;i<DataNeg.size();i++)
            {
                if(DataNeg.get(i).contains("^"))
                {
                    SplitNegArray=DataNeg.get(i).split("\\^");
                    SplitNeg = new ArrayList<>(Arrays.asList(SplitNegArray));
                    NegPower.add(SplitNeg);
                }
            }






            // checking original positive data
            for(int i=0;i<DataPos.size();i++)
            {
                System.out.println(DataPos.get(i));
            }

            //checking original negative data

            for(int i =0;i<rawNeg1.size();i++)
            {
                System.out.println(rawNeg1.get(i)[i]);
            }
            //checking sillppted postive
            for(int i=0;i<PosPower.size();i++)
            {
                for(int j=0;j<2;j++)
                {
                System.out.println(PosPower.get(i).get(j));
            }
                }
            //checking splitted negaitve
            for(int i=0;i<NegPower.size();i++)
                {
                    for(int j=0;j<2;j++)
                    {
                    System.out.println(NegPower.get(i).get(j));
                }
                    }
    }

    return "return";
 }
}

import java.util.ArrayList；
导入java.util.array；
公共类集成类{
公共静态最终字符串计算（字符串输入）
{
字符串为正[]；
字符串首字母[]；
字符串[]rawNeg=null；
字符串SplitPosArray[]=null；
字符串SplitNegArray[]=null；
ArrayList rawNeg1=新的ArrayList（）；
ArrayList DataNeg=新的ArrayList（）；
ArrayList DataPos=新的ArrayList（）；
ArrayList SplitPos=新的ArrayList（）；
ArrayList SplitNeg=新的ArrayList（）；
ArrayList PosPower=新的ArrayList（）；
ArrayList NegPower=新的ArrayList（）；
ArrayList tempX=新的ArrayList（）；
if（input.contains（“+”==true | | input.contains（“-”==true）
{
rawPositive=input.split（“\\+”）；
//将原始正数强制转换为数组列表
DataPos=newarraylist（Arrays.asList（rawPositive））；
//将最终数据转化为原始初始数据
rawNegInitial=DataPos.toArray（新字符串[DataPos.size（）]）；
//从正最终值中删除负值
对于（int i=0；i您不能“删除”数组中的元素。您可以将其指定为某个sentinel值，例如
null

List<String[]> test = ...
test.get(i)[k] = null;

列表测试=。。。
test.get（i）[k]=null；

您可以改为将其实现为列表列表：

List<List<String>> test = ...
test.get(i).remove(k);

列表测试=。。。
测试。获取（i）。移除（k）；
但是split方法包含字符串数组返回类型。快速解决方法：
新建ArrayList（Arrays.asList（Array））
就像我以前做的那样。但我认为您没有正确理解代码。请检查。我正在将阳性数据复制到阴性数据以进行排序。抱歉，我没有查看您的全部代码。我根据您的问题定义提供建议。