集合类库

谁借莪１个温暖的怀抱￠ 2023-01-15 14:21 119阅读 0赞

### 目录 ###

*  一、集合的概述
 *  二、Collection集合
 *   *   *   *  （一）Collection分类
             *  （二）Collection的常用方法
             *  （三）Collection集合中添加元素
             *  （四）判断是否包含某些元素
             *  （五） 移除集合中某些元素
             *  （六）集合与数组间的相互转换
 *  三、Iterator接口（迭代器）
 *   *   *   *   *  常用方法：
                 *  通过迭代器遍历集合
 *  四、for……each遍历集合
 *  五、List集合
 *   *   *   *  （一）List分类
             *  （二）List常用方法
             *  （三）List集合中增加元素
             *  （四）List集合中查找元素
             *  （五）List集合中修改元素
             *  （六）List集合中删除元素
             *  (七) Stack
 *  六、Queue集合
 *   *   *   *  (一) Queue概述
             *  (二) Queue集合常用方法
             *  (三) Queue集合添加，打印，删除元素
 *  七、泛型
 *   *   *   *   *  <> 里面写数据类型，表示只能存放该数据类型的数据。
             *  （一）自定义泛型类
             *  （二）自定义泛型类测试
             *  （三）自定义泛型类被子类继承时
             *  （四）自定义泛型方法
             *  （五）泛型通配符？？？
 *  八、Set集合
 *   *   *   *  （一）Set集合概述
             *  （二）HashSet集合中添加元素
 *  九、Map集合（java.util.Map）

# 一、集合的概述 #

当需要在java程序中记录多个类型不同的对象数据时，则准备一个集合。

集合的顶层框架是：java.util.Collection集合和java.util.Map集合

Collection存取元素单位是单个元素，Map是单对元素。

# 二、Collection集合 #

#### （一）Collection分类 ####

Collection包括List接口，Queue接口和Set接口。

List接口包括：ArrayList类,LinkedList类,Stack类,Vector类

Set接口包括: HashSet类,TreeSet类

#### （二）Collection的常用方法 ####

boolean add();							添加单个元素
    
    boolean addAll();						添加全部元素
    
    boolean contains();					判断是否包含指定对象
    
    boolean containsAll();				判断是否包含全部对象
    
    boolean retainAll();					保留当前集合中存在且参数集合中存在的所有对象
    
    boolean remove();						移除某个元素
    
    boolean removeAll();					移除指定的所有元素
    
    void clear();									清空集合
    
    int size();										返回包含对象的个数
    
    boolean isEmpty();						判断是否为空
    
    boolean equals();							判断是否相等
    
    int hashCode();								获取当前集合的哈希码值
    
    Object[] toArray();							将集合转为数组
    
    Iterator iterator();							获取当前集合的迭代器

#### （三）Collection集合中添加元素 ####

public class Test1 {
        
        public static void main(String[] args) {
        
            // 创建一个ArrayList集合指向Collection父类型
            Collection a1 = new ArrayList();
            // 输出结果为 [] // 因为还没有往里面添加元素
            System.out.println(a1);
            // 输出一行线方便与下面的输出分隔开，方便观察
            System.out.println("--------------------------------------");
            // 添加单个元素
            a1.add("wang");
            System.out.println(a1);
            a1.add(123);
            System.out.println(a1);
            a1.add("pikaqiu");
            System.out.println(a1);
            System.out.println("--------------------------------------");
            // 创建一个ArrayList集合指向Collection父类型
            Collection a2 = new ArrayList();
            // 将a1中的所有元素添加到a2里
            a2.addAll(a1);
            System.out.println(a2);
        }
    }

#### （四）判断是否包含某些元素 ####

public class Test2 {
        
        public static void main(String[] args) {
        
            // 创建一个ArrayList集合指向Collection父类型
            Collection a1 = new ArrayList();
            //往集合a1中添加一系列元素
            a1.add(1);
            a1.add(2);
            a1.add("pikaqiu");
            //判断a1中是否包含1,包含输出true，不包含输出false
            System.out.println("a1包含元素1："+a1.contains(1));
            //判断a1中是否包含5,包含输出true，不包含输出false
            System.out.println("a1包含元素5："+a1.contains(5));
            System.out.println("----------------------------------------");
            // 创建一个ArrayList集合指向Collection父类型
            Collection a2 = new ArrayList();
            //往集合a2中添加一系列元素
            a2.add(1);
            a2.add(2);
            // 判断集合a1是否包含集合a2
            System.out.println("a1包含集合a2："+a1.containsAll(a2));
            // 判断集合a2是否包含集合a1
            System.out.println("a2包含集合a1："+a2.containsAll(a1));
            System.out.println("----------------------------------------");
            System.out.println("一开始的a1："+a1);
            // 判断a1和a2都含有的对象并保留在a1中
            System.out.println(a1.retainAll(a2));
            System.out.println("后来的a1："+a1);
        }
    }

