爪哇2博客
爪哇2博客

爪哇 流排序示例

爪哇流排序

In 这个 post, we will see how to sort a list with 流.sorted() method.

爪哇 8 has 整型roduced 流.sort() method to sort list of elements conveniently. It helps us to write short and concise 功能al style code rather than boilerplate code.


爪哇.util.Stream has two overloaded versions of 已排序() method.

  1. 已排序():返回具有按自然顺序排序的元素的流
  2. 已排序(Comparator<? 超 T> comparator):返回具有按提供的比较器排序的元素的流

💡 你知道吗?

If you sort list of 整数s using 流.sorted() method then 可比 整型erface, implemented by 整数 类, will define natural ordering of list of 整数s .

让’s understand how can we use 流.sorted() to sort list of elements.

整数列表

We can simply use 已排序() method to sort list of 整型egers.

爪哇
1
2
3
4
5
 
清单<Integer> 结果 = listOfIntegers.()
                                         .已排序()
                                         .收藏(收藏家.到清单());
 

在这里,整数列表按以下顺序排序 可比 整数类实现的接口。

爪哇
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
上市 最后 整数 延伸 实施 可比<Integer> {
....
/ **
    *对两个{@code 整数}对象进行数字比较。
     *
     * @param   anotherInteger  {@code 整数}进行比较。
     * @return  如果此{@code 整数}为{@code 0},则值为
     *          等于参数{@code 整数};小于
     *          {@code 0}(如果此{@code 整数}在数值上较小)
     *          比参数{@code 整数};和更大的价值
     *          如果此{@code 整数}在数字上是{@code 0}
     *          大于参数{@code 整数}(带符号
     *           comparison).
     * @since   1.2
     */
    上市 整型 相比于(整数 anotherInteger) {
        返回 相比(这个., anotherInteger.);
    }
 
    / **
    *通过数字比较两个{@code 整型}值。
    *返回的值等于:
     *
    * 整数.valueOf(x).compareTo(Integer.valueOf(y))
     *
     *
     * @param  x第一个要比较的{@code 整型}
     * @param  y比较第二个{@code 整型}
    *如果{@code x == y},则返回值{@code 0};
     *        如果{@code x,则该值小于{@code 0}< y}; and
     *        如果{@code x,则该值大于{@code 0}> y}
     * @since 1.7
     */
    上市 静态的 整型 相比(整型 x, 整型 y) {
        返回 (x < y) ? -1 : ((x == y) ? 0 : 1);
    }
 

As you can see, 整数s are 相比d on 这个 basis of (x &lt; y) ? -1 : ((x == y) ? 0 : 1) logic.

You can pass 比较器.reverseOrder() to 已排序 method to reverse sort list of 整数s.

爪哇
1
2
3
4
5
 
清单<Integer> 相反的顺序 = listOfIntegers.()
                                               .已排序(比较器.相反的顺序())
                                               .收藏(收藏家.到清单());
 

比较器.reverseOrder()静态的 方法,并提供强加自然顺序相反的比较器。

让’请参阅完整的示例以对整数列表进行排序。

爪哇
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
组织.Arpit.爪哇2blog;
 
进口 爪哇.实用程序.数组;
进口 爪哇.实用程序.比较器;
进口 爪哇.实用程序.清单;
进口 爪哇.实用程序..收藏家;
 
上市 SortListOfIntegers {
 
    上市 静态的 虚空 主要([] args) {
        清单<Integer> listOfIntegers = 数组.asList( 整数[] {40,34,21,37,20});
 
        清单<Integer> 结果 = listOfIntegers.()
                                                .已排序()
                                                .收藏(收藏家.到清单());
        系统..打印(结果);
 
        清单<Integer> 相反的顺序 = listOfIntegers.()
                                                     .已排序(比较器.相反的顺序())
                                                     .收藏(收藏家.到清单());
        系统..打印(相反的顺序);
    }
 
}
 

输出:

[20、21、34、37、40]
[40,37,34,21,20]

排序字符串列表

We can simply use 已排序() method to sort list of 串s.

爪哇
1
2
3
4
5
 
清单<String> 结果 = listOfStrings.()
                                         .已排序()
                                         .收藏(收藏家.到清单());
 

在这里,字符串列表按以下顺序排序 可比 接口由String类实现。

爪哇
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
上市 最后
    实施 爪哇.io.可序列化, 可比<String>, 字符序列 {
....
/ **
    *按字典顺序比较两个字符串。
     *
     * @param   anotherString  {@code 串}进行比较。
     * @return  如果参数字符串等于,则为值{@code 0}
     *          这个字符串;如果该字符串小于{@code 0}
     *          在字典上小于string参数;和一个
     *          大于{@code 0}的值(如果此字符串是
     *          在字典上大于string参数。
     */
    上市 整型 相比于( anotherString) {
        整型 len1 = .长度;
        整型 len2 = anotherString..长度;
        整型 = 数学.(len1, len2);
        烧焦 v1[] = ;
        烧焦 v2[] = anotherString.;
 
        整型 k = 0;
         (k < ) {
            烧焦 c1 = v1[k];
            烧焦 c2 = v2[k];
            如果 (c1 != c2) {
                返回 c1 - c2;
            }
            k++;
        }
        返回 len1 - len2;
    }
 

As you can see, 整数s are 相比d on 这个 basis of (x &lt; y) ? -1 : ((x == y) ? 0 : 1) logic.

You can pass 比较器.reverseOrder() to 已排序 method to reverse sort list of 整数s.

爪哇
1
2
3
4
5
 
清单<String> 相反的顺序 = listOfStrings.()
                                               .已排序(比较器.相反的顺序())
                                               .收藏(收藏家.到清单());
 

比较器.reverseOrder()为 静态的 方法,并提供强加自然顺序相反的比较器。

让’请参阅完整的示例以对整数列表进行排序。

爪哇
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
组织.Arpit.爪哇2blog;
 
进口 爪哇.实用程序.数组;
进口 爪哇.实用程序.比较器;
进口 爪哇.实用程序.清单;
进口 爪哇.实用程序..收藏家;
 
上市 SortListOfStrings {
 
    上市 静态的 虚空 主要([] args) {
        清单<String> 语言列表 = 数组.asList( [] { “蟒蛇”, “ C ++”, “ 爪哇”, “ PHP” });
 
        清单<String> 已排序ListOfLanguages = 语言列表.()
                                                              .已排序()
                                                              .收藏(收藏家.到清单());
        系统..打印(已排序ListOfLanguages);
 
        清单<String> 已排序ListOfLanguagesRev = 语言列表.()
                                                                 .已排序(比较器.相反的顺序())
                                                                 .收藏(收藏家.到清单());
        系统..打印(已排序ListOfLanguagesRev);  
    }
 
}
 

输出:

[C ++,竞彩篮球分析,PHP,Python]
[Python,PHP,竞彩篮球分析,C ++]

排序自定义对象列表

按自然顺序对学生列表进行排序

创建一个名为的类 学生.java

爪哇
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
组织.Arpit.爪哇2blog;
 
上市 学生{
 
     名称;
    整型 年龄;
 
    上市 学生( 名称, 整型 年龄) {
        ();
        这个.名称 = 名称;
        这个.年龄 = 年龄;
    }
    上市 getName() {
        返回 名称;
    }
    上市 虚空 setName( 名称) {
        这个.名称 = 名称;
    }
    上市 整型 getAge() {
        返回 年龄;
    }
    上市 虚空 setAge(整型 年龄) {
        这个.年龄 = 年龄;
    }
 
    @Override
    上市 toString() {
        返回 “学生[name =“ + 名称 + “,age =” + 年龄 + “]”;
    }
}
 

让’s use 流’s 已排序()现在对学生列表进行排序。

爪哇
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
组织.Arpit.爪哇2blog;
 
进口 爪哇.实用程序.数组列表;
进口 爪哇.实用程序.清单;
进口 爪哇.实用程序..收藏家;
 
上市 学生名单 {
 
    上市 静态的 虚空 主要([] args) {
        清单<Student> 学生名单 = getListOfStudents();
 
        清单<Student> 已排序学生列表= 学生名单.()
                                                          .已排序()
                                                          .收藏(收藏家.到清单());
        系统..打印(已排序学生列表);
    }
 
    上市 静态的 清单<Student> getListOfStudents()
    {
        清单<Student> 学生清单= 数组列表<>();
 
        学生 s1= 学生(“彼得”,21);
        学生 s2= 学生(“ Harshal”,18);
        学生 s3= 学生(“安迪”,17);
        学生 s4= 学生(“玛丽”,20);
        学生 s5= 学生(“彼得”,19);
 
        学生清单.(s1);
        学生清单.(s2);
        学生清单.(s3);
        学生清单.(s4);
        学生清单.(s5);
 
        返回 学生清单;
    }
}
 

让’s run above program.

线程异常“main”java.lang.ClassCastException:org.arpit.java2blog.Student无法转换为java.lang.Comparable
在java.util.Comparators $ NaturalOrderComparator.compare(Comparators.java:47)
在java.util.TimSort.countRunAndMakeAscending(TimSort.java:355)
在java.util.TimSort.sort(TimSort.java:220)
在java.util.Arrays.sort(Arrays.java:1512)
在java.util.stream.SortedOps $ SizedRefSortingSink.end(SortedOps.java:353)
在java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:483)
在java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:472)
在java.util.stream.ReduceOps $ ReduceOp.evaluateSequential(ReduceOps.java:708)
在java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:234)
在java.util.stream.ReferencePipeline.collect(ReferencePipeline.java:566)
在org.arpit.java2blog.SortListOfStudents.main(SortListOfStudents.java:14)

