简单介绍Collection Iterator List Set Map HashMap的基本用法

短命女 2023-10-11 14:17 19阅读 0赞

## Collection集合 ##

*  **集合**：集合是java中提供的一种容器，可以用来存储多个数据。

**集合与数组的区别**

*  数组的长度是固定的。集合的长度是可变的。
 *  数组中存储的是同一类型的元素，可以存储基本数据类型值。集合存储的都是对象。而且对象的类型可以不一致。在开发中一般当对象多的时候，使用集合进行存储。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Jlbjk0MzY_size_16_color_FFFFFF_t_70]

### 常用方法 ###

*  `public boolean add(E e)`： 把给定的对象添加到当前集合中 。
 *  `public void clear()` :清空集合中所有的元素。
 *  `public boolean remove(E e)`: 把给定的对象在当前集合中删除。
 *  `public boolean contains(E e)`: 判断当前集合中是否包含给定的对象。
 *  `public boolean isEmpty()`: 判断当前集合是否为空。
 *  `public int size()`: 返回集合中元素的个数。
 *  `public Object[] toArray()`: 把集合中的元素，存储到数组中。

### 常用功能 ###

*  `public static <T> boolean addAll(Collection<T> c, T... elements)`:往集合中添加一些元素。
 *  `public static void shuffle(List<?> list) 打乱顺序`:打乱集合顺序。
 *  `public static <T> void sort(List<T> list)`:将集合中元素按照默认规则排序==(默认升序)==。
 *  `public static <T> void sort(List<T> list，Comparator<? super T> )`:将集合中元素按照指定规则排序。

代码演示：

public class CollectionsDemo {
        
        public static void main(String[] args) {
        
            ArrayList<Integer> list = new ArrayList<Integer>();
            //原来写法
            //list.add(12);
            //list.add(14);
            //list.add(15);
            //list.add(1000);
            //采用工具类 完成 往集合中添加元素  
            Collections.addAll(list, 5, 222, 1，2);
            System.out.println(list);
            //排序方法 
            Collections.sort(list);
            System.out.println(list);
        }
    }
    结果：
    [5, 222, 1, 2]
    [1, 2, 5, 222]

### Comparator比较器 ###

`public static <T> void sort(List<T> list)`:将集合中元素按照默认规则排序。升序

public class CollectionsDemo2 {
        
        public static void main(String[] args) {
        
            ArrayList<String>  list = new ArrayList<String>();
            list.add("cba");
            list.add("aba");
            list.add("sba");
            list.add("nba");
            //排序方法
            Collections.sort(list);
            System.out.println(list);
        }
    }

结果：

[aba, cba, nba, sba]

JAVA中提供了两种比较实现的方式  
一种是比较死板的采用`java.lang.Comparable`接口去实现  
一种是灵活的当我需要做排序的时候在去选择的`java.util.Comparator`接口完成。

Comparable方式  
实现Comparable接口，并重写`public int compareTo(Object o)`方法

我们采用的`public static <T> void sort(List<T> list)`这个方法完成的排序，实际上采用了第一种方式。  
观察String源码发现，String实现了Comparable接口 源码如下：

public final class String implements java.io.Serializable, Comparable<String>, CharSequence {

String类实现了这个接口，并完成了比较规则的定义，但是这样就把这种规则写死了，如果我想要字符串按照第一个字符降序排列，那么这样就要修改String的源代码，这是显然不可能的了，所以说这个方法死板。

这个时候我们可以使用第二种方法 实现Comparable接口

`public static <T> void sort(List<T> list，Comparator<? super T> )` 这个  
方法可以灵活的完成各种排序。  
这个里面就涉及到了Comparator这个接口，位于java.util包下，排序是comparator能实现的功能之一,该接口代表一个比较器，比较两个对象谁排在前谁排在后，比较的方法就是：

*  `public int compare(String o1, String o2)`：比较其两个参数的顺序。
    
    > 两个对象比较的结果有三种：大于，等于，小于。
    > 
    > 查看源码会发现，如果返回值为正数，那么两个对象将要交换位置
    > 
    > **正数则交换位置**
    > 
    > 如果要按照升序排序, o1-o2  
    > 则o1 小于o2，返回（负数），相等返回0，01大于02返回（正数）  
    > 如果要按照降序排序, o2-o1  
    > 则o1 小于o2，返回（正数），相等返回0，01大于02返回（负数）

操作如下:

public class CollectionsDemo3 {
        
