我的Java学习笔记-集合篇

阅读量：3958 次

发布时间：2019-05-24

本文共 11898 字，大约阅读时间需要 39 分钟。

一、理论部分

1.集合的概念(Collection，Map)

一系列对象的集合，类似于数学上的集合{1，2，3}。

可以添加，删除，修改，查找，比较。

Collection继承了Iterable接口。

2.与数组的区别

数组的长度一旦设定就不可以修改

集合可以任意修改长度

(个人觉得数组与ArrayList集合的关系有点像String与StringBuffer的关系)

3.集合的分类

在这里插入图片描述

4.迭代器

迭代器模式：就是提供一种方法对一个容器对象中的各个元素进行访问，而又不暴露该对象容器的内部细节。

接口的定义：

package java.util;public interface Iterator
   
     {
       boolean hasNext();//判断是否存在下一个对象元素    E next();//获取下一个元素    void remove();//移除元素}

使用1：Iterator iterator();

使用2：foreach循环

5.比较器

Comparable接口

public interface Comparable该接口对实现它的每个类的对象强加一个整体排序。

这个排序被称为类的自然排序，类的compareTo方法被称为其自然比较方法。

Collections.sort （和Arrays.sort ）可以自动对实现此接口的对象进行列表（和数组）排序。

只有一个方法：

public int compareTo(T o)	将此对象与指定的对象进行比较以进行排序

Comparator接口

public interface Comparator比较功能，对一些对象的集合施加了一个整体排序。

可以将比较器传递给排序方法（如Collections.sort或Arrays.sort ），以便对排序顺序进行精确控制。

常用方法	解读
public int compare(T o1, T o2)	比较其两个参数的顺序
public boolean equals(Object obj)	指示某个其他对象是否等于此比较器

二、操作部分

1. List接口介绍

java.util.List 接口继承自 Collection 接口，是单列集合的一个重要分支，习惯性地会将实现了 List 接口的对

象称为List集合。在List集合中允许出现重复的元素，所有的元素是以一种线性方式进行存储的，在程序中可以通过

索引来访问集合中的指定元素。另外，List集合还有一个特点就是元素有序，即元素的存入顺序和取出顺序一致。

常用方法	解读
public void add(int index, E element)	将指定的元素，添加到该集合中的指定位置上
public E get(int index)	返回集合中指定位置的元素
public E remove(int index)	移除列表中指定位置的元素, 返回的是被移除的元素
public E set(int index, E element)	用指定元素替换集合中指定位置的元素,返回值的更新前的元素

方法演示代码：

public class TestList {
           public static void main(String[] args) {
   			// 创建List集合对象            List
   
     list = new ArrayList
    
     ();			// 往 尾部添加 指定元素            list.add("图图");            list.add("小美");            list.add("不高兴");            System.out.println(list);			// add(int index,String s) 往指定位置添加            list.add(1,"没头脑");            System.out.println(list);			// String remove(int index) 删除指定位置元素 返回被删除元素			// 删除索引位置为2的元素            System.out.println("删除索引位置为2的元素");            System.out.println(list.remove(2));            System.out.println(list);			// String set(int index,String s)			// 在指定位置 进行 元素替代（改）			// 修改指定位置元素            list.set(0, "三毛");            System.out.println(list);			// String get(int index) 获取指定位置元素			// 跟size() 方法一起用 来 遍历的            for(int i = 0;i

ArrayList

java.util.ArrayList 集合数据存储的结构是数组结构。元素增删慢，查找快，由于日常开发中使用最多的功能为

查询数据、遍历数据，所以 ArrayList 是最常用的集合。

除继承自List外的常用方法	解读
public boolean add(E e)	将指定元素追加到此列表的末尾
public void clear()	从列表中删除所有元素
public boolean contains(Object o)	如果此列表包含指定的元素，则返回 true
public int indexOf(Object o)	返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1
public int size()	返回此列表中的元素数
public Object[] toArray()	以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的数组

方法演示代码：

判断集合里是否存在一个 name等于 "hero 1"的对象

import java.util.ArrayList;import charactor.Hero;public class TestArryList {
       public static void main(String[] args) {
           ArrayList heros = new ArrayList();          // 初始化5个对象        for (int i = 0; i < 5; i++) {
               heros.add(new Hero("hero " + i));        }        Hero specialHero = new Hero("special hero");        heros.add(specialHero);        String name = "hero 1";        for (int i = 0; i < heros.size(); i++) {
               Hero h = (Hero) heros.get(i);            if(name.equals(h.name ) ){
                   System.out.printf("找到了name是%s的对象",name);                break;            }        }             }  }

LinkedList

java.util.LinkedList 集合数据存储的结构是链表结构。方便元素添加、删除的集合。

除继承自List外的常用方法	解读
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

方法演示代码：

二叉树的创建与中序遍历

import java.util.ArrayList;import java.util.List; public class Node {
       // 左子节点    public Node leftNode;    // 右子节点    public Node rightNode;      // 值    public Object value;      // 插入 数据    public void add(Object v) {
           // 如果当前节点没有值，就把数据放在当前节点上        if (null == value)            value = v;          // 如果当前节点有值，就进行判断，新增的值与当前值的大小关系        else {
               // 新增的值，比当前值小或者相同                         if ((Integer) v -((Integer)value) <= 0) {
                   if (null == leftNode)                    leftNode = new Node();                leftNode.add(v);            }            // 新增的值，比当前值大            else {
                   if (null == rightNode)                    rightNode = new Node();                rightNode.add(v);            }          }      }   // 中序遍历所有的节点    public List

