测试开发之java集合篇（List,Map,Set）

ゞ浴缸里的玫瑰 2023-09-25 13:01 32阅读 0赞

#### 集合 ####

*   *  List集合
     *   *  1.1 List集合概述和特点
         *  1.2 List集合的特有方法
         *  1.3列表迭代器
         *  1.4 增强for循环
         *  1.5 List集合存储学生对象三种方式遍历
     *  List集合的实现类
     *   *  2.1 List集合子类的特点
         *  2.2 ArrayList集合存储学生对象三种方式遍历
         *  3.3 LinkedList集合的特有功能
     *  Set集合
     *   *  3.1 Set集合概述和特点
         *  3.2 HashSet集合概述和特点
         *  3.3 HashSet集合存储学生对象并遍历
         *  3.4 TreeSet集合概述和特点
     *  map集合
     *   *  4.2 Map集合的获取功能
         *  4.3 Map集合的遍历(方式1)
         *  4.4 Map集合的遍历(方式2)

### List集合 ###

#### 1.1 List集合概述和特点 ####

**List集合概述**

*  有序集合(也称为序列)，用户可以精确控制列表中每个元素的插入位置。用户可以通过整数索引访问元素，并搜索列表中的元素

**list集合特点**

*  有索引
 *  可以存储重复元素
 *  元素存取有序

#### 1.2 List集合的特有方法 ####

void add(int index,E element)	
    在此集合中的指定位置插入指定的元素
    E remove(int index)
    删除指定索引处的元素，返回被删除的元素
    E set(int index,E element)	
    修改指定索引处的元素，返回被修改的元素
    E get(int index)	
    返回指定索引处的元素

#### 1.3列表迭代器 ####

**ListIterator介绍**

1.  通过List集合的listIterator()方法得到，所以说它是List集合特有的迭代器
2.  用于允许程序员沿任一方向遍历的列表迭代器，在迭代期间修改列表，并获取列表中迭代器的当前位置

public class ListIteratorDemo {
        
        public static void main(String[] args) {
        
            //创建集合对象
            List<String> list = new ArrayList<String>();
    
            //添加元素
            list.add("hello");
            list.add("world");
            list.add("java");
    
            //获取列表迭代器
            ListIterator<String> lit = list.listIterator();
            while (lit.hasNext()) {
        
                String s = lit.next();
                if(s.equals("world")) {
        
                    lit.add("javaee");
                }
            }
    
            System.out.println(list);
    
        }
    }

#### 1.4 增强for循环 ####

**语法格式**

for(元素数据类型 变量名 : 数组/集合对象名) {
        
    	循环体;
    }

public class ForDemo {
        
          public static void main(String[] args) {
        
              int[] arr = {
        1,2,3,4,5};
              for(int i : arr) {
        
                  System.out.println(i);
              }
              System.out.println("--------");
      
              String[] strArray = {
        "hello","world","java"};
              for(String s : strArray) {
        
                  System.out.println(s);
              }
              System.out.println("--------");
      
              List<String> list = new ArrayList<String>();
              list.add("hello");
              list.add("world");
              list.add("java");
      
              for(String s : list) {
        
                  System.out.println(s);
              }
              System.out.println("--------");
      
              //内部原理是一个Iterator迭代器
              /*
              for(String s : list) {
                  if(s.equals("world")) {
                      list.add("javaee"); //ConcurrentModificationException
                  }
              }
              */
          }
      }

#### 1.5 List集合存储学生对象三种方式遍历 ####

**需求**  
创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合

### List集合的实现类 ###

#### 2.1 List集合子类的特点 ####

**ArrayList集合**  
底层是数组结构实现，查询快、增删慢  
**LinkedList集合**  
底层是链表结构实现，查询慢、增删快

#### 2.2 ArrayList集合存储学生对象三种方式遍历 ####

**需求**  
创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合

public class ArrayListDemo {
        
