（一）集合

概念：对象的容器，定义了对多个对象进行操作的常用方法，类似数组的功能

特点：长度不固定，只能存储引用类型

位置：Java.util.*

（二）Collection接口

特点：代表一组任意类型的对象，无序、无下标、不能重复

方法：

boolean add(Odject obj) —— 添加一个对象boolean addAll(Collection c) —— 将一个集合中的所有对象添加到此集合中void clear() —— 清空此集合中的所有对象boolean contains(Odject o) —— 检测此集合中是否包含o对象boolean equals(Odject o) —— 比较此集合是否与指定对象相等boolean isEmpty() —— 判断此集合是否为空boolean remove(Odject o) —— 在此集合中移除o对象int size() —— 返回此集合中的元素个数Object[] toArray() —— 将此集合转换成数组

Collection使用

import java.util.*;
​
public class Demo01 {
    public static void main(String[] args) {
        //创建集合
        Collection collection= new ArrayList();
        //1.添加元素
        collection.add("苹果");
        collection.add("橘子");
        collection.add("榴莲");
        System.out.println("元素个数："+collection.size());
        System.out.println(collection);
        //2.删除元素
        collection.remove("榴莲");
        System.out.println("删除之后："+collection.size());
        //3.遍历元素
        //使用增强for循环
        System.out.println("使用增强for循环");
        for (Object object:collection){
            System.out.println(object);
        }
        //使用迭代器
        System.out.println("使用迭代器");
        //hasNext(); ————有没有下一个元素
        //next(); ————获取下一个元素
        //remove(); ————删除当前元素
        Iterator it= collection.iterator();
        while(it.hasNext()){
            String s=(String)it.next();
            System.out.println(s);
        }
        //4.判断
        System.out.println(collection.contains("橘子"));
        System.out.println(collection.isEmpty());
    }
}

（三）List接口

特点：有序、有下标、元素可以重复

方法：

有Collection中的所有方法void add(int index,Object o) —— 在index位置插入对象oboolean addAll(int index,Collection c) —— 将一个集合中的元素添加到此集合中的index位置Object get(int index) —— 返回集合中指定位置的元素List subList(int formIndex,int toIndex) —— 返回 formIndex和 toIndex之间的集合元素

List使用

遍历元素

//使用 ListIterator迭代器
//和Iterator的区别：ListIterator可以向前或向后遍历，添加、删除、修改元素
        ListIterator listIterator=list.listIterator();
        System.out.println("使用列表迭代器从前往后");
        while (listIterator.hasNext()){
            System.out.println(listIterator.nextIndex()+","+listIterator.next());
        }
        System.out.println("使用列表迭代器从后往前");
        while (listIterator.hasPrevious()){
            System.out.println(listIterator.previousIndex()+","+listIterator.previous());
        }

获取位置

System.out.println(list.indexOf("黄瓜"));

List实现类

ArrayList

数组结构实现，查询快、增删慢，必须开辟连续的存储空间

JDK1.2版本，运行效率快、线程不安全

//创建集合
ArrayList arrayList=new ArrayList<>();
//遍历
ListIterator list=arrayList.listIterator();
System.out.println("使用列表迭代器从前往后");
        while (list.hasNext()){
            System.out.println(list.nextIndex()+","+list.next());
        }
System.out.println("使用列表迭代器从后往前");
        while (list.hasPrevious()){
            System.out.println(list.previousIndex()+","+list.previous());
        }

Vector

数组结构实现，查询快、增删慢

JDK1.0版本，运行效率慢、线程安全

public class Demo04 {
    public static void main(String[] args) {
        Vector vector = new Vector();
        vector.add("abc");
        vector.add("def");
        vector.add("ghi");
        //使用枚举器遍历
        Enumeration en=vector.elements();
        while (en.hasMoreElements()){
            String s=(String)en.nextElement();
            System.out.println(s);
        }
    }
}

linkedList

链表结构实现，增删快、查询慢，无需开辟连续的存储空间

（四）泛型

JDK1.5新特性，本质是参数化类型，把类型作为参数传递

形式：泛型类、泛型接口、泛型方法

语法： T称为类型占位符，表示一种引用类型，编写多个时用逗号隔开

好处：

提高代码的重用性

防止类型转换异常，提高代码的安全性

泛型类

语法：类名

使用泛型类创建对象

注意：1、泛型只能使用引用类型

2、不同泛型类型对象之间不能相互赋值

public class MyGeneric {
    //使用泛型 T
    //创建变量
    T t;
    //泛型作为方法的参数
    public void show (T t){
        System.out.println("泛型类："+t);
    }
    //泛型作为方法的返回值
    public T getT(){
        return t;
    }
}

泛型接口

语法：接口名

public interface MyInterface {
    String name="Joyce_yu";
    T serve(T t);
}

public class MyInterfaceImpl1 implements MyInterface{
    @Override
    public String serve(String t) {
        //TODO AUTO-generated method stub
        System.out.println("泛型接口1："+t);
        return t;
    }
}

