Java-List(有序，可重复,有索引)，HashSet(无序，不可重复)，TreeSet(有序，不可重复)，Map(具有映射关系)：HashMap与TreeMap(与Set相类似)

1.概念

• java集合存放于包java.util包中，是一个用来存放对象的容器
• 只能存放对象，例如：存放int是转换成Integer对象
• 集合存放的是多个对象的引用，对象本身还是放在堆内存中
• 集合可以存放不同类型，不限数量的数据类型

2 HashSet(无序，不可重复)

• HashSet是set接口的典型实现，大多数时候使用Set集合时都使用这个实现类。我们大多数时候说的set集合指的都是HashSet集合
• HashSet按Hash算法来存储集合中的元素，因此具有很好的存取和查找功能
• Hash具有以下特点：不能保证元素的排列顺序，不可重复，HashSet不是线程安全的，集合元素可以使null
• 当向HashSet集合中存入一个元素时，HashSet会调用该对象的hashCode()方法来得到该对象的hashcode值，然后根据hashCode值决定该对象在HashSet中的存储位置
• 如果两个元素的equals()方法返回true，但它们的hashCode()返回值不相等，hashSet将会把它们存储在不同的位置，但依然可以添加成功

2.1 代码如下：

package demo;

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

public class Test2 {
    public static void main(String[] args) {
        Set set=new HashSet();
        //Set<Object> set=new HashSet<Object>();//与上面的等价
        set.add(1);
        set.add("a");//添加对象到集合
        System.out.println("添加对象到集合:"+set);//添加对象到集合:[1, a]
        set.remove(1);//移除对象
        System.out.println("移除对象:"+set);//移除对象:[a]
        System.out.println("判断是否包含元素1:"+set.contains(1));//判断是否包含元素1:false
        System.out.println("判断是否包含元素a:"+set.contains("a"));//判断是否包含元素a:true
        set.clear();//清空集合
        System.out.println("清空集合:"+set);//清空集合:[]
        
        
        set.add("a");
        set.add("b");
        set.add("c");
        set.add("d");
        //set集合存的值是不重复的
        set.add(1);
        set.add(true);
        set.add(null);
        
        System.out.println(set);//[null, a, 1, b, c, d, true]
        //迭代器遍历集合
        System.out.println("迭代器遍历集合");
        Iterator it=set.iterator();
        while(it.hasNext()) {
            System.out.print(it.next()+"   ");//null   a   1   b   c   d   true 
        }
        //for Each迭代集合
        System.out.println();
        System.out.println("for Each迭代集合");
        for(Object obj:set) {//这个意思是说把set的每一个值取出来赋值给obj,直到循环set的所有值
            System.out.print(obj+"   ");//null   a   1   b   c   d   true   
        }
        System.out.println();
        System.out.println(set.size());//获取集合的元素个数:7
        
        //如果想要让集合只能存同样类型的对象，怎么做
        //使用泛型
        Set<String> set1=new HashSet<String>();//比如指定String为集合的泛型，那么这个集合不能存String类型之外的数据
        
        set1.add("abc");
        //set1.add(1);这样是不行的
        
        
    }
}

3.TreeSet(有序，不可重复)

• TreeSet可以确保集合元素处于排序状态，TreeSet支持两种排序方法：自然排序和定制排序

3.1 代码如下

package demo;

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

public class Test3 {

    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        Set<Integer> set=new TreeSet<Integer>();//TreeSet的自然排序
        set.add(5);
        set.add(2);
        set.add(4);
        set.add(3);
        set.add(1);
        System.out.println("添加对象到集合:"+set);//添加对象到集合:[1, 2, 3, 4, 5]
        set.remove(1);//移除对象
        System.out.println("移除对象:"+set);//移除对象:[2, 3, 4, 5]
        System.out.println("判断是否包含元素1:"+set.contains(1));//判断是否包含元素1:false
        //迭代器遍历集合
        System.out.println("迭代器遍历集合");
        Iterator<Integer> it=set.iterator();
        while(it.hasNext()) {
            System.out.print(it.next()+"   ");//2   3   4   5 
        }
        //for Each迭代集合
        System.out.println();
        System.out.println("for Each迭代集合");
        for(Integer i:set) {//这个意思是说把set的每一个值取出来赋值给obj,直到循环set的所有值
            System.out.print(i+"   ");//2   3   4   5 
        }
        System.out.println();
        System.out.println(set.size());//获取集合的元素个数:4
        set.clear();//清空集合
        System.out.println("清空集合:"+set);//清空集合:[]
        
