Java集合

集合

集合的概念

• 对象的的容器，定义了对多个对象进行操作的常用方法。可实现数组的功能

• 和数组的区别：

  • 数组长度固定，集合长度不固定

  • 数组可以存储基本数据类型和引用类型，集合只能存储引用类型

• 位置：java.util.*

Collection体系集合

• Conllection该体系结构的根接口，代表一组对象，称为“集合”

  • List 特点是有序、有下标、元素可重复

    • ArrayList

    • LinkedList

    • Vector(过时)

  • Set 特点是无序、无下标、元素不能重复

    • HashSet

    • SortSet

      • TreeSet

     

Collection接口

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

• 方法

  • 添加一个对象

     boolean add(Object obj)

  • 将一个集合中的所有对象添加到此集合中

     boolean addAll(Conllection c)

  • 清空此集合中所有对象

     void clear()

  • 检查此集合中是否包含o对象

     boolean contains(Object o)

  • 比较集合是否与指定对象相等

     boolean equals(Object o)

  • 判断此集合是否为空

     boolean isEmpty()

  • 在此集合中移除o对象

     boolean remove(Object o)

  • 返回此集合中的元素个数

     int size()

  • 将此集合转换成数组

     Object[] toArray()

     Collection collection = new ArrayList();//创建集合
     collection.add("苹果");//添加元素
     collection.add("西瓜");
     collection.add("榴莲");
     //遍历元素 for-each
     for(Object object :collection){
         System.out.println(object);
     }
     //接口 Iterator<E>
     //方法：
     //boolean hasNext() 是否有下一个元素
     //next() 返回下一个元素
     //remove()从迭代器指向collection中移除迭代器返回的最后一个元素（迭代器中只能用这个方法删除，不能用collection方法）
     Iterator it = collection.iterator();
     while(it.hasNext()){
         String s = (String)it.next();
         System.out.println(s);
     }

List接口与实现类

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

• 方法：

  • 在Index位置插入对象o

     void add(int index, Object o)

  • 将一个集合中的元素添加到此集合中的index位置

     boolean addAll(int index,Collection c)

  • 返回集合中指定位置的元素

     Object get(int index)

  • 返回formIndex和toIndex之间的集合元素

     List subList(int formInsex,int toIndex)

• 遍历

  • for循环

  • for-earch

  • 迭代器

     Iterator it = collection.iterator();
     while(it.hasNext()){
         System.out.println(it.next());
     }

  • 列表迭代器

     ListIterator lit = list.listIterator();
     while(lit.hasNext()){
         System.out.println(lit.next());
     }

List实现类

ArrayList

• 数组结构实现，需要开辟连续空间，查询快、增删慢

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

• 默认容量DEFAULT_CAPACITY=10

  • 若没有添加元素容量为0

  • 添加一个元素之后容量为10

  • 扩容是每次的1.5倍

  • 添加低11个元素时容量扩充为15

• 存放元素数组elementData

• 方法：

  • 创建集合

     ArrayList arrayList = new ArryList<>();

  • 添加元素

     arrayList.add();

  • 删除元素

     arrayList.remove();

  • 遍历元素 使用迭代器，同上 Iterator ListIterator

Vector

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

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

• 方法：

  • 创建集合Vector vector = new Vector<>();

  • 添加元素vector.add()

  • 删除vector.remove()

  • 遍历 使用枚举器

     Enumeration en = vector.elements();
     while(en.hasMoreElements()){
         String o = (Sting)em.nextElement();
         System.out.println(o);
     }

  • 判断 vector.contains()``vector.isEmpty()

•  

LinkedList

• 链表结构，无需开辟连续空间，增删快，查询慢

• 方法：

  • 创建集合LinkList linkList = new LinkList<>();

  • 添加元素linkList.add()

  • 删除linkList.remove()

  • 清空linkedList.clear()

  • 判断linkList.contains()``linkList.isEmpty()

  • 获取linkList.indexOf()

• 遍历

  • for循环

  • 增强for 即for-each

  • 迭代器

  • 列表迭代器

泛型和工具类

泛型

• 定义：Java泛型是JDK1.5中引入的一个新特性，本质是参数化类型，把类型作为参数传递

• 常见的形式有泛型类、泛型接口、泛型方法

• 语法：类名<T,...>T称为类型占位符，表示一种引用类型

   public class MyGeneric<T> {
       //使用泛型T
       //创建变量
       T t;
       //泛型作为方法的参数
       public void show(T t) {
           System.out.println(t);
       }
       //泛型作为方法的返回值
       public T getT() {
           return t;
       }
   }
   ​
   //使用泛型类创建对象
   //注意：泛型只能用引用类型，不同泛型类型对象之间不能相互赋值
   MyGeneric <String> myGeneric = new MyGeneric<String>();
   myGeneric.t = "hello";
   myGeneric.show("大家好");
   String str = myGeneric.get();

• 好处：

  • 提高代码的重用性

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

泛型接口

• 语法：接口名<T>

   public interface MyInterface<T> {//接口
       String name = "zhangshan";
       T sever(T t);
   }
   //实现类  确定类型
   public class MyInterfaceImpl1 implements MyInterface<String> {
       @Override
       public String server(String t) {
           System.out.println(t);
           return t;
       }
   }
   //不确定类型
   public class MyInterfaceImpl2<T> implements MyInterface<T> {
       @Override
       public T server(T t) {
           System.out.println(t);
           return t;
       }
   }
   //实现
   MyInterfaceImpl1 impl = new MyInterfaceImpl1();
   impl.server("xxxx");
   ​
   MyInterfaceImpl2<Integer> impl2 = new MyInterfaceImpl2<>();
   impl2.server(1000);

