list大数据转换对象_大数据之路week02 List集合的子类

最新推荐文章于 2024-07-13 02:54:23 发布

你的名字怎么是花

最新推荐文章于 2024-07-13 02:54:23 发布

阅读量182

点赞数

文章标签： list大数据转换对象

本文链接：https://blog.csdn.net/weixin_31085635/article/details/111970602

版权

本文详细介绍了Java集合框架中的List子类ArrayList、Vector和LinkedList的特点、操作效率及使用案例。ArrayList基于数组，查询快但增删慢；Vector线程安全但效率低；LinkedList查询慢但增删快，适用于频繁插入删除的场景。通过实例代码展示了如何存储和遍历字符串、自定义对象，并讨论了如何去除重复元素的方法和注意事项。此外，还提及了静态导入、可变参数等知识点的应用。

摘要由CSDN通过智能技术生成

1：List集合的子类(掌握)

(1)List的子类特点

ArrayList：

底层数据结构是数组，查询快，增删慢。

线程不安全，效率高。

Vector：

底层数据结构是数组，查询快，增删慢。

线程安全，效率低。

LinkedList：

底层数据结构是链表，查询慢，增删快。

线程不安全，效率高。

(2)ArrayList

A: 没有特有的功能需要学习

B: 案例：

a: ArrayList 存储字符串对象并遍历

1 packagecom.wyh.jdkNews;2

3 importjava.util.ArrayList;4 importjava.util.Iterator;5

6 /**

7 *@authorWYH8 *@version2019年11月16日上午9:16:239 *10 * ArrayList存储字符串并进行遍历，要求加入泛型，并用增强for遍历11 *12 * 1、迭代器13 * 2、普通for循环14 * 3、增强for循环15 */