        Person p1=new Person("zhangsan",17);
        Person p2=new Person("lisi",23);
        Person p3=new Person("wangwu",20);
        Person p4=new Person("zhaoliu",29);
        
        Set<Person> set1=new TreeSet<Person>(new Person());//TreeSet的定制排序
        set1.add(p2);
        set1.add(p4);
        set1.add(p3);
        set1.add(p1);
        
        System.out.println("for Each迭代集合");
        for(Person p:set1) {//这个意思是说把set的每一个值取出来赋值给obj,直到循环set的所有值
            System.out.println(p.name+"   "+p.age+"   ");//zhangsan   17   wangwu   20   lisi   23   zhaoliu   29   
        }
    }

}
//TreeSet定制排序，需要实现Comparator接口
class Person implements Comparator<Person>{ //把Person对象存到TreeSet中并按照年龄排序
    int age;
    String name;
    public Person() {
        
    }
    public Person(String name,int age) {
        this.name=name;
        this.age=age;
    }
    @Override
    public int compare(Person arg0, Person arg1) {
        // TODO 自动生成的方法存根
        if(arg0.age>arg1.age) {
            return 1;
        }else if(arg0.age<arg1.age) {
            return -1;
        }else {
            return 1;
        }
        
    }
    
}

4.List(有序，可重复,有索引)

• 默认按元素的添加顺序设置索引

4.1 ArrayList

package demo;

import java.util.ArrayList;

public class List {

    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        ArrayList<String> list=new ArrayList<String>();
        list.add("b");//第一个，索引下标0
        list.add("d");//第二个，索引下标1
        list.add("a");//允许使用重复元素
        list.add("e");
        list.add("c");
        list.add("a");
        
        System.out.println("按默认方式存入数据"+list);//按默认方式存入数据[b, d, a, e, c, a]
        System.out.println(list.get(2));//通过索引来访问指定位置的集合元素:a
        list.add(1,"f");
        System.out.println("在指定下标的位置插入数据"+list);//在指定下标的位置插入数据[b, f, d, a, e, c, a]
        
        ArrayList<String> list1=new ArrayList<String>();
        list1.add("123");
        list1.add("456");
        
        list.addAll(2, list1);//在指定元素位置插入集合
        System.out.println("按在指定元素位置存入集合数据"+list);//按在指定元素位置存入集合数据[b, f, 123, 456, d, a, e, c, a]
        
        System.out.println(list.indexOf("a"));//获取指定元素在集合第一次出现的索引下标:5
        System.out.println(list.lastIndexOf("a"));//获取指定元素在集合最后一次出现的索引下标:8
        
        
        list.remove(2);//根据指定索引下标移除元素
        System.out.println("移除对象:"+list);//移除对象:[b, f, 456, d, a, e, c, a]
        
        list.set(1,"ff");//修改指定下标的值
        System.out.println("修改指定下标之后的集合"+list);//修改指定下标之后的集合[b, ff, 456, d, a, e, c, a]
        
        @SuppressWarnings("unused")
        //根据索引的起始位置来截取一段元素形成一个新集合，元素的索引截取时包含开始，不包含结尾
        java.util.List<String> sublist=list.subList(2, 4);
        System.out.println("截取的数组:"+sublist);//截取的数组:[456, d]
        
        System.out.println(list.size());//获取集合的元素个数:8
        
    }

}

5.Map(具有映射关系)

• Map有两组值，一个是key，一个是value，类型不限，key不允许有重复值，key与value存在单向1对1关系

5.1 HashMap与TreeMap

package demo;

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