        public static void main(String[] args) {
        
            ArrayList<String> list = new ArrayList<String>();
            list.add("cba");
            list.add("aba");
            list.add("sba");
            list.add("nba");
            //排序方法  按照第一个单词的降序
            Collections.sort(list, new Comparator<String>() {
        
                @Override
                public int compare(String o1, String o2) {
        
                    return o2.charAt(0) - o1.charAt(0);
                }
            });
            System.out.println(list);
        }
    }

结果如下：

[sba, nba, cba, aba]

### 简述Comparable和Comparator两个接口的区别。 ###

**Comparable**：强行对实现它的每个类的对象进行整体排序。  
这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。

**Comparator** 强行对某个对象进行整体排序。  
可以将Comparator 传递给sort方法（如Collections.sort或 Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序。

## Iterator迭代器 ##

### 获取迭代器 ###

*  `public Iterator<E> iterator()`: 获取集合对应的迭代器，用来遍历集合中的元素的。

Iterator接口的常用方法如下：

*  `public E next()`:返回迭代的下一个元素。
 *  `public boolean hasNext()`:如果仍有元素可以迭代，则返回 true。
 *  remove(); 将迭代器新返回的元素删除。

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zbdz2Mzp-1595675286514)(E:\\Work\\Java\\资料\\基础进阶\\课件资料\\resource\\02\_迭代器的实现原理(1)\].bmp)

### 遍历 ###

while(it.hasNext()){
         //判断是否有迭代元素
                String s = it.next();//获取迭代出的元素
                System.out.println(s);
            }

## List集合 ##

`java.util.List`

List接口特点：

1.  它是一个元素存取有序的集合。例如，存元素的顺序是11、22、33。那么集合中，元素的存储就是按照11、22、33的顺序完成的）。
2.  它是一个带有索引的集合，通过索引就可以精确的操作集合中的元素（与数组的索引是一个道理）。
3.  集合中可以有重复的元素，通过元素的equals方法，来比较是否为重复的元素。

### 常用方法 ###

*  `public void add(int index, E element)`: 将指定的元素，添加到该集合中的指定位置上。

*  `public E get(int index)`:返回集合中指定位置的元素。
 *  `public E remove(int index)`: 移除列表中指定位置的元素, 返回的是被移除的元素。
 *  `public E set(int index, E element)`:用指定元素替换集合中指定位置的元素,返回值的更新前的元素。

### ArrayList集合 ###

`java.util.ArrayList`

元素增删慢，查找快，

由于日常开发中使用最多的功能为查询数据、遍历数据，所以`ArrayList`是最常用的集合。

### LinkedList集合 ###

`java.util.LinkedList`

方便元素添加、删除的集合。 查询慢

双向链表

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

*  `public void addFirst(E e)`:将指定元素插入此列表的开头。
 *  `public void addLast(E e)`:将指定元素添加到此列表的结尾。
 *  `public E getFirst()`:返回此列表的第一个元素。
 *  `public E getLast()`:返回此列表的最后一个元素。
 *  `public E removeFirst()`:移除并返回此列表的第一个元素。
 *  `public E removeLast()`:移除并返回此列表的最后一个元素。
 *  `public E pop()`:从此列表所表示的堆栈处弹出一个元素。
 *  `public void push(E e)`:将元素推入此列表所表示的堆栈。
 *  `public boolean isEmpty()`：如果列表不包含元素，则返回true。

LinkedList是List的子类，List中的方法LinkedList都是可以使用，这里就不做详细介绍，我们只需要了解LinkedList的特有方法即可。在开发时，**LinkedList集合也可以作为堆栈，队列的结构使用**。

## set集合 ##

继承自`Collection`接口，

它与`Collection`接口中的方法基本一致(**没有索引**)，并没有对`Collection`接口进行功能上的扩充，只是比`Collection`接口更加严格了。

与`List`接口不同的是，`Set`接口中\*\*元素无序\*\*，并且都会以某种规则保证存入的元素不出现重复。

*  遍历不能使用简单for循环

### HashSet集合 ###

`java.util.HashSet`是`Set`接口的一个实现类

所存储的元素是\*\*不可重复的**，并且元素都是**无序的\*\*(即存取顺序不一致)。

`java.util.HashSet`底层的实现其实是一个`java.util.HashMap`

> `HashSet`是根据对象的**哈希值**来确定元素在集合中的存储位置，因此具有良好的存取和查找性能。
> 
> 保证元素唯一性的方式依赖于：**`hashCode`与`equals`方法。**

#### HashSet集合存储数据的结构（哈希表） ####

##### 哈希值 #####

是一个十进制的整数，由系统给出（就是对象的地址值，但是逻辑地址，不是实际的物理地址）

