J2SE学习笔记：J2SE重点难点，数组排序、HashSet去重、HashMap遍历

package cn.itheima;
/**
 * 数组排序
 * @author Cuilitang
 *
 */
public class ArraySort {
	
	public static void main(String[] args) {
		int [] arr = {2,4,6,8,1,3,5,7,10,9};
		sort(arr);
		show(arr);
		int [] arr1 = {2,4,6,8,1,3,5,7,10,9};
		sort1(arr1);
		show(arr1);
		int [] arr2 = {2,4,6,8,1,3,5,7,10,9};
		sort2(arr2);
		show(arr2);
	}
	
	public static void show(int [] arr){
		for(int i = 0; i < arr.length; i++){
			System.out.print(arr[i] + " ");
		}
		System.out.println();
	}
	public static void swap(int [] arr, int x,int y){
		if(arr[x] > arr[y]){
			int temp = arr[x];
			arr[x] = arr[y];
			arr[y] = temp;
		}
	}
	
	/*
	 * 选择法：最原始的方法，每个元素（最后一个无需比较）分别跟自己右边的所有元素比。
	 */
	public static void sort(int [] arr){
		for(int x = 0; x < arr.length - 1;x++){
			for(int y = x+1;y < arr.length;y++){
					swap(arr,x,y);
					

			}
		}
	}

	/*
	 * 冒泡法：每个元素与自己上面的元素比较，比较一轮，冒泡上去一个最值
	 * 外循环控制循环次数，每循环一次最后一个就不需要比较，所以需要减去x，最后只剩1个未比较的元素的时候不需要比较，所以再减去1.
	 * 内循环是相邻两个数字进行比较进行比较。
	 */
	public static void sort1(int[] arr1) {
		for(int  x = 0; x < arr1.length-x-1; x++){
			for(int y = 0; y <arr1.length-x-1; y++ ){
				swap(arr1,y,y+1);
				
			}
		}	
	}

/*
 *今天刚百度到的： 插入排序算法
 *外循环控制循环次数
 *内循环控制比较的元素，也是相邻两个元素，当条件不满足时候就break。
 *与冒泡法不同的是冒泡法范围由大到小，这个则是范围慢慢变大，通过插入点右移不断扩大比较的范围。
 *新的元素进来之后跟已经有序的元素进行比较，直到遇到合适的插入点循环break，继续从外循环加入元素。
 * 
 */
	public static void sort2(int[] arr2){
		for(int i=1;i<arr2.length;i++){
        	for(int j=i;j>0;j--){
            	if (arr2[j]<arr2[j-1]){
                	int temp=arr2[j-1];
                    	arr2[j-1]=arr2[j];
                        arr2[j]=temp;   
                }else break;
            }
        }
	}
}

 

package cn.itheima;

import java.util.HashSet;
import java.util.Set;

public class HashSetTips {
	public static void main(String[] args) {
		Set<Person> set = new HashSet<Person>();
		set.add(new Person(1,"张三"));
		set.add(new Person(1,"张三"));
		
		for(Person p:set){
			System.out.println(p);
		}
	}

}

/*
 * hashCode判断对象是否相等时候，会去调用对象的hashCode（）方法和equals（）方法
 * 然而object的hashCode（）方法和equals（）方法都是比较内存Hash值，
 * 这样就无法进行判断对象是否符合我们的是否相同的标准
 * 所以自定义对象要存入HashSet，必须首先重写HashCode（）和equals（）
 * HashSet会先调用hashCode(),然后调用equals（）
 * 若是hashCode相等则不再调用equals（），直接判定重复覆盖。
 */

class Person{
	
	private int id;
	private String name;
	Person(int id,String name){
		this.id = id;
		this.name = name;
	}
	@Override
	public String toString(){
		return "id:"+id+"\t"+"name:"+name;
	}
	
	@Override
	public boolean equals(Object obj){
		Person p = (Person)obj;
		if(this.id == p.id && this.name.equals(p.name)){
			return true;
		}else return false;
	}
	
	@Override
	public int hashCode(){
		return id*31 + name.hashCode();
		
	}
	
}

 

package cn.itheima;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class IteratorMap {
	

	public static void main(String[] args) {
		Map<Integer,String> map = new HashMap<Integer,String>();
		map.put(1, "冠军");
		map.put(2, "亚军");
		map.put(3, "季军");
		map.put(4, "皇军");
		map.put(5, "皇协军");
		
		keysetIterator(map);
		System.out.println("-----割了去喂狗---------");
		entrysetIterator(map);
		
	}
	
	/**方法一：首先通过keySet（）将map中的key存储到set中
	 * 然后使用迭代器遍历set，在遍历set的迭代器内部通过map.get(key) 将value取出来。然后一块打印。
	 * 实际上是通过将key存储到set中然后对set的遍历实现的，在遍历set的 同时，使用get（）方法取出每个key的value。	
	 */
	public static void keysetIterator(Map<Integer,String> map){	
		Set<Integer> keySet = map.keySet();
		Iterator<Integer> it = keySet.iterator();
		while(it.hasNext()){
			Integer key = it.next();
			String value = map.get(key);     //遍历key的同时通过get方法取得value。
			System.out.println("key:"+key+"\t"+"value:"+value);
		}
				
	}
	
	/**方法二：使用Map.Entry类进行访问。
	 * JDK1.6对Map.Entry类的解释：映射项（键-值对）。Map.entrySet 方法返回映射的 collection 视图，其中的元素属于此类。
	 * 由此可见Map.Entry实际上是将键值对封装成一个元素（映射项），将映射项存储进set进行遍历。Entry本来就是入口的意思嘛。
	 * 最终也是借助对set元素的遍历实现的map遍历。
	 */
	public static void entrysetIterator(Map<Integer,String> map){
		Set<Entry<Integer,String>> entrySet = map.entrySet();
		Iterator<Entry<Integer, String>> it = entrySet.iterator();
		while(it.hasNext()){
			Entry<Integer, String> entry = it.next();
			Integer key = entry.getKey();
			String value = entry.getValue();
			System.out.println("key:"+key+"\t"+"value:"+value);
		}
	}

}

/**
 * 综上所述，其实map的遍历都是通过对set元素的迭代实现的，只不过中间过程不同。
 * keySet方法是将key存储进set，然后通过get（）取得value；
 * entrySet方法则是将Entry.Set类型存储进set，然后通过Entry.Set的getKey（）和getValue（）分别取得key和value。
*/