Java进阶语法之集合

怼烎@ 2024-03-31 17:33 119阅读 0赞

#### Java中的常见集合有哪些 ####

*  Collection接口
 *   *  常用的子接口
     *   *  List
         *   *  ArrayList
             *  LinkedList
         *  Set
         *   *  HashSet
         *  Queue
 *  Map接口
 *   *  Hashmap
     *  Hashtable
 *  补充
 *   *  泛型
     *  比较器
     *  Iterator
     *  工具类

## Collection接口 ##

### 常用的子接口 ###

List接口、Set接口、Queue接口

#### List ####

按照插入顺序保存数据，数据可以重复的。  
具体的实现类：ArrayList，LinkedList

##### ArrayList #####

import java.util.ArrayList;
    
    public class Java_Collection_List {
        
        public static void main(String[] args) {
        
            // TODO 创建第一个集合对象：ArrayList
            ArrayList list = new ArrayList();
            // 1. 不需要传递构造参数，直接new就可以，底层数组为空数组
            // 2. 构造参数需要传递一个int类型的值，用于设定底层数组的长度
            // 3. 构造参数需要传递一个Collection集合类型的值，用于将其他集合中的数据放置在当前集合中
    
            // TODO 增加数据
            // add方法可以增加数据，只要将数据作为参数传递到add方法即可
            // 添加数据时，如果集合中没有任何的数据，那么底层会创建长度为10的数组
            list.add("zhangsan");
            list.add("lisi");
            list.add("wangwu");
            list.add("zhaoliu");
    
            // TODO 访问集合中的数据
            // 获取集合中数据的条数
            System.out.println(list.size());
            // 获取指定位置的数据，可以采用索引的方式
            System.out.println(list.get(1));
            // 遍历集合中的数据
            for(int i = 0; i < list.size(); i++){
        
                // System.out.println("集合中的数据："+list.get(i));
            }
    
            // TODO 如果循环遍历集合数据时，不关心数据的位置，那么可以采用特殊的for循环
            // for (循环对象：集合) {}
            for( Object obj : list ){
        
                System.out.pcrintln("集合中的数据：" + obj);
            }
    
            // TODO 修改数据
            // 将指定位置的数据进行修改，set方法需要传递2个参数，第一个参数表示数据的位置，第二个参数修改的值
            // 方法会返回结果，这个结果就是更新前的值
            Object oldVal = list.set(1, "lisi");
            System.out.println("修改前的值：" + oldVal);
    
            // TODO 删除数据
            // 将指定位置的数据进行删除，remove方法需要传递1个参数，参数表示数据的位置
            // 方法会返回结果，这个结果就是删除的值
            Object removeVal = list.remove(1);
            System.out.println("删除的值：" + removeVal);
        }
    }

##### LinkedList #####

import java.util.LinkedList;
    
    public class Java_Collection_LinkedList {
        
        public static void main(String[] args) {
        
            LinkedList list = new LinkedList();
            list.element(); // 获取第一个数据
            list.pop(); // 弹出数据
        }
    }

#### Set ####

集，无序保存，数据不能重复  
具体的实现类：HashSet

##### HashSet #####

import java.util.HashSet;
    
    public class Java_Collection_Set {
        
        public static void main(String[] args) {
        
            // HashSet: Hash + Set
            // Hash: 哈希算法，散列算法
            // ArrayList: 数组
            // LinkedList:
            HashSet set = new HashSet();
            // TODO 增加数据
            set.add("zhangsan");
            set.add("zhangsan");
            set.add("lisi");
            set.add("wangwu");
    
            // TODO 删除数据
            set.remove("wangwu");
    
            // TODO 查询数据
            for(Object o : set){
        
                System.out.println(o);
            }
    
            System.out.println(set);
        }
    }

#### Queue ####

队列  
具体的实现类：ArrayBlockingQueue

import java.util.concurrent.ArrayBlockingQueue;
    
    public class Java_Collection_Queue {
        
        public static void main(String[] args) throws Exception{
        
            ArrayBlockingQueue queue = new ArrayBlockingQueue(3);
            // add方法如果增加数据增加不了，直接发生错误。
            queue.add("zhangsan");
            queue.add("lisi");
            queue.add("wangwu");
            queue.add("zhaoliu"); // 发生错误，Queue full
    
            queue.put("zhangsan");
            System.out.println("第一个人挂号");
            queue.put("lisi");
            System.out.println("第二个人挂号");
            queue.put("wangwu");
            System.out.println("第三个人挂号");
            queue.put("zhaoliu");
            System.out.println("第四个人挂号");
    
            boolean zhangsan = queue.offer("zhangsan");
            System.out.println(zhangsan);
            boolean lisi = queue.offer("lisi");
            System.out.println(lisi);
            boolean wangwu = queue.offer("wangwu");
            System.out.println(wangwu);
            boolean zhaoliu = queue.offer("zhaoliu");
            System.out.println(zhaoliu);
    
            System.out.println(queue.take());
            System.out.println(queue.take());
            System.out.println(queue.take());
            System.out.println(queue.take());
        }
    }