object类中有一个方法获取对象的哈希值

`int hashCode()` 返回该对象额哈希值。

##### 哈希表 #####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Jlbjk0MzY_size_16_color_FFFFFF_t_70 1]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Jlbjk0MzY_size_16_color_FFFFFF_t_70 2]

**储存元素不重复的原理**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Jlbjk0MzY_size_16_color_FFFFFF_t_70 3]

##### 重写equals和hashCode #####

@Override
        public boolean equals(Object o) {
        
            if (this == o)
                return true;
            if (o == null || getClass() != o.getClass())
                return false;
            Student student = (Student) o;
            return age == student.age &&
                   Objects.equals(name, student.name);
        }
    
        @Override
        public int hashCode() {
        
            return Objects.hash(name, age);
        }

### LinkHashSet集合 ###

为保证数据有序，加一个链表记录存入顺序

`java.util.LinkedHashSet`

链表和哈希表组合的一个数据存储结构。

**有序，且不重复**

\#可变参数

**自JDK1.5之后**

参数类型确定，参数个数不确定

格式

修饰符 返回值类型 方法名(参数类型... 形参名){  }

其实这个书写完全等价与

修饰符 返回值类型 方法名(参数类型[] 形参名){  }

只是后面这种定义，在调用时必须传递数组，而前者可以直接传递数据即可。

**JDK1.5**以后。出现了简化操作。**…** 用在参数上，称之为可变参数。

同样是代表数组，但是在调用这个带有可变参数的方法时，不用创建数组(这就是简单之处)，直接将数组中的元素作为实际参数进行传递，其实编译成的class文件，将这些元素先封装到一个数组中，在进行传递。这些动作都在编译.class文件时，自动完成了。

代码演示：

public class ChangeArgs {
        
        public static void main(String[] args) {
        
            int[] arr = {
         1, 4, 62, 431, 2 };
            int sum = getSum(arr);
            System.out.println(sum);
            //  6  7  2 12 2121
            // 求 这几个元素和 6  7  2 12 2121
            int sum2 = getSum(6, 7, 2, 12, 2121);
            System.out.println(sum2);
        }
    
        /*
         * 完成数组  所有元素的求和 原始写法
         
          public static int getSum(int[] arr){
            int sum = 0;
            for(int a : arr){
                sum += a;
            }
            
            return sum;
          }
        */
        //可变参数写法
        public static int getSum(int... arr) {
        
            int sum = 0;
            for (int a : arr) {
        
                sum += a;
            }
            return sum;
        }
    }

> 注意：
> 
> > 方法拥有多参数，参数中包含可变参数，可变参数一定要写在参数列表的末尾位置。
> > 
> > 一个方法列表，只能有一个可变参数

#### 可变参数的终极写法 ####

`public static void method(object...obj);`

## Map集合 ##

`java.util.Map`

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Jlbjk0MzY_size_16_color_FFFFFF_t_70 4]

*  `Collection`中的集合，元素是孤立存在的，向集合中存储元素采用一个个元素的方式存储。
 *  `Map`中的集合，元素是成对存在的。每个元素由键与值两部分组成，通过键可以找对所对应的值。
 *  `Collection`中的集合称为单列集合，`Map`中的集合称为双列集合。
 *  需要注意的是，`Map`中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。

### 常用方法 ###

Map接口中定义了很多方法，常用的如下：

*  `public V put(K key, V value)`: 把指定的键与指定的值添加到Map集合中。
    
    > 使用put方法时，若指定的键(key)在集合中没有，则没有这个键对应的值，返回null，并把指定的键值添加到集合中；
    > 
    > 若指定的键(key)在集合中存在，则返回值为集合中键对应的值（该值为替换前的值），并把指定键所对应的值，替换成指定的新值。
 *  `public V remove(Object key)`: 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。
 *  `public V get(Object key)` 根据指定的键，在Map集合中获取对应的值。
 *  `boolean containsKey(Object key)` 判断集合中是否包含指定的键。
 *  `public Set<K> keySet()`: 获取Map集合中所有的键，存储到Set集合中。
 *  `public Set<Map.Entry<K,V>> entrySet()`: 获取到Map集合中所有的键值对对象的集合(Set集合)。

### HashMap<K,V>集合 ###

存储数据采用的**哈希表结构**，元素的存取顺序不能保证一致。由于要保证键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

### LinkedHashMap<K,V> ###

存储数据采用的**哈希表结构+链表结构**。通过链表结构可以保证元素的存取顺序一致；通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

