1 package cn.demo.jdk5;
2
3 import java.util.ArrayList;
4 import java.util.Arrays;
5 import java.util.HashMap;
6 import java.util.Iterator;
7 import java.util.LinkedList;
8 import java.util.List;
9 import java.util.Map;
10 import java.util.Set;
11 import java.util.TreeSet;
12 import java.util.Map.Entry;
13
14 import org.junit.Test;
15
16 public class GenericTest {
17 @Test
18 public void demo11() {
19 List<?> list = new ArrayList<String>(); // ? 代表任意类型
20 // list.add("aaa");
21 // list.add(111);
22 // 当使用通配符后，不要使用类型相关方法
23
24 List<? extends String> list2 = new ArrayList<String>();
25
26 List<? extends Number> list3 = new ArrayList<Integer>();
27
28 List<? super String> list4 = new ArrayList<Object>();
29 }
30
31 @Test
32 public void demo10() {
33 // 打印数组中所有元素内容
34 List<String> list = new LinkedList<String>();
35
36 list.add("aaa");
37 list.add("bbb");
38 list.add("ccc");
39 print(list);
40
41 List<Integer> list2 = new LinkedList<Integer>();
42
43 list2.add(111);
44 list2.add(222);
45 list2.add(333);
46
47 print(list2);
48 }
49
50 // ? 代表任意类型
51 public void print(List<?> list) { // 泛型类型 可以是任何类型 --- 泛型通配符
52 for (Object string : list) {
53 System.out.println(string);
54 }
55 }
56
57 @Test
58 public void demo9() {
59 // 测试 泛型类 使用
60 /*
61 * 在创建工具类对象时，使用泛型String, 这个工具类对象完成对String数组 倒序和 交换
62 */
63 ArraysUtils<String> arraysUtils = new ArraysUtils<String>();
64 String[] arr1 = { "aaa", "bbb", "ccc", "ddd" };
65 // 交换位置
66 arraysUtils.changePosition(arr1, 1, 3);
67 System.out.println(Arrays.toString(arr1));
68
69 // 倒序
70 arraysUtils.reverse(arr1);
71 System.out.println(Arrays.toString(arr1));
72 }
73
74 @Test
75 public void demo8() {
76 // 将数组元素 倒序
77 String[] arr1 = { "aaa", "bbb", "ccc", "ddd" }; // ddd ccc bbb aaa
78 reverse(arr1);
79 System.out.println(Arrays.toString(arr1));
80
81 Integer[] arr2 = { 1, 2, 3, 4, 5 }; // 倒序
82 reverse(arr2);
83 System.out.println(Arrays.toString(arr2));
84
85 }
86
87 // 将数组倒序
88 public <T> void reverse(T[] arr) {
89 /*
90 * 只需要遍历数组前一半元素，和后一半元素 对应元素 交换位置
91 */
92 for (int i = 0; i < arr.length / 2; i++) {
93 // String first = arr[i];
94 // String second = arr[arr.length - 1 - i];
95 T temp = arr[i];
96 arr[i] = arr[arr.length - 1 - i];
97 arr[arr.length - 1 - i] = temp;
98 }
99 }
100
101 @Test
102 public void demo7() {
103 Integer[] arr1 = new Integer[] { 1, 2, 3, 4, 5 };
104 // 交换数组 两个指定位置元素 将2,4 交换位置
105 changePosition(arr1, 1, 3); // 使用泛型方法 参数必须是对象类型
106
107 System.out.println(Arrays.toString(arr1));
108
109 String[] arr2 = new String[] { "aaa", "bbb", "ccc", "ddd" };
110 // 交换 aaa和 ccc的位置
111 changePosition(arr2, 0, 2);
112
113 System.out.println(Arrays.toString(arr2));
114
115 }
116
117 // 使用泛型 编写交换数组通用方法，类型可以String 可以 int --- 通过类型
118 public <T> void changePosition(T[] arr, int index1, int index2) {
119 T temp = arr[index1];
120 arr[index1] = arr[index2];
121 arr[index2] = temp;
122 }
123
124 // public void changePosition(String[] arr, int index1, int index2) {
125 // String temp = arr[index1];
126 // arr[index1] = arr[index2];
127 // arr[index2] = temp;
128 // }
129 //
130 // // 传递数组 传递数组引用地址 ---- 不需要返回值
131 // public void changePosition(int[] arr, int index1, int index2) {
132 // int temp = arr[index1];// 将第一个元素保存到temp
133 // arr[index1] = arr[index2]; // 将第二个元素值 赋值 给第一个元素
134 // arr[index2] = temp; // 将temp的值 保存第二个元素
135 // }
136
137 @Test
138 public void demo6() {
139 List<Integer> ints = new LinkedList<Integer>(); // 第一句 泛型 两端 一样的
140 // List<Number> nums = new LinkedList<Integer>(); // 第二句 Number是
141 // Integer的父类型 ，表达式两端泛型不一致，会导致编译错误
142
143 }
144
145 @Test
146 public void demo5() {
147 // 使用类型安全的Map -- 因为map是一个键值对结构，执行两个类型泛型
148 Map<String, String> map = new HashMap<String, String>();
149
150 map.put("aaa", "111");
151 map.put("bbb", "222");
152
153 // 因为使用了泛型，所以key和value类型都必须为String
154
155 // 取出map元素 ----- 两种
156 // 第一种 通过 Map 的 keySet进行遍历
157 Set<String> keys = map.keySet(); // 获得key集合
158 for (String key : keys) {
159 System.out.println(key + ":" + map.get(key));
160 }
161 System.out.println("-------------------------");
162
163 // 第二种 通过 map的 entrySet ---- 获得每一个键值对
164 Set<Map.Entry<String, String>> entrySet = map.entrySet(); // 每一个元素
165 // 就是一个键值对
166 for (Entry<String, String> entry : entrySet) {
167 // 通过 entry的 getKey和getValue获得每一个键和值
168 System.out.println(entry.getKey() + ":" + entry.getValue());
169 }
170
171 }
172
173 @Test
174 public void demo4() {
175 // 使用类型安全Set
176 Set<String> set = new TreeSet<String>();
177
178 set.add("asd");
179 set.add("fdf");
180 set.add("bxc");
181 // 因为使用泛型 只能添加String类型元素
182
183 // 取出Set元素 --- 两种 因为Set是无序的，所以比List少一种遍历方法
184 // 第一种 继承 Collection 所以使用 Iterator 遍历
185 Iterator<String> iterator = set.iterator();
186 while (iterator.hasNext()) {
187 String s = iterator.next();
188 System.out.println(s);
189 }
190 System.out.println("------------------------");
191 // 第二种 JDK5 引入 foreach 可以使用foreach 遍历 Set
192 for (String s : set) {
193 System.out.println(s);
194 }
195
196 }
197
198 @Test
199 public void demo3() {
200 // 使用类型安全List
201 List<String> list = new LinkedList<String>();
202
203 list.add("aaa");
204 list.add("bbb");
205 list.add("ccc");
206 // 因为使用泛型，只能将list添加 String类型 元素
207
208 // 遍历List --- 三种
209 // 第一种 因为List是有序的（存入顺序和取出顺序一样） 通过 size 和 get方法进行遍历
210 for (int i = 0; i < list.size(); i++) {
211 String s = list.get(i);
212 System.out.println(s);
213 }
214 System.out.println("---------------------------------------------");
215 // 第二种 因为List 继承 Collection 接口 ，通过 Collection的iterator进行遍历
216 Iterator<String> iterator = list.iterator();
217 // 遍历iterator 通过 迭代器 hasNext 和 next 方法进行遍历
218 while (iterator.hasNext()) {
219 String s = iterator.next();
220 System.out.println(s);
221 }
222 System.out.println("---------------------------------------------");
223
224 // 第三种 JDK5 引入 foreach循环 结构 ，通过foreach结构 遍历 list
225 for (String s : list) {
226 System.out.println(s);
227 }
228 System.out.println("----------------------------------------------");
229 }
230
231 @Test
232 public void demo2() {
233 // 应用泛型 集合
234 List<String> list = new ArrayList<String>(); // 这个list中只能存放 String 类型数据
235 // list.add(123); // 只能添加Strring
236 list.add("abc");
237 list.add("def");
238
239 // 取出集合数据
240 for (int i = 0; i < list.size(); i++) {
241 String s = list.get(i);
242 System.out.println(s.toUpperCase());
243 }
244 }
245
246 @Test
247 public void demo1() {
248 // JDK5 之前 集合对象
249 List list = new ArrayList();
250 // 因为没有泛型类型检查，添加对象可以是任意类型
251 list.add("abc");
252 list.add(123);
253
254 // 操作集合中对象，遍历集合 将数据取出来 通过 size()方法和 get(index)方法 遍历 list 集合
255 for (int i = 0; i < list.size(); i++) {
256 // 取出对象时，数据类型丢失了
257 Object o = list.get(i);
258 // 操作 String 方法 ---- 强制将数据转换 相应类型
259 String s = (String) o;
260 System.out.println(s.toUpperCase());
261 }
262 }
263
264 // public static void main(String[] args) {
265 // // 应用泛型 集合
266 // List<String> list = new ArrayList<String>(); // 这个list中只能存放 String 类型数据
267 // // list.add(123); // 只能添加Strring
268 // list.add("abc");
269 // list.add("def");
270 //
271 // // 取出集合数据
272 // for (int i = 0; i < list.size(); i++) {
273 // String s = list.get(i);
274 // System.out.println(s.toUpperCase());
275 // }
276 // }
277 }
