如何将“String”数据转换为“ArrayList”

问题描述 投票：0回答：5

我在字符串中有如下数据：

String originalData = "[12345, 65656, abc, 7.5, 12/12/2023],[65656,abc,7.5,12/12/2020],[76767,565656,abc,7.5,12/12/2020]";

我想将以上内容存储在 ArrayList processedData();

输出：

processedData.get(0)= [12345, 65656, abc, 7.5, 12/12/2023]
processedData.get(0).get(0)= 12345
java string arraylist stringtokenizer
5个回答
0
投票
public static void main(String[] args) throws Exception {
    String originalData = "[12345, 65656, abc, 7.5, 12/12/2023],[65656,abc,7.5,12/12/2020],[76767,565656,abc,7.5,12/12/2020]";
    String[] array = originalData .substring(1, originalData .length() - 1).split("\\],\\[");
    List<List<String>> ans = new ArrayList<>(array.length);
    for (String str : array) {
        ans.add(toList(str));
    }
    System.out.println(ans.get(0));
    System.out.println(ans.get(2));
    System.out.println(ans.get(0).get(0));
}

private static List<String> toList(String source) {
    String[] array = source.split(",");
    List<String> ans = new ArrayList<>(array.length);
    for (String str : array) {
        ans.add(str.trim());
    }
    return ans;
}
0
投票

为了尽可能简单，请参考下面的代码。你需要的是最后的

list
。

public static void main(String[] args) {
        String originalData = "[12345, 65656, abc, 7.5, 12/12/2023],[65656,abc,7.5,12/12/2020],[76767,565656,abc,7.5,12/12/2020]";
        String [] newArray = originalData.split("\\],\\[");
        List<List<String>> list = new ArrayList<>();
        for(String s: newArray){
            String[] subArray = s.split(",");
            List subArrayList = Arrays.asList(subArray);
            list.add(subArrayList);
        }
        System.out.println(list.toString());
}
0
投票

tl;博士

[12345,65656,abc,7.5,12/12/2021],[42423,65656,abc,7.5,12/12/2022],[76767,565656,abc,7.5,12/12/2023]” 

Arrays
.stream( input.split( "],\\[" )  /* Escape the opening bracket with double backslash. */ )
.map( ( String s ) -> s.replace( "[" , "" ).replace( "\\]" , "" ) )
.map( ( String s ) -> List.of( s.split( "," ) ) )
.toList();

[[12345,65656,abc,7.5,12/12/2021], [42423,65656,abc,7.5,12/12/2022], [76767,565656,abc,7.5,12/12/2023]] ]

流和 lambdas

这里的其他答案似乎不错。但这是我自己的旋转，使用流和 lambdas。

首先，让我们规范化您的示例数据。你似乎做了一些草率的编辑/打字错误。我将修复您的各种分隔符和您丢失的数据字段。我更改了日期的年份以便于测试。

String input = "[12345,65656,abc,7.5,12/12/2021],[42423,65656,abc,7.5,12/12/2022],[76767,565656,abc,7.5,12/12/2023]";

按分隔符

],[
拆分输入字符串。左括号必须用一对反斜杠字符转义。

通过调用 

Arrays.stream
.

生成这些拆分块的结果数组的流

从该流中，通过删除所有剩余的括号来清理文本。

通过在逗号字符的内部定界符上拆分来交换每个清理过的文本。对生成的字符串数组进行不可修改的

List
。

将所有这些 

List
的字符串收集到一个 
List
中，这是一个字符串列表。

List < List < String > > listOfListsOfStrings =
        Arrays
                .stream( input.split( "],\\[" )  /* Escape the opening bracket with double backslash. */ )
                .map( ( String s ) -> s.replace( "[" , "" ).replace( "\\]" , "" ) )
                .map( ( String s ) -> List.of( s.split( "," ) ) )
                .toList();

在 Ideone.com . 看到这段代码实时运行

listOfListsOfStrings = [[12345,65656,abc,7.5,12/12/2021], [42423,65656,abc,7.5,12/12/2022], [76767,565656,abc,7.5,12/12/2023 ]]]

对象，不仅仅是字符串

更好的是，避免只对字符串操作进行编码。利用面向对象编程的类型丰富的环境。定义一个类来表示字符串列表的含义。

