Java基础笔记（三）

异常： 程序在运行时发生的不正常的情况
异常的分类：
Throwable:
Error:错误。由系统原因造成的，一般是系统资源分配冲突或者系统崩 溃等原因。
对于程序员来说Error是无法处理的。
Exception:异常。通常由程序造成的，一般 运算、io等等，可以处理的

默认是jvm进行异常处理。处理的方式打印异常名称、异常信息、异常发生的位置 当出现异常，程序中断，异常下边的代码将不会被执行。

      因为大部分异常java内部已经定义好了，所以当发生异常时，系统会自动 创建该异常的对象。因为main方法不能处理该异常，所以抛给了jvm。
      jvm默认的处理方式将该异常信息打印 printStackTrace();

---

throw:方法内部 手动抛出异常。
如果抛出的异常是受检异常，需要通过throws在声明处声明
throw new 异常类([“异常信息”])
throws:方法声明部分 声明该方法可能会抛出异常，
使用throws的方法不处理异常，谁调用谁处理
方法名() throws 异常类列表{ *
}

throw + 异常对象
throws+异常类列表

在throws抛出异常后，调用者必须处理：
1）使用try-catch处理
2）继续通过throws抛出

---

try{ 可能出现异常的代码 （资源分配） } catch(…){ 出现异常处理的代码 } finally{ 不管是否出现异常，均会执行的代码
（释放资源） }

  思考：如果try中包含return，finally语句中也包含return，执行顺序？

 try - catch -finally: 如果try没有异常：try-finally 如果try有异常：try-catch-finally
  如果try没有异常，且try中有return，try-finally-return
 如果try有异常且try有return，try-catch-finally-return 

——–>finally永远都执行

---

如果try中包含return，finally在return之前执行。

异常处理： 受检异常、非受检异常

如果发生的异常是RuntimeException或其子类，那么
1 在函数内部使用throw抛出异常对象，不用处理，编译可以通过
2在函数后通过throws声明抛出异常，不用处理，编译通过

异常分为两类： 编译时检测的异常（受检异常） 编译时不检测的异常（非受检异常 RuntimeException及子类）

---

基本类：
/*
* 包装类： byte Byte
* short Short
* int Integer
* long Long
* char Character
* float Float
* double Double
* boolean Boolean
* 包装类，方便使用。
* 可以用于基本类型和字符串类型之间的转换
* String Integer.toString(int i)
* String Double.toString(double d)
* 字符串转换成基本类型
* int Integer.parseInt(“123”)
* double Double.parseDouble(“1.2”)
* 进制转换 Integer.toHexString() Integer.toOctalString()
* Integer.toBinaryString()
* Integer.parseInt(“”,”“)
* 装箱：基本类型—》引用类型
* 拆箱：引用类型–》基本类型
*/
Integer i = 10; // 自动装箱 new Integer（10）
i = i + 100;// 先自动拆箱 i.intValue()+100 再装箱 new Integer（）
// java默认情况下，会在常量池中创建 -128~127常量
Integer m = 127;
Integer n = 127;
System.out.println(m == n);// true

    Integer a = 128;
    Integer b = 128;
    System.out.println(a == b);// false
    // 正数的hashCode（）就是其本身，long类型可能会不同
    System.out.println(a.hashCode());
    System.out.println(b.hashCode());

    Long l = new Long(12345678900000L);
    System.out.println(l.hashCode());

---

---