        public static void main(String[] args) {
        
            //创建ArrayList集合对象
            ArrayList<Student> array = new ArrayList<Student>();
    
            //创建学生对象
            Student s1 = new Student("林青霞", 30);
            Student s2 = new Student("张曼玉", 35);
            Student s3 = new Student("王祖贤", 33);
    
            //把学生添加到集合
            array.add(s1);
            array.add(s2);
            array.add(s3);
    
            //迭代器：集合特有的遍历方式
            Iterator<Student> it = array.iterator();
            while (it.hasNext()) {
        
                Student s = it.next();
                System.out.println(s.getName() + "," + s.getAge());
            }
            System.out.println("--------");
    
            //普通for：带有索引的遍历方式
            for(int i=0; i<array.size(); i++) {
        
                Student s = array.get(i);
                System.out.println(s.getName() + "," + s.getAge());
            }
            System.out.println("--------");
    
            //增强for：最方便的遍历方式
            for(Student s : array) {
        
                System.out.println(s.getName() + "," + s.getAge());
            }
        }
    }

#### 3.3 LinkedList集合的特有功能 ####

> public void addFirst(E e)  
> 在该列表开头插入指定的元素  
> public void addLast(E e)  
> 将指定的元素追加到此列表的末尾  
> public E getFirst()  
> 返回此列表中的第一个元素  
> public E getLast()  
> 返回此列表中的最后一个元素  
> public E removeFirst()  
> 从此列表中删除并返回第一个元素  
> public E removeLast()  
> 从此列表中删除并返回最后一个元素

### Set集合 ###

#### 3.1 Set集合概述和特点 ####

**Set集合的特点**

*  元素存取无序
 *  没有索引、只能通过迭代器或增强for循环遍历
 *  不能存储重复元素

#### 3.2 HashSet集合概述和特点 ####

**HashSet集合的特点**

*  底层数据结构是哈希表
 *  对集合的迭代顺序不作任何保证，也就是说不保证存储和取出的元素顺序一致
 *  没有带索引的方法，所以不能使用普通for循环遍历
 *  由于是Set集合，所以是不包含重复元素的集合

public class HashSetDemo01 {
        
        public static void main(String[] args) {
        
            //创建集合对象
            HashSet<String> hs = new HashSet<String>();
    
            //添加元素
            hs.add("hello");
            hs.add("world");
            hs.add("java");
    
            hs.add("world");
    
            //遍历
            for(String s : hs) {
        
                System.out.println(s);
            }
        }
    }

#### 3.3 HashSet集合存储学生对象并遍历 ####

创建一个存储学生对象的集合，存储多个学生对象，使用程序实现在控制台遍历该集合  
要求：学生对象的成员变量值相同，我们就认为是同一个对象

public class Student {
        
        private String name;
        private int age;
    
        public Student() {
        
        }
    
        public Student(String name, int age) {
        
            this.name = name;
            this.age = 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;
        }
    
        @Override
        public boolean equals(Object o) {
        
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
    
            Student student = (Student) o;
    
            if (age != student.age) return false;
            return name != null ? name.equals(student.name) : student.name == null;
        }
    
        @Override
        public int hashCode() {
        
            int result = name != null ? name.hashCode() : 0;
            result = 31 * result + age;
            return result;
        }
    }

public class HashSetDemo02 {
        
        public static void main(String[] args) {
        
            //创建HashSet集合对象
            HashSet<Student> hs = new HashSet<Student>();
    
            //创建学生对象
            Student s1 = new Student("林青霞", 30);
            Student s2 = new Student("张曼玉", 35);
            Student s3 = new Student("王祖贤", 33);
    
            Student s4 = new Student("王祖贤", 33);
    
            //把学生添加到集合
            hs.add(s1);
            hs.add(s2);
            hs.add(s3);
            hs.add(s4);
    
            //遍历集合(增强for)
            for (Student s : hs) {
        
                System.out.println(s.getName() + "," + s.getAge());
            }
        }
    }

#### 3.4 TreeSet集合概述和特点 ####

**TreeSet集合概述**

*  元素有序，可以按照一定的规则进行排序，具体排序方式取决于构造方法
 *  TreeSet()：根据其元素的自然排序进行排序
 *  TreeSet(Comparator comparator) ：根据指定的比较器进行排序
 *  没有带索引的方法，所以不能使用普通for循环遍历
 *  由于是Set集合，所以不包含重复元素的集合

public class TreeSetDemo01 {
        
        public static void main(String[] args) {
        
            //创建集合对象
            TreeSet<Integer> ts = new TreeSet<Integer>();
    
            //添加元素
            ts.add(10);
            ts.add(40);
            ts.add(30);
            ts.add(50);
            ts.add(20);
    
            ts.add(30);
    
            //遍历集合
            for(Integer i : ts) {
        
                System.out.println(i);
            }
        }
    }

