7.29 HashMap和快速排序以及泛型的使用

HashMap

collection：无序、可重复的一组数据
	List：有序、可重复
		ArrayList：底层是可变数组，遍历元素更快，改变值也就更快
		LinkedList：底层是双向链表，插入、删除更块
	Set：无序、不可重复

Map：实现一一对应(Entry)
	HashMap
	
其他常用实现类：
List接口：Vector：list当中唯一线程安全的集合类
					ConcurrentLinkedList：线程安全的链式表
Set接口：LinkedHashSet：有顺序的HashSet
Map接口：ConcurrentHashMap：线程安全的HashMap并且还是有顺序的
				对所有数据分段上锁

HashTable的特点：
	所有数据都上锁，如果一个线程访问了某段数据，其他人都不能访问所有数据
	
在面试中被问到多线程集合处理时可以回答：
	不在多线程的情况系使用集合类！！！

Map集合和泛型的使用：
TestMap 类：

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;

/**
 * @Author daniu
 * @Date 2020/7/29
 * @Description 英文名和中文名对应
 */
public class TestMap {
    public static void main(String[] args) {
        HashMap map = new HashMap();
        map.put("CN","中华人民共和国");
        map.put("UK","大不列颠联合王国");
        map.put("US","美利坚合众国");//增
        map.put("FU","大不列颠联合王国");
//        System.out.println(map.get("CN"));//查
//        System.out.println(map.get("FR"));//指向为空，代表不存在
//        map.remove("US");//删
//        System.out.println(map.get("US"));
//        map.remove("CN","ABC");
//        System.out.println(map.get("CN"));
//        map.containsKey("key");
//        map.containsValue("value");
//        map.put("CN","中国");//改
//        System.out.println(map.get("CN"));
//        map.replace("CN","中华人民共和国");//改
//        System.out.println(map.get("CN"));
        //遍历的方式
        Set entry = map.entrySet();//使用entrySet方法获取键值对的集合
        for (Object o : entry) {
            System.out.println(o);
        }
        //遍历key的方式
        Set keys = map.keySet();
        Iterator iterator = keys.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
//        for (Object key : keys) {
//            System.out.println(key + ":" + map.get(key));
//        }
        //遍历value的方式
        Collection values = map.values();
        for (Object value : values) {
            System.out.println(value);
        }
        System.out.println(map);

    }
}

Dog类：

public class Dog<T> implements Comparable<Dog>{
    public Dog() {
    }

    public Dog(int dogId) {
        this.dogId = dogId;
    }

    int dogId;
    @Override
    public int compareTo(Dog o) {
        return this.dogId - o.dogId;
    }

    public T getTest(T t){
        return t;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "dogId=" + dogId +
                '}';
    }
}

Entry类：

public class Entry {
    Object key;
    Object value;
    public void put(Object key,Object value){
        this.key = key;
        this.value = value;
    }
    public Object get(Object key){

        return value;
    }
}

TsetTMap类：

public class TastTMap {
    public static void main(String[] args) {
        HashMap<String,Entry> map = new HashMap<>();
        map.put("",new Entry());
        Set<Map.Entry<String,Entry>> entrys = map.entrySet();
        Set<String> keys = map.keySet();
        Collection<Entry> values = map.values();
    }
}

TestCollenction类：

public class TestCollenction {
    public static void main(String[] args) {
//        List list = new ArrayList();
//        list.add("abc");
//        list.add(123);
//        list.add("hellow");
//        list.add(3.1415926);
//        Collections.sort(list, new Comparator<Object>() {
//            @Override
//            public int compare(Object o1, Object o2) {
//                return -1;
//            }
//        });
//        System.out.println(list);
        List<Dog> dogList = new ArrayList<>();
        Dog d1 = new Dog(1);
        Dog d2 = new Dog(4);
        Dog d3 = new Dog(3);
        Dog d4 = new Dog(2);
        dogList.add(d1);
        dogList.add(d2);
        dogList.add(d3);
        dogList.add(d4);
        System.out.println(dogList);
        Collections.sort(dogList);
        System.out.println(dogList);

    }
}

TestT类：

public class TestT {
    public static void main(String[] args) {
//        ArrayList<String> list = new ArrayList();
//        list.add("1");
//        list.add("abs");
//        Iterator<String> itr = list.iterator();
//        while (itr.hasNext()) {
//            System.out.println(itr.next() + "abc");
//        }
        Dog<String> d = new Dog<>();
        String ab = d.getTest("ab");

    }
}

快速排序

public class QuickSort {
    public static void quick(int[]a,int start,int end){
        int i = start,j = end;
        if(i >= j )return;
        int tmp = a[start];
        while(i < j){
            while ( a[j] >= tmp && i < j) j --;
            a[i] = a[j];
            while (a[i] <= tmp && i < j) i++;
            a[j] = a[i];
        }
        a[i] = tmp;
        quick(a,start,j - 1);
        quick(a, i + 1,end);
    }
    public static int[] randomArrays(int length){
        int[] a = new int[length];
        for (int i = 0; i < a.length; i++) {
            Random r = new Random();
            a[i] = r.nextInt(100);
        }
        return a;
    }

    public static void main(String[] args) {
        int []a = randomArrays(10);
        System.out.println(Arrays.toString(a));
        quick(a,0,a.length - 1);
        System.out.println(Arrays.toString(a));
    }
}