java基础【5】理论

缺乏、安全感 2023-07-07 05:58 12阅读 0赞

## java基础【5】理论 ##

## 异常 ##

java中异常分为两种，编译异常和运行异常，  
一般我们处理的方法是用throw或者throws抛出异常，或者使用try catch捕捉异常  
throw和throws是两种比较消极的处理异常的方式，它们的区别是：  
throw是语句抛出异常，throws是方法抛出异常  
throws是可以单独使用，而throw不可以单独使用  
throws是在方法函数头，throw是在函数体

## 集合 ##

集合中有list和set还有map三种集合  
list和set的集合是继承了collection接口，而map不是  
list的存储数据可以有重复的，set存储数据不能有重复的，map也是不能有重复的数据

## list ##

list是collection接口的实现  
list的下面包含了又arraylist和linkedlist还有vector  
arraylist：底层数据结构是数组，是线程不同步的，查询数据较快  
linkedlist：底层数据结构是链表，也是线程不同步的，增删的速度较快  
vector：底层的数据结构也是数组，是线程同步的，查询，增删的速度都巨慢  
由下面的示例可以看出，list的集合是无线，而且可以有重复的  
list示例

public class Test03 {
        
    
        public static void main(String[] args) {
        
    
            ArrayList<Object> arrayList = new ArrayList<>();
            LinkedList<Object> linkedList = new LinkedList<>();
            Vector<Object> vector = new Vector<>();
    
            arrayList.add("hello");
            arrayList.add("hello");
            arrayList.add(1);
            arrayList.add(4);
            arrayList.add(3);
            arrayList.add(1);
    
            linkedList.add("hello");
            linkedList.add("hello");
            linkedList.add(1);
            linkedList.add(4);
            linkedList.add(3);
            linkedList.add(1);
    
            vector.add("hello");
            vector.add("hello");
            vector.add(1);
            vector.add(4);
            vector.add(3);
            vector.add(1);
    
            for (Object array : arrayList) {
        
                System.out.println("arrayList"+array);
            }
            for (Object linked : linkedList) {
        
                System.out.println("linkedList"+linked);
            }
    
            for (Object vec : vector) {
        
                System.out.println("vector"+vec);
            }
    
        }
    }

输出的是：  
arrayListhello  
arrayListhello  
arrayList1  
arrayList4  
arrayList3  
arrayList1  
linkedListhello  
linkedListhello  
linkedList1  
linkedList4  
linkedList3  
linkedList1  
vectorhello  
vectorhello  
vector1  
vector4  
vector3  
vector1

## set ##

set也是collection接口的实现  
set集合里面包含hashset，linkedhashset和treeset  
hashset：底层数据是哈希表，插入的数据是有序，唯一的，依赖hashcode()和equals()来保证数的唯一性  
linkedhashset：底层数据结构是哈希表和链表，插入的数据是无序，唯一的，使用哈希表保证数据的唯一，使用链表保证数据的有序  
treeset：底层数据结构是红黑树。插入的数据是唯一，有序的，比较器排序，根据比较的返回值是否是0来决定  
由下面的示例可以看出，set里面的数据都是唯一的，  
hashset和treeset都是有序的，linkedhashset的数据是无序的  
set示例

public class Test02 {
        
        public static void main(String[] args) {
        
            HashSet<Object> set = new HashSet<>();
            LinkedHashSet<Object> linkedHashSet = new LinkedHashSet<>();
            TreeSet<Object> treeSet = new TreeSet<>();
            for (String s : Arrays.asList("a", "b", "h", "d", "a", "f", "c")) {
        
                set.add(s);
                linkedHashSet.add(s);
                treeSet.add(s);
            }
            System.out.println("HashSet"+set);
            System.out.println("linkedHashSet"+linkedHashSet);
            System.out.println("treeSet"+treeSet);
        }
    }

输出的是：  
HashSet\[a, b, c, d, f, h\]  
linkedHashSet\[a, b, h, d, f, c\]  
treeSet\[a, b, c, d, f, h\]

## map ##

map本身就是一个接口  
map主要的实现类有hashmap，hashtable，treemap  
hashmap：底层是哈希表数据结构，是线程不同步的，可以有null值  
hashtable，底层也是哈希数据结构，是线程同步的，不可以有null值  
treemap：底层是二叉树结构，可以对map中的元素进行排序  
由下面的示例可以看出，他们的键都是唯一且有顺序的，但是值可以有重复  
hashtable的键是反着的  
map示例

public class Test extends Finala {
        
        public static void main(String[] args) {
        
            HashMap<Object, Object> hashMap = new HashMap<>();
            Hashtable<Object, Object> map = new Hashtable<>();
            TreeMap<Object, Object> treeMap = new TreeMap<>();
            map.put(3,"张");
            map.put(1,"张");
            map.put(3,"刘");
            map.put(2,"刘");
            map.put(1,"张");
    
            treeMap.put(3,"张");
            treeMap.put(1,"张");
            treeMap.put(3,"刘");
            treeMap.put(2,"刘");
            treeMap.put(1,"张");
    
            hashMap.put(3,"张");
            hashMap.put(1,"张");
            hashMap.put(3,"刘");
            hashMap.put(2,"刘");
            hashMap.put(1,"张");
    
            for (Map.Entry<Object, Object> entry : treeMap.entrySet()) {
        
                System.out.println("treeMap"+entry);
            }
    
            for (Map.Entry<Object, Object> entry : map.entrySet()) {
        
                System.out.println("Hashtable"+entry);
            }
            for (Map.Entry<Object, Object> entry : hashMap.entrySet()) {
        
                System.out.println("hashMap"+entry);
            }
        }
    }

输出的是：  
treeMap1=张  
treeMap2=刘  
treeMap3=刘  
Hashtable3=刘  
Hashtable2=刘  
Hashtable1=张  
hashMap1=张  
hashMap2=刘  
hashMap3=刘