集合与数组互转

　　一.集合转数组

　　以ArrayList集合为例，使用该集合的一个成员方法toArray()，可以将一个集合对象转化为一个数组。如下所示：　　

1 void listToArray(){
2         List<String> list=new ArrayList<>();//创建一个集合对象
3         list.add("a");//向集合对象里添加元素
4         list.add("b");
5         list.add("c");
6         System.out.println("原集合:"+list);//打印集合
7         Object[] array = list.toArray();//集合转数组
8         System.out.println("集合转数组后:"+Arrays.toString(array));//打印数组
9     }

　　上述代码打印结果：

原集合:[a, b, c]
集合转数组后:[a, b, c]

　　二.数组转集合

　　对于数组转集合，类Arrays给我们提供了一个方法asList()，可以生成一个“集合”，我们看一下生成的该集合有什么特点：

 1 Object[] listToArray1(){
 2    List<String> list=new ArrayList<>();//创建一个集合对象
 3    list.add("a");//向集合对象里添加元素
 4    list.add("b");
 5    list.add("c");
 6    return list.toArray();//集合转数组
 7 }
 8 void arrayToList1(){
 9    Object[] array = listToArray1();
10    List<Object> asList = Arrays.asList(array);
11    System.out.println("数组转假集合:"+asList);
12    /**
13     * 注意:
14     * 我们通过查看Java API源代码可以知道,
15     * Arrays.asList(T... a)产生的集合,并非真正意义上的集合,Arrays.asList()方法返回的是类Arrays的一个私有静态内部类,并非真正意义上的集合体系,
16     * 实际上仍然是一个数组,我们可将该集合称为"假集合"
17     * 该"假集合"可以像数组一样对元素进行遍历查询,
18     * 但是不能像真正的集合那样对元素进行增删改,否则会报错
19     */
20 }

　　既然Arrays.asList(T... a)产生的是“假集合”，那么如何通过数组转化成一个真正的集合呢？我们可以在“假集合”的基础上，产生一个“真集合”：　　

 1 void arrayToList2(){
 2         Object[] array = listToArray1();
 3         List<Object> asList = Arrays.asList(array);//假集合
 4         ArrayList<Object> list = new ArrayList<>(asList);//假集合转真集合
 5         System.out.println("集合中原来的元素:"+list);
 6         list.add("d");
 7         list.add("e");
 8         System.out.println("向集合中添加两个元素后:"+list);
 9         list.remove(1);
10         System.out.println("删除集合中角标为1的元素后:"+list);
11         list.set(0,"哈哈");
12         System.out.println("修改集合中角标为0的元素后:"+list);
13     }

　　上述代码打印后的结果如下：

集合中原来的元素:[a, b, c]
向集合中添加两个元素后:[a, b, c, d, e]
删除集合中角标为1的元素后:[a, c, d, e]
修改集合中角标为0的元素后:[哈哈, c, d, e]

　　三.集合中元素的排序问题

　　我们先来看一个对集合中元素进行重新排序的案例：

 1 void sortList(){
 2         List<String> list=new ArrayList<>();
 3         list.add("张三");
 4         list.add("李四");
 5         list.add("王五");
 6         list.add("赵六");
 7         list.add("田七");
 8         list.add("刘八");
 9         list.add("孙九");
10         System.out.println("排序前,默认按照元素插入的先后顺序进行排序:");
11         for (int i=0;i<list.size();i++){
12             System.out.print(list.get(i)+"  ");
13         }
14         System.out.println();
15         /*
16             类Collections为我们提供了一个sort()方法,该方法传入了两个参数,
17             一个是待排序的集合对象,
18             另一个是实现了接口Comparator的类的实例
19          */
20         Collections.sort(list, Collator.getInstance(java.util.Locale.CHINA));
21         /**
22          * 注意：
23          * 这是根据的汉字的拼音的字母排序的，而不是根据汉字一般的排序方法
24          */
25         System.out.println("排序后,按照指定的排序规则进行排序:");
26         for (int i=0;i<list.size();i++){
27             System.out.print(list.get(i)+"  ");
28         }
29     }

