Java集合

Java集合类存放于java.util包中，是一个用来存放对象的容器。

1. 集合只能存放对象。如将一个int类型放入集合中，则其实是自动转成Integer类后存入的，Java中每一种基本类型都有对应的引用类型。
2. 集合存放的是多个对象的引用，对象本身还是存放在堆内存中。
3. 集合可以存放不同类型、不限数量的数据类型。

Java集合可分为Set、List和Map三大体系。
Set：无序、不可重复的集合。
List：有序、可重复的集合。
Map：具有映射关系的集合。

在JDK5之后，增加了泛型，Java集合可以记住容器中对象的数据类型。

1.HashSet

HashSet是Set接口的典型实现。

HashSet用Hash算法来存储集合中的元素，因此具有很好的存取和查找性能。

当向HashSet集合中存入一个元素时，HashSet会调用该对象的hashCode()方法来得到该对象的hashCode值，然后根据hashCode值决定该对象在HashSet中的存储位置。

如果两个元素的equals()方法返回true，但它们的hashCode()返回值不相等，则HashSet将会把它们存储在不同的位置，但依然可以添加成功。

HashSet具有以下特点：

• 不能保证元素的排列顺序。
• 不可重复（hashcode值）。
• HashSet不是线程安全的。
• 集合元素可以是null。

HashSet类 实现 set接口 继承 Collection接口

HashSet的一些常用操作如下：

import java.util.HashSet;
import java.util.Set;

public class Test {
    public static void main(String[] args) {
        Set s = new HashSet();
        s.add(1);  //添加
        s.remove(1);  //移除
        s.contains(1);  //判断是否存在此元素
        s.clear();  //清空集合
        s.size();  //集合元素数量
    }
}

使用迭代器遍历集合：

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class Test {
    public static void main(String[] args) {
        Set s = new HashSet();
        s.add("a");
        s.add("b");
        s.add("c");
        Iterator it = s.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
    }
}

输出结果为：

a
b
c

还可以用for each迭代集合：

s.add("a");
s.add("b");
s.add("c");
for (Object obj : s) { //把set的每个值取出来赋给obj，直到循环完set的所有值
      System.out.println(obj);
}

如果想让集合只能存相同类型的对象，须使用泛型

Set<String> s = new HashSet<String>();

2.TreeSet

TreeSet 实现 NavigableSet接口 继承 SortedSet接口 继承 Set接口 继承 Collection接口

TreeSet可以确保集合元素处于排序状态。
TreeSet支持两种排序方法：自然排序和定制排序。默认情况下采用自然排序。

import java.util.Set;
import java.util.TreeSet;

public class Test {
    public static void main(String[] args) {
        Set<Integer> s = new TreeSet<Integer>();
        //自然排序
        s.add(3);
        s.add(2);
        s.add(1);
        System.out.println(s);
    }
}

输出为：

[1, 2, 3]

定制排序：

import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;

public class Test {
    public static void main(String[] args) {
        Person p1 = new Person(18,"张三");
        Person p2 = new Person(19,"李四");
        Person p3 = new Person(20,"王五");
        Set<Person> s = new TreeSet<Person>(new Person());
        s.add(p1);
        s.add(p2);
        s.add(p3);
        for (Person p : s) {
            System.out.println(p.name + "   " + p.age);
        }
    }
}

class Person implements Comparator<Person> { //把person对象存到TreeSet中去并按年龄从小到大排序
    int age;
    String name;
    public Person() {

    }
    public Person(int age, String name) {
        this.age = age;
        this.name = name;
    }

    @Override
    public int compare(Person o1, Person o2) {
        if (o1.age > o2.age) {
            return 1;
        } else if (o1.age < o1.age) {
            return -1;
        }
        return 0;
    }
}

输出为：

张三   18
李四   19
王五   20

这个代码是有问题的，如果年龄不是按照这样添加，则输出是不对的，应该是compare实现的问题，这里先不深究。

3.List与ArrayList

ArrayList类 实现 List接口 继承 Colletion接口

• List代表一个元素有序、且可重复的集合，集合中的每个元素都有其对应的顺序索引。索引从0开始。
• List允许使用重复元素，可以通过索引来访问指定位置的集合元素。
• List默认按元素的添加顺序设置元素的索引。
• List集合添加了一些根据索引来操作集合元素的方法。

void add(int index, Object ele)
boolean addAll(int index, Collection eles) 向List中添加另外的List
Object get(int index)
int indexOf(Object obj)
int lastIndexOf(Object obj)
Object remove(int index)
Object set(int index, Object ele)
List subList(int fromIndex, int toIndex) 返回值中包含开始索引不包含结束索引。

4.Map

Map用于保存具有映射关系的数据，Map集合中保存ey和value两组值。key和value都可以是任何引用类型的数据。

Map中的key不允许重复。

key和value之间存在单向一对一关系，即通过指定的key总能找到唯一确定的value。