#### （五） 移除集合中某些元素 ####

public class Test3 {
        
        public static void main(String[] args) {
        
            // 创建一个ArrayList集合指向Collection父类型
            Collection a1 = new ArrayList();
            //往集合a1中添加一系列元素
            a1.add(1);
            a1.add(2);
            a1.add("pikaqiu");
            System.out.println("一开始的a1:"+a1);
            //移除a1中的元素1，移除成功输出移除元素成功，失败了输出移除元素失败
            System.out.println(a1.remove(1)?"移除元素成功":"移除元素失败");
            System.out.println("移除元素后的a1："+a1);
            System.out.println("-------------------------------------------------");
    
            // 创建一个ArrayList集合指向Collection父类型
            Collection a2 = new ArrayList();
            //往集合a1中添加一系列元素
            a2.add(1);
            a2.add(2);
            a2.add(3);
            a2.add(4);
            a2.add(5);
            a2.add("pikaqiu");
            a2.add("pikaqiu1");
            a2.add("wangwenxiao");
            System.out.println("一开始的a2"+a2);
            // 在a2中移除掉所有a1元素，移除成功输出移除元素成功，失败了输出移除元素失败
            System.out.println(a2.removeAll(a1)?"移除元素成功":"移除元素失败");
            System.out.println("移除元素后的a1："+a1);
            System.out.println("-------------------------------------------------");
            // 往a1里添加一些元素进行此处的判断
            a1.add(1);
            a1.add(2);
            a1.add("pikaqiu");
            // 输出未清空集合前的a1
            System.out.println("一开始的a1"+a1);
            //清空集合a1
            a1.clear();
            // 输出清空集合后的a1
            System.out.println("清空集合后的a1："+a1);
            // 判断集合a1是否为空
            System.out.println("集合a1是否为空："+a1.isEmpty());
            // 判断集合a2是否为空
            System.out.println("集合a2是否为空："+a2.isEmpty());
            System.out.println("-------------------------------------------------");
    
    
        }
    }

#### （六）集合与数组间的相互转换 ####

public class Test4 {
        
        public static void main(String[] args) {
        
            // 创建一个ArrayList集合指向Collection父类型
            Collection a1 = new ArrayList();
            //往集合a1中添加一系列元素
            a1.add(1);
            a1.add(2);
            a1.add(3);
            a1.add(4);
            a1.add(5);
            a1.add("pikaqiu");
            a1.add("pikaqiu1");
            a1.add("wangwenxiao");
            //将集合转为数组
            Object[] objects=a1.toArray();
            //打印数组中所有元素
            System.out.println("数组中元素："+ Arrays.toString(objects));
            System.out.println("-------------------------------------------");
            //将数组转为集合
            Collection objects1=Arrays.asList(objects);
            //打印集合中的所有蒜素
            System.out.println("集合中元素："+objects1);
            System.out.println("-------------------------------------------");
    
        }
    }

# 三、Iterator接口（迭代器） #

**迭代器是什么：迭代器是用于遍历集合中的元素的一种方式**

##### 常用方法： #####

boolean hasNext(); 判断集合中是否有可以访问的元素

E next(); 用于取出一个元素并且指向下一个元素

void remove(); 用于删除访问到的最后一个元素

##### 通过迭代器遍历集合 #####

public class Test6 {
        
        public static void main(String[] args) {
        
            // 创建一个ArrayList集合指向Collection父类型
            Collection a1 = new ArrayList();
            //往集合a1中添加一系列元素
            a1.add(1);
            a1.add(2);
            a1.add(3);
            a1.add("pikaqiu1");
            a1.add("pikaqiu2");
            a1.add("pakaqiu3");
            System.out.println("该集合为："+a1);
            // 创建该集合的一个迭代器
            Iterator iterator = a1.iterator();
            // 利用while循环依次输出集合内数据
            // 注意 interator.hasNext() 是用来判断当前集合是否还有数据可供输出，该方法返回一个boolean值类型
            while(iterator.hasNext()){
        
                System.out.println(iterator.next());
            }
            System.out.println("-----------------------------------");
            System.out.println("利用迭代器遍历进行字符串拼接输出集合样式");
            System.out.println("此处需要再创建一个迭代器,上面的迭代器已然结束");
            // 创建一个该集合的迭代器
            Iterator iterator1=a1.iterator();
            StringBuilder sb=new StringBuilder();
            sb.append("[");
            while(iterator1.hasNext()){
        
                Object o=iterator1.next();
                if(iterator1.hasNext()) {
        
                   sb.append(o).append(",").append(" ");
                }else {
        
                    sb.append(o).append("]");
                }
                System.out.println(sb);
            }
    
        }
    }