　　上述代码运行后结果如下：

排序前,默认按照元素插入的先后顺序进行排序:
张三  李四  王五  赵六  田七  刘八  孙九
排序后,按照指定的排序规则进行排序:
李四  刘八  孙九  田七  王五  张三  赵六

　　通过上述案例可以看出，我们对集合中的元素进行排序，实际上在内部采用了对比较器接口的重新定义。

　　一般来说，我们常用的比较器接口主要有两个，一个是接口Comparator，另一个是接口Comparable。我们查看这两个接口用于元素比较的核心方法如下：

public interface Comparator<T> {
        int compare(T o1, T o2);//用于比较传入的两个参数的大小
        boolean equals(Object obj);//用于比较是否相等
    }

public interface Comparable<T> {
        public int compareTo(T o);//用指定对象与传入的参数比较大小
    }

　　上述两个比较器接口中，我们主要来看用于比较大小的方法。在对两个对象元素进行比较时，返回1表示前面的元素比后面的元素大，返回0表示两个元素相等，返回-1表示前面的元素比后面的元素小。我们知道，集合里可以储存任意对象，接下来，我们在集合里储存自定义的对象，然后对这些对象元素进行排序。

　　我们先用接口Comparable，重写里面的compareTo()方法，具体如下：　　

 1 import java.util.ArrayList;
 2 import java.util.Collections;
 3 import java.util.List;
 4 public class Test3 {
 5     //定义一个学生A内部类,令其实现接口Comparable,重写里面的comparaTo()方法
 6     static class StudentA implements Comparable{
 7         private String name;
 8         private int age;
 9         public StudentA() {
10         }
11         public StudentA(String name, int age) {
12             this.name = name;
13             this.age = age;
14         }
15         public String getName() {
16             return name;
17         }
18         public void setName(String name) {
19             this.name = name;
20         }
21         public int getAge() {
22             return age;
23         }
24         public void setAge(int age) {
25             this.age = age;
26         }
27         @Override
28         public String toString() {
29             return "StudentA{" +
30                     "name=‘" + name + ‘\‘‘ +
31                     ", age=" + age +
32                     ‘}‘;
33         }
34         //比较年龄大小
35         @Override
36         public int compareTo(Object o) {
37             StudentA otherStu= (StudentA) o;
38             int otherStuAge = otherStu.getAge();
39             return this.getAge()>otherStuAge?1:this.getAge()<otherStuAge?-1:0;
40         }
41     }
42     public static void main(String[] args) {
43         List<StudentA> list=new ArrayList<>();
44         StudentA stuA1 = new StudentA("小明", 17);
45         StudentA stuA2 = new StudentA("小光", 15);
46         StudentA stuA3 = new StudentA("小光", 16);
47         StudentA stuA4 = new StudentA("小光", 14);
48         StudentA stuA5 = new StudentA("小光", 18);
49         list.add(stuA1);
50         list.add(stuA2);
51         list.add(stuA3);
52         list.add(stuA4);
53         list.add(stuA5);
54         System.out.println("排序前,默认排序:");
55         for (int i=0;i<list.size();i++){
56             System.out.println(list.get(i));
57         }
58         Collections.sort(list);
59         System.out.println("按照StudentA的age升序排列:");
60         for (int i=0;i<list.size();i++){
61             System.out.println(list.get(i));
62         }
63         Collections.reverse(list);
64         System.out.println("按照StudentA的age降序序排列:");
65         for (int i=0;i<list.size();i++){
66             System.out.println(list.get(i));
67         }
68     }
69 }