如果此类的主要目的仅仅是透明且不变地传递数据，请将您的类定义为 record。您可以在本地定义记录，或嵌套在一个类中，或作为一个单独的类。

我会想象您的输入数据描述的是待售产品。

record Product( int id , int category , String description , BigDecimal price , LocalDate availability ) {}

向该记录添加静态方法以处理我们的

List< String >
.

record Product( int id , int category , String description , BigDecimal price , LocalDate availability )
{
    static Product fromListOfStrings ( List < String > listOfStrings )
    {
        System.out.println( "listOfStrings = " + listOfStrings );
        return new Product(
                Integer.parseInt( listOfStrings.get( 0 ) ) ,
                Integer.parseInt( listOfStrings.get( 1 ) ) ,
                listOfStrings.get( 2 ) ,
                new BigDecimal( listOfStrings.get( 3 ) ) ,
                LocalDate.parse( listOfStrings.get( 4 ) , DateTimeFormatter.ofPattern( "MM/dd/uuuu" ) )
        );
    }
}

如前所述使用流和 lambda 处理输入字符串。但是添加另一个调用 

Stream::map
以在我们的记录中调用该静态工厂方法。该工厂方法返回一个 
Product
对象。我们将这些
Product
对象收集到一个列表中。

String input = "[12345,65656,abc,7.5,12/12/2021],[42423,65656,abc,7.5,12/12/2022],[76767,565656,abc,7.5,12/12/2023]";
List < Product > products =
        Arrays
                .stream( input.split( "],\\[" )  /* Escape the opening bracket with double backslash. */ )
                .map( ( String s ) -> s.replace( "[" , "" ).replace( "]" , "" ) )
                .map( ( String s ) -> List.of( s.split( "," ) ) )
                .map( Product :: fromListOfStrings )
                .toList();

运行时：

listOfStrings = [12345, 65656, abc, 7.5, 12/12/2021]
listOfStrings = [42423, 65656, abc, 7.5, 12/12/2022]
listOfStrings = [76767, 565656, abc, 7.5, 12/12/2023]
products.toString() = [Product[id=12345, category=65656, description=abc, price=7.5, availability=2021-12-12], Product[id=42423, category=65656, description=abc, price=7.5, availability=2022-12-12], Product[id=76767, category=565656, description=abc, price=7.5, availability=2023-12-12]]

ISO 8601

提示：当以文本方式交换日期时间值时，请始终使用标准 ISO 8601 格式，而不是本地化的模糊格式。对于仅限日期的值，标准格式为 YYYY-MM-DD。

0
投票

对于 java.util，最好始终使用它的完整名称，否则如果短名称实例太多，就会出现问题。

/*
        char[] crbr = {'[',']'};
        String brl = new Character(crbr[0]).toString();
        String brr = new Character(crbr[1]).toString();
        originalData = originalData.replaceAll(brl,"");
        originalData = originalData.replaceAll(brr,"");
        */
        // Above code will remove any of the brackets anywhere in  originalData  with the uncommented code following if wanted uncomment above
    // next line didn't notice the brackets were only at the ends of the whole string

   originalData = originalData.trim();
      originalData = originalData.substring(1,(arl[csv].length()-1));
        String[] arl = originalData.split(","):
          int arln = arl.length; 
         java.util.ArrayList<String>  arlst = new java.util.ArrayList<String>(arln);
              for(int csv=0; csv<arln; csv++){
           arl[csv] =  arl[csv].trim();  
                arlst.add(arl[csv]);
                        }
0
投票

这是一个单行：

List<List<String>> lists = Arrays.stream(input.replaceAll("^\\[|]$", "").split("] *, *\\["))
  .map(s -> Arrays.asList(s.split(" *, *")))
  .collect(Collectors.toList());

首先修剪前导/尾随 

[
和 
]
然后将列表作为字符串流式传输，然后将它们拆分为 
List<String>
然后收集它们。

拆分

"] *, *\\["
和
" *, *"
（而不是
"],\\["
和
","
）意味着无论逗号前后是否有空格，这都会起作用。

作为方法：

List<List<String>> toListOfList(String input) {
    return Arrays.stream(input.replaceAll("^\\[|]$", "").split("] *, *\\["))
      .map(s -> Arrays.asList(s.split(" *, *")))
      .collect(Collectors.toList());
}
最新问题
© www.soinside.com 2019 - 2024. All rights reserved.