1. 首页首页
  2. 编程汇总编程汇总

数组转换成list集合_字符串转数组js

编程汇总 • • 阅读 8

数组转换成list集合_字符串转数组jsString str 1 2 3 List strings Arrays asList str strings add eee 报错如下 Exception in thread main java lang UnsupportedO at java util AbstractList

        String str[] = {"1","2","3"};

        List strings = Arrays.asList(str);

        strings.add("eee");

报错如下:

Exception in thread “main” java.lang.UnsupportedOperationException

at java.util.AbstractList.add(AbstractList.java:148)

at java.util.AbstractList.add(AbstractList.java:108)

at Test.test1(Test.java:31)

at Test.main(Test.java:24)

为了创建出一个真正的ArrayList，代码应该如下所示：(这种方法创建的集合可以进行集合的增加)

        String str[] = {"1","2","3"};

        List strings = new ArrayList(Arrays.asList(str));

        strings.add("4");

        System.out.println(strings);

更加高效的代码如下:

        String str[] = {"1","2","3"};

        List strings = new ArrayList(str.length);

        Collections.addAll(strings,str);

        strings.add("4");

        System.out.println(strings);

2.集合转数组

(1)错误演示

很多人习惯下面用法:

        List strings = new ArrayList();

        String[] objects = (String[]) strings.toArray();

编译通过，运行报错如下:

Exception in thread “main” java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.String;

at Test.test1(Test.java:32)

at Test.main(Test.java:26)