# 四、for……each遍历集合 #

public class Test7 {
        
        public static void main(String[] args) {
        
            //创建一个ArrayList集合指向Collection父类型
            Collection a1 = new ArrayList();
            //往集合a1中添加一系列元素
            a1.add(1);
            a1.add(2);
            a1.add(3);
            a1.add(4);
            a1.add(5);
            a1.add("pikaqiu");
            a1.add("pikaqiu1");
            a1.add("wangwenxiao");
            
            //for each 遍历集合并输出数据
            for(Object o:a1){
        
                System.out.println(o);
            }
        }
    }

# 五、List集合 #

#### （一）List分类 ####

List的实现类主要有ArrayList，LinkedList，Stack ……

ArrayList： 底层是采用**动态数组**进行数据管理的，支持下标访问，增删元素不方便。

LinkedList： 底层是采用**双向链表**进行数据管理的，访问不方便，但是增删元素方便

Stack：**栈，先进后出，后进先出**

#### （二）List常用方法 ####

void add(int index,E element) 向集合中指定位置添加元素

boolean addAll(int index,Collection<?extends E>c) 向集合中添加所有元素

E get(int index) 从集合中获取指定位置的元素

int indexOf(Object o) 查找参数指定的对象是否存在，存在则返回对象所在下标，不存在返回-1

int lastIndexOf(Object o) 反向查找参数指定的对象是否存在，存在则返回对象所在下标，不存在返回-1

E set(int index,E element) 修改指定位置的元素

E remove(int index) 删除指定位置的元素

List subList(int fromIndex,int toIndex) 用于获取子List

#### （三）List集合中增加元素 ####

public class Test1 {
        
        public static void main(String[] args) {
        
    
            // 创建一个list集合对象LinkedList指向父类型List
            // 由于此处要进行List集合的增加操作，而list实现类里LinkedList类方便增删操作，所以利用LinkedList实现类
            List list1 = new LinkedList();
            // 向集合中添加元素,可以指定下标也可以不指定下标
            // 如果不指定下标则依次增加，如果指定下标则按照下标进行添加
            list1.add(0,1);
            list1.add(1,"wang");
            list1.add(2,666);
            System.out.println("一开始的list1集合："+list1);
            System.out.println("在下标1处添加元素222，那么此处往后的元素会依次后移");
            list1.add(1,222);
            System.out.println("在下标为1处添加元素222后的list1集合："+list1);
            System.out.println("---------------------------------------------------------");
            
            // 创建一个list集合对象LinkedList指向父类型List
            // 由于此处要进行List集合的增加操作，而list实现类里LinkedList类方便增删操作，所以利用LinkedList实现类
            List list2 = new LinkedList();
            // 向集合中添加元素,可以指定下标也可以不指定下标
            // 如果不指定下标则依次增加，如果指定下标则按照下标进行添加
            list2.add(0,111111);
            list2.add(1,"wang11111111");
            list2.add(2,66611111);
            System.out.println("集合list2："+list2);
            System.out.println("在集合list1下标3处增加list2所有元素，那么此处往后的下标会依次后移");
            list1.addAll(3,list2);
            System.out.println("在集合list1下标3处增加list2所有元素后的list1:"+list1);
            System.out.println("---------------------------------------------------------");
    
        }
    }

#### （四）List集合中查找元素 ####

public class Test2 {
        
