一、集合概述、

1.什么是集合

所处位置：位于java.util包下

集合类似于一个容器，可以用来存储数据。

2.集合容器的特点

1.集合容器的长度是可变的

2.集合容器只能存储引用数据类型，也就是对象的引用，非对象本身

3.一个集合容器可以存储不同引用数据类型的数据

4.可以使用泛型，存储指定引用数据类型数据

3.集合容器与数组容器的区别

1.集合容器的长度是可以变化的，数组一旦初始化长度就不能改变

2.集合容器只能存储引用数据类型、数组容器既可以存储引用数据类型也可以存储基本数据类型

3.一个集合可以存储多种引用数据类型，数组容器只能存储一种数据类型。

二、集合的体系结构
集合分为Collection(集合)，和Map（映射）。

1.Collection 单列集合的顶级接口。

List（列表）子接口

--ArrayList 实现类

--linkedList 实现类

--Vector 实现类

Set（集）子接口

--HashSet 实现类

--TreeSet 实现类

--linkedHashSet 实现类

2.Map集合，双列集合的顶级接口

Map 接口

--HashMap 实现类

--TreeMap 实现类

--HashTable 实现类

--Properties 实现类

--linkedHashMap

三、Collection集合的使用

Collection接口，常见的成员方法

1.public boolean add(Object e):添加元素

2.public boolean addAll(Collection c):添加集合

3.public boolean remove(Object o)删除元素

4.public boolean removeIf(Predicate filter):按照条件删除元素

5.public void clear()：清空容器

6.public int size():集合容器的长度

7.public boolean contains(Object o):判断集合容器中是否包含指定元素

8.public boolean isEmpty():判断集合容器是否为空

9.public Object[] toArray():将集合容器转为数组容器

10.Interator iterator():获取迭代器对象

增强for循环的使用：

