1 import org.junit.Test;
2
3 import java.util.ArrayList;
4 import java.util.Arrays;
5 import java.util.Iterator;
6 import java.util.List;
7
8
9 /**
10 * 1.list接口框架
11 * /----Collection接口：单列集合，用来存储一个一个的对象
12 * /----list接口：存储有序的、可重复的数据。 ---> “动态”数组,替换原有的数组
13 * /----ArrayList:作为List接口的主要实现类，线程不安全的，效率高的，底层使用Object[]存储
14 * /----LinkedList:，对于频繁的插入、删除操作，使用此类效率比ArrayList高；底层使用双向链表存储
15 * /----Vector:作为List接口的古老实现类，线程安全的，效率不高的，底层使用Object[]存储
16 *
17 * 2. ArrayList的源码分析：
18 * 2.1 jdk 7 情况下：
19 * ArrayList list = new ArrayList();//底层创建了长度为10的 Object[] 数组elementData
20 * list.add(1);//elementData[0] = new Integer(1);
21 * ...
22 * List.add(11);如果此次添加导致底层elementData数组容量不够，则扩容。默认情况下，扩容为原来的1.5倍，同时需要将原有数组的数据复制
23 * 到新的数组中。
24 *
25 * 结论：建议开发中使用带参的构造器：ArrayList list = new ArrayList(int initialCapacity);
26 *
27 * 2.2 jdk 8 中ArrayList的变化：
28 * ArrayList list = new ArrayList();//底层Object[] elementData 初始化为 {},并没有创建长度为10的数组
29 *
30 * list.add(123);//第一次调用add()时，底层才创建了长度为10的数组，并将数据123添加到elementData[0]
31 * ...
32 * 后续的添加和扩容操作和jdk 7无异。
33 * 2.3小结：jdk 7中的ArrayList的对象的创建类似于单例模式中的饿汉式，而jdk8中ArrayList的对象的创建类似于单例的懒汉式，
34 * 延迟了数组的创建，节省了内存。
35 *
36 * 3.linkedList的源码分析：
37 * LinkedList list = new LinkedList(); //内部声明了Node类型的first和last属性，默认值为null，
38 * list.add(123);//将123封装到Node中，创建了Node对象。
39 *
40 * 其中Node定义：体现了LinkedList的双向链表的说法
41 * private static class Node<E> {
42 * E item;
43 * Node<E> next;
44 * Node<E> prev;
45 *
46 * Node(Node<E> prev, E element, Node<E> next) {
47 * this.item = element;
48 * this.next = next;
49 * this.prev = prev;
50 * }
51 * }
52 *
53 *
54 * 面试题：比较ArrayList，LinkedList，Vector三者的异同？
55 * 同：三个类都实现了List接口，存储数据相同：存储有序的、可重复的数据
56 * 不同：见上
57 *
58 * 4.List接口中的常用方法
59 * void add(int index, Object ele):在index位置上插入ele元素
60 * boolean addAll(int index,Collection eles):从index位置开始将eles中的所有元素加进来
61 * Object get(int index):获取指定位置的元素
62 * int indexOf(Object obj):返回obj在集合中首次出现的位置
63 * int lastIndexOf(Object obj):返回obj在集合中最后一次次出现的位置
64 * Object remove(int index):移除指定index位置上的元素，并返回此元素
65 * Object set(int index, Object ele):设置指定index位置的元素为ele
66 * List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子元素
67 *
68 * 总结：常用方法
69 * 增：add(Object)
70 * 删:remove(int index)/remove(Object obj)
71 * 改:set(int index, Object ele)
72 * 查:get(int index)
73 * 插:add(int index, Object ele)
74 * 长度:size()
75 * 遍历: ① Iterator迭代器方式
76 * ②增强for循环
77 * ③普通的循环
78 * @author FuJingchao
79 * @Date: 2021/12/17 - 20:30
80 */
81 public class ListTest {
82 /*
83 List接口中的常用方法测试
84 */
85 @Test
86 public void test1(){
87 ArrayList list = new ArrayList();
88 list.add(123);
89 list.add(456);
90 list.add("AA");
91 list.add(new Person("Tom",12));
92 list.add(456);
93
94 System.out.println(list);//[123, 456, AA, Person{name='Tom', age=12}, 456]
95
96 // void add(int index, Object ele):在index位置上插入ele元素
97 list.add(1,"BB");
98 System.out.println(list);//[123, BB, 456, AA, Person{name='Tom', age=12}, 456]
99
100 //boolean addAll(int index,Collection eles):从index位置开始将eles中的所有元素加进来
101 List list1 = Arrays.asList(1, 2, 3,4,5);
102 list.addAll(list1);
103 System.out.println(list.size());//11
104 System.out.println(list);//[123, BB, 456, AA, Person{name='Tom', age=12}, 456, 1, 2, 3, 4, 5]
105
106 //Object get(int index):获取指定位置的元素
107 System.out.println(list.get(1));//BB
108
109 }
110
111 @Test
112 public void test2(){
113 //int indexOf(Object obj):返回obj在集合中首次出现的位置，没有的话返回-1
114 //int lastIndexOf(Object obj):返回obj在集合中最后一次出现的位置,没有的话返回-1
115 ArrayList list = new ArrayList();
116 list.add(123);
117 list.add(456);
118 list.add("AA");
119 list.add(new Person("Tom",12));
120 list.add(456);
121
122 System.out.println(list.indexOf(456));//1
123 System.out.println(list.lastIndexOf(456));//4
124
125 //Object remove(int index):移除指定index位置上的元素，并返回此元素
126 // list.remove(3);
127 // System.out.println(list);//[123, 456, AA, 456]
128
129 //Object set(int index, Object ele):设置指定index位置的元素为ele
130 list.set(1,"gg");
131 System.out.println(list);//[123, gg, AA, Person{name='Tom', age=12}, 456]
132
133 //List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的左闭右开的子集合
134 System.out.println(list.subList(1,3));//[gg, AA]
135 }
136 @Test
137 public void test3(){
138 //遍历
139 ArrayList list = new ArrayList();
140 list.add(123);
141 list.add(456);
142 list.add("AA");
143 list.add(new Person("Tom",12));
144 list.add(456);
145
146 //方式一
147 Iterator iterator = list.iterator();
148 while (iterator.hasNext()){
149 System.out.println(iterator.next());
150 }
151 System.out.println("*****************");
152
153 //方式二
154 for(Object obj : list){
155 System.out.println(obj);
156 }
157 System.out.println("******************");
158
159 //方式三
160 for (int i = 0; i < list.size(); i++) {
161 System.out.println(list.get(i));
162 }
163 }
164 }
1 /**
2 * @author fu jingchao
3 * @creat 2021/12/8-14:53
4 */
5 public class Person {
6 private String name;
7 private int age;
8
9 public Person() {
10 }
11
12 public Person(String name, int age) {
13 this.name = name;
14 this.age = age;
15 }
16
17 public String getName() {
18 return name;
19 }
20
21 public void setName(String name) {
22 this.name = name;
23 }
24
25 public int getAge() {
26 return age;
27 }
28
29 public void setAge(int age) {
30 this.age = age;
31 }
32
33 @Override
34 public String toString() {
35 return "Person{" +
36 "name='" + name + '\'' +
37 ", age=" + age +
38 '}';
39 }
40
41 @Override
42 public boolean equals(Object o) {
43 System.out.println("Person equals()....");
44 if (this == o) return true;
45 if (o == null || getClass() != o.getClass()) return false;
46
47 Person person = (Person) o;
48
49 if (age != person.age) return false;
50 return name != null ? name.equals(person.name) : person.name == null;
51 }
52
53 // @Override
54 // public int hashCode() {
55 // int result = name != null ? name.hashCode() : 0;
56 // result = 31 * result + age;
57 // return result;
58 // }
59 }