Date的使用：
Date date = new Date();// 获得系统当前时间
System.out.println(date);

    long time = date.getTime();
    Date d2 = new Date(time);

    // 使用定义好的日期格式化工具类
    DateFormat df = DateFormat.getDateInstance(DateFormat.SHORT);
    System.out.println(df.format(date));

    // 将字符串转换成Date对象
    try {
        Date d3 = df.parse("15-03-04");
    } catch (ParseException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

    // 自定义格式格式化日期和时间
    // 注意： 月MM 分 mm 秒：ss 毫秒：SSS
    SimpleDateFormat sdf = new SimpleDateFormat("yyy/MM/dd hh:mm:ss:SSS");
    System.out.println(sdf.format(new Date()));

---

Calendar的使用：
Calendar calendar = Calendar.getInstance();
int year = calendar.get(Calendar.YEAR);
int month = calendar.get(Calendar.MONTH);
int week = calendar.get(Calendar.DAY_OF_WEEK);
System.out.println(year);
String[] months = { “1月”, “2月”, “3月”, “4月”, “5月”, “6月”, “7月”, “8月” };
System.out.println(months[month]);// 0-11
String[] weeks = { “”, “Sunday”, “Monday”, “Tuesday” };
System.out.println(weeks[week]);
System.out.println(calendar.get(Calendar.DAY_OF_MONTH));
System.out.println(calendar.get(Calendar.HOUR_OF_DAY));// 24小时

    String str = String.format("%d年", year);
    System.out.println(str);
    // %s String %c char %d int %f float double
    System.out.println(String.format("%.2f", 10 / 3.0));

---

StringBuffer:
StringBuffer类：字符串的容器，里面的内容是可以变 .线程安全

StringBuilder jdk1.5 线程不安全 效率高

存储：
StringBuffer append()
StringBuffer insert(int offset,string s)

删除：
StringBuffer delete(int start,int end)
StringBuffer deleteCharAt(int index)

修改：
StringBuffer replace(int start,int end,String str)
void setCharAt(int index,char ch)

获得：
char charAt(int index)
int indexOf()
int lashIndexOf()

int length()

反转:
StringBuffer reverse()

---

---

List
List接口：特点：存储对象有序的，可以重复的
增加： void add(int index,Object o)
boolean addAll(int index , Collection c)
删除：
Object remove（int index）
修改：
Object set（int index，Object o）：返回原来的元素
查询：
ListIterator listIterator（）
List subList（int fromIndex，int toIndex）
Object get（int index）
ArrayList类：List接口的实现类 通过下标操作，类似于数组。可以看作为可变长度的数组 数组有序的： FIFO 先进先出 （First In First Out）

  ListIterator:父接口Iterator
  List特定的迭代器，可以镶嵌和向后获取数据，支持增删改的操作
  hasNext() next() hasPreivious() previous() previousIndex()      add() set()

---

Set：
Set接口：无序的（存储的顺序和添加的顺序不一致）。不能存放重复的元素

HashSet类：使用的数据结构是哈希表，线程不安全的

保证加入集合的对象的唯一性：
    int hashCode()
    boolean equals(Object obj)

比较的过程：
首先调用对象的hashCode（）方法，如果哈希值不同，直接添加到集合中。
如果hashCode（）相同，则会调用equals（）方法判断内容是否相同，如果返回false，表示内容不同，直接添加到集合中
如果返回true，则不可以添加到集合中

哈希值相同不一定是同一个对象，同一个对象的哈希值一定相同。

步骤：
1）自定义类，
2）重写hashCode（）：自定义算法
a、 eclipse自动生成
b、通常让属性的hashCode（）的和返回，基本类型直接求和，引用类型通过调用hashCode（）
3)重写equals（）方法
a、 eclipse自动生成
b、依次比较属性的值是否全部都相等

---

TreeSet:底层使用的数据结构是二叉树，线程不安全。会对存入集合的对象进行排序。
*
* 保证加入集合的对象是可排序的：
* 1）让自定义的类实现Comparable接口，int compareTo（）
* 2 ）自定义比较器：
* 创建比较器，实现Comparator接口，接口int compare（）
* 把比较器对象作为参数传递给集合的构造方法
实例：
class Dog implements Comparable {
private String name;
private int age;

public String getName() {
    return name;
}

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

public int getAge() {
    return age;
}

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

public Dog(String name, int age) {
    super();
    this.name = name;
    this.age = age;
}

public Dog() {
    super();
}

@Override
public String toString() {
    return "Dog [name=" + name + ", age=" + age + "]";
}

@Override
public int hashCode() {
    final int prime = 31;
    int result = 1;
    result = prime * result + age;
    result = prime * result + ((name == null) ? 0 : name.hashCode());
    return result;
}

@Override
public boolean equals(Object obj) {
    if (this == obj)
        return true;
    if (obj == null)
        return false;
    if (getClass() != obj.getClass())
        return false;
    Dog other = (Dog) obj;
    if (age != other.age)
        return false;
    if (name == null) {
        if (other.name != null)
            return false;
    } else if (!name.equals(other.name))
        return false;
    return true;
}

@Override
public int compareTo(Object o) {
    Dog d = (Dog) o;
    if (this.age < d.age)
        return -1;
    else if (this.age > d.age)
        return 1;
    else
        return this.name.compareTo(d.name); // 年龄相同再继续比较姓名
}

}

// 自定义比较器
// 比较名字是否相等,如果名字相同再按照年龄排序
class MyCompare implements Comparator {

@Override
public int compare(Object o1, Object o2) {
    if (!(o1 instanceof Dog))
        throw new ClassCastException("类型转换出错");
    if (!(o2 instanceof Dog))
        throw new ClassCastException("类型转换出错");
    Dog d1 = (Dog) o1;
    Dog d2 = (Dog) o2;
    int n = d1.getName().compareTo(d2.getName());
    return n == 0 ? d1.getAge() - d2.getAge() : n;
}

}