第11次java作业

8、

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

class Plural{

    private double x;
    private double y;   
    public double getX() {return x;}
    public void setX(double x) {this.x = x;}
    public double getY() {return y;}
    public void setY(double y) {this.y = y;}
    public Plural() {x = 0; y = 0;}
    public Plural(double x, double y) {this.x = x; this.y = y;}
    public void show() {
        if (y == 0)
            System.out.println(x);
        else if(y<0)
            System.out.println(x + " - " + -y + "i");
	        else 
	        	System.out.println(x + " + " + y + "i");
    }
}

class PluralComparator implements Comparator<Plural> {
    public int compare(Plural o1, Plural o2) {
        return o1.getX() < o2.getX() ? 1 : -1;
    }
}
public class test {

    public static void main(String[] args) {
    	ArrayList<Plural> lst = new ArrayList<>();
        lst.add(new Plural(0, 2.3));
        lst.add(new Plural(-5, 4));
        lst.add(new Plural(-1.2, -3));
        lst.add(new Plural(1, 0));
        Collections.sort(lst, Collections.reverseOrder(new PluralComparator()));
        for(Plural p : lst)
            p.show();
    }
}

10、

import java.util.HashMap;

class myException{
    public HashMap<Class, String> hm = new HashMap<>();
    public myException() {
        hm.put(NullPointerException.class, "空指针异常");
        hm.put(ArithmeticException.class, "算术异常");
        hm.put(Exception.class, "其他异常");
    }
}
public class test {

    public static void main(String[] args) {
        myException ex=  new myException();
        try {
        	String s = null;
            System.out.println(s.charAt(0));
        }catch (NullPointerException e) {
        	Class<?> c = NullPointerException.class;
            System.out.println(ex.hm.get(c));
        }catch (ArithmeticException e) {
        	Class<?> c = ArithmeticException.class;
            System.out.println(ex.hm.get(c));
        }catch (Exception e) {
        	Class<?> c = Exception.class;
            System.out.println(ex.hm.get(c));
            e.printStackTrace();
        }
    }
}

11、
List接口及其实现类是容量可变的列表，可按索引访问集合中的元素。
List:
特点：集合中的元素有序、可重复；
(1)ArrayList 动态数组结构，插入移除数据慢，查询数据快，按索引查找，不是线程安全的。
(2)LinkedList 链表结构，插入移除数据块，只需要替换首尾节点地址就行，查询数据慢，需要按列表节点顺序依次查找。不是线程安全。
(3)Vector 实现可自动增长的数组结构，有序，可重复，线程安全。
(4)Stack继承Vector，有着先进后出的特性,线程安全

Set:
Set的特点：无序，不重复。
(1)HashSet 能够快速定位一个元素。通过散列码来存储元素，要尽量避免散列冲突。存入HashSet中的对象必须实现HashCode方法和equals方法。
(2)TreeSet 如果想要排序，可以使用

Map:
Map是一种把键对象和值对象进行关联的一种容器。
特点：key不允许重复。
(1)HashMap 实现一个键到值映射的哈希表，通过键取得对象，没有顺序，通过get(key)来获取value，允许存储空对象，而且允许键是空(由于键必须是唯一，当然只能有一个)。
(2)HashTable实现一个映像，所有的键必须非空，线程安全。
(3)TreeMap treemap结构是红黑树，是一种自平衡二叉查找树。
红黑树的五点规定：
a每个节点都只能是红色或者黑色
b根节点是黑色
c每个叶节点（叶子节点，空节点）是黑色的。
d从每个叶子到根的所有路径上不能有两个连续的红色节点。
e从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。
ArrayList：

import java.util.ArrayList;
import java.util.Iterator;

public class test {
	public static void main(String[] args) {
		ArrayList<Integer> li = new ArrayList<Integer>();
		for( int i=0;i<10;i++ ) 
		li.add(i); 
		for (int i = 0; i < li.size(); i++) {
			int n = li.get(i);
			System.out.print(n+" ");
		}
		System.out.println(" ");
		li.add(0,99);
		for (Integer n:li) {
			System.out.print(n+" ");
		}
		System.out.println(" ");
		li.remove(1);
		li.remove((Integer)5);
		Iterator<Integer> it = li.iterator();
		while (it.hasNext()) {
			int n = it.next();
			System.out.print(n+" ");
		}
	}
}

LinkedList：