你知道为什么我们这里例外吗?
We got the ClassCastException exception because we did not implement 可比 整型erface in 学生 类.

让’s implement 可比 整型erface in 学生 类.

爪哇
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
组织.Arpit.爪哇2blog;
 
上市 学生 实施 可比<Student>{
 
     名称;
    整型 年龄;
 
    上市 学生( 名称, 整型 年龄) {
        ();
        这个.名称 = 名称;
        这个.年龄 = 年龄;
    }
    上市 getName() {
        返回 名称;
    }
    上市 虚空 setName( 名称) {
        这个.名称 = 名称;
    }
    上市 整型 getAge() {
        返回 年龄;
    }
    上市 虚空 setAge(整型 年龄) {
        这个.年龄 = 年龄;
    }
 
    @Override
    上市 toString() {
        返回 “学生[name =“ + 名称 + “,age =” + 年龄 + “]”;
    }
 
    @Override
    上市 整型 相比于(学生 o) {
        返回 这个.getName().相比于(o.getName());
    }
 
}
 

Run 学生名单 again, and you will get below 出put.

[学生[姓名=安迪,年龄= 17],学生[姓名= harshal,年龄= 18],学生[姓名=玛丽,年龄= 20],学生[姓名= Peter,年龄= 21],学生[姓名= Peter ,年龄= 19]]

