集合二

1 Map接口

1.1 Map接口概述

• Map和Collection并列存在。用于保存具有映射关系的数据。
• Map中的key和value都可以是任何引用类型的数据。
• Map的key用Set来存放，不允许重复，即同一个Map对象所对应的类，必须重写hashCode()和equals()方法。
• key和value之间存在单向一对一的关系，即通过制定的key总能找到唯一的、确定的value。
• Map接口的常用实现类：HashMap、TreeMap、LinkedHashMap和Properties。其中，HashMap是Map接口中使用频率最高的实现类。

1.2 Map接口中常用的方法

•  添加元素

V put(K key, V value);

 

• 示例：

package day18;

import java.util.HashMap;
import java.util.Map;

/**
 * @motto： 一身转战三千里，一剑可当百万兵。
 * @author： 不为往事扰，余生只爱笑。
 * @version： 1.0
 * @since： 2019-06-18
 */
public class CollectionTest {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<>();

        map.put("abc","123");

        System.out.println("集合中的元素:" + map);
    }
}

View Code

 

• 将指定Map集合中的元素添加到此Map集合之中。

void putAll(Map<? extends K, ? extends V> m);

 

• 示例：

package day18;

import java.util.HashMap;
import java.util.Map;

/**
 * @motto： 一身转战三千里，一剑可当百万兵。
 * @author： 不为往事扰，余生只爱笑。
 * @version： 1.0
 * @since： 2019-06-18
 */
public class CollectionTest {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<>();
        map.put("abc","123");

        Map<String,String> map1 = new HashMap<>();
        map1.put("bcd","234");

        map.putAll(map1);

        System.out.println("集合中的元素:" + map);
    }
}

View Code

 

• 根据指定的key移除元素，并返回key对应的value。

V remove(Object key);

 

• 示例：

package day18;

import java.util.HashMap;
import java.util.Map;

/**
 * @motto： 一身转战三千里，一剑可当百万兵。
 * @author： 不为往事扰，余生只爱笑。
 * @version： 1.0
 * @since： 2019-06-18
 */
public class CollectionTest {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<>();
        map.put("abc","123");
        map.put("bcd","234");
        map.put("cde","345");

        map.remove("abc");

        System.out.println("集合中的元素:" + map);
    }
}

View Code

 

• 清空map集合中的所有元素。

void clear();

 

• 示例：

package day18;

import java.util.HashMap;
import java.util.Map;

/**
 * @motto： 一身转战三千里，一剑可当百万兵。
 * @author： 不为往事扰，余生只爱笑。
 * @version： 1.0
 * @since： 2019-06-18
 */
public class CollectionTest {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        map.put("abc", "123");
        map.put("bcd", "234");
        map.put("cde", "345");

        map.clear();

        System.out.println("集合中的元素:" + map);
    }
}

View Code

 

• 根据指定的key获取value。.

V get(Object key);

 

• 示例：

package day18;

import java.util.HashMap;
import java.util.Map;

/**
 * @motto： 一身转战三千里，一剑可当百万兵。
 * @author： 不为往事扰，余生只爱笑。
 * @version： 1.0
 * @since： 2019-06-18
 */
public class CollectionTest {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        map.put("abc", "123");
        map.put("bcd", "234");
        map.put("cde", "345");

        String e = map.get("e");

        System.out.println("集合中的元素key为e对应的value值：" + e);
    }
}

View Code

 

• 判断map集合中是否包含指定的key。

boolean containsKey(Object key);

 

• 示例：

package day18;

import java.util.HashMap;
import java.util.Map;

/**
 * @motto： 一身转战三千里，一剑可当百万兵。
 * @author： 不为往事扰，余生只爱笑。
 * @version： 1.0
 * @since： 2019-06-23
 */
public class CollectionTest {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        map.put("abc", "123");
        map.put("bcd", "234");
        map.put("cde", "345");

        boolean flag = map.containsKey("abc");
        System.out.println("判断集合中是否包含指定的key:" + flag);
    }
}

View Code

 

• 判断集合中是否包含指定的value。

boolean containsValue(Object value);

 

• 示例：

package day18;

import java.util.HashMap;
import java.util.Map;

/**
 * @motto： 一身转战三千里，一剑可当百万兵。
 * @author： 不为往事扰，余生只爱笑。
 * @version： 1.0
 * @since： 2019-06-23
 */
public class CollectionTest {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        map.put("abc", "123");
        map.put("bcd", "234");
        map.put("cde", "345");