for(数据类型变量名（元素名）：要遍历的数组容器）{

}

集合容器的简单使用:

示例：

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class Demo01 {
    public static void main(String[] args) {
        Collection c=new ArrayList();
        //1.添加元素
        c.add("Maria");
        c.add("Jerry");
        c.add("Michael");
        c.add("Tom");
        c.add("Jane");
        //2.删除元素
        c.remove("Jane");
        //3.遍历容器1
        Object[] obj=c.toArray();
        for(int i=0;i 
四、List接口及其子类的使用 
1.List集合的特点： 
1.元素存储是有序的 
2.存储的元素可以重复 
3.有索引的 
2.常见的成员方法： 
 
 Collect有的List都有 
 public void add(int index, Object element)：在指定的索引处添加元素
 public E get(int index)：获取指定索引处的元素
 public Object remove(int index)：删除指定索引处的元素
 public Object set(int index, Object element)：修改指定索引处的元素，返回被修改的数据 
 
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Demo01 {
    public static void main(String[] args) {
        List l=new ArrayList();
        //1.添加元素
        l.add("Maria");
        l.add("Jerry");
        l.add("Michael");
        l.add("Tom");
        l.add("Jane");
        //2.删除元素
        l.remove("Jane");
        //3.在指定的索引处添加元素
        l.add(0,"Jane");
        //遍历容器1
        Object[] obj=l.toArray();
        for(int i=0;i 
3.List子类ArrayList使用方法 
ArrayList集合的特点？
 1.有序的(存入的顺序和取出的顺序是一样的)
 2.元素可以重复的
 3.有索引的 
ArrayList底层使用的数据结构:数组数据结构 
public class Demo01 {
    public static void main(String[] args) {
        ArrayList l=new ArrayList();
        //1.添加元素
        l.add("Maria");
        l.add("Jerry");
        l.add("Michael");
        l.add("Tom");
        l.add("Jane");
        //2.删除元素
        l.remove("Jane");
        //3.在指定的索引处添加元素
        l.add(0,"Jane");
        //遍历容器1
        Object[] obj=l.toArray();
        for(int i=0;i 
练习一：删除集合{"aaa","bbb","aaa","aaa","ccc","ddd"}中所有"aaa"元素 
import java.util.ArrayList;
import java.util.Iterator;
public class Demo01 {
    public static void main(String[] args) {
        ArrayList al=new ArrayList();
        al.add("aaa");
        al.add("bbb");
        al.add("aaa");
        al.add("aaa");
        al.add("ccc");
        al.add("ddd");
        /*for(int i=0;i 
4.List子类linkedList使用方法 
linkedList集合的特点？
 1.有序的(存入的顺序和取出的顺序是一样的)
 2.元素可以重复的
 3.有索引的 
linkedList底层使用的数据结构：双向链表数据结构 
linkedList常见的成员方法 
 
 List有的linkedList也有 
 1.public void addFirst(Object e):将元素添加到第一个位置
 2.public void addLast(Object e)：将元素添加到最后一个位置
 3.public Object getFirst()：获取第一个位置的元素
 4.public Object getLast()：获取最后一个位置的元素
 5.public Object removeFirst()：删除第一个位置的元素
 6.public Object removeLast()：删除最后一个位置的元素 
 
数组数据结构的优缺点：查找快，增删慢 
链表数据结构的优缺点：增删快，查询慢 
五、Set接口及其子类的使用 
1.Set集合的特点 
1.不保证顺序(存入的顺序和取出的顺序是不一样的)
 2.元素唯一
 3.无索引 
常见的成员方法：和Collection类似 
2.Set集合的遍历 
1.转数组遍历 
 
2.迭代器遍历 
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
public class Demo01 {
    public static void main(String[] args) {
        Set s = new TreeSet<>();
        s.add("e");
        s.add("f");
        s.add("b");
        s.add("a");
        s.add("c");
        s.add("d");
        s.add("z");
        s.add("h");
        Iterator it=s.iterator();
        while (it.hasNext()){
            String ss=it.next();
            System.out.println(ss);
        }
    }
}
 
 3.Set子类TreeSet的使用 
TreeSet集合的特点： 
1.不保证顺序(存入的顺序和取出的顺序是不一样的)
 2.元素唯一
 3.无索引
 4.可以自动排序(由小到大)插入是按字典序排序的 
注意事项：如果插入的是自定义对象，需要让类实现Comparable接口并且要重写compareTo方法 
TreeSet底层的数据结构：红黑树 
TreeSet常用成员方法：和Set差不多。 
TreeSet的使用(插入自定义类对象): 
//创建集合容器
		TreeSet ts = new TreeSet();
		//添加元素
		ts.add(new Pig("tom", 18));
		ts.add(new Pig("jerry", 19));
		ts.add(new Pig("tony", 20));
		System.out.println(ts);//运行报错：类型转换异常 
注意：如果我们想要使用TreeSet来存储自定义对象的话，要满足两个条件之一才可以正常运行 
条件1，自然排序 
什么是自然排序： 
1.自定义类，实现Comparable接口
 2.重写抽象方法compareTo()
 3.在compareTo()方法中写比较规
 返回值为0：集合中的元素只有一个
 返回值为正数：集合中的元素是正序
 返回值为负数：集合中的元素是倒数 
举例： 
import java.util.TreeSet;
public class Demo01 {
    public static void main(String[] args) {
        TreeSet ts = new TreeSet();//创建集合对象
        //向集合中存储自定义对象
        ts.add(new Pig("Tom", 14));
        ts.add(new Pig("jerry",15));
        ts.add(new Pig("Michael",12));
        //遍历集合并输出
        for(Pig p:ts){
            System.out.println("ts1:"+p.getName()+"  "+p.getAge());
        }
    }
}
class Pig implements Comparable{
    private String name;
    private int age;
    public Pig(){
    }
    public Pig(String name,int age){
        this.name=name;
        this.age=age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public int compareTo(Object o) {
        return -1;
    }
}
 
 
 练习：按照年龄小到大进行排序Compare中写法 
public int compareTo(Object o) {
        Pig p=(Pig)o;
        int i=this.age-p.age;
        return i;
    } 
练习：按照对象的年龄由小到大进行排序，如果年龄相同，再根据姓名字典顺序比较，如果
 姓名也相同，就去重？ 
 public int compareTo(Object o) {
        Pig p=(Pig)o;
        int i=this.age-p.age;
        return i==0?p.name.compareTo(this.name):i;
    } 
条件2：比较器Comparator 
如何实现比较器？
 1.自定义类
 2.创建TreeSet集合对象，在构造方法中传递Comparator的对象
 3.重写compare()方法
 4.在compare()中写比较规则
 返回值为0：集合中的元素只有一个
 返回值为正数：集合中的元素是正序
 返回值为负数：集合中的元素是倒数 
TreeSet ts = new TreeSet(new Comparator(){
            @Override
            public int compare(Pig o1, Pig o2) {
                return 0;
            }
        });//创建集合对象 
排序方法和Comparable类似。 
 4.Set子类HashSet的使用
特点：
 1.无序的
 2.元素唯一的(存储自定义对象时，需要在类中重写hashCode()和equals()方法)
 3.无索引    
 数据结构：哈希表  
 常见的方法？
 和Set方法是一样的 
遍历的方式？
 方式一：转数组
 方式二：迭代器
 方式三：增强for 
去重重写方法： 
 @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Pig)) return false;
        Pig pig = (Pig) o;
        return age == pig.age &&
                name.equals(pig.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    } 
 4.Set子类linkedHashSet的使用 
特点：
 1.有序的
 2.元素唯一的
 3.无索引 
底层采用的数据结构：哈希表+链表 
其他与HashSet类似。 
六、Map集合的使用 
1.Map接口 
特点：
 1.无序的
 2.无索引
 3.元素唯一的 键唯一 值可以重复
 4.双列的集合框架 
常见的成员方法： 
 
 1.V put(K key,V value)：1.添加元素 2.修改，返回被修改前的值
 2.V remove(Object key)：根据键来删除元素，返回被删除的元素的值
 3.int size()：获取集合容器的长度
 4.void clear()：清空
 5.V get(Object key)：根据键获取值
 6.boolean containsKey(Object key)：判断是否包含指定的键的元素
 7.boolean containsValue(Object value)：判断是否包含指定的值的元素
 8.Set keySet()：将map集合中的所有的键获取到，扔到Set集合中
 9.Collection values()：将map集合中的所有的值后去到，扔到Collection集合
 10.Set> entrySet()：将键值对对象扔到Set集合中 
 
Map集合的遍历（通过键获取值） 
import java.util.Set;
import java.util.TreeMap;

public class Demo01 {
    public static void main(String[] args) {
        TreeMap tm=new TreeMap();
        tm.put("dd",11);
        tm.put("aa",11);
        tm.put("bb",11);
        tm.put("cc",11);
        Set k=tm.keySet();
        for(String str:k){
            Integer i=tm.get(str);
            System.out.println(i);
        }
    }
} 
通过键值对象来获取键和值 
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

public class Demo01 {
    public static void main(String[] args) {
        TreeMap tm=new TreeMap();
        tm.put("dd",11);
        tm.put("aa",11);
        tm.put("bb",11);
        tm.put("cc",11);
        Set> k=tm.entrySet();
        for(Map.Entry entry:k){
            String str=entry.getKey();
            Integer it=entry.getValue();
            System.out.println("Key:"+str+" Value:"+it);
        }
    }
} 
2.Map接口子类HashMap使用
 特点：
 1.无序的
 2.无索引
 3.元素唯一的 键唯一 值可以重复（自定义对象作为键需要重写equal方法和HashCode方法）
 4.双列的
 数据结构？哈希表，HashSet底层使用的就是HashMap
 常见的方法？和Map集合中的方法是一样的。 
练习：HashMap存储自定义对象，对自定义对象去重，自定义对象作为键。 
import java.util.*;

public class Demo01 {
    public static void main(String[] args) {
        HashMap tm=new HashMap();
        tm.put(new Person("Tom",14),001);
        tm.put(new Person("Jane",42),002);
        tm.put(new Person("jerry",67),003);
        tm.put(new Person("jerry",67),004);
        Set> k=tm.entrySet();
        for(Map.Entry entry:k){
            Person p=entry.getKey();
            Integer it=entry.getValue();
            System.out.println("Key:"+p.getName()+" "+p.getAge()+" Value:"+it);
        }
    }
}
class Person{
    private String name;
    private int age;
    public Person(){

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Person)) return false;
        Person person = (Person) o;
        return age == person.age &&
                Objects.equals(name, person.name);
    }
}
 
3.Map接口子类TreeMap使用 
特点：
 1.无序的
 2.无索引
 3.元素唯一的
 键唯一
 值可以重复
 4.双列的
 5.可以排序的(根据键来排序)   
 数据结构？
 红黑树，TreeSet底层使用的就是TreeMap
 常见的方法？和Map集合中的方法是一样的 
注意:当键值为自定义对象时，需要满足自然排序或者时比较器。 
七、泛型编程 
1.什么是泛型 
泛型即参数化类型，使用泛型一般都会与集合有关。 
2.泛型的作用 
运用泛型可以创建类型安全更好的集合，让许多问题尽可能在编译时期就能抓到。 
没有泛型：集合中以对象的引用形式存储，拿出时都是Object类型的引用。 
使用泛型：例如ArrayList仅有Fish对象能以引用形式加入到ArrayList中。不能把非Fish放进ArrayList中，取出来也是Fish的引用。 
public class Demo01 {
    public static void main(String[] args) {
        ArrayList s = new ArrayList();
        s.add("aaa");
        s.add("bbb");
        s.add("ccc");
        String[] ss=new String[3];
        s.toArray(ss);
        System.out.println(ss[0]);
        System.out.println(ss[1]);
        System.out.println(ss[2]);
    }
} 
 泛型的注意事项： 
1.泛型里面不能写基本数据类型
 2.前面的<>和后面的<>里的数据类型要匹配
 3.在jdk新特性，后面<>可以省略不写了
 ArrayList al = new ArrayList();
 ArrayList al = new ArrayList<>();
 ArrayList al = new ArrayList();

集合框架、泛型

Java相关栏目本月热门文章