JavaSE 异常、集合

异常处理

异常

程序若是运行时错误，会导致程序的崩溃，指运行时发生的不正常事件，能够被程序处理，可以使程序继续运行

运行时异常：也称为非检测异常，这些异常在编译使其不检测，程序中可以选择处理，也可以不处理，如果不处理运行时会中断，但编译没有问题

非运行时异常：也称为检测异常，是必须进行处理的异常，如果不处理，会发生编译错误

错误

错误是编译时错误，程序不能正常运行，要进行必要的代码修改

异常捕获

try：不能单独存在，必须与catch或finally搭配才能使用，作用是进行异常的捕获

catch：也不能单独使用，必须与try搭配，可以有多个，但父类的异常类型必须在最后，处理异常的代码只会在出现对应异常时执行

finally：不能单独使用，必须与 try搭配，只能有一个，通常用于资源的释放，其中的代码无论如何都会执行，除非存在”System. exit(1); ”强行退出程序，即使有 return也会执行到 finally中的代码

throw 向外抛出异常，只能抛一个异常

Throws 写在方法后面，可以抛出多个异常，用”,”隔开

集合

集合与数组

1.    数组长度是固定的，集合的长度是动态生成的

2.    数组的类型是固定的，集合存储的类型可以是不固定的(不指定泛型)或固定(指定类型)

List & ArrayList

1.    创建普通集合：长度是动态的，可以存储任何数据类型

List list = new ArrayList();      //ArrayList采用数组方式存储
list.add(Object);                //添加一个元素
list.add(index, object);          //在index位置添加一个元素，index从0开始
list.clear();                    //清空集合
list.remove(index);              //移除指定下标的元素
list.size();                     //获取集合大小
list.get(index);                 //获取index位置的元素

2.    创建泛型集合

List<String> list = newArrayList<String>();

区别：泛型集合 规定了存储的数据类型，而普通集合可以存任意类型

LinkedList

List list = new LinkedList();		//LinkedList以链表的形式存储
(LinkedList)list.addFirst(Object); 	//该方法在LinkedList类中，因此需要强转
(LinkedList)list.add(Object);

集合排序

package com.etc.homework.list;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Main {

	public static void main(String[] args) {

		
		List<Person> list = new ArrayList<Person>();
		
		Person person_0 = new Person();
		person_0.setName("aaa");
		person_0.setPassword("111");
		person_0.setAge(10);

		Person person_1 = new Person();
		person_1.setName("bbb");
		person_1.setPassword("222");
		person_1.setAge(30);
		
		Person person_2 = new Person();
		person_2.setName("ccc");
		person_2.setPassword("333");
		person_2.setAge(20);
		
		list.add(person_0);
		list.add(person_1);
		list.add(person_2);
		
		/* 集合的排序步骤：
		 * 1.Collections.sort(list);
		 * 2.实现Comparable接口
		 * 3.覆写compareTo方法
		 */
		Collections.sort(list);
		
		for(int i=0;i<list.size();i++){
			System.out.println(list.get(i));
		}
		
	}
	
}

package com.etc.homework.list;
/**
 * Person
 */
public class Person implements Comparable<Person> {

	private String name;
	private String password;
	private int age;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	@Override
	public String toString() {
		return "Person [name=" + name + ", password=" + password + ", age="
				+ age + "]";
	}
	/*
	 * 实现compareTo方法
	 */
	@Override
	public int compareTo(Person person) {
		// TODO Auto-generated method stub
		return this.age < person.getAge() ? -1 : this.age == person.getAge() ? 0 : 1;
	}

}

HashSet & TreeSet

Set set = new HashSet();
set.size();
set.add(Object);
set.remove(Object);
set.clear();
//遍历方式
for(Object obj : set) {			//增强for循环形式
	System.out.println(obj);
}
Iterator iterator = set.iterator();
while(iterator.hasNext()) {		//使用迭代器迭代
	System.out.println(iterator.next());
}
//特点：添加重复的数据会被忽略

//与HashSet基本一致，但TreeSet可以自动进行排序
//TreeSet以第一个添加的类型为泛型
treeSet.first();             //取第一个元素
treeSet.last();             //取最后一个元素

HashMap & TreeMap

Map map = new HashMap();
map.put(key, value); 			//重复添加同一个key时，会覆盖之前的值
map.get(key);
map.remove(key);
map.clear();
map.size();
//遍历方式：
//推荐遍历法：	
Iterator<Entry<String, String>> iterator2 = map.entrySet().iterator();
while (iterator2.hasNext()) {
	Entry<String, String> entry = iterator2.next();
// Map.Entry<String, String> entry = iterator2.next();
	System.out.println(entry.getKey()+ " : " + entry.getValue());	
}
//keySet遍历
Iterator<String> iterator = map.keySet().iterator();
while(iterator.hasNext()) {
	String index = iterator.next();
	System.out.println(index + " : " + map.get(index));
}
//与HashMap基本一致，但key值会自动排序

Arrays类自动排序

String[] strArr = new String[5];
Arrays.sort(strArr); 			//可以对任意数组进行排序