　　接下来，我们再通过接口Comparator实现自定义排序。在使用该方法时，我们需要写一个比较器类来实现接口Comparator，并重写里面的compare(Object o1, Object o2)方法。具体如下：

 1 import java.util.ArrayList;
 2 import java.util.Collections;
 3 import java.util.Comparator;
 4 import java.util.List;
 5 public class Test4 {
 6     static class StudentB{
 7         private String name;
 8         private int age;
 9         public StudentB() {
10         }
11         public StudentB(String name, int age) {
12             this.name = name;
13             this.age = age;
14         }
15         public String getName() {
16             return name;
17         }
18         public void setName(String name) {
19             this.name = name;
20         }
21
22         public int getAge() {
23             return age;
24         }
25         public void setAge(int age) {
26             this.age = age;
27         }
28         @Override
29         public String toString() {
30             return "StudentB{" +
31                     "name=‘" + name + ‘\‘‘ +
32                     ", age=" + age +
33                     ‘}‘;
34         }
35     }
36     static class MyComparator implements Comparator {
37
38         @Override
39         public int compare(Object o1, Object o2) {
40             StudentB stuB1= (StudentB) o1;
41             StudentB stuB2= (StudentB) o2;
42             return stuB1.getAge()>stuB2.getAge()?1:stuB1.getAge()<stuB2.getAge()?-1:0;
43         }
44     }
45     public static void main(String[] args) {
46         List<StudentB> list=new ArrayList<>();
47         StudentB stuB1 = new StudentB("小明", 17);
48         StudentB stuB2 = new StudentB("小光", 15);
49         StudentB stuB3 = new StudentB("小光", 16);
50         StudentB stuB4 = new StudentB("小光", 14);
51         StudentB stuB5 = new StudentB("小光", 18);
52         list.add(stuB1);
53         list.add(stuB2);
54         list.add(stuB3);
55         list.add(stuB4);
56         list.add(stuB5);
57         System.out.println("排序前,默认排序:");
58         for (int i=0;i<list.size();i++){
59             System.out.println(list.get(i));
60         }
61         //创建自定义的比较器对象
62         MyComparator mc=new MyComparator();
63         Collections.sort(list,mc);
64         System.out.println("按照StudentB的age升序排列:");
65         for (int i=0;i<list.size();i++){
66             System.out.println(list.get(i));
67         }
68         Collections.reverse(list);
69         System.out.println("按照StudentB的age降序序排列:");
70         for (int i=0;i<list.size();i++){
71             System.out.println(list.get(i));
72         }
73     }
74 }

　　上述代码运行后的结果如下：

排序前,默认排序:
StudentB{name=‘小明‘, age=17}
StudentB{name=‘小光‘, age=15}
StudentB{name=‘小光‘, age=16}
StudentB{name=‘小光‘, age=14}
StudentB{name=‘小光‘, age=18}
按照StudentB的age升序排列:
StudentB{name=‘小光‘, age=14}
StudentB{name=‘小光‘, age=15}
StudentB{name=‘小光‘, age=16}
StudentB{name=‘小明‘, age=17}
StudentB{name=‘小光‘, age=18}
按照StudentB的age降序序排列:
StudentB{name=‘小光‘, age=18}
StudentB{name=‘小明‘, age=17}
StudentB{name=‘小光‘, age=16}
StudentB{name=‘小光‘, age=15}
StudentB{name=‘小光‘, age=14}

　　最后，使用比较器不仅可以比较两个元素的大小，从而实现自定义排序，还可以运用于集合中元素的查重。 在对集合中的元素进行查重时，我们通常还要配合对象的toString()方法，以及hashCode()和equals()方法进行。

原文地址：https://www.cnblogs.com/lizhangyong/p/8376318.html

时间： 2024-08-26 14:51:50

集合与数组互转的相关文章

java集合和数组互转

方法一:使用Arrays.asList()方法String[] strs = {"one","two","three"};List<String> strList = Array.asList(strs);注意:1)这个方法返回的是基于数组的List视图,并未正在的创建List对象,所以不能对List进行增加和删除操作,进行修改List是,同样会修改到数组.2)数组转换成只读的List,使用Collections.unmodifiab