### Map集合遍历键找值方式 ###

键找值方式：即通过元素中的键，获取键所对应的值

分析步骤：

1.  获取Map中所有的键，由于键是唯一的，所以返回一个Set集合存储所有的键。方法提示:`keyset()`
2.  遍历键的Set集合，得到每一个键。
3.  根据键，获取键所对应的值。方法提示:`get(K key)`

代码演示：

public class MapDemo01 {
        
        public static void main(String[] args) {
        
            //创建Map集合对象 
            HashMap<String, String> map = new HashMap<String,String>();
            //添加元素到集合 
            map.put("胡歌", "霍建华");
            map.put("郭德纲", "于谦");
            map.put("薛之谦", "大张伟");
    
            //获取所有的键  获取键集
            Set<String> keys = map.keySet();
            // 遍历键集 得到 每一个键
            for (String key : keys) {
        
              	//key  就是键
                //获取对应值
                String value = map.get(key);
                System.out.println(key+"的CP是："+value);
            }  
        }
    }

### Entry键值对对象 ###

我们已经知道，`Map`中存放的是两种对象，一种称为**key**(键)，一种称为**value**(值)，它们在在`Map`中是一一对应关系，这一对对象又称做`Map`中的一个`Entry(项)`。`Entry`将键值对的对应关系封装成了对象。即键值对对象，这样我们在遍历`Map`集合时，就可以从每一个键值对（`Entry`）对象中获取对应的键与对应的值。

既然Entry表示了一对键和值，那么也同样提供了获取对应键和对应值得方法：

*  `public K getKey()`：获取Entry对象中的键。
 *  `public V getValue()`：获取Entry对象中的值。

在Map集合中也提供了获取所有Entry对象的方法：

*  `public Set<Map.Entry<K,V>> entrySet()`: 获取到Map集合中所有的键值对对象的集合(Set集合)。

### 1.6 Map集合遍历键值对方式 ###

键值对方式：即通过集合中每个键值对(Entry)对象，获取键值对(Entry)对象中的键与值。

操作步骤与图解：

1.  获取Map集合中，所有的键值对(Entry)对象，以Set集合形式返回。方法提示:`entrySet()`。
2.  遍历包含键值对(Entry)对象的Set集合，得到每一个键值对(Entry)对象。
3.  通过键值对(Entry)对象，获取Entry对象中的键与值。 方法提示:`getkey() getValue()`

public class MapDemo02 {
        
        public static void main(String[] args) {
        
            // 创建Map集合对象 
            HashMap<String, String> map = new HashMap<String,String>();
            // 添加元素到集合 
            map.put("胡歌", "霍建华");
            map.put("郭德纲", "于谦");
            map.put("薛之谦", "大张伟");
    
            // 获取 所有的 entry对象  entrySet
            Set<Entry<String,String>> entrySet = map.entrySet();
    
            // 遍历得到每一个entry对象
            for (Entry<String, String> entry : entrySet) {
        
               	// 解析 
                String key = entry.getKey();
                String value = entry.getValue();  
                System.out.println(key+"的CP是:"+value);
            }
        }
    }

### Hashtable<K,V> ###

不能存储空null

同步，单线程，线程安全，速度慢

\#JDK9新增集合操作

加了几种集合工厂方法,更方便创建少量元素的集合、map实例。新的List、Set、Map的静态工厂方法可以更方便地创建集合的不可变实例。

public class HelloJDK9 {
          
        public static void main(String[] args) {
          
            Set<String> str1=Set.of("a","b","c");  
            //str1.add("c");这里编译的时候不会错，但是执行的时候会报错，因为是不可变的集合  
            System.out.println(str1);  
            Map<String,Integer> str2=Map.of("a",1,"b",2);  
            System.out.println(str2);  
            List<String> str3=List.of("a","b");  
            System.out.println(str3);  
        }  
    }

需要注意以下两点：

> 1:of()方法只是Map，List，Set这三个接口的静态方法，其父类接口和子类实现并没有这类方法，比如 HashSet，ArrayList等待；
> 
> 2:返回的集合是不可变的；

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Jlbjk0MzY_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200725192804829.bmp?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Jlbjk0MzY=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Jlbjk0MzY_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200811232620278.bmp?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Jlbjk0MzY=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Jlbjk0MzY_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200811232725733.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Jlbjk0MzY=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Jlbjk0MzY_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200811232809772.bmp?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Jlbjk0MzY=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Jlbjk0MzY_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200725192928826.bmp?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Jlbjk0MzY=,size_16,color_FFFFFF,t_70