学过JVM的应该知道上面的意思是Object数组不能转变为String数组。[代表以为数组,L代表数组的元素是引用类型，后面是具体的元素类型

对于这个现象我们可以这么解释：Java中允许向上和向下转型，但是这个转型是否成功是根据Java虚拟机中这个对象的类型来实现的。Java虚拟机中保存 了每个对象的类型。而数组也是一个对象。数组的类型是[Ljava.lang.Object。把[Ljava.lang.Object转换成 [Ljava.lang.String是显然不可能的事情，因为这里是一个向下转型，而虚拟机只保存了这是一个Object的数组，不能保证数组中的元素 是String的，所以这个转型不能成功。数组里面的元素只是元素的引用，不是存储的具体元素，所以数组中元素的类型还是保存在Java虚拟机中的。

根据上面的解释，我们可以把这个问题归纳到下面这个模型：

Object objs[]=new Object[10];

String strs[]=(String[])objs;

这样子和刚才上面编译错误是一样的。如果我们修改一下这个代码，如下：

String strs[]=new String[10];

Object objs[]=strs;

这样子就可以编译通过了。所以这个问题我们可以归结为一个Java转型规则的问题。

(2)正确的做法:(延伸一点直接打印数组打印的是数组的)

最菜鸡的做法是:

        List list = new ArrayList();

        list.add("1");

        String strings[]=new String[list.size()];

        for(int i=0,j=list.size();i
            strings[i]=list.get(i);

        }



        System.out.println(strings);

        System.out.println(strings.getClass());

        System.out.println(Arrays.toString(strings));

结果:

[Ljava.lang.String;@20724356

class [Ljava.lang.String;

[1]

比较简便的做法:

        List list = new ArrayList();

        list.add("1");

        String[] strings = new String[list.size()];

        list.toArray(strings);



        System.out.println(strings);

        System.out.println(strings.getClass());

        System.out.println(Arrays.toString(strings));

结果同上。

3.数组转数组–代码用到了commons-beanutils包

最常见的就是字符串数组类型转int、long数组，或者字符串类型转Integer、Long、Integer型转int(也就是包装类型转原始类型)。

最原始的for循环转换赋值在这里就不试了。

数组类型的转换:

import org.apache.commons.beanutils.ConvertUtils;



import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.List;



public class Test {

    public static void main(String[] args) {

        String str[] = { "1", "2", "3" };



       // 字符串数组转long数组

        long[] str2lon = (long[]) ConvertUtils.convert(str, long.class);

        System.out.println(str2lon);

        // 字符串数组转Long数组

        Long[] str2Lon = (Long[]) ConvertUtils.convert(str, Long.class);

        System.out.println(str2Lon);





        // 字符串数组转int数组

        int[] str2int = (int[]) ConvertUtils.convert(str, int.class);

        System.out.println(str2int);

        // 字符串数组转Integer数组

        Integer[] str2Int = (Integer[]) ConvertUtils.convert(str, Integer.class);

        System.out.println(str2Int);



        // int型数组转为String数组

        String int2Str[] = (String[]) ConvertUtils.convert(str2int, String[].class);

        System.out.println(int2Str);

        // Integer型数组转为String数组

        String Int2Str[] = (String[]) ConvertUtils.convert(str2Int, String[].class);

        System.out.println(Int2Str);



        // long型数组转为String数组

        String lon2str[] = (String[]) ConvertUtils.convert(str2lon, String[].class);

        System.out.println(lon2str);

        String Lon2str[] = (String[]) ConvertUtils.convert(str2Lon, String[].class);

        System.out.println(Lon2str);

    }

}

[J@15a6d5e1

[Ljava.lang.Long;@7c23b1e1

[I@b736a73

[Ljava.lang.Integer;@4651a9e4

[Ljava.lang.String;@1b68dbcd

[Ljava.lang.String;@1367dca

[Ljava.lang.String;@207c5965

[Ljava.lang.String;@43d1068c

关于包装类型转原始类，可以用commons-lang包的ArrayUtils操作，参考:https://www.cnblogs.com/qlqwjy/p/9467178.html

补充:补充一点JVM相关知识

在Java中，任何类型都有class，包括基本数据类型与void。在Java中 [ 代表数组, [[ 代表二维数组。依次类推。

其他的描述标识符如下:

B—基本数据类型byte

C—基本数据类型char

D—基本数据类型double

F—基本数据类型float

I—基本数据类型int

J—基本数据类型long

S—基本数据类型short

Z—基本数据类型boolean

V—特殊类型void

L—对象类型(也就是引用类型)。例如 Ljava/lang/Object.

需要注意的是八种基本数据类型也有 calss,而且其对应包装类型有一个TYPE成员变量就是其基本数据类型。特殊类型void也有class。基本类型的数组与引用类型数组也都有class

public static final Class  TYPE = (Class) Class.getPrimitiveClass("int");

例如:

        System.out.println(int.class);

        System.out.println(Integer.class);

        System.out.println(Integer.TYPE);



        System.out.println(Integer[].class);

        System.out.println(int[].class);

        System.out.println(void.class);

结果:

int
class java.lang.Integer
int
class [Ljava.lang.Integer;
class [I
void

注意int不是对象，所以没有getClass方法。只有int.class

==================数组与集合排序==================

JDK自带的排序方法可以满足大部分要求。我们知道要在集合中排序，需要使用可以排序的集合或者自己手动排序。使用可排序的集合如TreeMap,TreeSet。如果手动排序就是用Collections.sort传入一个比较器即可。

1.数组排序

在使用Arrays.sort()对int、double、long等基本类型的数组进行排序时，只有正序排序的方法。要实现倒序排序，只有使用Integer、Double、Long等代替。

包装类型比较的时候可以传入比较器，如下:

import java.util.Arrays;

import java.util.Collections;

import java.util.Comparator;



public class PlainTest {



    public static void main(String[] args) {

        // 基本数据类型Arrays.sort正序

        char[] chars = { 'a', 'b', 'd', 'e', 'c', 'e', 'd', 'a' };

        Arrays.sort(chars);

        System.out.println(chars);



        // 原生数组正序

        Character[] characters = { 'a', 'b', 'd', 'e', 'c', 'e', 'd', 'a' };

        Arrays.sort(characters);

        System.out.println(Arrays.toString(characters));



        // 原生数组逆序

        Arrays.sort(characters, Collections.reverseOrder());

        System.out.println(Arrays.toString(characters));



        // 自己实现逆序号排序

        Arrays.sort(characters, new Comparator() {

            @Override

            public int compare(Character o1, Character o2) {

                if (o1 > o2) {

                    return -1;

                } else if (o1 < o2) {

                    return 1;

                }

                return 0;

            }

        });

        System.out.println(Arrays.toString(characters));

    }



}

结果:

aabcddee
[a, a, b, c, d, d, e, e]
[e, e, d, d, c, b, a, a]
[e, e, d, d, c, b, a, a]

查看源码:(逆序是通过反转compare来实现的)

    public static  Comparator reverseOrder() {

        return (Comparator) ReverseComparator.REVERSE_ORDER;

    }



    private static class ReverseComparator

        implements Comparator>, Serializable {



        private static final long serialVersionUID = 7207038068494060240L;



        static final ReverseComparator REVERSE_ORDER

            = new ReverseComparator();



        public int compare(Comparable c1, Comparable c2) {

            return c2.compareTo(c1);

        }



        private Object readResolve() { return reverseOrder(); }

    }
2.集合排序
集合排序与数组类似。
import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.Comparator;

import java.util.List;



public class PlainTest {



    public static void main(String[] args) {

        Character[] characters = { 'a', 'b', 'd', 'e', 'c', 'e', 'd', 'a' };

        List list = new ArrayList(Arrays.asList(characters));

        System.out.println(list);



        // 集合正序

        Collections.sort(list);

        System.out.println(list);



        // 集合逆序

        Collections.sort(list, Collections.reverseOrder());

        System.out.println(list);



        // 自己实现逆序号排序

        Collections.sort(list, new Comparator() {

            @Override

            public int compare(Character o1, Character o2) {

                if (o1 > o2) {

                    return -1;

                } else if (o1 < o2) {

                    return 1;

                }

                return 0;

            }

        });

        System.out.println(list);

    }



}
结果:
[a, b, d, e, c, e, d, a]

 [a, a, b, c, d, d, e, e]

 [e, e, d, d, c, b, a, a]

 [e, e, d, d, c, b, a, a]
转自：https://www.cnblogs.com/qlqwjy/p/10010205.html

                    

                    


                    

                        

                            

                                编程小号
                            

                            

                                

                                    
                                        
                                    
                                

                            

                        

                    

                

                

                    
                    
                    

                        
                        

                             上一篇
                            2025-03-06 13:30
                        

                    

                    
                    


                    
                    
                    

                        
                        

                            下一篇 
                            2025-04-11 18:40
                        

                    

                    
                    
                


                

                    
相关推荐

                    
                

                

                    

                        版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，
                        请发送邮件至 举报，一经查实，本站将立刻删除。
如需转载请保留出处：https://bianchenghao.cn/hz/119520.html