如您所见,“学生”列表按学生姓名排序。

按自然顺序对学生列表进行排序

按名称对学生列表进行降序排列。

爪哇
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
组织.Arpit.爪哇2blog;
 
进口 爪哇.实用程序.数组列表;
进口 爪哇.实用程序.清单;
进口 爪哇.实用程序..收藏家;
 
上市 学生名单 {
 
    上市 静态的 虚空 主要([] args) {
        清单<Student> 学生名单 = getListOfStudents();
 
        清单<Student> 已排序ListOfStudent2 = 学生名单.()
                                                           .已排序(比较器.相反的顺序())
                                                           .收藏(收藏家.到清单());
        系统..打印(已排序学生列表);
    }
 
    上市 静态的 清单<Student> getListOfStudents()
    {
        清单<Student> 学生清单= 数组列表<>();
 
        学生 s1= 学生(“彼得”,21);
        学生 s2= 学生(“ Harshal”,18);
        学生 s3= 学生(“安迪”,17);
        学生 s4= 学生(“玛丽”,20);
        学生 s5= 学生(“彼得”,19);
 
        学生清单.(s1);
        学生清单.(s2);
        学生清单.(s3);
        学生清单.(s4);
        学生清单.(s5);
 
        返回 学生清单;
    }
}
 

