异常、集合与泛型

• 异常：

1. error ：JVM抛出的异常，程序自身无法处理
2. Exception ：程序自身可以处理的异常。

  Exception的分类：  

1. 运行时异常即非检查异常，编译可以通过。  RuntimeException及其子类都是；
2. 非运行时异常即检查异常，编译不通过。除了上述都是该异常。

  异常的处理机制：

           要么抛出异常，要么catch。  结构如下：

                             try {    可能产生异常的代码（当其上边代码异常，下边的执行不到）   }

                              catch（异常类型   e）{    捕获并处理异常     }  注：有多重异常时，会顺序去执行，

                                    直到被catch住，因此子类异常在前，父类在后，最后一个catch为Exception 异常

                             finally {     一定会被执行的代码    }

  自定义异常：

              继承Exception 异常，创建构造方法用super（）调用Exception 里的构造方法。

• 集合框架图：

List和Set的区别：

     List 元素是有序（因为有索引）、可以重复；Set 元素是无序且不能重复的

      LinkedList改快读慢；ArrayList读快改慢，Hash  介于之间

Map：  键、值对来存取。键（key）是唯一的

       HashMap 添加、删除映射关系效率更高；TreeMap中的键是有序的。

• 对于自定义对象进行排序，用TreeSet  有两种方法可实现

           第一种：强制让该对象具备比较性，即：让该对象的类实现 Comparable接口，并复写接口中的compareTo（）方法，TreeSet的底层数据结构是二叉树，存的时候排序的方式是按 比较后return的正数、负数、0来判断，小的左边、大的右边的原理，在取得时候则按照有小到大的顺序来取，达到了排序的目的

            第二种：当在无法修改别人代码或者对象不具备比较性的时候，可以自己创建一个比较器（类），该类实现Comparator接口，并复写接口中的compare（）方法。然后创建比较器new  Comparator（）的对象作为参数传递给构造函数即可。

public class Student implements Comparable<Student> {
	private String name;
	private int score;

	public Student(String name, int score) {
		this.name = name;
		this.score = score;
	}

	public String getNmae() {
		return name;                            //让实现Comparable接口，强制具备比较性
	}

	public int getScore() {
		return score;
	}

	public int compareTo(Student stu) {
		// return this.score<stu.score?-1:(this.score==stu.score)?0:1;
		if (this.score > stu.score) {
			return 1;
		} else if (this.score == stu.score) {
			return this.name.compareTo(stu.name);
		}
		return -1;

	}
}

import java.util.Comparator;

public class MyComparator implements Comparator<Student> {
	public int compare(Student o1, Student o2) {
		Student s1 = (Student) o1;
		Student s2 = (Student) o2;
		int num = s1.getNmae().compareTo(s2.getNmae());
		if (num == 0) {
			return new Integer(s1.getScore()).compareTo(new Integer(s2
					.getScore()));
		}
		return num;                        //创建一个比较器
	}
}

public class SetDemo {
	Set<Student> set = new TreeSet<Student>(new MyComparator());  //new 一个比较器作为参数传递

	public void method() {
		set.add(new Student("张三1", 70));
		set.add(new Student("张三2", 40));
		set.add(new Student("张三4", 80));
		set.add(new Student("张三3", 60));
		set.add(new Student("张三5", 40));
		Iterator<Student> it = set.iterator();
		while (it.hasNext()) {
			Student s = it.next();
			System.out.println("姓名:" + s.getNmae() + "---分数" + s.getScore());
		}
	}
}

• 泛型：

             作用：参数化类型，安全简单

             结构：类名 <  T  >      T代表的是一个类型名称

            泛型的限制：      < T extends  类型 >    T被限制为必须是后边 类型的 子类

            通配符： < ？ >

 

 

转载于:https://my.oschina.net/xia0828/blog/887840