HashMap是实现Map接口的类。

基本操作：

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

public class Test1 {
    public static void main(String[] args) {
        Map<String,Integer> map = new HashMap<String,Integer>();
        map.put("a",1);  //添加元素
        map.get("a");  //获取元素
        map.size();  //长度
        map.containsKey("a");
        map.containsValue(1);
        map.remove("a");  //移除元素

        map.put("b",2);
        map.put("c", 100);
        Set<String> keys = map.keySet();  //获取key的集合
        map.values();  //获取value的集合

        //遍历Map
        for (String key : keys) {
            System.out.println("key: " + key + ", value: " + map.get(key));
        }

        //第二种遍历方式
        map.entrySet();
        Set<Map.Entry<String,Integer>> entries = map.entrySet();
        for (Map.Entry<String,Integer> en : entries) {
            System.out.println("key: " + en.getKey() + ", value: " + en.getValue());
        }
    }
}

TreeMap

TreeMap存储Key-Value对时，需要根据Key对key-value对进行排序。TreeMap可以保证所有的key-value对处于有序状态。

TreeMap的key的排序分为自然排序和定制排序。
对自然排序来说，TreeMap的所有key必须实现Comparable接口，而且所有的key应该时同一个类的对象，否则将会抛出ClassCastException。
TreeMap的自然排序是英文字典排序。

一般使用map集合，不会使用过于复杂的对象做key。

import java.util.Map;
import java.util.TreeMap;

public class Test1 {
    public static void main(String[] args) {
        Map<Integer, String> treeMap = new TreeMap<Integer, String>();
        treeMap.put(3, "d");
        treeMap.put(2, "e");
        treeMap.put(1, "e");
        System.out.println(treeMap);
    }
}

结果为：

{1=e, 2=e, 3=d}

5.操作集合的工具类：Collections

Collections是一个操作Set、List和Map等集合的工具类。

Collections中提供了大量方法对集合元素进行排序、查询和修改等操作，还提供了对集合对象设置不可变、对集合对象实现同步控制等方法。

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

public class Test1 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("1");
        System.out.println(list);

        Collections.reverse(list);  //反转List中元素的顺序
        System.out.println(list);

        Collections.shuffle(list);  //对List集合元素进行随机排序
        System.out.println(list);

        Collections.sort(list);  //list集合字典升序排序
        System.out.println(list);
        
        Collections.swap(list,0,2);  //指定位置元素交换
        System.out.println(list);
		
		System.out.println(Collections.max(list));  //根据元素的自然顺序，返回给定集合中的最大元素
		System.out.println(Collections.min(list));  //根据元素的自然顺序，返回给定集合中的最小元素

		System.out.println(Collection.frequency(list, "a"));  //返回指定集合中指定元素的出现次数

		Collections.replaceAll(list, "a", "m");  //使用新值替换list对象的所有旧值
    }
}

输出为：

[a, b, c, 1]
[1, c, b, a]
[c, a, 1, b]
[1, a, b, c]
[b, a, 1, c]
c
1

根据指定的Comparator产生的顺序对List集合元素进行排序和返回：

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

public class Test1 {
    public static void main(String[] args) {
        Student s1 = new Student(10,"张三");
        Student s2 = new Student(18,"李四");
        Student s3 = new Student(14,"王五");
        List<Student> stu = new ArrayList<Student>();
        stu.add(s1);
        stu.add(s2);
        stu.add(s3);
        for (Student s : stu) {
            System.out.println(s.name + ": " + s.age + "岁");
        }
        Collections.sort(stu,new Student());
        System.out.println("排序后：");
        for (Student s : stu) {
            System.out.println(s.name + ": " + s.age + "岁");
        }

        //根据Comparator指定的顺序，返回给定集合中的最大/小元素
        Student sMax = Collections.max(stu,new Student());
        Student sMin = Collections.min(stu,new Student());
        System.out.println("年龄最大：" + sMax.name + ", " + sMax.age + "岁");
        System.out.println("年龄最小：" + sMin.name + ", " + sMin.age + "岁");
    }
}

class Student implements Comparator<Student> {
    int age;
    String name;
    public Student() {

    }
    public Student(int age, String name) {
        this.age = age;
        this.name = name;
    }

    @Override
    public int compare(Student student, Student t1) {  //根据年龄升序排列对象
        if (student.age > t1.age) {
            return 1;
        } else if (student.age < t1.age) {
            return -1;
        } else {
            return 0;
        }
    }
}

输出为：

张三: 10岁
李四: 18岁
王五: 14岁
排序后：
张三: 10岁
王五: 14岁
李四: 18岁
年龄最大：李四, 18岁
年龄最小：张三, 10岁

同步控制

Collections类中提供了多个synchronizedXxx()方法，该方法可使指定集合包装成线程同步的集合，从而可以解决多线程并发访问集合时的线程安全问题。