输出:

[学生[姓名=彼得,年龄= 21],学生[姓名=彼得,年龄= 19],学生[姓名=玛丽,年龄= 20],学生[姓名= harshal,年龄= 18],学生[姓名= Andy ,年龄= 17]]

使用比较器按年龄对学生列表进行排序

爪哇
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
组织.Arpit.爪哇2blog;
 
进口 爪哇.实用程序.数组列表;
进口 爪哇.实用程序.清单;
进口 爪哇.实用程序..收藏家;
 
上市 学生名单 {
 
    上市 静态的 虚空 主要([] args) {
        清单<Student> 学生名单 = getListOfStudents();
 
        清单<Student> 学生名单ByAge = 学生名单.()
                                                         .已排序((s1,s2) -> s1.getAge()-s2.getAge())
                                                         .收藏(收藏家.到清单());
        系统..打印(学生名单ByAge);
    }
 
    上市 静态的 清单<Student> getListOfStudents()
    {
        清单<Student> 学生清单= 数组列表<>();
 
        学生 s1= 学生(“彼得”,21);
        学生 s2= 学生(“ Harshal”,18);
        学生 s3= 学生(“安迪”,17);
        学生 s4= 学生(“玛丽”,20);
        学生 s5= 学生(“彼得”,19);
 
        学生清单.(s1);
        学生清单.(s2);
        学生清单.(s3);
        学生清单.(s4);
        学生清单.(s5);
 
        返回 学生清单;
    }
}
 

输出:

[学生[name = Andy,年龄= 17],学生[name = Harshal,年龄= 18],学生[name = Peter,年龄= 19],学生[name = Mary,年龄= 20],学生[name = Peter ,年龄= 21]]

You can also use 比较器.comparing(Function&lt;? 超 T, ? 延伸 U&gt; keyExtractor) to sort it on the basis of 年龄.
比较器.comparing() 接受一个 功能 会根据类型映射排序键,然后返回一个由该排序键进行比较的Comparator。
让’s say you want to sort list of 学生s on the basis of 年龄. You can extracts sort key 年龄 from 学生 object and 比较器.comparing() will 返回 a comparator which will sort by that sort key.

爪哇
1
2
3
4
5
6
 
功能<学生,整数> 好玩 = (s) -> s.getAge();
    清单<Student> 学生名单ByAge = 学生名单.()
                                               .已排序(比较器.比较(好玩))
                                               .收藏(收藏家.到清单());
 

Here 比较器.comparing() 返回s a 新 比较器 to sort based on 年龄.

我们也可以使用 方法参考 在这里,因为我们只是在s.getAge() 功能界面.

爪哇
1
2
3
4
5
6
 
功能<学生,整数> 好玩 = 学生:: getAge
    清单<Student> 学生名单ByAge = 学生名单.()
                                            .已排序(比较器.比较(好玩))
                                                .收藏(收藏家.到清单());
 

让’s say you want to sort list of 学生s on the basis of 年龄 in descending order. You can pass another comparator to 比较器.comparing() to make custom sorting based on sort key.

爪哇
1
2
3
4
5
 
清单<Student> 已排序ListOfStudent5 = 学生名单.()
                                                           .已排序(比较器.比较(学生:: getAge,(年龄1,年龄2) -> 年龄2 - 年龄1))
                                                           .收藏(收藏家.到清单());
 