public class Map {
    public static void main(String[] args) {
        //前面试接口，后面是实现类
        //Map<String,Integer> map=new HashMap;
        HashMap<String,Integer> map=new HashMap<String,Integer>();
        
        map.put("b",1);
        map.put("c",2);
        map.put("a",2);
        
        System.out.println("按默认方式存入数据："+map);//按默认方式存入数据：{a=2, b=1, c=2}
        
        System.out.println("根据key取值："+map.get("b"));//根据key取值：1
        
        map.remove("c");
        System.out.println("根据key移除键值对:"+map);//根据key移除键值对:{a=2, b=1}
        
        System.out.println("获取集合的元素个数:"+map.size());//获取集合的元素个数:2
        
        System.out.println("判断当前的集合是否存在指定的key:"+map.containsKey("b"));//判断当前的集合是否存在指定的key:true
        
        System.out.println("判断当前的集合是否存在指定的value:"+map.containsValue(1));//判断当前的集合是否存在指定的value:true
        
        System.out.println("获取map集合的key的集合："+map.keySet());//获取map集合的key的集合：[a, b]
        
        System.out.println("获取map集合的所有value值："+map.values());//获取map集合的所有value值：[2, 1]
        
        Set<String> keys=map.keySet();
        //for Each迭代集合,通过map.keySet()遍历map集合
        System.out.println();
        System.out.println("for Each迭代集合,通过map.keySet()遍历map集合");
        for(String key:keys) {//这个意思是说把set的每一个值取出来赋值给key,直到循环keys的所有值
            System.out.println("key:"+key+",value:"+map.get(key));key:a,value:2  key:b,value:1
        }
    
        //for Each迭代集合,	通过map.entrySet()遍历map集合
        Set<Entry<String,Integer>> entrys=map.entrySet();
        System.out.println();
        System.out.println("for Each迭代集合,通过map.entrySet()遍历map集合");
        for(Entry<String,Integer> en:entrys) {//这个意思是说把set的每一个值取出来赋值给key,直到循环keys的所有值
            System.out.println("key:"+en.getKey()+",value:"+en.getValue());//key:a,value:2 key:b,value:1
        }
        
        map.clear();//清空集合
        System.out.println("清空数据："+map);//清空数据：{}
        
        
        //TreeMap自然排序是遵循字典排序，自定义排序与HashSet相类似
        TreeMap<Integer,String> map1=new TreeMap<Integer,String>();
        map1.put(4, "a");
        map1.put(2, "a");
        map1.put(3, "a");
        map1.put(1, "a");
        
        System.out.println("TreeMap："+map1);//TreeMap：{1=a, 2=a, 3=a, 4=a}
        
        TreeMap<String,String> map2=new TreeMap<String,String>();
        map2.put("b", "b");
        map2.put("c", "c");
        map2.put("d", "d");
        map2.put("a", "a");
        map2.put("ab", "ab");
        
        System.out.println("TreeMap："+map2);//TreeMap：{a=a, ab=ab, b=b, c=c, d=d}
    
    }
}

6.collection

package demo;

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

public class Collectiontest {
    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        ArrayList<String> list=new ArrayList<String>();
        list.add("b");//第一个，索引下标0
        list.add("cd");//第二个，索引下标1
        list.add("ca");//允许使用重复元素
        list.add("a");
        list.add("1");
        
        System.out.println("按默认方式存入数据:"+list);//按默认方式存入数据:[b, cd, ca, a, 1]
        Collections.reverse(list);
        System.out.println("反转List中元素的顺序:"+list);//反转List中元素的顺序:[1, a, ca, cd, b]
        
        Collections.shuffle(list);
        System.out.println("对List中元素进行随机排序:"+list);//对List中元素进行随机排序:[a, 1, ca, cd, b]
        
        Collections.sort(list);
        System.out.println("List集合字典升序排序:"+list);//List集合字典升序排序:[1, a, b, ca, cd]
        
        
        System.out.println("输出最大："+Collections.max(list));//输出最大：cd
        System.out.println("输出最小："+Collections.min(list));//输出最小：1
        
        Collections.swap(list, 0, 4);//
        System.out.println("将指定list集合中的i处元素和j处元素进行交换后:"+list);//将指定list集合中的i处元素和j处元素进行交换后:[cd, a, b, ca, 1]
        
        

        
        Student s1=new Student(14,"zhangsan");
        Student s2=new Student(12,"lisi");
        Student s3=new Student(13,"wangwu");
        Student s4=new Student(11,"suiliu");
        
        ArrayList<Student> stus=new ArrayList<Student>();//自定义排序
        stus.add(s1);
        stus.add(s2);
        stus.add(s3);
        stus.add(s4);
        
        for(Student stu:stus) {
            System.out.print(stu.name+","+stu.age+"    ");//zhangsan,14    lisi,12    wangwu,13    suiliu,11    
        }
        
        Collections.sort(stus,new Student());//按照指定方法排序
        System.out.println();
        for(Student stu:stus) {
            System.out.print(stu.name+","+stu.age+"    ");//suiliu,11    lisi,12    wangwu,13    zhangsan,14    
        }
        
        Student ss=Collections.min(stus,new Student());
        System.out.println(ss.name+"输出最大："+ss.age);//suiliu输出最大：11
    }

}
class Student implements Comparator<Student>{

    int age;
    String name;
    public Student() {
        
    }
    public Student(int age,String name) {
        this.name=name;
        this.age=age;
    }
    @Override
    public int compare(Student arg0, Student arg1) {//根据年龄升序排列
        // TODO 自动生成的方法存根
        if(arg0.age>arg1.age) {
            return 1;
        }else if(arg0.age<arg1.age) {
            return -1;
        }else {
            return 1;
        }
        
    }
    
}