        boolean flag = map.containsValue("3");
        System.out.println("判断集合中是否包含指定的value:" + flag);

    }
}

View Code

 

• 返回map中key-value的个数。

int size();

 

• 示例：

package day18;

import java.util.HashMap;
import java.util.Map;

/**
 * @motto： 一身转战三千里，一剑可当百万兵。
 * @author： 不为往事扰，余生只爱笑。
 * @version： 1.0
 * @since： 2019-06-23
 */
public class CollectionTest {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        map.put("abc", "123");
        map.put("bcd", "234");
        map.put("cde", "345");

        int size = map.size();
        System.out.println("map中key-value的个数是：" + size);
    }
}

View Code

 

• 判断集合中是否包含元素（判断集合是否为空集合）

boolean isEmpty();

 

• 示例：

package day18;

import java.util.HashMap;
import java.util.Map;

/**
 * @motto： 一身转战三千里，一剑可当百万兵。
 * @author： 不为往事扰，余生只爱笑。
 * @version： 1.0
 * @since： 2019-06-23
 */
public class CollectionTest {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        map.put("abc", "123");
        map.put("bcd", "234");
        map.put("cde", "345");

        boolean flag = map.isEmpty();
        System.out.println("判断集合是否为空集合：" + flag);
    }
}

View Code

 

• 判断当前map集合是否和指定的map集合相等（重写了hashCode()和equals()方法，意味着会比较元素的内容）

boolean equals(Object o);

 

• 示例：

package day18;

import java.util.HashMap;
import java.util.Map;

/**
 * @motto： 一身转战三千里，一剑可当百万兵。
 * @author： 不为往事扰，余生只爱笑。
 * @version： 1.0
 * @since： 2019-06-23
 */
public class CollectionTest {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        map.put("abc", "123");
        map.put("bcd", "234");
        map.put("cde", "345");

        Map<String, String> map1 = new HashMap<>();
        map1.put("abc", "123");
        map1.put("bcd", "234");
        map1.put("cde", "345");

        System.out.println("map集合是否和指定的map集合相等：" + map.equals(map1));

    }
}

View Code

 

• 返回map集合所有key构成的Set集合。

Set<K> keySet();

 

• 示例：

package day18;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/**
 * @motto： 一身转战三千里，一剑可当百万兵。
 * @author： 不为往事扰，余生只爱笑。
 * @version： 1.0
 * @since： 2019-06-23
 */
public class CollectionTest {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        map.put("abc", "123");
        map.put("bcd", "234");
        map.put("cde", "345");

        Set<String> set = map.keySet();
        for (String s : set) {
            System.out.println("map集合中的所有key分别是：" + s);
        }
    }
}

View Code

 

• 返回所有value组成的Collection集合。

Collection<V> values();

 

• 示例：

package day18;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;

/**
 * @motto： 一身转战三千里，一剑可当百万兵。
 * @author： 不为往事扰，余生只爱笑。
 * @version： 1.0
 * @since： 2019-06-23
 */
public class CollectionTest {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        map.put("abc", "123");
        map.put("bcd", "234");
        map.put("cde", "345");

        Collection<String> values = map.values();
        for (String value : values) {
            System.out.println("map集合中的value值是：" + value);
        }
    }
}

View Code

 

• 返回所有key-value组成的Set集合。

Set<Map.Entry<K, V>> entrySet();

 

• 示例：

package day18;

import java.util.HashMap;
import java.util.Map;

/**
 * @motto： 一身转战三千里，一剑可当百万兵。
 * @author： 不为往事扰，余生只爱笑。
 * @version： 1.0
 * @since： 2019-06-23
 */
public class CollectionTest {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        map.put("abc", "123");
        map.put("bcd", "234");
        map.put("cde", "345");

        for (Map.Entry<String, String> entry :  map.entrySet()) {
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println("map集合中元素的key是：" + key + "，value是：" + value);
        }

    }
}

View Code

1.3 Map实现类之HashMap

• HashMap是Map接口中使用频率最高的实现类。
• 允许使用null键和null值，和HashSet一样，不保证映射的顺序。
• 所有的key构成的集合Set是无序的（不代表是随机的）、不可重复的。所以，key所在的类需要重写hashCode()和equals()方法。
• 所有的value构成的集合Collection是无序的、可以重复的。
• 一个key-value构成了一个Map.Entry对象。

1.4 Map实现类之LinkedHashMap