这里,
比较器.comparing()有两个参数。
学生::getAge 定义排序键。
(age1,age2) -&gt; 年龄2 - 年龄1) 在排序键的基础上定义自定义排序。

这是完整的示例。

爪哇
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
 
组织.Arpit.爪哇2blog;
 
进口 爪哇.实用程序.数组列表;
进口 爪哇.实用程序.比较器;
进口 爪哇.实用程序.清单;
进口 爪哇.实用程序.功能.功能;
进口 爪哇.实用程序..收藏家;
 
上市 学生名单 {
 
    上市 静态的 虚空 主要([] args) {
        清单<Student> 列表 = getListOfStudents();
 
        功能<学生,整数> 好玩 = (s) -> s.getAge();
        清单<Student> 列表ByAge = 列表.()
                                         .已排序(比较器.比较(好玩))
                                         .收藏(收藏家.到清单());
        系统..打印(“按年龄升序排列的列表:”+列表ByAge);
 
        清单<Student> 列表ByAgeRev = 列表.()
                                           .已排序(比较器.比较(学生:: getAge
                                                                         ,(年龄1,年龄2) -> 年龄2 - 年龄1))
                                           .收藏(收藏家.到清单());
 
        系统..打印(“按年龄降序排列的列表:”+列表ByAgeRev);
    }
 
    上市 静态的 清单<Student> getListOfStudents()
    {
        清单<Student> 学生清单= 数组列表<>();
 
        学生 s1= 学生(“彼得”,21);
        学生 s2= 学生(“ Harshal”,18);
        学生 s3= 学生(“安迪”,17);
        学生 s4= 学生(“玛丽”,20);
        学生 s5= 学生(“彼得”,19);
 
        学生清单.(s1);
        学生清单.(s2);
        学生清单.(s3);
        学生清单.(s4);
        学生清单.(s5);
 
        返回 学生清单;
    }
}
 

输出:

按年龄升序排列的列表:[学生[姓名=安迪,年龄= 17],学生[姓名= harshal,年龄= 18],学生[姓名= Peter,年龄= 19],学生[姓名=玛丽,年龄= 20] ,学生[姓名=彼得,年龄= 21]]
按年龄降序排列的列表:[学生[姓名=彼得,年龄= 21],学生[姓名=玛丽,年龄= 20],学生[姓名= Peter,年龄= 19],学生[姓名= harshal,年龄= 18] ,学生[姓名=安迪,年龄= 17]]

按姓名和年龄对学生列表进行排序

让’s说您想按姓名列出学生,如果姓名相同,则需要按年龄排序。

您可以将Comparator.thenComparing()与Comparator.comparing()结合使用来实现相同目的。

让’借助示例进行查看。

爪哇
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
组织.Arpit.爪哇2blog;
 
进口 爪哇.实用程序.数组列表;
进口 爪哇.实用程序.比较器;
进口 爪哇.实用程序.清单;
进口 爪哇.实用程序..收藏家;
 
上市 学生名单 {
 
    上市 静态的 虚空 主要([] args) {
        清单<Student> 列表 = getListOfStudents();
 
        清单<Student> 列表ByNameAge = 列表.()
                                           .已排序(比较器.比较(学生:: getName)
                                                             .然后比较 (学生:: getAge))
                                           .收藏(收藏家.到清单());
 
        系统..打印(列表ByNameAge);
    }
 
    上市 静态的 清单<Student> getListOfStudents()
    {
        清单<Student> 学生清单= 数组列表<>();
 
        学生 s1= 学生(“彼得”,21);
        学生 s2= 学生(“ Harshal”,18);
        学生 s3= 学生(“安迪”,17);
        学生 s4= 学生(“玛丽”,20);
        学生 s5= 学生(“彼得”,19);
 
        学生清单.(s1);
        学生清单.(s2);
        学生清单.(s3);
        学生清单.(s4);
        学生清单.(s5);
 
        返回 学生清单;
    }
}
 

输出:

