常用的Map遍历方式

public class mapdemo1 {

	public static void main(String[] args) {
		Map<String, String> map = new HashMap<String, String>();
		map.put("尹志平", "小龙女");
		map.put("令狐冲", "东方不败");
		map.put("李斌", "王凤鸣");
		method2(map);
	}
	private static void method2(Map<String, String> map) {
		//第二种 Set<Map.Entry<String, String>> entrys = map.entrySet()
		//Set集合放的是Map的Entry对象，Entry里面放的是map对象
		//通过结婚证对象获取key（丈夫）和value（媳妇）
		/**
		 * class Entry<K, V>{
		 * 		K key;
		 * 		V value;
		 * 
		 * 		public Entry(K key, V value){
		 * 			this.key = key;
		 * 			this.value = value;
		 * 		}
		 * 		public K getKey(){
		 * 			return key;
		 * 		}
		 * 		public K getValue(){
		 * 			return value;
		 * 		}
		 * }
		 */
		//Entry是Map的内部类
		System.out.println("通过Map.entrySet使用Set遍历key和value");
		Set<Map.Entry<String, String>> entrys = map.entrySet();
		for (Map.Entry<String, String> entry : entrys) {
			String key = entry.getKey();
			String value = entry.getValue();
			System.out.println("key:"+ key + "value:" + value);
		}
		System.out.println("通过Map.entrySet使用iterator遍历key和value");
		Iterator<Map.Entry<String, String>> iterator = map.entrySet().iterator();
		while(iterator.hasNext()) {
			Map.Entry<String, String> entry = iterator.next();
			System.out.println("key = " + entry.getKey() + " " + "value = " + entry.getValue());
		}
	}

	private static void method1(Map<String, String> map) {
		//第一种
		System.out.println("通过Map.keySet遍历key和value--繁琐");
		//1. 繁琐的方法
		Set<String> KeySet = map.keySet();
		for (String value : KeySet) {
			System.out.println("key = " + value + " " + "value = " + map.get(value));
		}
		//2. 简单方法
		System.out.println("通过Map.keySet遍历key和value--简单");
		for(String keyString : map.keySet()) {
			System.out.println("key = " + keyString + " " + "value = " + map.get(keyString));
		}
	}

}

map和collection区别

/**
 * Map是另外一种顶层接口，和Collection接口没有任何关系
 * 
 * Map和Collecion有什么区别？
 * 			Map：是一个双列集合 key不可以重复
 * 			Collection：是单列集合，有不同的子体系，有的允许重复有索引有序（List），有的不允许重复且无序（Set）
 * @author chenxin
 *
 *	Map的常用功能：
 *			判断：boolean containsKey(Object key)
 *				boolean containsValue(Object value)
 *				boolean isEmpty()
 *				
 *
 *			删除：void clear()
 *				V remove(Object key)：根据key删除对应关系，并且返回被删除key对应的value
 *
 *			遍历功能：Set<Map.Entry<K,V>> entrySet()
 *
 *			获取功能：V get(Object key)
 *					Set<K> keySet()
 *					Collection<V> values()
 *					int size()
 *			
 *			添加（映射）功能：V put(K key, V value)
 */
public class mapdemo2 {
	public static void main(String[] args) {
		Map<String, String> map = new HashMap<String, String>();
		
//		//V put(K key, V value):将key映射到value功能，如果key存在，就覆盖value，并将原来的value返回
//		System.out.println(map.put("001", "zhangsan"));
//		System.out.println(map.put("002", "lisi"));
//		System.out.println(map.put("001", "wangwu"));
//		System.out.println(map);
//		
//		//boolean containsKey(Object key):判断指定的key是否存在
//		//boolean containsValue(Object value)：判断指定的value是否存在
//		//boolean isEmpty()
		map.put("001", "zhangsan");
		map.put("002", "lisi");
		map.put("003", "wangwu");
		
		//Collection<V> values()：查每个key对应的value值
		Collection<String> collection = map.values();
		for (String valueString : collection) {
			System.out.println(valueString);
		}
	}

