05-JAVA异常与集合

• 在捕获异常的代码块里(try{}里的代码)，如果前面的代码有异常了，就不会执行后面的。
• getMessage()方法，用来得到有关异常时间的信息。
• printStackTrace()用来跟踪异常时间发生时执行堆栈的内容。

HashSet

• 按Hash算法来存储集合中的元素，因此具有很好的存取和查找性能。
• 特点：
  1. 不能保证元素的排练顺序
  2. 不可重复
  3. HashSet不是线程安全的。
  4. 集合元素可以使用null
• HashSet判断两个对象相等的条件：两个对象通过equals()方法比较想等，并且两个对象的hashCode()方法返回值页想等。
• Demo:

public class HashSetDemo {
    public static void main(String[] args) {
        Set s = new HashSet();
        //添加元素
        s.add(1);
        s.add("a");
        //移除元素
        s.remove(1);
        //是否包含某个元素
        System.out.println(s.contains("a"));
        s.clear();
        s.add("a");
        s.add("b");
        //第一种遍历方式，recommend
        for (Object o : s) {
            System.out.println(o);
        }
        //使用迭代器进行遍历
        Iterator iterator = s.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
        //集合的大小
        System.out.println(s.size());
        //集合存同样类型的对象
        Set<Integer> intSet = new HashSet<Integer>();
    }
}

TreeSet

• TreeSet可以确保集合元素处于排序状态。
• 支持两种排序方法：自然排序和定制排序。默认情况下是自然排序。
• 必须放入同样类型的对象，否则可能发生类型转换异常。

public class TreeSetDemo {
    public static void main(String[] args) {
        Set<Integer> s = new TreeSet<Integer>();
        s.add(5);
        s.add(3);
        s.add(2);
        s.add(1);
        System.out.println(s);
        s.remove(5);
        System.out.println(s.contains(2));
        for (Integer integer : s) {
            System.out.println(integer);
        }
        //在TreeSet的构造函数要传入 -> new Person(),因为我们自定义了comparetor
        Set<Person> personSet = new TreeSet<>(new Person());
        Person p1 = new Person(12,"bob");
        Person p2 = new Person(18, "alice");
        personSet.add(p1);
        personSet.add(p2);
        System.out.println("order -> ");
        for (Person person : personSet) {
            System.out.println(person.age + " : " + person.name);
        }
    }
}

class Person implements Comparator<Person> {
    public int age;
    public String name;
    public Person(){

    }
    public Person(int age, String name){
        this.age = age;
        this.name = name;
    }
    @Override
    public int compare(Person p1, Person p2) {
        if (p1.age > p2.age) {
            return 1;
        }
        else if(p1.age < p2.age)
        {
            return -1;
        }
        else
        {
            return 0;
        }
    }
}

List与ArrayList

• List代表一个元素有序、且可重复的集合，集合中的每个元素都有其对应的顺序索引。
• List允许使用重复元素，可以通过索引来访问指定位置的集合元素。
• List默认按元素的添加顺序设置元素的索引。
• List集合里添加了一些根据索引来操作集合元素的方法。

public class ListDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("a");
        list.add("c");
        list.add("b");
        System.out.println(list);
        //根据索引访问元素
        System.out.println(list.get(2));
        //可以重复
        list.add("a");
        System.out.println(list.size());
        //在指定索引下标的位置插入元素
        list.add(1,"f");
        System.out.println(list);

        List<String> l = new ArrayList<>();
        l.add("123");
        l.add("456");
        //在指定位置插入集合
        list.addAll(2,l);
        System.out.println(list);
        //获取指定元素在集合中第一次、最后一次出现的索引下标
        System.out.println(list.indexOf("f"));
        list.add("f");
        System.out.println(list.lastIndexOf("f"));
        //根据指定索引下标移除数据
        list.remove(0);
        System.out.println(list);
        //修改指定索引的值
        list.set(0,"fffff");
        System.out.println(list);
        //截取list集合, subList(i,j),i -> j，不包含j
        List<String> subList = list.subList(1, 3);
        System.out.println(subList);
        //集合的长度
        System.out.println(list.size());
    }
}

Map

• Map用于保存具有映射关系的数据，因此Map集合里保存着两组值，一组值用于保存Map里的Key，另外一组用于保存Map里的Value。
• Map中的Key不允许重复，即同一个Map对象的任何两个Key通过equals方法比较中返回false。
• 主要使用HashMap

public class HashMapDemo {
    public static void main(String[] args) {
        Map<String, Integer> hashMap = new HashMap<>();
        hashMap.put("a",1);
        hashMap.put("b",2);
        hashMap.put("c",3);
        System.out.println(hashMap);
        //根据key取值
        System.out.println(hashMap.get('b'));
        //根据key移除键值对
        hashMap.remove("a");
        //map的大小
        System.out.println(hashMap.size());
        //判断当前map是否包含指定的key，value
        System.out.println(hashMap.containsKey("b"));
        System.out.println(hashMap.containsValue(2));
        //遍历
        //第一种遍历方式
        Set<String> keySet = hashMap.keySet();
        for (String key : keySet) {
            System.out.println("key:"+key+", Value:"+hashMap.get(key));
        }
        //第二种遍历方式
        Set<Map.Entry<String, Integer>> entries = hashMap.entrySet();
        for (Map.Entry<String, Integer> entry : entries) {
            System.out.println(entry.getKey()+"->" +entry.getValue());
        }  
    }
}

• TreeMap
  • TreeMap可以保证所有Key-Value对处于有序状态。默认情况下根据Map的key进行排序。

Collection

public class CollectionDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("b");
        //使用新值替换掉旧值
        Collections.replaceAll(list,"c","a");
        System.out.println(list);
        //返回指定元素第出现次数
        int frequency = Collections.frequency(list,"b");
        System.out.println(frequency);
        System.out.println(list);
        //交换第0个和第3个第位置
        Collections.swap(list,0,2);
        System.out.println(list);
        //返回list中最大元素
        String max = Collections.max(list);
        System.out.println(max);
        //反转list集合的顺序
        Collections.reverse(list);
        System.out.println(list);
        //对list集合进行随机排序
        Collections.shuffle(list);
        System.out.println(list);
        //list集合字典升序排列
        Collections.sort(list);
        System.out.println(list);

        Student s1 = new Student(12, "a");
        Student s2 = new Student(14, "b");
        Student s3 = new Student(13, "c");
        ArrayList<Student> studentArrayList = new ArrayList<>();
        studentArrayList.add(s1);
        studentArrayList.add(s2);
        studentArrayList.add(s3);
        for (Student student : studentArrayList) {
            System.out.println(student.age+"->"+student.name);
        }
        //根据年龄进行排序
        Collections.sort(studentArrayList,new Student());
        for (Student student : studentArrayList) {
            System.out.println(student.age + "->" + student.name);
        }
    }
}

class Student implements Comparator<Student>{
    int age;
    String name;

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

    public Student() {
    }

    @Override
    public int compare(Student t1, Student t2) {
        if(t1.age > t2.age)
        {
            return 1;
        }
        else if(t1.age < t2.age)
        {
            return -1;
        }
        else
        {
            return 0;
        }
    }
}