java 集合与数组的互转方法，与源码分析

前言 java数组与集合需要互相转换的场景非常多,但是运用不好还是容易抛出UnSupportedOperationException.下面讲解一下互转的方法,以及结合源码分异常产生的原因 集合转数组 List<String> strList = new ArrayList<>(10); strList.add("aa"); strList.add("bb"); strList.add("cc"); String[] str

集合框架-数组与集合互转

数组和集合类同是容器,有何不同? 数组虽然也可以存储对象,但长度是固定的:集合长度是可变的. 数组中可以对象和存储基本数据类型,集合只能存储对象. 集合框架-数组转成集合 java.util 类 Arrays * Arrays:用于操作数据的工具类提供了很多常见的方法比如排序,搜索等. * 该类中的方法都是静态的. * 数组转成集合   Arrays.asList([]); * 好处:可以使用集合list的方法来操作数组中的元素.可以使用集合 改查方法,只要不改变数组长度都可以. * 弊端:不可

集合和数组的区别

集合和数组的区别? *                     1)长度的区别: *                         数组:长度是固定的 *                         集合:长度是可变的 *                     2)内容的区别: *                         数组存储的是同一种类型的元素:举例:水杯中的水 *                         集合存储的是不同类型的元素:举例:杯子:加水,加可乐; *

集合转数组,数组转集合,集合中只可以装引用数据类型

1 package com.pang.jihe_demo; 2 3 import java.util.ArrayList; 4 import java.util.Arrays; 5 import java.util.List; 6 7 public class Demo01 { 8 public static void main(String[] args) { 9 //集合转数组,集合中只可以装引用数据类型 10 ArrayList<Integer> list = new ArrayList

集合 和 数组 的区别

集合框架 包含三块内容 对外的接口 ,接口的实现和对集合运算的算法. 一 集合 和数组的区别: 1.数组声明元素的类型,而集合不声明. 2.数组声明之后有固定的大小.一旦生成无法改变.而集合是可以改变大小的, 集合提供了更多的成员方法,能满足更多的需求. 3.数组无论是效率还是检查类型都是最好的. 数组是JAVA语言内置的数据类型,它是一个线性的序列,所以它可以快速的访问其他的元素. 4.数组是大小固定的,一旦创建无法扩容:集合大小不固定. 5.数组的存放类型只能是一种,集合的存放类型可不是一种

Java中集合与数组的切换

在Java开发中常常遇见集合与数组的互相切换,如何实现呢,呵呵呵,很简单: import java.util.ArrayList; import java.util.Arrays; import java.util.HashSet; import java.util.List; import java.util.Set; public class Test { /** * 将Set集合转换为数组 * * @author GaoHuanjie */ private static void setT

浅谈集合---动态数组

集合---一个存储数据的"无底洞"\动态数组,集合的作用和数组一样可以存储多个数据.但是集合中能够存储的数据的个数是动态增长的.随着我们往集合中新增元素的增多而自动增大.那么为什么它的长度可以变化呢? 其实集合的本质就是数组,只不过当数组中存储的元素的个数等于数组长度的时候,就会自动new一个新数组,长度是原来的数组的两倍,在将原始的数据拷贝到新数组中,然后把旧数组的引用重新指向刚刚new的新数组,从而实现了动态增长! 浅谈集合---动态数组,布布扣,bubuko.com

Java 集合与数组之间的转换

Java 集合与数组之间的转换 @author ixenos 数组转集合 Arrays.asList(T... a) 先给结论:用 Arrays.asList(T... a) 将数组转换成集合 (T...a)是可变参数,看成(T[] a)即可 <T> List<T> asList(T... a) 返回一个受指定数组支持的固定大小的列表,这是披着List外表的纯数组,只是原数组的一个视图(对返回列表的更改会“直接写”到数组.) 返回的列表是可序列化的,并且实现了 RandomAcce