集合的遍历 List Set TreeSet LinkedList Map（2）

package listdamo;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import java.util.Map.Entry;

public class listdemo3 {
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub

	}

	public void listAlldemo11() {
		List<?> list = new ArrayList<String>(); // ? 代表任意类型
		// list.add("aaa");
		// list.add(111);
		// 当使用通配符后，不要使用类型相关方法
		List<? extends String> list2 = new ArrayList<String>();
		List<? extends Number> list3 = new ArrayList<Integer>();
		List<? super String> list4 = new ArrayList<Object>();
	}

	// linklist集合
	public void linkListDemo10() {
		// 打印数组中所有元素内容
		List<String> list = new LinkedList<String>();

		list.add("aaa");
		list.add("bbb");
		list.add("ccc");
		print(list);

		List<Integer> list2 = new LinkedList<Integer>();

		list2.add(111);
		list2.add(222);
		list2.add(333);

		print(list2);
	}
// ? 代表任意类型
	public void print(List<?> list) { // 泛型类型 可以是任何类型 --- 泛型通配符
		for (Object string : list) {
			System.out.println(string);
		}
	}

	public void demo9() {
		// 测试 泛型类 使用
		/*
		 * 在创建工具类对象时，使用泛型String, 这个工具类对象完成对String数组 倒序和 交换
		 */

		String[] arr1 = { "aaa", "bbb", "ccc", "ddd" };
		// 交换位置
		changePosition(arr1, 1, 3);
		System.out.println(Arrays.toString(arr1));

		// 倒序
		reverse(arr1);
		System.out.println(Arrays.toString(arr1));
	}

	public void demo8() {
		// 将数组元素 倒序
		String[] arr1 = { "aaa", "bbb", "ccc", "ddd" }; // ddd ccc bbb aaa
		reverse(arr1);
		System.out.println(Arrays.toString(arr1));

		Integer[] arr2 = { 1, 2, 3, 4, 5 }; // 倒序
		reverse(arr2);
		System.out.println(Arrays.toString(arr2));

	}
// 将数组倒序
	public <T> void reverse(T[] arr) {
		/*
		 * 只需要遍历数组前一半元素，和后一半元素 对应元素 交换位置
		 */
		for (int i = 0; i < arr.length / 2; i++) {
			// String first = arr[i];
			// String second = arr[arr.length - 1 - i];
			T temp = arr[i];
			arr[i] = arr[arr.length - 1 - i];
			arr[arr.length - 1 - i] = temp;
		}
	}

	public void demo7() {
		Integer[] arr1 = new Integer[] { 1, 2, 3, 4, 5 };
		// 交换数组 两个指定位置元素 将2,4 交换位置
		changePosition(arr1, 1, 3); // 使用泛型方法 参数必须是对象类型
		System.out.println(Arrays.toString(arr1));

		String[] arr2 = new String[] { "aaa", "bbb", "ccc", "ddd" };
		// 交换 aaa和 ccc的位置
		changePosition(arr2, 0, 2);
		System.out.println(Arrays.toString(arr2));

	}

	// 使用泛型 编写交换数组通用方法，类型可以String 可以 int --- 通过类型
	public <T> void changePosition(T[] arr, int index1, int index2) {
		T temp = arr[index1];
		arr[index1] = arr[index2];
		arr[index2] = temp;
	}
// public void changePosition(String[] arr, int index1, int index2) {
	// String temp = arr[index1];
	// arr[index1] = arr[index2];
	// arr[index2] = temp;
	// }
	//
	// // 传递数组 传递数组引用地址 ---- 不需要返回值
	// public void changePosition(int[] arr, int index1, int index2) {
	// int temp = arr[index1];// 将第一个元素保存到temp
	// arr[index1] = arr[index2]; // 将第二个元素值 赋值 给第一个元素
	// arr[index2] = temp; // 将temp的值 保存第二个元素
	// }

	public void demo6() {
		List<Integer> ints = new LinkedList<Integer>(); // 第一句 泛型 两端 一样的
		// List<Number> nums = new LinkedList<Integer>(); // 第二句 Number是
		// Integer的父类型 ，表达式两端泛型不一致，会导致编译错误

	}