16 public classArrayListDemo01 {17 public static voidmain(String[] args) {18 ArrayList array = new ArrayList();19

20 array.add("赵以浩");21 array.add("王友虎");22 array.add("齐博源");23

24 //迭代器

25 Iterator it =array.iterator();26 while(it.hasNext()) {27 String s =it.next();28 System.out.println(s);29 }30

31 System.out.println("----------------");32

34 //普通for循环

35 for(int x = 0;x

40 System.out.println("----------------");41

42 //增强for进行遍历

43 for(String s : array) {44 System.out.println(s);45 }46 }47 }

b: ArrayList存储自定义对象并遍历

学生 Student类：

1 packagecom.wyh.jdkNews;2

3 /**

4 *@authorWYH5 *@version2019年11月14日下午7:15:016 */

7 public classStudent {8 privateString name;9 private intage;10 public Student(String name, intage) {11 super();12 this.name =name;13 this.age =age;14 }15 publicStudent() {16 super();17 //TODO Auto-generated constructor stub

18 }19 publicString getName() {20 returnname;21 }22 public voidsetName(String name) {23 this.name =name;24 }25 public intgetAge() {26 returnage;27 }28 public void setAge(intage) {29 this.age =age;30 }31

32 @Override33 public booleanequals(Object obj) {34 if (this ==obj)35 return true;36 if (obj == null)37 return false;38 if (getClass() !=obj.getClass())39 return false;40 Student other =(Student) obj;41 if (age !=other.age)42 return false;43 if (name == null) {44 if (other.name != null)45 return false;46 } else if (!name.equals(other.name))47 return false;48 return true;49 }50

53 }

测试类：

1 packagecom.wyh.jdkNews;2

3 importjava.util.ArrayList;4 importjava.util.Iterator;5

6 /**

7 *@authorWYH8 *@version2019年11月16日上午9:16:239 *10 * ArrayList存储自定义对象并进行遍历，要求加入泛型，并用增强for遍历11 *12 * 1、迭代器13 * 2、普通for循环14 * 3、增强for循环15 */

16 public classArrayListDemo02 {17 public static voidmain(String[] args) {18 ArrayList array = new ArrayList();19

20 //创建学生对象

21 Student s1 = new Student("小花",18);22 Student s2 = new Student("小月",19);23 Student s3 = new Student("小王",22);24 Student s4 = new Student("小强",24);25 Student s5 = new Student("小紫",16);26

27 //将学生对象添加到集合中去

28 array.add(s1);29 array.add(s2);30 array.add(s3);31 array.add(s4);32 array.add(s5);33

35 //迭代器、

36 Iterator it =array.iterator();37

38 while(it.hasNext()) {39 Student s =it.next();40 System.out.println(s.getName()+"---"+s.getAge());41 }42

43 System.out.println("---------------");44

45 //普通for循环

46 for(int i = 0;i

51 System.out.println("----------------");52

53 //增强for循环

54 for(Student s : array) {55 System.out.println(s.getName()+"---"+s.getAge());56

57 }58

61 }62 }

(3)Vector

A: 特有功能

a: 添加

public void addElement(E obj) 将指定的组件添加到此向量的末尾，将其大小增加1。 ------add()

b：获取

public E elementAt(int index) 返回指定索引处的组件。 -----get()

public Enumberation elements() -----Iterator()

(4)LinkedList

A: 特有的功能

a: 添加

addFirst()

addLast()

b: 删除

removeFirst()

removeLast()

c: 获取

getFirst()

getLast()

B: 案例：

a: LinkedList 存储字符串并且遍历

1 packagecom.wyh.LinkedList;2

3 importjava.util.Iterator;4 importjava.util.LinkedList;5

6 /**

7 *@authorWYH8 *@version2019年11月16日下午9:40:019 */

10 public classLinkedListDemo2 {11 public static voidmain(String[] args) {12 //创建集合对象

13 LinkedList linkList = newLinkedList();14

15 //将学生对象添加到集合中去

16 linkList.add("aa");17 linkList.add("bb");18 linkList.add("cc");19 linkList.add("dd");20 linkList.add("ee");21

22 //创建迭代器对象

23 Iterator it =linkList.iterator();24

25 while(it.hasNext()) {26 String s =(String)it.next();27 System.out.println(s);28 }29

33 }34 }

b: LinkedList存储自定义对象并遍历

1 packagecom.wyh.LinkedList;2

3 importjava.util.Iterator;4 importjava.util.LinkedList;5

6 /**

7 *@authorWYH8 *@version2019年11月14日下午7:14:339 *10 * LinkedList 存储对象并遍历。11 */

12 public classLinkedListDemo1 {13 public static voidmain(String[] args) {14 //创建集合对象

15 LinkedList linkList = newLinkedList();16

17 //创建学生对象

18 Student s1 = new Student("王友虎",22);19 Student s2 = new Student("赵以浩",23);20 Student s3 = new Student("李宏灿",21);21 Student s4 = new Student("李先锋",22);22 Student s5 = new Student("齐博源",23);23

24 //将学生对象添加到集合中去

25 linkList.add(s1);26 linkList.add(s2);27 linkList.add(s3);28 linkList.add(s4);29 linkList.add(s5);30

31 //创建迭代器对象

32 Iterator it =linkList.iterator();33

34 while(it.hasNext()) {35 Student s =(Student)it.next();36 System.out.println(s.getName()+"------"+s.getAge());37 }38

42 }43

44 }

(5)案例；

A: 去除集合中的多个字符串的重复元素

如果字符串的内容相同，即为重复元素。

a: 思路1:创建一个新的集合，依次遍历旧集合，如果新集合里没有该元素，就添加，反之，有就不添加。

1 packagecom.wyh.LinkedList;2

3 importjava.util.ArrayList;4 importjava.util.Iterator;5

6 /**

7 *@authorWYH8 *@version2019年11月14日下午8:53:329 *10 * 去除ArrayList中的重复字符串对象11 * 思路1:创建一个新的集合，依次遍历旧集合，如果新集合里没有该元素，就添加，反之，有就不添加。12 */

13 public classArrayListDemo4 {14 public static voidmain(String[] args) {15 //创建集合对象

16 ArrayList a = newArrayList();17

18 a.add("AAA");19 a.add("BBB");20 a.add("CCC");21 a.add("AAA");22 a.add("AAA");23 a.add("AAA");24 a.add("BBB");25 a.add("CCC");26

28 //创建迭代器

29 Iterator it =a.iterator();30

31 //创建一个新的集合

32 ArrayList newa = newArrayList();33

35 while(it.hasNext()) {36 String s =(String) it.next();37 if(!(newa.contains(s))) {38 newa.add(s);39 }40 }41

42 //遍历

43 Iterator it1 =newa.iterator();44 while(it1.hasNext()) {45 String s =(String)it1.next();46 System.out.println(s);47 }48

49 }50

51 }

b: 不创建新的集合，就在以前的集合上做。选择排序的思想

1 packagecom.wyh.LinkedList;2

3 importjava.util.ArrayList;4

5 /**

6 *@authorWYH7 *@version2019年11月14日下午8:53:398 *9 * 去除ArrayList中的重的字符串对象10 * 思路2:不创建新的集合，就在以前的集合上做。选择排序的思想11 */

12 public classArrayListDemo5 {13 public static voidmain(String[] args) {14 //创建集合对象

15 ArrayList a = newArrayList();16

17 a.add("AAA");18 a.add("BBB");19 a.add("CCC");20 a.add("AAA");21 a.add("AAA");22 a.add("AAA");23 a.add("BBB");24 a.add("CCC");25

27 for(int i = 0;i

38 //遍历

39 for(int i = 0;i

45 }

B: 去除集合中的多个自定义对象的重复元素

如果自定义对象的成员变量值都相同，即为重复元素。

知识扩展：

contains方法的底层是equals方法，所以不能用这个进行比较。

* 而我们学生类里面没有equals方法，所以这时候就默认使用的是它父亲(Object)的equals方法。

* 而Object的equals方法，默认比较的是地址值,又因为，new的地址值都不同，所以用equals比较总是失败。

* 怎么解决？

* 重写equals方法

重写后的Student类；

1 packagecom.wyh.LinkedList;2

3 /**

4 *@authorWYH5 *@version2019年11月14日下午7:15:016 */

53 }

思路1:创建一个新的集合，依次遍历旧集合，如果新集合里没有该元素，就添加，反之，有就不添加。

1 packagecom.wyh.LinkedList;2

3 importjava.util.ArrayList;4 importjava.util.Iterator;5

6 /**

7 *@authorWYH8 *@version2019年11月14日下午7:28:069 *10 * 去除ArrayList中的重复对象11 * 思路1:创建一个新的集合，依次遍历旧集合，如果新集合里没有该元素，就添加，反之，有就不添加。12 *13 * contains方法的底层是equals方法，所以不能用这个进行比较。14 * 而我们学生类里面没有equals方法，所以这时候就默认使用的是它父亲(Object)的equals方法。15 * 而Object的equals方法，默认比较的是地址值,又因为，new的地址值都不同，所以用equals比较总是失败。16 * 怎么解决？17 * 重写equals方法18 *19 */

20 public classArrayListDemo2 {21 public static voidmain(String[] args) {22 //创建集合对象

23 ArrayList aList = newArrayList();24

25 //创建学生对象

26 Student s1 = new Student("齐博源",22);27 Student s2 = new Student("王友虎",22);28 Student s3 = new Student("赵以浩",24);29 Student s4 = new Student("李先锋",24);30 Student s5 = new Student("李宏灿",22);31 Student s6 = new Student("李宏灿",22);32 Student s7 = new Student("赵以浩",24);33 Student s8 = new Student("齐博源",22);34

37 //将学生对象添加到集合中去

38 aList.add(s1);39 aList.add(s2);40 aList.add(s3);41 aList.add(s4);42 aList.add(s5);43 aList.add(s6);44 aList.add(s7);45 aList.add(s8);46

50 //创建一个新的集合

51 ArrayList aList2 = newArrayList();52

54 //使用迭代器进行遍历

55 Iterator it =aList.iterator();56

57 while(it.hasNext()) {58 Student s =(Student)it.next();59 System.out.println(s.getName()+"---"+s.getAge());60 if(!aList2.contains(s)) {61 aList2.add(s);62

63 }64 }65

66 System.out.println("----------去重后-----------");67

68 //遍历新集合

69 Iterator it2 =aList2.iterator();70 while(it2.hasNext()) {71 Student s =(Student)it2.next();72 System.out.println(s.getName()+"---"+s.getAge());73 }74

76 }77

78 }

思路2:不创建新的集合，就在以前的集合上做。选择排序的思想

1 packagecom.wyh.LinkedList;2

3 importjava.util.ArrayList;4 importjava.util.Iterator;5

6 /**

7 *@authorWYH8 *@version2019年11月14日下午8:09:359 *10 *11 * 去除ArrayList中的重复对象12 * 思路2:不创建新的集合，就在以前的集合上做。选择排序的思想13 */

14 public classArrayListDemo3 {15 public static voidmain(String[] args) {16 //创建集合对象

17 ArrayList aList = newArrayList();18

19 //创建学生对象

20 Student s1 = new Student("齐博源",22);21 Student s2 = new Student("王友虎",22);22 Student s3 = new Student("赵以浩",24);23 Student s4 = new Student("李先锋",24);24 Student s5 = new Student("李宏灿",22);25 Student s6 = new Student("赵以浩",24);26 Student s7 = new Student("王友虎",22);27 Student s8 = new Student("齐博源",22);28

31 //将学生对象添加到集合中去

32 aList.add(s1);33 aList.add(s2);34 aList.add(s3);35 aList.add(s4);36 aList.add(s5);37 aList.add(s6);38 aList.add(s7);39 aList.add(s8);40

43 for(int i = 0 ;i

47 j--;48 }49 }50 }51

52 for(int i = 0;i

58 }

C:用LInkedlIst模拟一个栈数据结构的集合类(面试题！！)

创建我们模拟LinkedList的类：

1 packagecom.wyh.LinkedList;2

3 importjava.util.Iterator;4 importjava.util.LinkedList;5

6 /**

7 *@authorWYH8 *@version2019年11月14日下午9:28:249 *10 * 利用LinkedList模拟栈数据结构的集合测试11 *12 */

13 public classMyStack01 {14

15 privateLinkedList list;16

17 publicMyStack01() {18 this.list = newLinkedList();19 }20

22 //添加功能

23 public voidadd(Object obj) {24 list.addFirst(obj);25 }26

27 //获取功能

28 publicObject get() {29 //return list.getFirst();

30 return list.removeFirst(); //删除栈顶元素，并且返回被删除的元素.

31 }32

34 publicIterator iterator() {35 //TODO Auto-generated method stub

36 returnlist.iterator();37 }38

40 public intsize() {41 //TODO Auto-generated method stub

42 returnlist.size();43 }44

45 public booleanisEmpty() {46 returnlist.isEmpty();47 }48

49 }

创建测试类：

1 packagecom.wyh.LinkedList;2

3 importjava.util.Iterator;4

5 /**

6 *@authorWYH7 *@version2019年11月14日下午9:36:128 */

9 public classMyStackTest01 {10 public static voidmain(String[] args) {11 MyStack01 ms = newMyStack01();12

13 ms.add("123");14 ms.add("321");15 ms.add("789");16

17 /*for(int i = ms.size();i>0;i--) {18 System.out.println(ms.get());19 }*/

22 //while循环

23 while(!ms.isEmpty()) {24 System.out.println(ms.get());25 }26

29 /*//for循环30 for(int i = 0;i<=ms.size()+1;i++) {31 System.out.println(ms.get());32 }*/

35 /*//创建迭代器36 Iterator it = ms.iterator();37

38 while(it.hasNext()) {39 String s = (String)it.next();40 System.out.println(s);41 }*/

43 }44

45 }

2、泛型(掌握)

(1)泛型概述

是一种把明确类型的工作推迟到创建对象或者调用该方法的时候才去明确的特殊类型

(2)格式

注意：该数据类型只能是引用类型

(3)好处：

A: 把运行时期出现的问题提前到了编译时期

B: 避免了强制类型转换

C: 优化了程序设计，解决了黄色警告线的问题，让程序更加的安全。

(4)泛型的前生今世

A: 泛型的由来

早期的时候，我们使用Object来表示任意类型。

向下转型的时候是没有任何问题的，但是在向下转型的时候隐含了转型的问题。

也就是说这样的程序时不安全的，所以Java在JDK1.5的之后，引入了泛型，提高系统的安全性。

Object类型作为任意类型的时候，在向下转型的时候，会隐含一个转型问题。

B: 泛型类

泛型类：

1 packagecom.wyh.Object;2

3 /**

4 *@authorWYH5 *@version2019年11月15日下午9:09:396 *7 * 把泛型应用在类上,泛型类8 */

9 public class ObjectTool02{10 privateT obj;11

12 publicT getObj() {13 returnobj;14 }15

16 public voidsetObj(T obj) {17 this.obj =obj;18 }19

20 }

泛型类的测试：

1 packagecom.wyh.Object;2

3 /**

4 *@authorWYH5 *@version2019年11月15日下午9:11:096 *7 * 泛型类测试8 */

9 public classObjectToolDemo02 {10 public static voidmain(String[] args) {11 ObjectTool02 obj = new ObjectTool02();12 //obj.setObj(new Integer(2));//编译的时候就会报错

13 obj.setObj(new String("小虎"));14 String i =obj.getObj();15 System.out.println(i);16

17 ObjectTool02 obj2 = new ObjectTool02();18 //obj2.setObj(new String("xiaohu"));//编译的时候就会报错

19 obj2.setObj(new Integer(23));20 Integer j =obj2.getObj();21 System.out.println(j);22

23 }24 }

C: 泛型方法

泛型方法，类上不加泛型，在方法中添加：

1 packagecom.wyh.Object;2

3 /**

4 *@authorWYH5 *@version2019年11月15日下午9:26:176 *7 * 泛型方法8 *9 */

12 //泛型方法

13 public classObjectTool03 {14 public voidshow(T t) {15 System.out.println(t);16 }17 }

测试：

1 packagecom.wyh.Object;2

3 /**

4 *@authorWYH5 *@version2019年11月15日下午9:28:226 */

7 public classObjectToolDemo03 {8 public static voidmain(String[] args) {9 //问题1

10 /*ObjectTool03 obj = new ObjectTool03();11 obj.show("王友虎");12 obj.show(123);13 obj.show(true);*/

15 //问题2

16 /*ObjectTool03 obj = new ObjectTool03();17 obj.show("王友虎");18 //obj.show(123);19 //obj.show(true);20 */

22 //问题3、如果到这还听得懂，说明泛型类是没有问题的23 //但是，我现在定义的类和方法的类型是一致的，谁说过一定要一致的呢？24 //如果类上没有定义泛型的话，那么还能不能接收任意类型的呢？(答案是肯定可以的，泛型方法)ObjectTool03 第二段代码

25 ObjectTool03 obj = newObjectTool03();26 obj.show("王友虎");27 obj.show(123);28 obj.show(true);29

31 }32

33 }

D: 泛型接口

创建泛型接口：

1 packagecom.wyh.Object;2

3 /**

4 *@authorWYH5 *@version2019年11月15日下午9:46:166 *7 * 泛型接口8 */

9 public interface Inter{10 public abstract voidshow(T t);11 }

创建实现类将接口实现：

1 packagecom.wyh.Object;2

3 /**

4 *@authorWYH5 *@version2019年11月15日下午9:47:306 */

9 //第一种情况，我们在实现的时候就知道是什么类型的了。

10 /*public class InterImpl implements Inter{11

12 @Override13 public void show(String s) {14 System.out.println(s);15

16 }17 }*/

19 //第二种情况，

20 public class InterImpl implements Inter{21

22 @Override23 public voidshow(T t) {24 System.out.println(t);25

26 }27 }

创建测试类进行测试：

1 packagecom.wyh.Object;2

3 /**

4 *@authorWYH5 *@version2019年11月15日下午9:48:096 */

7 public classInterTest {8 public static voidmain(String[] args) {9

10 /*//第一种情况测试11 Inter inte = new InterImpl();12 inte.show("王友虎");*/

14 //第一种情况测试

15 Inter inte = new InterImpl();16 inte.show("王友虎");17

18 Inter inte1 = new InterImpl();19 inte1.show(123);20

22 }23

24 }

E: 泛型高级之通配符

?: 任意类型，如果没有明确，那就是Object类型以及任意的Java类了

? extends E: 向下限定，限定E 及其子类

? super E: 向上限定，限定E 及其父类

1 packagecom.wyh.generic;2

3 importjava.util.ArrayList;4 importjava.util.Collection;5

6 /**

7 *@authorWYH8 *@version2019年11月15日下午10:00:399 *10 * 泛型之高级通配符11 *12 * ?: 任意类型，如果没有明确，那就是Object类型以及任意的Java类了13 * ? extends E: 向下限定，限定E 及其子类14 * ? super E: 向上限定，限定E 及其父类15 */

17 classAnimal{18

19 }20

21 class Dog extendsAnimal{22

23 }24

25 class Cat extendsAnimal{26

27 }28

29 public classGenericDemo1 {30 public static voidmain(String[] args) {31

32 //泛型如果明确写的时候，前后必须一致！

33 Collection c1 = new ArrayList();34 /*

35 * Collection c2 = new ArrayList(); Collection c3 = new36 * ArrayList(); Collection c4 = new ArrayList();37 */

39 //? 表示任一类型是可以滴

40 Collection> c5 = new ArrayList();41 Collection> c2 = new ArrayList();42 Collection> c3 = new ArrayList();43 Collection> c4 = new ArrayList();44

45 //? extends E: 向下限定，限定E 及其子类46 //Collection extends Animal> c6 = new ArrayList();//报错

47 Collection extends Animal> c7 = new ArrayList();48 Collection extends Animal> c8 = new ArrayList();49 Collection extends Animal> c9 = new ArrayList();50

51 //? super E: 向上限定，限定E 及其父类

52 Collection super Animal> c10 = new ArrayList();53 Collection super Animal> c13 = new ArrayList();54 //Collection super Animal> c11 = new ArrayList();//报错55 //Collection super Animal> c12 = new ArrayList();

59 }60 }

3、增强for循环(掌握)增强for其实就是来替代器迭代器的，怎么验证？并发修改异常

(1)是for循环的一种

(2)格式：

for(元素的数据类型变量名：数组或者Collection集合的对象){

使用该变量即可，该变量其实就是数组或者集合中的元素。

}

(3)好处：

简化了数组和集合的遍历

(4)弊端

增强for循环的目标不能为null。建议在使用前，现判断是否为null。

1 packagecom.wyh.jdkNews;2

3 importjava.util.ArrayList;4 importjava.util.List;5

6 /**

7 *@authorWYH8 *@version2019年11月16日上午8:44:599 *10 * JDK5 的新特性: 自动装箱，泛型，增强for，静态导入，可变参数，枚举11 *12 * 增强for: for循环13 * 格式:14 * for(元素数据类型变量名 : 数组或者是Collection 集合){15 * 变量，直接使用16 * }17 *18 * 好处: 简化了数组和集合的遍历19 *20 * 弊端: 增强for的目标不能为null21 * 解决: 在进行增强for之前我们要先进行不为null的判断22 */

23 public classForDemo01 {24 public static voidmain(String[] args) {25 int[] arr = {1,2,3,4,5};26

27 for(int x = 0;x

31 System.out.println("---------------");32

33 for(intx:arr) {34 System.out.println(x);35 }36

37 System.out.println("---------------");38

39 //定义一个字符串数组

40 String[] arrayList = {"小虎","小沛","小王"};41 for(String array : arrayList) {42 System.out.println(array);43

44 }45

46 System.out.println("---------------");47 //定义一个ArrayList

48 ArrayList array = new ArrayList();49 array.add("林青霞");50 array.add("刘亦菲");51 array.add("景甜");52

53 for(String array1 : array) {54 System.out.println(array1);55

56 }57

58 System.out.println("---------------");59

60 //NullPointerException报空指针错误61 //62

63 List list = null;64 if (list != null) {65 for(String x : list) {66 System.out.println(x);67 }68 }69

70 System.out.println("---------------");71 //增强for其实就是来替代器迭代器的，怎么验证？并发修改异常。ConcurrentModificationException

72 for(String array1 : array) {73 if("刘亦菲".equals(array1)) {74 array.add("小王");75 }76

77 }78 System.out.println("array1:"+array);79

81 }82

85 }

4、静态导入(了解)

(1)可以导入到方法级别的导入

(2)格式

import static 包名....类名.方法名;

(3)注意事项：

A: 方法必须是静态的

B：如果多个类下有同名的方法，就不好区分了。还得加上前缀，所以一般我们并不使用静态导入，但是一定要能够看得懂。

1 packagecom.wyh.StaticImport;2

3 /**

4 *@authorWYH5 *@version2019年11月16日上午9:40:426 * 静态导入7 *8 * 格式: import static 包名....类名.方法名9 * 可以直接导入到方法级别10 */

11 import staticjava.lang.Math.abs;12 import staticjava.lang.Math.pow;13 import staticjava.lang.Math.max;14

16 public classStaticImportDemo01 {17 public static voidmain(String[] args) {18

19 System.out.println(java.lang.Math.abs(100));20 System.out.println(java.lang.Math.pow(2, 4));21 System.out.println(java.lang.Math.max(10, 50));22 //太复杂

24 System.out.println(Math.abs(100));25 System.out.println(Math.pow(2, 4));26 System.out.println(Math.max(10, 50));27 //依旧太复杂

29 System.out.println(abs(100));30 System.out.println(pow(2, 4));31 System.out.println(java.lang.Math.max(10, 50));32 //静态导包

33 }34

35 private static void max(int i) {//底层源码就是数组

36 System.out.println(i);37 }38 }

5、可变参数(掌握)

(1)如果我们在写方法的时候，参数个数不明确，就应该定义可变参数。

(2)格式：

修饰符返回值类型方法名(数据类型... 变量){ }

注意：

A: 该变量其实是一个数组名

B: 如果一个方法有多个参数，并且有可变参数，可变参数必须在最后。

(3)Arrays工具类的一个方法

asList()把数组转成集合

注意: 这个集合的长度不能改变。

1 packagecom.wyh.args;2

3 /**

4 *@authorWYH5 *@version2019年11月16日上午9:52:416 *7 * 可变参数:8 * 访问修饰符返回值方法名(数据类型... 变量名){9 *10 * }11 *12 * 1.这里的变量名是一个数组13 * 2.如果一个方法拥有可变参数,并且拥有多个参数,那么可变参数是放在最后一个。14 *15 *16 * 需求:我要写一个求和函数,具体几个数据求和我并不清楚,但是我在调用的时候就知道了.17 * 为了解决这个问题,Java就提供了一个东西: 可变参数18 */

19 public classArgsDemo01 {20 public static voidmain(String[] args) {21 //两个数据的求和

22 int a = 10;23 int b = 20;24 int result =sum(a, b);25 System.out.println("result:"+result);26

27 //三个数据的求和

28 int c = 30;29 int result2 =sum(a,b,c);30 System.out.println("result:"+result2);31

32 //四个数据的求和

33 int d = 40;34 int result3 =sum(a,b,c,d);35 System.out.println("result:"+result3);36

38 }39

40 //可变参数

41 private static int sum(int... a) {//底层源码就是数组

42 int s = 0;43 for(intx : a) {44 s +=x;45 }46 returns;47 }48

49 /*private static int sum(int a, int b,int c,int d) {50 return a+b+c+d;51 }52

53 private static int sum(int a, int b,int c) {54 return a+b+c;55 }56

58 private static int sum(int a, int b) {59 return a+b;60 }*/

62 }

1 packagecom.wyh.args;2

3 importjava.util.Arrays;4 importjava.util.List;5

6 /**

7 *@authorWYH8 *@version2019年11月16日上午10:15:379 *10 * static List asList(T... a) :把数组转成一个集合11 * 注意：12 * 虽然是把一个数组转成一个集合，但是其本质是数组，所以，它的长度固定13 */

14 public classArraysDemo01 {15 public static voidmain(String[] args) {16 String[] s = {"小虎","小花","小美"};17

18 List list =Arrays.asList(s);19 //UnsupportedOperationException20 //list.add("123");21 //UnsupportedOperationException22 //list.remove(1);

23 list.set(1,"小雪"); //可以进行修改

26 for(String s1 : list) {27 System.out.println(s1);28 }29 }30

31 }

6、练习(掌握)

A: 集合的嵌套遍历。

先来看看逻辑图：

代码实现：(学生类不重复给出了)

1 packagecom.wyh.list_son_test;2

3 importjava.util.ArrayList;4

5 /**

6 *@authorWYH7 *@version2019年11月16日上午10:28:038 *9 * 集合的嵌套遍历10 *11 * 需求：12 * 我们班里有学生，每一个学生可以看作是一个对象，可以使用一个集合来表示我们一个班的学生，ArrayList13 * 但是呢，隔壁也有一个班级，也同样拥有一个ArrayList来表示一个班的学生14 * 而我们现在有多个ArrayList，也是要用集合来进行存储，怎么办呢？15 * 其实就是 ArrayList>16 */

17 public classArrayListDemo01 {18 public static voidmain(String[] args) {19 //创建大集合对象

20 ArrayList> bigArrayList = new ArrayList>();21

22 //创建第一个班级

23 ArrayList firstArrayList = new ArrayList();24 //创建学生对象

25 Student s1 = new Student("唐三藏",30);26 Student s2 = new Student("孙悟空",29);27 Student s3 = new Student("猪八戒",28);28 Student s4 = new Student("白龙马",27);29 Student s5 = new Student("沙悟净",26);30 //将学生对象添加到集合中去

31 firstArrayList.add(s1);32 firstArrayList.add(s2);33 firstArrayList.add(s3);34 firstArrayList.add(s4);35 firstArrayList.add(s5);36 //再将这个班级放到学生系统中去

37 bigArrayList.add(firstArrayList);38

40 //创建第二个班级

41 ArrayList secondArrayList = new ArrayList();42 //创建学生对象

43 Student s11 = new Student("刘备",40);44 Student s22 = new Student("关羽",38);45 Student s33 = new Student("张飞",35);46 //将学生对象添加到集合中去

47 secondArrayList.add(s11);48 secondArrayList.add(s22);49 secondArrayList.add(s33);50 //再将这个班级放到学生系统中去

51 bigArrayList.add(secondArrayList);52

54 //创建第三个班级

55 ArrayList thirdArrayList = new ArrayList();56 //创建学生对象

57 Student s111 = new Student("宋江",29);58 Student s222 = new Student("鲁智深",45);59 Student s333 = new Student("武松",28);60 //将学生对象添加到集合中去

61 thirdArrayList.add(s111);62 thirdArrayList.add(s222);63 thirdArrayList.add(s333);64 //再将这个班级放到学生系统中去

65 bigArrayList.add(thirdArrayList);66

67 //增强for循环进行遍历

68 for(ArrayListarray : bigArrayList) {69 System.out.println("---------");70 for(Student i : array) {71 System.out.println(i.getName()+"---"+i.getAge());72 }73 }74

77 }78

79 }

B: 产生10个1-20之间的随机数，要求随机数不能重复。

1 packagecom.wyh.random;2

3 importjava.util.ArrayList;4 importjava.util.Random;5

6 /**

7 *@authorWYH8 *@version2019年11月16日上午11:13:179 * 随机产生10个1-20之间的数，不能重复10 *11 * 可以用集合实现12 *13 * 1、创建产生随机数对象14 * 2、创建存储产生随机数的集合15 * 3、创建统计随机数个数的变量，从0 开始16 * 4、判断统计变量是否小于10，17 * 是:不搭理它，跳过18 * 不是: 先产生一个随机数，判断在集合中是否存在，19 * 存在: 不搭理他20 * 不存在: 进行添加，统计变量+121 *22 */

23 public classRandomDemo01 {24 public static voidmain(String[] args) {25 //创建产生随机数对象

26 Random r = newRandom();27

28 //创建存储产生随机数的集合

29 ArrayList array = new ArrayList();30

31 //创建统计随机数个数的变量，从0 开始

32 int count = 0;33

34 //判断统计变量是否小于10，

35 while(count<10) {36 int number = r.nextInt(20)+1; //r.nextInt(20) 范围在0-19 对他进行+1 保证在1-20

37 if(!array.contains(number)) {38 array.add(number);39 count++;40 }41 }42

44 for(Integer i : array) {45 System.out.println(i);46 }47

48 }49

50 }

C: 键盘录入多个数据，以0结束，并在控制台输出最大值。

1 packagecom.wyh.random;2

3 importjava.util.ArrayList;4 importjava.util.Arrays;5 importjava.util.Scanner;6

7 /**

8 *@authorWYH9 *@version2019年11月16日下午3:20:3310 */

11 public classScannerDemo01 {12 public static voidmain(String[] args) {13 //创建控制台输入对象

14 Scanner sc = newScanner(System.in);15

16 //创建存储从控制台输入的数的集合

17 ArrayList array = new ArrayList();18

21 boolean flag = true;22

23 while(flag) {24 //友情提示

25 System.out.print("请输入所要存储的数据,输入 0 表示停止:");26 int number =sc.nextInt();27 if(number==0) {28 flag = false;29 }else if(!array.contains(number)){30 array.add(number);31 }32 }33

34 Object[] obj =array.toArray();35 Arrays.sort(obj);36 for(Object x : obj) {37 System.out.print(x+" ");38 }39 System.out.println("您录入的最大值是:"+obj[obj.length-1]);40

41 /*//遍历集合42 System.out.print("您总共存入的数据有:");43 for(Integer i : array) {44 System.out.print(i+" ");45 }*/

49 }50

51 }

7、总之，学完这一节需要掌握的代码有：

集合存储元素，加入泛型，并且可以使用增强for循环遍历

你的名字怎么是花

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
list大数据转换对象_大数据之路week02 List集合的子类

1：List集合的子类(掌握)(1)List的子类特点ArrayList：底层数据结构是数组，查询快，增删慢。线程不安全，效率高。Vector：底层数据结构是数组，查询快，增删慢。线程安全，效率低。LinkedList：底层数据结构是链表，查询慢，增删快。线程不安全，效率高。(2)ArrayListA: 没有特有的功能需要学习B: 案例：a: ArrayList 存储字符串对象并遍历1 packa...
复制链接

扫一扫