泛型方法

• 语法：<T> 返回值类型

   //在类里面的方法
   public <T> void show(T t) {
       System.out.println("xxxx");
   }
   //使用时先创建对象，在调用方法时，直接传递参数，参数类型随传入参数改变

泛型集合

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

• 特点：

  • 编译时即可检查，而非运行时抛出异常

  • 访问时，不必类型转换（拆箱）

  • 不同泛型之间引用不能相互赋值，泛型不存在多态

• 语法：比如ArrayList<String> array = new ArrayList<String>();

Set接口与实现类

Set接口

• 创建集合：Set<String> set = new HashSet<>();

• 遍历：

  • 增强for for-each （无下标，不能用for循环）

  • 使用迭代器

Set实现类

• HashSet集合

  • 创建集合：HashSet<String> hashSet = new HashSet<String>();

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

  • 遍历：同上

  • 存储过程：（重复依据）

    • 根据hashcode计算保存的位置，如果此位置为空，则直接保存，如果不为空执行第二步

    • 在执行equals方法，如果equals方法为true，则认为是重复，否则形成链表

  •  

• TreeSet

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

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

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

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

  • 存储结构：红黑树

  • 创建集合：Treeet<String> trssSet = new TreeSet<>();

  • 存储无比较规则的类时，要求：元素必须实现Comparable接口，compareTo()返回值为0，认为是重复元素

  • 定制比较Comparator比较器

     //创建集合，并指定比较规则
     TreeSet<Person> person = TreeSet<>(new Comparator<Person>() {
         @Override
         public int compare(Person o1,Person o2) {
             //比较规则  先比年龄后比名字
             int n1 = o1.getAge()-o2.getAge();
             int n2 = o1.getName().comparableTo(o2.getName());
             return n1 == 0 ? n2 : n1;
         }
     });

Map接口与实现类

Map父接口

• 特点：

  • 存储一队数据（Key-Value），无序、无下标，键不可重复，值可重复

• 方法：

  • 将对象存入集合中，关联键值。key重复覆盖原值

     V put(K key,V value)

  • 根据键获取对应值

     Object get(Object key)

  • 返回所有键值

     ​

  • 返回包含所有值的Collection集合

     Collection<V> values()

  • 键值匹配的Set集合

     Set<Map.Entry<K,V>>

• Map接口的使用

  • 创建Map集合

     Map<String,String> map = new HashMap<>();

  • 添加元素

     map.put("cn","中国");

  • 删除（用key）

     map.remove("cn");

  • 遍历

    • 使用KeySet()

       Set<String> keyset = map.KeySet();
       for(String key : keyset) {
           System.out.println(key+"---"+map.get(key));
       }

    • 使用entrySet()方法（效率较高）

       Set<Map.Entry<String,String>> entries = map.entrySet();
       for(Map.Entry<String,String> entry : entries) {
           System.out.println(entry.getKey()+"---"+entry.getValue());
       }

    • 判断

       map.containKey("cn");//是否有key
       map.containsValue("中国")//是否有value

HashMap的使用

• 方法

  • 创建集合 刚创建hashmap之后没后添加元素table=null,size=0,添加一个元素后最大容量为16，目的是节省空间

     HashMap<Student,String> student = new HashMap<Student,String>();

  • 添加元素

     student.put(s1,"beijing");

  • 删除.remove()

  • 遍历 同上

  • 判断

• 总结

  • HashMap刚创建时，table是null，为了节省空间，当添加第一个元素时，table容量调整为16

  • 当元素个数大于阙值（16*0.75=12）时，会进行扩容，扩容大小为原来的2倍。目的是减少调整元素的个数

  • jdk1.8当每个个链表长度大于8，并且数组元素个数大于等于64时，会调整为红黑树，目的是提高执行效率

  • jdk1.8当链表长度小于6时，调整成链表

  • jdk1.8以前，链表头插，jdk1.8后尾插

Map集合实现类

• HashMap

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

• Hashtable

  • JDK1.0版本，线程安全，运行效率慢；不允许null作为key或是value

• Properties

  • Hashtable的子类，要求key和value都是String。通常用于配置文件的读取

• TreeMap

  • 实现了SortedMap接口（是Map的子接口），可以对key自动排序

  • 方法：

    • 创建对象

       TreeMap<String,String> treeMap = new TreeMap<Student,String>();

    • 添加元素treemap.put(s1,"biejing");

    • 删除treeMap.remove();

    • 遍历 同上

Colletions工具类

• 概念：集合了工具类，定义了除了存取以外的集合常用方法

• 方法：

  • 反转集合中元素的顺序

     public static void reverse(List<?> list)

  • 随机重置集合元素的顺序(打乱)

     public static void shuffle(List<?> list)

  • 升序排序（元素类型必须实现Comparable接口）

     public static void sort(List<?> list)

  • list转成数组list.toArray()

  • 数组转成集合

    • Array.asList()转换成受限集合后不能修改

    • 把基本类型数组转成集合时，需要修改为包装类型

    •