// map 和HashMap
	public void mapDemo5() {
		// 使用类型安全的Map -- 因为map是一个键值对结构，执行两个类型泛型
		Map<String, String> map = new HashMap<String, String>();

		map.put("aaa", "111");
		map.put("bbb", "222");

		// 因为使用了泛型，所以key和value类型都必须为String

		// 取出map元素 ----- 两种
		System.out.println("------ 第一种 通过 Map 的 keySet进行遍历----------");
		// 第一种 通过 Map 的 keySet进行遍历
		Set<String> keys = map.keySet(); // 获得key集合
		for (String key : keys) {
			System.out.println(key + ":" + map.get(key));
		}
		System.out.println("-------------------------");
		System.out.println("-----第二种 通过 map的 entrySet ---- 获得每一个键值对-------");
		// 第二种 通过 map的 entrySet ---- 获得每一个键值对
		Set<Map.Entry<String, String>> entrySet = map.entrySet(); // 每一个元素
		// 就是一个键值对
		for (Entry<String, String> entry : entrySet) {
			// 通过 entry的 getKey和getValue获得每一个键和值
			System.out.println(entry.getKey() + ":" + entry.getValue());
		}

	}

	// Tree Set 集合
	public void treeSetDemo4() {
		// 使用类型安全Set
		Set<String> set = new TreeSet<String>();

		set.add("asd");
		set.add("fdf");
		set.add("bxc");
		// 因为使用泛型 只能添加String类型元素

		// 取出Set元素 --- 两种 因为Set是无序的，所以比List少一种遍历方法
		// 第一种 继承 Collection 所以使用 Iterator 遍历
		Iterator<String> iterator = set.iterator();
		while (iterator.hasNext()) {
			String s = iterator.next();
			System.out.println(s);
		}
		System.out.println("------------------------");
		// 第二种 JDK5 引入 foreach 可以使用foreach 遍历 Set
		for (String s : set) {
			System.out.println(s);
		}

	}
// linkedlist 集合
	public void linkedListDemo3() {
		// 使用类型安全List
		List<String> list = new LinkedList<String>();

		list.add("aaa");
		list.add("bbb");
		list.add("ccc");
		// 因为使用泛型，只能将list添加 String类型 元素

		// 遍历List --- 三种
		// 第一种 因为List是有序的（存入顺序和取出顺序一样） 通过 size 和 get方法进行遍历
		for (int i = 0; i < list.size(); i++) {
			String s = list.get(i);
			System.out.println(s);
		}
		System.out.println("---------------------------------------------");
		// 第二种 因为List 继承 Collection 接口 ，通过 Collection的iterator进行遍历
		Iterator<String> iterator = list.iterator();
		// 遍历iterator 通过 迭代器 hasNext 和 next 方法进行遍历
		while (iterator.hasNext()) {
			String s = iterator.next();
			System.out.println(s);
		}
		System.out.println("---------------------------------------------");

		// 第三种 JDK5 引入 foreach循环 结构 ，通过foreach结构 遍历 list
		for (String s : list) {
			System.out.println(s);
		}
		System.out.println("----------------------------------------------");
	}

	// list 集合
	public void listDemo2() {
		// 应用泛型 集合
		List<String> list = new ArrayList<String>(); // 这个list中只能存放 String 类型数据
		// list.add(123); // 只能添加Strring
		list.add("abc");
		list.add("def");

		// 取出集合数据
		for (int i = 0; i < list.size(); i++) {
			String s = list.get(i);
			System.out.println(s.toUpperCase());
		}
	}

	// list 集合
	public void listDemo1() {
		// JDK5 之前 集合对象
		List list = new ArrayList();
		// 因为没有泛型类型检查，添加对象可以是任意类型
		list.add("abc");
		list.add(123);

		// 操作集合中对象，遍历集合 将数据取出来 通过 size()方法和 get(index)方法 遍历 list 集合
		for (int i = 0; i < list.size(); i++) {
			// 取出对象时，数据类型丢失了
			Object o = list.get(i);
			// 操作 String 方法 ---- 强制将数据转换 相应类型
			String s = (String) o;
			System.out.println(s.toUpperCase());
		}
	}

	// public static void main(String[] args) {
	// // 应用泛型 集合
	// List<String> list = new ArrayList<String>(); // 这个list中只能存放 String 类型数据
	// // list.add(123); // 只能添加Strring
	// list.add("abc");
	// list.add("def");
	//
	// // 取出集合数据
	// for (int i = 0; i < list.size(); i++) {
	// String s = list.get(i);
	// System.out.println(s.toUpperCase());
	// }
	// }
}