public class MyInterfaceImpl2  implements MyInterface{
    @Override
    public T serve(T t) {
        System.out.println("泛型接口2："+t);
        return t;
    }
}

泛型方法

语法：返回值类型

public class MyGenericMethod {
    public  T show(T t){
        System.out.println("泛型方法："+t);
        return t;
    }
}

运行测试

public class TestGeneric {
    public static void main(String[] args) {
        MyGenericmyGeneric1=new MyGeneric();
        myGeneric1.t="hello";
        myGeneric1.show("hello,everyone!");
        String string=myGeneric1.getT();
​
        MyGenericmyGeneric2=new MyGeneric();
        myGeneric2.t=100;
        myGeneric2.show(200);
        Integer integer=myGeneric2.getT();
​
        //泛型接口
        MyInterfaceImpl1 impl1=new MyInterfaceImpl1();
        impl1.serve("Joyce_yu");
​
        MyInterfaceImpl2 impl2=new MyInterfaceImpl2();
        impl2.serve(1000);
​
        //泛型方法
        MyGenericMethod myGenericMethod=new MyGenericMethod();
        myGenericMethod.show("TFBoys");
        myGenericMethod.show(520);
    }
}

 运行结果

 

 泛型集合

概念：参数化类型、类型安全的集合，强制集合元素的类型必须一致

特点：

编译即可检查，而非运行时抛出异常访问时不必类型转换（拆箱）不同泛型之间引用不能相互赋值，泛型不存在多态

（五）Set接口

特点：无序、无下标、元素不可重复

方法：全部继承自Collection中的方法

HashSet

存储结构：哈希表（数组+链表+红黑树）

存储过程：

根据hashcode计算保存位置，如果此位置为空，则直接保存，如果不为空则执行第二步执行equals方法，如果结果为true，则认为是重复，否则，形成链表补充内容

     3. 补充内容

 

TreeSet

基于排列顺序实现元素不可重复

实现了SortedSet接口，对集合元素自动排序

元素对象的类型必须实现Comparable接口，指定排序规则

通过CompareTo方法确定是否为重复元素

import java.util.Comparator;
import java.util.TreeSet;
​
public class Demo05 {
    public static void main(String[] args) {
        //创建集合，并指定比较规则
        TreeSet treeSet=new TreeSet<>(new Comparator(){
            @Override
            public int compare(String s1, String s2) {
                int n1=s1.length()-s2.length();
                int n2=s1.compareTo(s2);
                return n1==0?n2:n1;
            }
        });
        treeSet.add("World");
        treeSet.add("China");
        treeSet.add("Liaoning");
        treeSet.add("Fushun");
        treeSet.add("Xinbin");
        treeSet.add("Shangjiahe");
        treeSet.add("Wulong");
        System.out.println(treeSet);
​
    }
}

（六）Map接口

特点：存储键值对，键不能重复、值可以重复，无序、无下标

方法：

V put(K key,V value) —— 将对象存入到集合中，关联键值；key重复则覆盖原值Object get(Object,key) —— 根据键获取对应的值Set —— 返回所有keyCollection values() —— 返回包含所有值的Collection集合Set> —— 键值匹配的Set集合

import java.util.HashMap;
import java.util.Map;
import java.util.Set;
​
public class Demo06 {
    public static void main(String[] args) {
        //创建Map集合
        Map map=new HashMap<>();
        //1.添加元素
        map.put("cn","中国");
        map.put("uk","英国");
        map.put("us","美国");
        System.out.println("元素个数："+map.size());
        System.out.println(map.toString());
        //2.删除
        map.remove("us");
        System.out.println("删除之后："+map.size());
        //3.遍历
        //entrySet();效率高于 keySet();
        //3.1使用 keySet();
        Set keyset=map.keySet();
        for (String key:map.keySet()){
            System.out.println(key+"--keySet--"+map.get(key));
        }
        //3.2使用 entrySet();
        Set> entries=map.entrySet();
        for (Map.Entry entry:entries){
            System.out.println(entry.getKey()+"--entrySet--"+entry.getValue());
        }
        //4.判断
        System.out.println(map.containsKey("cn"));
        System.out.println(map.containsValue("法国"));
    }
}

运行结果

HashMap

JDK1.2版本，线程不安全，运行效率快；允许null作为key或value

存储结构：哈希表（数组+链表+红黑树）

TreeMap

存储结构：红黑树

（七）Collections

package 集合框架;
​
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
​
public class Demo07 {
    public static void main(String[] args) {
        List list=new ArrayList<>();
        list.add(20);
        list.add(5);
        list.add(12);
        list.add(30);
        list.add(6);
        //sort排序
        System.out.println("排序前："+list.toString());
        Collections.sort(list);
        System.out.println("排序后："+list.toString());
        //binarySearch二分查找
        int i=Collections.binarySearch(list,13);
        System.out.println("二分查找出的位置是："+i);
        //copy复制
        List dest=new ArrayList<>();
        for (int k = 0; k  list2=Arrays.asList(names);
        System.out.println("数组转成集合："+list2);
    }
}

运行结果