本文共 5391 字，大约阅读时间需要 17 分钟。

异常机制

常见异常分类

异常处理

捕获try-catch 声明异常(throws)

手动抛出异常 throw

public class TestThrow {
   	public static void main(String[] args) {
   		Person p=new Person();		p.setAge(-10);	}}class Person{
   	private int age;	public int getAge() {
   		return age;	}	public void setAge(int age) {
   		if(age<=0) {
   			throw new IllegalAgeException("年龄不能为负数");		}		this.age = age;	}}class IllegalAgeException extends RuntimeException{
   	public  IllegalAgeException() {
   			}public  IllegalAgeException(String msg) {
   		super(msg);	}}

容器 collection

数组就是一种容器，可以在其中放置对象或基本数据类型，线性序列，快速访问数组元素，效率高，但是不灵活，容量事先定义好

Set没有顺序不可以重复 List有顺序可以重复 Map：HashMap

泛型

帮助我们建立安全的集合，泛型的本质就是“数据类型的参数化”，可以理解为数据类型的一个占位符（形式参数），即告诉编译器，在调用泛型时必须传入实际类型

package cn.chenye.collection;public class TestGeneric {
   	public static void main(String[] args) {
   		MyCollection
   
     mc=new MyCollection
    
     ();		mc.set("chenye", 0);		//mc.set(12313, 1);		//Integer a =(Integer)mc.get(1);		String b=mc.get(0);		System.out.print(b);	}}class MyCollection
     
      {
   	Object[] objs=new Object[5];	public void set(E obj,int index) {
   		objs[index]=obj;	}	public E get(int index) {
   		return (E)objs[index];	}}
     
    
   

List

有序，可重复的容器，List中每个元素都有索引标记，根据元素的索引标记访问元素，List允许加入重复的元素（e1.equals(e2))

List接口常用的实现类有3个，ArrayList，LinkedList，Vector

ArrayList底层是数组实现的，查询效率高，增删效率低，线程不安全，数组长度有限，但ArrayList是可以寻访任意数量的对象，长度不受限制

手动实现ArrayList

package cn.my.collection;/** * 自定义实现ArrayList * @author ASUS * */public class MyArrayList {
   	private Object[] elementData;	private int size;	private static final int SIZE=10;	public  MyArrayList() {
   		elementData=new Object[SIZE];	}	public  MyArrayList(int capacity) {
   		elementData=new Object[capacity];	}	public static void main(String[] args) {
   		 MyArrayList s1=new  MyArrayList(20);		 s1.add("asad");		 s1.add("asdf");		 System.out.println(s1);	}	public void add(Object obj) {
   		elementData[size++]=obj;	}	@Override	public String toString() {
   		StringBuilder sb=new StringBuilder();		sb.append("[");		for(int i=0;i

ArrayList和LinkedList

LinkedList相当于链表

package cn.my.collection;//import org.w3c.dom.Node;/** * 自定义链表 * @author ASUS *增加小的封装，增加泛型 */public class MyLinkedList {
   	private Node first;	private Node last;	private int size;				public void add(int index ,Object obj) {
   		checkRange(index);		Node newNode=new Node(obj);		Node temp=getNode(index);		if(temp!=null) {
   			Node up=temp.previous;			up.next=newNode;			newNode.previous=up;			newNode.next=temp;			temp.previous=newNode;		}	}		public void remove(int index) {
   		checkRange(index);		Node temp=getNode(index);		if(temp!=null) {
   			Node up=temp.previous;			Node down=temp.next;			if(up!=null) {
   				up.next=down;			}			if(down!=null) {
   				down.previous=up;			}			if(index==0) {
   				first=down;			}			if(index==size-1) {
   				last=up;			}			size--;		}	}			public Object get(int index) {
   			checkRange(index);		Node temp=getNode(index);		return temp!=null?temp.element:null;			}		private void checkRange(int index) {
   		if(index<0||index>size-1) {
   			throw new RuntimeException("illegal!"+index);		}	}			public Node getNode(int index) {
   		checkRange(index);		Node temp=null;		if(index<=(size>>1)) {
   			temp=first;			for(int i=0;i
   
    index;i--) {
   				temp=temp.previous;			}		}		return temp;	}		public void add(Object obj) {
   		Node node=new Node(obj);		if(first==null) {
   			first=node;			last=node;		}else {
   			node.previous=last;			node.next=null;			last.next=node;			last=node;		}		size++;	}	@Override	public String toString() {
   		StringBuilder sb=new StringBuilder("[");		Node temp=first;		while(temp!=null) {
   			sb.append(temp.element+" ,");			temp=temp.next;		}		sb.setCharAt(sb.length()-1, ']');		return sb.toString();	}		public static void main(String[] args) {
   		MyLinkedList lk=new MyLinkedList();		lk.add("c");		lk.add("h");		lk.add("e");		lk.add("n");		lk.add("y");		lk.add("e");				System.out.println(lk);		lk.add(4,"!");		System.out.println(lk);			}	}class Node{
   	Node previous;	Node next;	Object element;		public Node(Node previous,Node next,Object obj) {
   		super();		this.previous=previous;		this.next=next;		this.element=element;	}	public Node(Object element) {
   		// TODO Auto-generated constructor stub		super();		this.element=element;	}}
   

Vector向量 线程安全的

Map接口

Map是用来存储键值对的，key-value。Map类中存储的键值对通过键来标识，所以键值对不能重复

HashMap

• 哈希表的基本结构就是“数组＋链表”，哈希表将两者优点结合 ***

1. 基本结构 普通存储键值对
2. 解决键重复的问题
3. 重写toString方法 打印Map内容
4. get查找键值对
5. 完善封装 增加泛型

哈希表的底层实现原理：

1. https://blog.csdn.net/zhaozao5757/article/details/79500475
2. https://blog.csdn.net/ddfdjffd/article/details/96487143

package cn.chenye.collection;import java.util.HashMap;import java.util.Map;public class TestMap {
   	public static void main(String[] args) {
   		Map
   
    m1=new HashMap<>();		m1.put(1, "chen");		m1.put(2, "ye");		m1.put(3, "!");		System.out.println(m1.get(1));		System.out.println(m1.size());		System.out.println(m1.isEmpty());		System.out.println(m1.containsKey(2));		System.out.println(m1.containsValue("!"));				Map
    
     m2=new HashMap<>();		m2.put(4, "handsome");		System.out.println(m1.equals(m2));		m1.putAll(m2);		System.out.println(m1);		System.out.println(m2);			}}
    
   

TreeMap

TreeMap是红黑二叉树的典型实现

Comparable接口 HashTable特点

HashMap线程不安全，效率高，允许key或value为null；

HashTable线程安全，效率低，不允许key或value为null；

HashSet TreeSet

Java中HashMap和TreeMap的区别深入理解

迭代器iterator的使用 遍历List，Set，Map