2.Set接口介绍

java.util.Set 接口和 java.util.List 接口一样，同样继承自 Collection 接口，它与 Collection 接口中的方法基本一致，并没有对 Collection 接口进行功能上的扩充，只是比 Collection 接口更加严格了。

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

常用方法与List接口的差不多

方法演示代码：

public class TestSet {
   	public static void main(String[] args) {
   		//创建 Set集合		HashSet
   
     set = new HashSet
    
     ();		//添加元素		set.add(new String("cba"));		set.add("abc");		set.add("bac");		set.add("cba");		//遍历		for (String name : set) {
   			System.out.println(name);		}	}}

HashSet

java.util.HashSet 是 Set 接口的一个实现类，它所存储的元素是不可重复的，并且元素都是无序的(即存取顺序不一致)。

HashSet 是根据对象的哈希值来确定元素在集合中的存储位置，因此具有良好的存取和查找性能。

保证元素唯一性的方式依赖于： hashCode 与 equals 方法。

除继承自List外的常用方法	解读
public boolean add(E e)	将指定元素追加到此列表的末尾
public void clear()	从列表中删除所有元素
public boolean contains(Object o)	如果此列表包含指定的元素，则返回 true
public int size()	返回此列表中的元素数

方法演示代码：

创建一个长度是100的字符串数组，使用长度是2的随机字符填充该字符串数组，统计这个字符串数组里重复的字符串有多少种

public class TestHashSet {
       //随机字符串    private static String randomString(int length) {
           String pool = "";        for (short i = '0'; i <= '9'; i++) {
               pool += (char) i;        }        for (short i = 'a'; i <= 'z'; i++) {
               pool += (char) i;        }        for (short i = 'A'; i <= 'Z'; i++) {
               pool += (char) i;        }        char cs[] = new char[length];        for (int i = 0; i < cs.length; i++) {
               int index = (int) (Math.random() * pool.length());            cs[i] = pool.charAt(index);        }        String result = new String(cs);        return result;    }    public static void main(String[] args) {
           //创建并初始化字符串数组        String[] strings = new String[100];        //Scanner scanner = new Scanner(System.in);        for (int i = 0; i < strings.length; i++) {
               //String str = scanner.next().substring(0,2);            strings[i] = randomString(2);        }        //遍历字符串        int k= 1;        for (String s :                strings) {
               System.out.print(s+"\t");            if(k%10==0)                System.out.println();            k++;        }        //把重复的字符串放入HashSet中        HashSet
   
     hashSet = new HashSet<>();        for (int i = 0; i < strings.length; i++) {
               int count = 0;            for (int j = 1; j < strings.length; j++) {
                   if(strings[j].equalsIgnoreCase(strings[i])){
                       count++;                    if(count==2){
                           hashSet.add(strings[j]);                        break;                    }                }            }        }        //遍历HashSet        int x = hashSet.size();        System.out.println(x);        for (String hs :                hashSet) {
               System.out.println(hs);        }    }}

TreeSet

java.util.TreeSet 是 Set 接口的一个实现类。

TreeSet集合底层数据结构采用红黑树实现，元素唯一且已经排好序。

默认情况下，TreeSet中的数据是从小到大排序的。

除继承自Set外的常用方法	解读
public boolean add(E e)	将指定元素追加到此列表的末尾
public void clear()	从列表中删除所有元素
public boolean contains(Object o)	如果此列表包含指定的元素，则返回 true
public int size()	返回此列表中的元素数
public E ceiling(E e)	返回此集合中最小元素大于或等于给定元素，如果没有此元素，则返回 null
public Comparator<? super E> comparator()	返回用于对该集合中的元素进行排序的比较器，或null，如果此集合使用其元素的natural ordering
public E first()/last()	返回此集合中当前的第一个（最低）元素/最后（最高）元素