• LinkedHashMap是HashMap的子类。
• 在HashMap存储结构的基础上，使用了一对双向链表来记录添加元素的顺序。
• 和LinkedHashSet类似，LinkedHashMap可以维护Map的迭代顺序。

1.5 Map实现类之TreeMap

• TreeMap存储key-value对的时候，需要根据key-value对进行排序。TreeMap可以保证所有的key-value对处于有序状态。
• TreeMap底层使用红黑树结构存储数据。
• TreeMap的key的排序：
  • 自然排序：TreeMap的所有key必须使用Comparable接口，而且所有的key应该是同一个类的对象，否则将会抛出异常（ClassCastException）。
  • 自定义排序：创建TreeMap的时候，传入一个Comparator对象，该对象负责对TreeMap中的所有key进行排序。
• TreeMap判断两个key相等的标准：两个key通过compareTo()方法或compare()方法返回的值，是大于0、等于0还是小于0判断。　

1.6 Map实现类之Hashtable

• Hashtable是个古老的Map实现了，JDK1.0就提供了。不同于HashMap，Hashtable是线程安全的。
• Hashtable实现原理和HashMap相同，功能相同。底层都是哈希表结构，查询速度快，很多情况下可以互用。
• 和HashMap不同的是，Hashtable不允许使用null作为key和value。
• 和HashMap一样，Hashtable也不能保证其中的key-value对的顺序。
• Hashtable判断两个key相等、两个value相等的标准，和HashMap一致。

1.7 Map实现类之Properties

• Properties类是Hashtable的子类，该对象用于处理属性文件。
• 由于属性文件里的key、value都是字符串类型，所以Properties里的key和value也是字符串类型。
• 存取数据的时候，建议使用setProperty和getProperty方法。

 

• 示例：

package day18;

import java.util.Properties;

/**
 * @motto： 一身转战三千里，一剑可当百万兵。
 * @author： 不为往事扰，余生只爱笑。
 * @version： 1.0
 * @since： 2019-06-23
 */
public class CollectionTest {
    public static void main(String[] args) {
        Properties properties = new Properties();
        properties.setProperty("aa", "123");
        String property = properties.getProperty("aa");
        System.out.println("property:" + property);

    }
}

View Code

 

• 示例：
  • hello.properties　　

name=zhangsan
age=12

View Code

• • CollectionTest.java　　

package day18;

import java.io.FileInputStream;
import java.io.IOException;
import java.util.Properties;
import java.util.Set;

/**
 * @motto： 一身转战三千里，一剑可当百万兵。
 * @author： 不为往事扰，余生只爱笑。
 * @version： 1.0
 * @since： 2019-06-23
 */
public class CollectionTest {
    public static void main(String[] args) throws IOException {
        Properties properties = new Properties();
        properties.load(new FileInputStream("hello.properties"));

        Set<String> nameSet = properties.stringPropertyNames();

        for (String name : nameSet) {
            String property = properties.getProperty(name);
            System.out.println("key:" + name + ",value:" + property);
        }
    }
}

View Code

 

2 Collections工具类

2.1 概述

• Collections是一个操作Set、List和Map等集合的工具类。
• Collections中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作，还提供了对集合对象设置不可变、对集合对象实现同步控制等方法。

2.2 常用方法

2.2.1 排序

• 对List集合中的元素进行反转。

public static void reverse(List<?> list) { }

 

• 示例：

package day18;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * @motto： 一身转战三千里，一剑可当百万兵。
 * @author： 不为往事扰，余生只爱笑。
 * @version： 1.0
 * @since： 2019-06-23
 */
public class CollectionTest {
    public static void main(String[] args)  {
        List<String> list = new ArrayList<>();
        list.add("11");
        list.add("22");
        list.add("33");
        list.add("44");

        System.out.println("集合中的元素是：" + list);

        Collections.reverse(list);

        System.out.println("反转后的集合中的元素是：" + list);
    }
}

View Code

 

• 对List集合中的元素进行随机排序。

public static void shuffle(List<?> list){}

 

• 示例：

package day18;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * @motto： 一身转战三千里，一剑可当百万兵。
 * @author： 不为往事扰，余生只爱笑。
 * @version： 1.0
 * @since： 2019-06-23
 */
public class CollectionTest {
    public static void main(String[] args)  {
        List<String> list = new ArrayList<>();
        list.add("11");
        list.add("22");
        list.add("33");
        list.add("44");

        System.out.println("集合中的元素是：" + list);

        Collections.shuffle(list);

        System.out.println("对List集合中的元素进行随机排序后的元素是：" + list);
    }
}