        public static void main(String[] args) {
        
            // 创建一个list集合对象ArrayList指向父类型List
            // 由于此处要进行List集合的增加操作，而list实现类里ArrayList类支持下标访问，所以利用ArrayList实现类
            List list1 = new ArrayList();
            // 向集合中添加元素,可以指定下标也可以不指定下标
            // 如果不指定下标则依次增加，如果指定下标则按照下标进行添加
            // 向集合中添加一系列元素
            list1.add(0,1);
            list1.add(1,"wang");
            list1.add(2,666);
            list1.add(3,1111);
            list1.add(4,"pi");
            list1.add(5,777);
            System.out.println("list1集合为："+list1);
            // 访问下标为3的元素
            System.out.println("下标为3的元素是："+list1.get(3));
            System.out.println("---------------------------------------");
            System.out.println("查看集合list中是否存在666元素，存在返回元素所在下标位置");
            System.out.println(list1.indexOf(666));
            System.out.println("查看集合list中是否存在66元素，不存在返回-1");
            System.out.println(list1.indexOf(66));
        }
    }

#### （五）List集合中修改元素 ####

public class Test3 {
        
        public static void main(String[] args) {
        
            //定义一个list集合
            List list1 = new ArrayList();
            // 向集合中添加一系列元素
            list1.add(0,1);
            list1.add(1,"wang");
            list1.add(2,666);
            list1.add(3,1111);
            list1.add(4,"pi");
            list1.add(5,777);
            System.out.println("一开始的list1集合为："+list1);
            System.out.println("---------------------------------------------");
            // 获取修改数据
            Scanner s=new Scanner(System.in);
            System.out.print("请输入要修改元素的下标：");
            int index=s.nextInt();
            // 判断所修改数据是否存在
            if(index<list1.size()) {
        
                System.out.print("指定元素存在，请输入修改值：");
                String value=s.next();
                // 对list集合进行修改操作
                list1.set(index,value);
                System.out.println("被修改后的list1集合为："+list1);
            }else {
        
                System.out.print("指定元素不存在，修改进程结束！");
            }
            System.out.println("---------------------------------------------");
        }
    }

#### （六）List集合中删除元素 ####

public class Test4 {
        
        public static void main(String[] args) {
        
            //定义一个list集合
            List list1 = new ArrayList();
            // 向集合中添加一系列元素
            list1.add(0,1);
            list1.add(1,"wang");
            list1.add(2,666);
            list1.add(3,1111);
            list1.add(4,"pi");
            list1.add(5,777);
            System.out.println("一开始的list1集合为："+list1);
            System.out.println("-------------------------------------------------------");
            // 获取删除元素数据
            Scanner s=new Scanner(System.in);
            System.out.print("请输入要删除元素的下标：");
            int index=s.nextInt();
            // 对集合进行删除操作
            if(index<list1.size()) {
        
                System.out.println("指定删除元素存在，删除成功！");
                list1.remove(index);
            }else {
        
                System.out.println("指定元素不存在，删除失败！");
            }
            System.out.println("删除元素后的集合为："+list1);
            System.out.println("-------------------------------------------------------");
            // 获取删除元素数据
            System.out.print("请输入要删除元素的值：");
            String value=s.next();
            // 对集合进行删除操作
            list1.remove(value);
            System.out.println("删除元素后的集合为："+list1);
            System.out.println("-------------------------------------------------------");
    
        }
    }

#### (七) Stack ####

public class Test5 {
        
        public static void main(String[] args) {
        
            // new一个stack
            Stack stack = new Stack();
            // 对栈元素依次入栈并打印
            for(int i=1;i<10;i++){
        
                stack.push(i*3);
                System.out.println("第"+i+"个入栈的数据是："+(i*3));
            }
            System.out.println("stack= "+stack);
            System.out.println("--------------------------------------------");
            // 查看栈顶元素并打印
            System.out.println("stack中栈顶元素是："+stack.peek());
            System.out.println("--------------------------------------------");
            // 对栈中元素依次出栈并打印
            int size=stack.size();
            for(int i=1;i<=size;i++){
        
                // 得到出栈元素
                Object o= stack.pop();
                System.out.println("第"+i+"个出栈的数据是："+o);
            }
            System.out.println("---------------------------------------------");
    
        }
    }

# 六、Queue集合 #

#### (一) Queue概述 ####

先进先出， 实现类主要有LinkedList类

#### (二) Queue集合常用方法 ####

boolean offer(E e);			将一个对象添加至队尾，若添加成功则返回true
    
    E poll();			从队首返回并删除一个元素
    
    E peek();              返回队首的元素，但并不删除

#### (三) Queue集合添加，打印，删除元素 ####

public class Test1 {
        
        public static void main(String[] args) {
        
            // 创建一个对象
            Queue queue1 = new LinkedList();
            // 添加元素
            queue1.offer(1);
            queue1.offer(2);
            queue1.offer(3);
            // 打印出集合
            System.out.println("queue1= "+queue1);
            System.out.println("-----------------------------------------------");
            int size=queue1.size();
            for(int i=1;i<=size;i++){
        
                System.out.println(queue1.poll()+"删除成功");
                System.out.println("删除后的queue1："+queue1);
            }
        }
    }