	private static void method(Map<String, String> map) {
		//Set<K> keySet():因为map的key是不重复的，所以有了可以实现的keySet方法
		//遍历set有三种方法：转数组；迭代器，增强for
		Set<String> keys = map.keySet();
		for (String key : keys) {
			System.out.println(key);
		}
	}
}

Iterator遍历

/**
 * 集合遍历方式：
 * 			1. toArray(),可以把集合转换成数组，然后遍历数组即可
 * 			2. iterator(),可以返回一个迭代器对象，我们通过迭代器（遍历器）对象来迭代集合
 * Iterator：对Collection 进行迭代的迭代器。可以用于遍历集合
 * E next(): 返回下一个元素
 * boolean hasNext():
 * 
 * Exception in thread "main" java.util.NoSuchElementException
 * @author chenxin
 *
 */
public class IteratorDemo {
	public static void main(String[] args) {
		//method();
		//创建集合对象
		Collection collection = new ArrayList<>();
		//添加集合元素
		collection.add("hello");
		collection.add("world");
		collection.add("java");
		
		Iterator iterator = collection.iterator();
        //用hasNext() 判断是否有值，返回true或者false，用next()方法把元素取出。
		while(iterator.hasNext()) {
			System.out.println(iterator.next());
		}
	}

	private static void method() {
		//创建集合对象
		Collection collection = new ArrayList<>();
		//添加集合元素
		collection.add("hello");
		collection.add("world");
		collection.add("java");
		//获取数组
		Object[] objs = collection.toArray();
		
		//遍历数组
		for (int i = 0; i < objs.length; i++) {
			System.out.println(objs[i]);
		}
	}
}

Collections和Collection区别

public class collectionsDemo {
	/**
	 * 	static int binarySearch(List list, Object key):二分查找指定元素key在指定列表的索引位置
		前提有序 如12345
		List集合不加泛型的话只能放对象，不能放基本数据类型：4类8种（整浮字符布尔）
		所以List<int> list = new ArrayList<int>();写法错误，String是属于类类型的，引用数据类型三种：类/接口/数据类型
	 */
	
	public static void main(String[] args) {
		//static void swap(List list, int a, int b):列表交换某两个索引位置，不是元素
		List<Integer> lists = new ArrayList<Integer>();
		lists.add(1);
		lists.add(3);
		Collections.swap(lists, 0, 1);
		System.out.println(lists);
	}

	private static void method6() {
		//static void sort(List list):排序，默认从小到大
		List<Integer> lists = new ArrayList<Integer>();
		lists.add(1);
		lists.add(3);
		lists.add(2);
		lists.add(4);
		Collections.sort(lists);
		System.out.println(lists);
	}

	private static void method5() {
		//static void shuffle(List list):随机置换
		List<String> list = new ArrayList<String>();
		list.add("hello");
		list.add("world");
		list.add("java");
		
		Collections.shuffle(list);
		System.out.println(list);
	}

	private static void method4() {
		//static void reverse(List list):反转
		List<String> list = new ArrayList<String>();
		list.add("hello");
		list.add("world");
		list.add("java");
		
		Collections.reverse(list);
		System.out.println(list);
	}

	private static void method3() {
		//static void fill(List list, Object obj):使用指定对象填充指定列表的所有元素
		List<String> list = new ArrayList<String>();
		list.add("hello");
		list.add("world");
		list.add("java");
		System.out.println(list);
		Collections.fill(list, "android");
		System.out.println(list);
	}

	private static void method2() {
		//static void copy(List destination, List source):原列表的数据覆盖到目标列表
		//源列表
		List<String> source = new ArrayList<>();
		source.add("hello");
		source.add("world");
		source.add("java");
		
		//创建目标列表,目标列表长度至少等于源列表的长度
		List<String> destination = new ArrayList<>();
		destination.add("");
		destination.add("");
		destination.add("");
		destination.add("");
		Collections.copy(destination, source);
		System.out.println(destination);
	}

	private static void method() {
		List<Integer> lists = new ArrayList<Integer>();
		lists.add(1);
		lists.add(2);
		lists.add(3);
		lists.add(4);
		
		int index = Collections.binarySearch(lists, 4);
		System.out.println(index);
	}
}