### map集合 ###

**\#\#\# 4.1 Map集合概述和特点  
概述**

interface Map<K,V>  K：键的类型；V：值的类型

**特点**

*  键值对映射关系
 *  一个键对应一个值
 *  键不能重复，值可以重复
 *  元素存取无序

#### 4.2 Map集合的获取功能 ####

V put(K key,V value)	添加元素
    V remove(Object key)	根据键删除键值对元素
    void clear()	移除所有的键值对元素
    boolean containsKey(Object key)	判断集合是否包含指定的键
    boolean containsValue(Object value)	判断集合是否包含指定的值
    boolean isEmpty()	判断集合是否为空
    int size()	集合的长度，也就是集合中键值对的个数

public class MapDemo02 {
        
        public static void main(String[] args) {
        
            //创建集合对象
            Map<String,String> map = new HashMap<String,String>();
    
            //V put(K key,V value)：添加元素
            map.put("张无忌","赵敏");
            map.put("郭靖","黄蓉");
            map.put("杨过","小龙女");
    
            //V remove(Object key)：根据键删除键值对元素
    //        System.out.println(map.remove("郭靖"));
    //        System.out.println(map.remove("郭襄"));
    
            //void clear()：移除所有的键值对元素
    //        map.clear();
    
            //boolean containsKey(Object key)：判断集合是否包含指定的键
    //        System.out.println(map.containsKey("郭靖"));
    //        System.out.println(map.containsKey("郭襄"));
    
            //boolean isEmpty()：判断集合是否为空
    //        System.out.println(map.isEmpty());
    
            //int size()：集合的长度，也就是集合中键值对的个数
            System.out.println(map.size());
    
    
            //输出集合对象
            System.out.println(map);
        }
    }

#### 4.3 Map集合的遍历(方式1) ####

**遍历思路**

> 我们刚才存储的元素都是成对出现的，所以我们把Map看成是一个夫妻对的集合 把所有的丈夫给集中起来 遍历丈夫的集合，获取到每一个丈夫  
> 根据丈夫去找对应的妻子

**步骤分析**

> 获取所有键的集合。用keySet()方法实现 遍历键的集合，获取到每一个键。用增强for实现 根据键去找值。用get(Object  
> key)方法实现

public class MapDemo01 {
        
        public static void main(String[] args) {
        
            //创建集合对象
            Map<String, String> map = new HashMap<String, String>();
    
            //添加元素
            map.put("张无忌", "赵敏");
            map.put("郭靖", "黄蓉");
            map.put("杨过", "小龙女");
    
            //获取所有键的集合。用keySet()方法实现
            Set<String> keySet = map.keySet();
            //遍历键的集合，获取到每一个键。用增强for实现
            for (String key : keySet) {
        
                //根据键去找值。用get(Object key)方法实现
                String value = map.get(key);
                System.out.println(key + "," + value);
            }
        }
    }

#### 4.4 Map集合的遍历(方式2) ####

**遍历思路**

> 我们刚才存储的元素都是成对出现的，所以我们把Map看成是一个夫妻对的集合 获取所有结婚证的集合 遍历结婚证的集合，得到每一个结婚证  
> 根据结婚证获取丈夫和妻子

**步骤分析**

> 获取所有键值对对象的集合 Set<Map.Entry<K,V>> entrySet()：获取所有键值对对象的集合  
> 遍历键值对对象的集合，得到每一个键值对对象 用增强for实现，得到每一个Map.Entry 根据键值对对象获取键和值  
> 用getKey()得到键 用getValue()得到值

public class MapDemo02 {
        
        public static void main(String[] args) {
        
            //创建集合对象
            Map<String, String> map = new HashMap<String, String>();
    
            //添加元素
            map.put("张无忌", "赵敏");
            map.put("郭靖", "黄蓉");
            map.put("杨过", "小龙女");
    
            //获取所有键值对对象的集合
            Set<Map.Entry<String, String>> entrySet = map.entrySet();
            //遍历键值对对象的集合，得到每一个键值对对象
            for (Map.Entry<String, String> me : entrySet) {
        
                //根据键值对对象获取键和值
                String key = me.getKey();
                String value = me.getValue();
                System.out.println(key + "," + value);
            }
        }
    }