精华内容
下载资源
问答
  • 数组,ListSet相互转化

    万次阅读 多人点赞 2018-06-03 23:41:29
    转载:https://blog.csdn.net/my_precious/article/details/530102321.数组转化为List:String[] strArray= new String[]{"Tom", "Bob", "Jane"};List strList= Arrays.asList...

    转载:https://blog.csdn.net/my_precious/article/details/53010232

     

    1. 数组转化为List:

    String[] strArray= new String[]{"Tom", "Bob", "Jane"};
    
    List strList= Arrays.asList(strArray);

     

    2. 数组转Set

    String[] strArray= new String[]{"Tom", "Bob", "Jane"};
    
    Set<String> staffsSet = new HashSet<>(Arrays.asList(staffs));
    
    staffsSet.add("Mary"); // ok
    
    staffsSet.remove("Tom"); // ok

     

    3. List转Set

    String[] staffs = new String[]{"Tom", "Bob", "Jane"};
    
    List staffsList = Arrays.asList(staffs);
    
    Set result = new HashSet(staffsList);

     

    4. set转List

    String[] staffs = new String[]{"Tom", "Bob", "Jane"};
    
    Set<String> staffsSet = new HashSet<>(Arrays.asList(staffs));
    
    List<String> result = new ArrayList<>(staffsSet);

     

     

     

    展开全文
  • rt。var set = new Set(); set.add(元素),如何遍历set 还有转化set,var list = new Array();我定义了一个list,怎么把set转化list
  • Java Array、ListSet互相转化

    万次阅读 多人点赞 2017-12-16 15:23:51
    Java ArrayListSet互相转化 ArrayListSet互转实例 1 ArrayList互转 2 ListSet互转 ...Java Array、ListSet互相转化1. Array、ListSet互转实例1.1 Array、List互转 Array转ListString[] s = new St

    Java Array、List、Set互相转化

    1. Array、List、Set互转实例

    1.1 Array、List互转

    • ArrayList

      String[] s = new String[]{"A", "B", "C", "D","E"};
      List<String> list = Arrays.asList(s);

      注意这里list里面的元素直接是s里面的元素( list backed by the specified array),换句话就是说:s的修改,直接影响list

      s[0] ="AA";
      System.out.println("list: " + list);

      输出结果

      list: [AA, B, C, D, E]
    • ListArray

      String[] dest = list.toArray(new String[0]);//new String[0]是指定返回数组的类型
      System.out.println("dest: " + Arrays.toString(dest));

      输出结果

      dest: [AA, B, C, D, E]

      注意这里的dest里面的元素不是list里面的元素,换句话就是说:list中关于元素的修改,不会影响dest

      list.set(0, "Z");
      System.out.println("modified list: " + list);
      System.out.println("dest: " + Arrays.toString(dest));

      输出结果

      modified list: [Z, B, C, D, E]
      dest: [AA, B, C, D, E]

      可以看到list虽然被修改了,但是dest数组没有没修改。

    1.2 List、Set互转

    因为ListSet都实现了Collection接口,且addAll(Collection<? extends E> c);方法,因此可以采用addAll()方法将ListSet互相转换;另外,ListSet也提供了Collection<? extends E> c作为参数的构造函数,因此通常采用构造函数的形式完成互相转化。

    //List转Set
    Set<String> set = new HashSet<>(list);
    System.out.println("set: " + set);
    //Set转List
    List<String> list_1 = new ArrayList<>(set);
    System.out.println("list_1: " + list_1);

    toArray()一样,被转换的List(Set)的修改不会对被转化后的SetList)造成影响。

    1.3 Array、Set互转

    1.1 1.2可完成Array和Set的互转

    //array转set
    s = new String[]{"A", "B", "C", "D","E"};
    set = new HashSet<>(Arrays.asList(s));
    System.out.println("set: " + set);
    //set转array
    dest = set.toArray(new String[0]);
    System.out.println("dest: " + Arrays.toString(dest));

    2.Arrays.asList()Collection.toArray()

    上述列出的互相转换离不开Arrays.asList()Collection.toArray()两个重要的方法;

    This method acts as bridge between array-based and collection-based APIs, in combination with Collection.toArray. The returned list is serializable and implements RandomAccess.

    • Arrays.asList()

      @SafeVarargs
        @SuppressWarnings("varargs")
        public static <T> List<T> asList(T... a) {
            return new ArrayList<>(a);
        }

      这里出现的ArrayList<>并不是我们通常使用的java.util.ArrayList,因为java.util.ArrayList没有数组作为参数的构造函数。查看对应的源码发现,其实Arrays类的静态内部类。

      
       /**
         * @serial include
         */
        private static class ArrayList<E> extends AbstractList<E>
            implements RandomAccess, java.io.Serializable
        {
            private static final long serialVersionUID = -2764017481108945198L;
            private final E[] a;
      
            ArrayList(E[] array) {
                a = Objects.requireNonNull(array);
            }
      
            @Override
            public int size() {
                return a.length;
            }
      
            @Override
            public Object[] toArray() {
                return a.clone();
            }
      
            @Override
            @SuppressWarnings("unchecked")
            public <T> T[] toArray(T[] a) {
                int size = size();
                if (a.length < size)
                    return Arrays.copyOf(this.a, size,
                                         (Class<? extends T[]>) a.getClass());
                System.arraycopy(this.a, 0, a, 0, size);
                if (a.length > size)
                    a[size] = null;
                return a;
            }
      
            @Override
            public E get(int index) {
                return a[index];
            }
      
            @Override
            public E set(int index, E element) {
                E oldValue = a[index];
                a[index] = element;
                return oldValue;
            }
      
            @Override
            public int indexOf(Object o) {
                E[] a = this.a;
                if (o == null) {
                    for (int i = 0; i < a.length; i++)
                        if (a[i] == null)
                            return i;
                } else {
                    for (int i = 0; i < a.length; i++)
                        if (o.equals(a[i]))
                            return i;
                }
                return -1;
            }
      
            @Override
            public boolean contains(Object o) {
                return indexOf(o) != -1;
            }
      
            @Override
            public Spliterator<E> spliterator() {
                return Spliterators.spliterator(a, Spliterator.ORDERED);
            }
      
            @Override
            public void forEach(Consumer<? super E> action) {
                Objects.requireNonNull(action);
                for (E e : a) {
                    action.accept(e);
                }
            }
      
            @Override
            public void replaceAll(UnaryOperator<E> operator) {
                Objects.requireNonNull(operator);
                E[] a = this.a;
                for (int i = 0; i < a.length; i++) {
                    a[i] = operator.apply(a[i]);
                }
            }
      
            @Override
            public void sort(Comparator<? super E> c) {
                Arrays.sort(a, c);
            }
        }

      可以看到,这个由Arrays类实现的另一个Arrays$ArrayList,对于java.util.ArrayList类来讲,是比较简单粗糙的类。

      • 没有扩容机制;

      • 无法在指定位置add(int index, E element),调用该方法会抛异常;

        这些不同让这个ArrayList看起来实际上就是一个List-View的数组

    • Collection.toArray()

    虽然ListSet的具体实现类都对Collection.toArray()方法进行了不同程度的重写,但是大致都差不多。

    这里选AbstractCollection.toArray()的实现:

    
    public <T> T[] toArray(T[] a) {
            // Estimate size of array; be prepared to see more or fewer elements
            int size = size();
            T[] r = a.length >= size ? a :
                      (T[])java.lang.reflect.Array
                      .newInstance(a.getClass().getComponentType(), size);//如果给定的参数T[] a的长度足够存放当前collection(list or set)的元素,则采用该参数来存放元素;否则则根据参数给定的类型反射生成一个数组;
      //因此这里的参数T[] a有俩作用;第一:可能用作存放元素;第二:为返回数组提供类型
            Iterator<E> it = iterator();
            for (int i = 0; i < r.length; i++) {
                if (! it.hasNext()) { // fewer elements than expected 集合的size少于给定的参数数组的长度
                    if (a == r) {
                        r[i] = null; // null-terminate 最后一个元素被设置为null,表明collection元素结束;
                    } else if (a.length < i) {
                        return Arrays.copyOf(r, i);
                    } else {
                        System.arraycopy(r, 0, a, 0, i);
                        if (a.length > i) {
                            a[i] = null;
                        }
                    }
                    return a;
                }
                r[i] = (T)it.next();
            }
            // more elements than expected
            return it.hasNext() ? finishToArray(r, it) : r;
        }
    展开全文
  • 集合---->数组: List list = new ArrayList

    集合---->数组:

    List<Integer> list = new ArrayList<Integer>();

    list.add(4);

    list.add(6);

    list.add(8);

    Integer[] arr= new Integer[list.size()];

    arr = list.toArray(arr);


    数组--->集合:

    Integer arr = new Integer[]{3,4,5,7};

    List list = Arrays.asList(arr);


    Set------> List 并排序

    class User{

     private Integer id

     private String name;

     private String address;

    set get....


    }

    Set<User> users = new HashSet<User>();

    List<User> sortUsers = new ArrayList<User>(users);

    Collections.sort(sortUsers , new Comparator<User>(){

    @Override

    public int compare(User u1, User u2){

    return u1.getId()-o2.getId();

    }

    });



    展开全文
  • SetList之间转化

    万次阅读 2016-09-21 13:48:59
    List list = new ArrayList(set); Set set = new HashSet(list); //但是有一点,转换当中可能要丢失数据,尤其是从list转换到set的时候,因为set不能有重复数据 //还有转换到set之后,他们原先在list上的顺序就没了, ...
    <span style="font-size:18px;">List list = new ArrayList(set);
    Set set = new HashSet(list);
    //但是有一点,转换当中可能要丢失数据,尤其是从list转换到set的时候,因为set不能有重复数据 </span>
    <span style="font-size:18px;">//还有转换到set之后,他们原先在list上的顺序就没了,
     public class Csdn {     
        public static void main(String[] args) {        
            List<String> list = new ArrayList<String>();         
            Collections.addAll(list, "quan","jin","long");//填充         
            Set<String> set=new HashSet<String>();         
            set.addAll(list);//给set填充         
            list.clear();//清空list,不然下次把set元素加入此list的时候是在原来的基础上追加元素的         
            list.addAll(set);//把set的数据填充到list内
        }
     }</span>

    展开全文
  • ResultSet转化为json,json转化为List,轻松搞定
  • Set集合可否强制转化list

    千次阅读 2007-01-07 17:13:00
    我在Hibernate中的xml文件中定义了双向映射,并附加了一个元素one-to-many产生的Set元素,并在持久化类用getSubSubject()取到了定义的Set集合,强制转化list行吗? List list = (List)getSubSubject(); //Set ...
  • list,set,map相互转化

    2012-07-23 18:11:24
    1.listset   Java代码  Set set = new HashSet(new ArrayList()); 2.setlist   Java代码  List list = new ArrayList(new HashSet()); 3.数组转为list   Java代码  ...
  • Array、ListSet互相转化

    千次阅读 2018-10-18 14:08:25
    Array、List互转 数组转List String[] s = new String[]{"A", "B", "C", "D","E"}; List&lt;String&gt; list = Arrays.asList(s); List转Array String...
  • listset集合是java中最常见的两种数据结构,都是Collection的子集,今天就简单的说说他们两者的遍历以及相互转化吧。 一、list的遍历 有三种遍历方法: /**  * list的三种遍历  * @author Owner  ...
  • Java Map集合 转化为List为List排序

    千次阅读 2016-03-30 22:48:06
    Java 集合 简单的Map 和 List 之间的转化 以及List的排序
  • list set map collection之间的转化

    万次阅读 2012-08-17 15:40:22
    ★ 数组转Collection 使用Apache Jakarta Commons Collections: import org.apache.commons.collections.CollectionUtils; String[] strArray = {"aaa", ...List strList = new ArrayList();...Set
  • java集合的相互转化(map,set,list,array)

    千次阅读 2017-12-18 11:30:31
    1.应用场景java中有丰富的集合类,日常开发中几乎时刻需要使用到各种各样的集合类,其中常用的集合类包括有Map,Set,List,Array等等。下面我们就来针对各个集合类的相互转化做一下总结。2.实测代码二话不说,直接上...
  • json字符串转化为list泛型

    千次阅读 2015-04-07 14:55:27
    List<User> userList = new ArrayList(); for ( int i = 0 ; i (); i++) { User user = (User) JSONObject.toBean( JSONObject.fromObject(jsonArray. get (i)), User. class ); userList.add(user); } ...
  • python中setlist、tuple、dict相互转化

    千次阅读 2019-06-12 21:10:40
    list1 = [1, 2, 3, 4] tuple1 = (5, 6, 7, 8) set1 = {9, 10, 11, 12} dict1 = {"a": "13", "b": "14", "c": "15", "d": "16"} 转为list print(list(tuple1)) = [5, 6, 7, 8] print(list(set1)) = [9, 10, 1...
  • List, Object>>转化为List工具类

    热门讨论 2013-08-17 08:51:57
    一般使用springjdbc、hibernate的sql查询,库获取到的数据都是List, Object>>结果集,如果我们要转化为JavaBean,则需要做一系列的map.get(),然后obj.set()。 此工程中就是解决List, Object>>转化为JavaBean工具类...
  • Java- Set 转换成List

    万次阅读 2019-04-17 10:14:31
    转载:... Set 转换成List 有两种方法, 假设有Set集合 Set<String> myset=new HashSet<String>(); 1. 使用Arrays.asList(T... a) 转换成List, 此转换返回的list ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 147,619
精华内容 59,047
关键字:

把set转化为list