import java.util.Iterator;
import java.util.LinkedList;
public class test {
	public static void main(String[] args) {
		String String = new String("AAA");
		String String2 = new String("BBB");
		String String3 = new String("CCC");
		LinkedList<String> li = new LinkedList<String>();
		li.add(String);
		li.add(String2);
		li.add(String3);
		for (int i = 0; i < li.size(); i++) {
			String n = li.get(i);
			System.out.println(n);
		}
		System.out.println(" ");
		li.add(0,String3);
		for (String n:li) {
			System.out.println(n);
		}
		System.out.println(" ");
		li.remove(1);
		li.remove("CCC");
		Iterator<java.lang.String> it = li.iterator();
		while (it.hasNext()) {
			String n = (java.lang.String) it.next();
			System.out.println(n);
		}
	}
}

HashSet：

import java.util.HashSet;
import java.util.Iterator;

public class test {   
    public static void main(String[] args) {   
        HashSet<Character> set = new HashSet<Character>();
        set.add('a');   
        set.add('b');   
        set.add('c');   
        set.add('d');   
        set.add('e');   
        Iterator<Character> it = set.iterator();
        while (it.hasNext()) {
          char str = it.next();
          System.out.print(str+" ");
        }
        System.out.println();
        set.remove('c');
        for (char str : set) {
              System.out.print(str+" ");
        }
        System.out.println(set.size());
    }   
}

TreeSet：

import java.util.Iterator;
import java.util.TreeSet;
 
public class test {
	public static void main(String[] args) {
		TreeSet<Pet>  t = new TreeSet<Pet>();
		Pet cat=new Pet("cat",3);
		t.add(new Pet("dog",2));
		t.add(new Pet("dog",3));
		t.add((Pet)cat);
		Iterator<Pet> it = t.iterator();
		while(it.hasNext()){
			Pet pet = (Pet) it.next();
			System.out.println(pet.getAge()+"  "+ pet.getName());
		}
		System.out.println();
		t.pollLast();
		System.out.println(t.contains((Pet)cat));
		t.remove((Pet)cat);
		for(Pet stu: t) {
	        System.out.println(stu.getAge()+"  "+stu.getName());
	    }
	}
}
 
class Pet implements Comparable<Object>{
	private String name;
	private int age;
	public Pet(String name, int age) {
		this.age = age;
		this.name = name;
	}
	public String getName() {
		return name;
	}
	public int getAge() {
		return age;
	}
	@Override
	public int compareTo(Object o) {
		if(!(o instanceof Pet))
			throw new RuntimeException("不是pet");
		Pet p = (Pet) o;
		if(this.age>p.age)
			return 1;
		else if(this.age == p.age){
			return this.name.compareTo(p.name);
		}else
		return -1;
	}
}

HashMap：

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

public class test {
	public static void main(String[] args) {
		HashMap<Integer, String> hashMap = new HashMap<>();
		for (int i = 0; i < 5; i++) {
			hashMap.put(i, "随机数" + (int) (Math.random() * 100));
		}
		System.out.println("size: "+hashMap.size());
		for(Map.Entry<Integer, String> entry :hashMap.entrySet() ) {
			System.out.println(entry.getKey()+"  "+entry.getValue());
		}
		System.out.println("key是3: "+hashMap.get(2));
		for(int key:hashMap.keySet()) {
			System.out.print(key+" ");
		}
		for(String value:hashMap.values()) {
			System.out.print(value+" ");
		}
		System.out.println();
		System.out.println("包含键值为4的吗？ "+hashMap.containsKey(4));
		System.out.println("包含指定值为100的吗？ "+hashMap.containsValue("随机数100"));
		Iterator<Entry<Integer, String>> it = hashMap.entrySet().iterator();
		while(it.hasNext()) {
			Entry<Integer, String> next = it.next();
			System.out.println(next.getKey()+"  "+next.getValue());
		}
		System.out.println("-----------------");
		hashMap.remove(3);
		for(int k: hashMap.keySet()) {
			System.out.println(k+"  "+hashMap.get(k));
		}
	}
}

TreeMap：

import java.util.Iterator;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;
public class test {
    public static void main(String[] args) {
        TreeMap<Integer,String> map = new TreeMap<Integer,String>();
        map.put(1,"hello");
        map.put(2,"byebye");
        map.put(3,"mygold");   
        Set<Integer> keys = map.keySet();
        Iterator<Integer> iter = keys.iterator();
        while(iter.hasNext())
        {
               int key = iter.next();
               System.out.println(key+" : "+map.get(key));
        }
        System.out.println();
        map.remove(2);
        Set<Entry<Integer, String>> value = map.entrySet();
        Iterator<Entry<Integer, String>> iter1 = value.iterator();
        while(iter1.hasNext())
        {
               Entry<Integer, String> key = iter1.next();
               System.out.println(key.getKey()+" : "+key.getValue());
        }
    }
}