# 七、泛型 #

##### <> 里面写数据类型，表示只能存放该数据类型的数据。 #####

#### （一）自定义泛型类 ####

public class Person<T> {
        
        private String name;
        private int age;
        private T high;
    
        public Person() {
        
            super();
        }
    
        public Person(String name, int age, T high) {
        
            this.name = name;
            this.age = age;
            this.high = high;
        }
    
        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 T getHigh() {
        
            return high;
        }
    
        public void setHigh(T high) {
        
            this.high = high;
        }
    
        @Override
        public String toString() {
        
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    ", high=" + high +
                    '}';
        }
    }

#### （二）自定义泛型类测试 ####

public class PersonTest {
        
        public static void main(String[] args) {
        
            Person<String> p=new Person<>();
            p.setHigh("111");
            System.out.println(p);
        }
    }
    
     	输出：Person{
        name='null', age=0, high=111}
    	输出结果对应的是Person类中的toString方法

#### （三）自定义泛型类被子类继承时 ####

//  person类中的泛型在继承的时候都是没有保留的 
    1.    public class SubPerson extends Person {
         //丢弃泛型并且没有指定类型，默认为Object类型 }
    2.    public class SubPerson extends Person<String> {
         //丢弃泛型但是指定了泛型类型 }

#### （四）自定义泛型方法 ####

语法格式：
        	[访问权限] <泛型> 返回值类型  方法名[泛型标识 参数名称]{
          方法体； }

例如：
        public <E> void t[E e]{
        }

#### （五）泛型通配符？？？ ####

<?>      无限制通配符:表示我们可以传入任意类型的参数
        <? extends E>    类型的上界是E，只能是E或者E的子类
        <? super E>		类型的下界是E，只能是E或者E的父类

# 八、Set集合 #

#### （一）Set集合概述 ####

Set集合不分进入次序
            Set数据不允许重复，list的数据允许重复
            Set集合的实现类主要有HashSet（底层是哈希表进行数据管理的）
                			和TreeSet（底层是红黑树进行数据管理的）
    		（HashSet的底层是Map集合
    			有序二叉树（是特殊的二叉树）：左子节点<根节点<右子节点
    			红黑树数特殊的有序二叉树 ）

#### （二）HashSet集合中添加元素 ####

public class Test1 {
        
        public static void main(String[] args) {
        
            HashSet<String> s = new HashSet<>();
            System.out.println(s);
            s.add("wang");
            System.out.println(s);
            s.add("wen");
            System.out.println(s);
            s.add("xiao");
            System.out.println(s);
            System.out.println("--------------------");
            System.out.println("验证元素不能重复：");
            System.out.println(s.add("wang")?"元素插入成功":"元素重复，插入失败");
        }
    }

（三）TreeSet

实现自然排序
        public int compareTo( ){
        
        		// return 0;  //调用对象和参数对象相等
        		// return -1;  //调用对象小于参数对象
                // return 1;   // 调用对象大于参数对象
    	}
    实现比较器排序
        Comparator<类型> c=new Comparator<类型>(){
        
              public int compare(类型 n1,类型 n2){
        
                  //n1是新增对象，n2是已有对象
                  return n1.getAge()-n2.getAge(); // 按照年龄排序
              }
    	}

# 九、Map集合（java.util.Map） #

（一）Map集合概述

Map<K,V>  K:Key,相当于目录   V：Value，值
            Key是不允许重复的，该列相当于collection
            Key和Value都是String类型的
            Map集合的主要实现类： HashMap类，TreeMap类，Hashtable类

（二)Map集合常用方法

V put(K Key,V value)     将该对数据存入Map，如果集合中中已经包含Key，那么替换Key
                              所对应的Value，返回值为该Key来源的Value，若没有则返回null
        V get(Object Key)        返回与参数Key所对应的Value对象，如果不存在则返回null
        boolean containKey(Object Key)     判断集合中是否包含指定的Key
        boolean containValue(Object Value)     判断集合中是否包含指定的KeyValue
        V remove(Object Key)          根据参数指定的key进行删除
        Set<k>  KeySet()            返回此映射中包含的键的Set视图
        Collection<V>  values()           返回此映射总包含的值的Set视图
        Set<Map.Entry<K,V>>  entrySet()            返回此映射中包含的映射的Set视图