代码如下（示例）：

public static void main(String[] args) {
           TreeSet
   
     ts = new TreeSet<>();        ts.add(33);        ts.add(2);        ts.add(11);        ts.add(9);		//元素没有下标，只能通过迭代器或者foreach循环遍历        Iterator it = ts.iterator();        while (it.hasNext()){
               System.out.println(it.next());//运行结果按从小到大的顺序输出        }    }

3.Map接口介绍

Map 中的集合，元素是成对存在的(键值对)。每个元素由键与值两部分组成，通过键可以找对所对应的值。

Collection 中的集合称为单列集合， Map 中的集合称为双列集合。

Map 中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。

常用方法	解读
public V put(K key, V value)	把指定的键与指定的值添加到Map集合中
public V remove(Object key)	把指定的键所对应的键值对元素在Map集合中删除，返回被删除元素的值。
public V get(Object key)	根据指定的键，在Map集合中获取对应的值。
public Set keySet()	获取Map集合中所有的键，存储到Set集合中。
public Set<Map.Entry<K,V>> entrySet()	获取到Map集合中所有的键值对对象的集合(Set集合)

代码如下（示例）：

public class TestMap {
   	public static void main(String[] args) {
   		//创建 map对象		Map
   
     map = new HashMap
    
     ();		//添加元素到集合		map.put("黄晓明", "杨颖");		map.put("文章", "马伊琍");		map.put("邓超", "孙俪");		System.out.println(map);		//删除键为"邓超"对应的键值对		System.out.println(map.remove("邓超"));		System.out.println(map);		// 想要查看 黄晓明的媳妇 是谁		System.out.println(map.get("黄晓明"));		System.out.println(map.get("邓超"));//输出null	}}

HashMap

java.util.HashMap<K,V> 是Map接口的一个实现类。

除继承自Map外的常用方法	解读
public void clear()	从这张地图中删除所有的映射
public boolean containsKey(Object key)	如果此映射包含指定键的映射，则返回 true
public boolean containsValue(Object value)	如果此地图将一个或多个键映射到指定值，则返回 true
public int size()	返回此地图中键值映射的数量

代码如下（示例）：

HashMap键与值的翻转

import java.util.ArrayList;import java.util.HashMap;import java.util.List;public class TestHashMap {
       public static void main(String[] args) {
           HashMap
   
     hashMap = new HashMap<>();        hashMap.put("adc","物理英雄");        hashMap.put("apc","魔法英雄");        hashMap.put("t","坦克");        List
    
      listKey = new ArrayList<>(hashMap.keySet());        List
     
       listValues = new ArrayList<>(hashMap.values());        HashMap
      
        hashMap1 = new HashMap<>();        hashMap1.put(listValues.get(0),listKey.get(0));        hashMap1.put(listValues.get(1),listKey.get(1));        hashMap1.put(listValues.get(2),listKey.get(2));        System.out.println(hashMap1);    }}

TreeMap

java.util.TreeMap<K,V> 是Map接口的一个实现类。

是一个有序的key-value集合，基于红黑树的 NavigableMap实现。

该映射根据其键的大小顺序进行排序，或者根据创建映射时提供的 Comparator进行排序。

构造方法

我懒得做个表了，凑合一下吧！

除继承自Map外的常用方法	解读
public void clear()	从这张地图中删除所有的映射
public boolean containsKey(Object key)	如果此映射包含指定键的映射，则返回 true
public boolean containsValue(Object value)	如果此地图将一个或多个键映射到指定值，则返回 true
public int size()	返回此地图中键值映射的数量
public Comparator<? super K> comparator()	返回用于订购此地图中的键的比较器，或null如果此地图使用其键的natural ordering
public V replace(K key, V value)	只有当目标映射到某个值时，才能替换指定键的条目
public Set<Map.Entry<K,V>> entrySet()	返回此地图中包含的映射的Set视图

代码如下（示例）：

输出为：

import java.util.Iterator;import java.util.Map;import java.util.TreeMap;public class TestTreeMap {
       public static void main(String[] args) {
           TreeMap
   
     map = new TreeMap<>();        String key = null;        Integer integ = null;        for (int i = 0; i < 5; i++) {
               map.put("Z"+i+"z",i*10);        }        map.put("X",-2);        map.put("y",5);        Iterator iter = map.entrySet().iterator();        while(iter.hasNext()) {
               Map.Entry entry = (Map.Entry)iter.next();            // 获取key            key = (String)entry.getKey();            // 获取value            integ = (Integer)entry.getValue();            System.out.println("[key - "+key+"]  [value - "+integ+"]");        }    }}