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

Collection集合

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

集合与数组的区别

• 数组的长度是固定的。集合的长度是可变的。

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

常用方法

• 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的源代码，这是显然不可能的了，所以说这个方法死板。

扫描二维码关注公众号，回复： 11848474 查看本文章

这个时候我们可以使用第二种方法 实现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() 返回该对象额哈希值。

哈希表

储存元素不重复的原理

重写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

• 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:返回的集合是不可变的；