## Map接口 ##

具体的实现类：HashMap，HashTable

### Hashmap ###

import java.util.HashMap;
    
    public class Java_Collection_Map {
        
        public static void main(String[] args) {
        
            // TODO 集合 - Map
            // HashMap: Hash + Map
            // 数据存储是无序
            HashMap map = new HashMap();
            
            // 添加数据: put
            // 修改数据: put方法也可以修改数据，返回值就是被修改的值
            map.put("zhangsna", "1");
            System.out.println(map.put("zhangsan", "4"));
            map.put("lisi", "2");
            map.put("wangwu", "3");
            
            // TODO 查询数据
            System.out.println(map.get("zhangsan"));
            
            // TODO 删除数据
            map.remove("zhangsan");
    
            System.out.println(map);
        }
    }

### Hashtable ###

import java.util.HashMap;
    import java.util.Hashtable;
    
    public class Java_Collection_HashTable {
        
        public static void main(String[] args) {
        
            // TODO 集合 - Map
            // Hashtable
            Hashtable table = new Hashtable();
            table.put(null, null);
            HashMap map = new HashMap();
            map.put(null, null);
            
            // TODO 1. 实现方式不一样的：继承父类不一样
            // TODO 2. 底层结构的容量不同：HashMap(16), Hashtable(11)
            // TODO 3. HashMap的K, V都可以为null, Hashtable的K, V不能是null
            // TODO 4. HashMap的数据定位采用的是Hash算法, 但是Hashtable采用的就是hashcode
            // TODO 5. HashMap的性能较高，但是Hashtable较低
        }
    }

## 补充 ##

### 泛型 ###

public class Java_Collection_Generic {
        
        public static void main(String[] args) {
        
            // TODO 集合 - Collection
            // 泛型语法
            // TODO 泛型和类型的区别
            // 有时，也把泛型称之为类型参数
            MyContainer<User7> myContainer = new MyContainer<>();
        }
    }
    
    // TODO 容器类
    class MyContainer<C> {
        
        public C data;
    }
    class User7 {
        
    
    }

### 比较器 ###

import java.util.ArrayList;
    import java.util.Comparator;
    
    public class Java_Comparator {
        
        public static void main(String[] args) {
        
            ArrayList list = new ArrayList();
            list.add(1);
            list.add(3);
            list.add(2);
            list.sort(new NumberComparator());
        }
    }
    
    class NumberComparator implements Comparator<Integer> {
        
        @Override
        public int compare(Integer o1, Integer o2) {
        
            // TODO 如果第一个数比第二个数要大，那么返回结果为正数，表示升序
            // return o1 - o2;
            // TODO 如果第一个数比第二个数要小，那么返回结果为负数，表示降序
            // return o2 - o1;
            // TODO 如果第一个数和第二个数一样大，那么返回结果为0
            return 0;
        }
    }

### Iterator ###

import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Set;
    
    public class Java_Collection_Iterator {
        
        public static void main(String[] args) {
        
            // TODO 集合 - Map
            HashMap<String, Integer> map = new HashMap<String, Integer>();
            map.put("a", 1);
            map.put("b", 2);
            map.put("c", 3);
    
            Set<String> keys =  map.keySet();
    
            Iterator<String> iterator = keys.iterator();
            // hasNext方法用于判断是否存在下一条数据
            while(iterator.hasNext()){
        
                // 获取下一条数据
                String key = iterator.next();
                if("b".equals(key)){
        
                    iterator.remove();
                }
                System.out.println(map.get(key));
            }
        }
    }

### 工具类 ###

import java.util.Arrays;
    import java.util.List;
    
    public class Java_Collection_Util {
        
        public static void main(String[] args) {
        
            int[] is = {
        3, 5, 2, 1, 4};
            int[] is1 = {
        1, 2, 3, 4, 5};
            int[] is2 = {
        1, 2, 3, 4, 5, 6};
            System.out.println(Arrays.toString(is));
            System.out.println(is);
    
            List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5);
    
            // 排序(默认为升序)
            Arrays.sort(is); // 1,2,3,4,5
            System.out.println(Arrays.toString(is));
            
            // 二分查找法，排序后的数组
            System.out.println(Arrays.binarySearch(is, 5));
            
            // 数组的比较
            System.out.println(Arrays.equals(is2, is1));
            System.out.println(Arrays.equals(is2, 0, 5, is1, 0, 5));
        }
    }

**参考资料**：[7天搞定Java基础，Java零基础极速入门][7_Java_Java]

[7_Java_Java]: https://www.bilibili.com/video/BV1o841187iP?p=117&spm_id_from=pageDriver&vd_source=a1af903e57688df870625021f7f3a7eb