[学生[姓名=安迪,年龄= 17],学生[姓名= harshal,年龄= 18],学生[姓名=玛丽,年龄= 20],学生[姓名= Peter,年龄= 19],学生[姓名= Peter ,年龄= 21]]

As you can see, there are two students 名称d Peter in the list then, 已排序 by 年龄.

锻炼

给定Employee对象的列表,您需要对Employee进行排序’s 名称 in descending order and 返回 a 已排序 list of 雇员(清单<Employee>)
这是Employee类的定义。

爪哇
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
组织.Arpit.爪哇2blog;
 
上市 雇员 {
 
     名称;
 
    上市 雇员( 名称) {
        ();
        这个.名称 = 名称;
    }
 
    上市 getName() {
        返回 名称;
    }
 
    上市 虚空 setName( 名称) {
        这个.名称 = 名称;
    }
 
    @Override
    上市 toString() {
        返回 “员工[name =“ + 名称 + “]”;
    }
}
 


导入联系人

您可能还喜欢:

分享这个

作者

关注作者

相关文章

  • 在竞彩篮球分析中将日期转换为LocalDate
    1月12日

    爪哇日期到LocalDate

    在这篇文章中,我们将看到如何在竞彩篮球分析中将Date转换为LocalDate。有时,我们可能需要将Date转换为新的竞彩篮球分析 8 API,反之亦然。在竞彩篮球分析中,有多种将Date转换为LocalDate的方法。另请参见:使用Date类的[InInstant()方法将竞彩篮球分析中的LocalDate转换为Date…]

  • 在竞彩篮球分析中将LocalDate转换为Date
    1月11日

    迄今为止的竞彩篮球分析 LocalDate

    在这篇文章中,我们将看到如何将LocalDate转换为Date。 爪哇 8引入了许多有关日期和时间的新API。有多种方法可以将竞彩篮球分析 LocalDateTime转换为日期。使用Instant对象您可以使用来自Zone的Instant对象将LocalDate转换为Date。这是 […]

  • 将流转换为竞彩篮球分析中的列表
    12月31日

    爪哇流列表

    在本文中,我们将看到如何在竞彩篮球分析中将Stream转换为List。在竞彩篮球分析中,有多种方法可以将Stream转换为List。使用Collectors.toList()可以将Collectors.toList()传递给Stream.collect()方法,以在竞彩篮球分析中将Stream转换为List。流’的collect方法对Stream和Collectors的元素执行可变的约简操作。toList()提供[…]

  • 在竞彩篮球分析中将LocalDateTime转换为时间戳
    11月18日

    在竞彩篮球分析中将LocalDateTime转换为时间戳

    在本文中,我们将如何将LocalDateTime转换为Timestamp。在学习如何将localdatetime转换为时间戳之前,让我们了解LocalDateTime和Timestamp,并了解这种转换的重要性。 LocalDateTime LocalDateTime在竞彩篮球分析 8中已引入。LocalDateTime可以导入时间包:import 爪哇.time.LocalDateTime; LocalDateTime是使用的不可变对象[…]

  • 8月28日

    A In-Depth guide to 爪哇 8Stream API

    在这篇文章中,我们将看到竞彩篮球分析 8流的深入概述,其中包含许多示例和练习。简介您可能认为Stream必须类似于InputStream或OutputStream,但是’并非如此。流表示支持顺序和并行聚合操作的一系列元素。流不存储[…]

  • 要映射的竞彩篮球分析流列表
    4月26日

    要映射的竞彩篮球分析流列表

    在本文中,我们将看到如何在竞彩篮球分析 8中使用Stream将List转换为Map。’s toMap()可与Stream一起使用,以在竞彩篮球分析中将List转换为Map。考虑一个名为Movie的类,它具有3个字段–ID,名称和流派[crayon-601f41432d542459244395 /]创建电影列表并将其转换为[…]

发表评论

您的电子邮件地址不会被公开。 必需的地方已做标记 *

订阅我们的新闻

获取质量教程到您的收件箱。现在订阅。


让’s be Friends

©2020 爪哇2博客