View Code

 

• 对List集合中的元素按照自然顺序进行排序。

public static <T extends Comparable<? super T>> void sort(List<T> list){}

 

• 示例：

package day18;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * @motto： 一身转战三千里，一剑可当百万兵。
 * @author： 不为往事扰，余生只爱笑。
 * @version： 1.0
 * @since： 2019-06-23
 */
public class CollectionTest {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("11");
        list.add("22");
        list.add("44");
        list.add("33");

        System.out.println("集合中的元素是：" + list);

        Collections.sort(list);

        System.out.println("自然排序后的List集合的元素是：" + list);
    }
}

View Code

 

• 对List集合的元素进行自定义排序。

public static <T> void sort(List<T> list, Comparator<? super T> c) {}

 

• 示例：

package day18;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/**
 * @motto： 一身转战三千里，一剑可当百万兵。
 * @author： 不为往事扰，余生只爱笑。
 * @version： 1.0
 * @since： 2019-06-23
 */
public class CollectionTest {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("11");
        list.add("22");
        list.add("44");
        list.add("33");

        System.out.println("集合中的元素是：" + list);

        Collections.sort(list, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return -o1.compareTo(o2);
            }
        });

        System.out.println("自定义排序后的List集合的元素是：" + list);
    }
}

View Code

 

• 将指定List集合中的i处元素和j处元素进行交换。

public static void swap(List<?> list, int i, int j){}

 

• 示例：

package day18;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * @motto： 一身转战三千里，一剑可当百万兵。
 * @author： 不为往事扰，余生只爱笑。
 * @version： 1.0
 * @since： 2019-06-23
 */
public class CollectionTest {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("11");
        list.add("22");
        list.add("44");
        list.add("33");

        System.out.println("集合中的元素是：" + list);

        Collections.swap(list,1,3);

        System.out.println("交换元素后的List集合中的元素是：" + list);
    }
}

View Code

2.2.2 查找、替换

• 根据元素的自然顺序，返回给定集合中的最大元素。

public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll){}

 

• 示例：

package day18;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * @motto： 一身转战三千里，一剑可当百万兵。
 * @author： 不为往事扰，余生只爱笑。
 * @version： 1.0
 * @since： 2019-06-23
 */
public class CollectionTest {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("11");
        list.add("22");
        list.add("44");
        list.add("33");

        System.out.println("集合中的元素是：" + list);

        System.out.println("根据元素的自然顺序返回给定集合中的最大元素是：" + Collections.max(list));
    }
}

View Code

 

• 根据Comparator指定的顺序，返回给定集合中的最大元素。

public static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp){}

 

• 示例：

package day18;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/**
 * @motto： 一身转战三千里，一剑可当百万兵。
 * @author： 不为往事扰，余生只爱笑。
 * @version： 1.0
 * @since： 2019-06-23
 */
public class CollectionTest {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("11");
        list.add("22");
        list.add("44");
        list.add("33");

        System.out.println("集合中的元素是：" + list);

        System.out.println("自定义排序返回给定集合中的最大元素是：" + Collections.max(list, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        }));
    }
}

View Code

 

• 返回指定集合中指定元素出现的个数。

public static int frequency(Collection<?> c, Object o){}

 

• 示例：

package day18;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * @motto： 一身转战三千里，一剑可当百万兵。
 * @author： 不为往事扰，余生只爱笑。
 * @version： 1.0
 * @since： 2019-06-23
 */
public class CollectionTest {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("11");
        list.add("22");
        list.add("11");
        list.add("44");
        list.add("33");
        list.add("11");

        System.out.println("集合中的元素是：" + list);

        int frequency = Collections.frequency(list, "aa");
        System.out.println("返回指定集合中出现元素的个数：" + frequency);

        frequency = Collections.frequency(list, "11");
        System.out.println("返回指定集合中出现元素的个数：" + frequency);
    }
}

View Code

 

• 将List集合中的指定元素替换成指定的新元素。

public static <T> boolean replaceAll(List<T> list, T oldVal, T newVal)

 

• 示例：

package day19;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * @author xuweiwei
 * @version 1.0
 * @since 2019-06-24
 */
public class CollectionTest {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("aa");
        list.add("bb");
        list.add("cc");

        Collections.replaceAll(list,"aa","张三");

        System.out.println("集合中的元素是：" + list);
    }
}

View Code

 

转载于:https://www.cnblogs.com/xuweiweiwoaini/p/11070197.html