Exception的父类是Throwable捕获到的异常，可以在当前方法的 catch 块中处理，也可抛出给调用者去处理

String类的常用方法

1. catch注意顺序，从子类向父类写

2. int xx=input.nextint();
   

throwable有error（主要是系统错误）和exception（有runtimeexception，称为非检查异常）两个类，非检查异常又分为空指针异常，数组下标越界异常，类型转换异常以及算术异常

Comparable接口的比较

omparator 接口

java中集合框架有：

Collection接口（List接口（ArrayList类）、Queue接口（LinkedList类）、Set接口（HashSet类））

Map接口（HashMap类）

Collections工具类（进行Collection对象操作，最常用List的sort方法）

Arrays工具类（针对数组进行操作)

studentList.add(new Student(1 + "","小明"));
为什么是这样书写  (1+"")这就是一个字符串啊，数字+""就转成字符串了，等同于"1"。

package package1;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

import java.util.Random;

public class CollectionsTest2 {

List<String> stringlist = new ArrayList<String>();

Random random = new Random();

String str="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";

public void stringTest() {

for(int i=10;i<20;i++) {

int j = random.nextInt(10)+1;

StringBuilder string =   new StringBuilder();

for(int x=0;x<j;x++) {

int y = random.nextInt(str.length());

string.append(str.charAt(y));

}

String string1 = string.toString();

stringlist.add(string1);

System.out.println("添加字符串"+string1);

}

System.out.println("——————————排序前——————————");

for(String str:stringlist) {

System.out.println(str);

}

Collections.sort(stringlist);

System.out.println("——————————排序后——————————");

for(String str:stringlist) {

System.out.println(str);

}

}

public static void main(String[] args) {

CollectionsTest2 a =new CollectionsTest2();

a.stringTest();

}

}

Collections工具类

java.util.Collections

是Java集合框架中，用来操作集合对象的工具类，与Map，Collection并列的

也是Java集合框架的成员

string 类型排序顺序---先是第一列，然后第二列，依次进行

数字：0-9

大写字母：A-Z

小写字母：a-z

package package1;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.List;

import java.util.Random;

class CollectsTest {

public void testSort1() {

List<Integer> integerlist = new ArrayList<Integer>();

Random random = new Random();

Integer k;

for(int i=0;i<10;i++) {

do {

k=random.nextInt(100);

}while(integerlist.contains(k)) ;

integerlist.add(k);

System.out.println("成功添加了"+k);

}

System.out.println("————————————排序前————————————");

for(Integer integer:integerlist) {

System.out.println("元素"+integer);

}

Collections.sort(integerlist);

System.out.println("————————————排序后————————————");

for(Integer integer:integerlist) {

System.out.println("元素"+integer);

}

}

public void testSort2() {

List<String> stringlist = new ArrayList<String>();

stringlist.add("aaa");

stringlist.add("abbbb");

stringlist.add("Aaaa");

stringlist.add("badsaf");

System.out.println("——————排序前————————");

for(String str : stringlist) {

System.out.println(str);}

Collections.sort(stringlist);

System.out.println("——————排序hou————————");

for(String str : stringlist) {

System.out.println(str);}

}

public static void main(String[] args) {

// TODO Auto-generated method stub

CollectsTest a =new CollectsTest();

a.testSort2();

}

}

try-catch-finally

try{

    //一些会抛出异常的方法

}catch （Exception e）{

    //处理该异常的代码块   

}catch （Exception2 e）{

    //处理Exception2的代码块

} finally {

    //最终将要执行的代码

}

e.printStachTrace();-打印出具体的异常信息。

try catch finally语句先执行catch然后再finally 最后返回main方法中的调用者

try-catch异常处理

try{

    //一些会抛出异常的方法   

} catch （Exception e）{

    //处理该异常的代码块

}

try抛出很多种类的异常时，需要多重catch捕获

使用多重catch时，一定要注意顺序问题，先小后大，即先子类后父类的顺序捕获异常。

Exception类包括非检查异常【RuntimeException】和检查异常

非检查异常分为

空指针异常【NullpointerException】,

数组下标越界异常【ArrayIndexOutOfBoundsExceotion】,

类型转换异常【ClassCastException】，

算术异常【ArithmeticException】等，

这种异常会由Java虚拟机自动抛出并自动铺获

检查异常主要有文件异常【IOException】

finally{  

无论是否发生异常都会执行的代码

  }

package immoc.collection;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

import java.util.Random;

public class CollectionsTest {

public void testSort1() {

List <Integer> integerList=new ArrayList<Integer>();

Random random =new Random();

Integer k;

for (int i = 0; i < 10; i++) {

do {

k=random.nextInt(100);

} while (integerList.contains(k));

integerList.add(k);

System.out.println("添加"+k);

}

System.out.println("=======qian=======");

for (Integer integer:integerList) {

System.out.println("before"+integer);

}

Collections.sort(integerList);

System.out.println("========hou========");

for (Integer integer:integerList) {

System.out.println("after"+integer);

}

}

public void testSort2() {

List<String> stringsList=new ArrayList<String>();

Random random=new Random();

Integer kInteger;

for (int i = 0; i <10; i++) {

Integer tempLength =random.nextInt(10);

StringBuilder temp = new StringBuilder(tempLength);

do {

for (int j = 0; j < tempLength; j++) {

int charInt;

charInt=(random.nextInt(95)+32);

temp.append(String.valueOf((char)charInt));

}

} while (stringsList.contains(temp));

stringsList.add(temp.toString());

System.out.println("添加"+temp.toString());

}

System.out.println("=======qian=======");

for (String st:stringsList) {

System.out.println("before"+st);

}

Collections.sort(stringsList);

System.out.println("========hou========");

for (String st:stringsList) {

System.out.println("after"+st);

}

}

public static void main(String[] args) {

// TODO Auto-generated method stub

CollectionsTest collectionsTest=new CollectionsTest();

collectionsTest.testSort2();

}

}

String 对象创建后则不能被修改，是不可变的，所谓的修改其实是创建了新的对象，所指向的内存空间不同。

public class Student implements Comparable<Student>{

@Override

public int compareTo(Student o){

return this.id.compareTo(o.id);//字符串类型实现了compareTo接口

字符串先比较第一位排序

把comparator作为参数传递给sort方法

sort（list，comparetor）

collections.sort(student,new studentcomparator);

}

}

comparable定义了对象的默认比较规则

comparator定义了对象的临时比较规则