集合

集合

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

2. 和数组的区别：

   1. 数组长度固定，集合长度不固定

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

3. 位置：Java. util.*;

Collection体系集合

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

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

方法：

• add（Object obj）//添加一个对象

• addAll(Collection c)//将一个集合中的所有对象添加到此集合中。

• clear()//清空此集合中的所有对象。

• contains(Object o)//检查此集合中是否包含o对象

• equals(Object o)//比较此集合是否与指定对象相等

• isEmpty()//判断此集合是否为空

• remove(Object o)//在此集合中移除o对象

• size()//返回此集合中的元素个数

• toArray()//将此集合转为数组。

迭代器遍历：iterator（）；

package com.gather;
​
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
​
/*
* Collection接口的使用
* 1.添加元素
* 2.删除元素
* 3.遍历元素
* 4.判断
* */
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("苹果");
        //collection.clear();
        //System.out.println("删除以后"+collection.size());
        //遍历元素
        //1.增强for循环
        for (Object objct:collection) {
            System.out.println(objct);
        }
        System.out.println("============");
        //2.使用迭代器（专门用来遍历集合的一种方式）
        //hasNext()；有没有下一个元素
        //next（）；获取下一个元素
        //remove（）；删除当前元素
        //注意：迭代器再用的时候 没法用Collection来删除 会触发并发操作异常
        Iterator it = collection.iterator();
        while (it.hasNext()){
            String s=(String) it.next();
            System.out.println(s);
        }
        System.out.println("================");
        //4判断元素是否存在
        System.out.println(collection.contains("波罗蜜"));
        System.out.println(collection.isEmpty());
    }
}

List

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

实现类：

• ArrayList【重点】：

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

  • JDK1.2,运行效率快、线程不安全

  源码分析：

  • DEFAULT_CRPACITY=10默认容器

  • 注意：如果没有向集合添加任何元素，容量0，添加一个元素之后容量10，每次扩容是原来的1.5倍

  • elementData存放元素的数组

  • size 实际元素个数

  • add（）添加元素

• LinkedList

  • 链表结构模式，增删快，查询慢

• Vector

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

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

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

方法：

• add（int index,Object o）//在index位置插入对象o

• addALL(int index,Collection c)//将一个集合中的元素添加到此集合中的index位置

• get(int index)//返回集合中指定位置的元素。

• subList(int formIndex,int toIndex)//返回fromIndex和toIndex之间的集合元素

列表迭代器：listIterator()

• 和迭代器的区别就是列表可以实现从后往前遍历

package com.gather;
​
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
​
public class Demo03 {
    public static void main(String[] args) {
        //先创建集合
        List list = new ArrayList();
        //添加数据
        list.add("苹果");
        list.add("小米");
        list.add(0,"华为");
        System.out.println(list);
        //删除数据
       //list.remove(0);
        //System.out.println(list);
        //遍历
        //for循环
        System.out.println("=========for循环遍历========");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        //增强for
        System.out.println("=========增强for循环遍历========");
        for (Object object:list) {
            System.out.println(object);
        }
        //迭代器
        System.out.println("=========迭代器遍历========");
        Iterator it= list.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
        //使用列表迭代器
        System.out.println("=========列表迭代器遍历========");
        ListIterator lit = list.listIterator();
        System.out.println("==========从前往后遍历============");
        while (lit.hasNext()){
            System.out.println(lit.nextIndex()+":"+lit.next());
        }
        System.out.println("==========从后往前遍历============");
        while (lit.hasPrevious()){
            System.out.println(lit.previousIndex()+":"+lit.previous());
        }
        //判断
        System.out.println(list.contains("苹果"));
        System.out.println(list.isEmpty());
        //获取位置
        System.out.println(list.indexOf("华为"));
    }
}

添加基本数据类型

package com.gather;
​
import java.util.ArrayList;
import java.util.List;
​
public class Demo04 {
    public static void main(String[] args) {
        //创建集合
        List list=new ArrayList();
        //添加数字(自动装箱)
        list.add(20);
        list.add(30);
        list.add(40);
        list.add(50);
        list.add(60);
        System.out.println("元素个数："+list.size());
        System.out.println(list.toString());
        //删除操作
        //list.remove(20);//这里的20代表的是角标，所以会报异常
        //list.remove((Object)20);//这里给20强制类型转换一下，变成引用类型
        //补充方法：subList；返回子集合,含头不含尾
        List list1 = list.subList(1, 3);
        System.out.println(list1);
    }
}

Set

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

实现类：

• HashSet

  1. 基于HashCode计算元素存放位置

  2. 当存入元素的哈希码相同时，会调用equals进行确认，如结果为true，则拒绝后者存入。

package com.gather.Set;
​
import java.util.HashSet;
import java.util.Iterator;
​
//HashSet
//存储结构：哈希表（数组+链表+红黑树）
public class Demo02 {
    public static void main(String[] args) {
        //新建集合
        HashSet<String> hashSet = new HashSet<>();
        //添加数据
        hashSet.add("刘德华");
        hashSet.add("梁朝伟");
        hashSet.add("周润发");
        hashSet.add("林志玲");
        //hashSet.add("刘德华");
        System.out.println("元素个数"+hashSet.size());
        System.out.println(hashSet);
        //遍历
        System.out.println("========增强for==========");
        for (String string:
             hashSet) {
            System.out.println(string);
        }
        System.out.println("========使用迭代器==========");
        Iterator iterator = hashSet.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        //判断
        System.out.println(hashSet.contains("郭富城"));
        System.out.println(hashSet.isEmpty());
    }
}

存储过程：

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

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

• SorteSet

  • TreeSet

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

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

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

    • public int compareTo(Person o) {
          int n1=this.getName().compareTo(o.getName());
          int n2=this.age-o.getAge();
      ​
          return n1==0?n2:n1;
      }

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

泛型

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

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

• 语法：

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

• 好处：

  • 提高代码的重用性

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

泛型类

• 注意：

  • 泛型类只能使用引用类型

  • 不同泛型类型对象之间不能相会赋值

定义：

package com.gather.MyGeneric;
//泛型类
//语法：类名<T>
//T是占位符，表示一种引用类型，如果编写多个使用逗号隔开
public class Demo01<T> {
    //使用泛型
    //1.创建一个变量
    T t;
    //2.添加方法作为方法的参数
    public void show(T t){
        System.out.println(t);
    }
    //3.泛型作为方法的返回值
    public T getT(){
        System.out.println(t);
        return t;
    }
}

测试

package com.gather.MyGeneric;
​
public class TestDemo01 {
    public static void main(String[] args) {
        //使用泛型类来创建对象
        Demo01<String> generic = new Demo01<>();
        generic.t="hello";
        generic.show("wsdmw");
        generic.getT();
        System.out.println("==================");
        Demo01<Integer> generic2 = new Demo01<>();
        generic2.t=100;
        generic2.show(200);
        generic2.getT();
    }
}

泛型接口

定义：

package com.gather.MyInterface;
//泛型接口
//语法：接口名<T>
public interface Demo01<T> {
    String name="lcj";
    T server(T t);
}

实现类：

package com.gather.MyInterface;
​
public class TeseInterfacelm implements Demo01<String> {
​
    @Override
    public String server(String s) {
        System.out.println(s);
        return s;
    }
}

测试类

package com.gather.MyInterface;
​
public class TestDemo01 {
    public static void main(String[] args) {
        TeseInterfacelm teseInterfacelm = new TeseInterfacelm();
        teseInterfacelm.server("lcj");
        MyInterfaceImpl<Integer> integerMyInterface = new MyInterfaceImpl<>();
        integerMyInterface.server(10000);
    }
}

泛型方法

定义：

package com.gather.MyGenericMethod;
/*
* 泛型方法
* 语法：<T>返回值类型
* */
public class Demo01 {
    //泛型方法
    public <T> T show(T t){
        System.out.println("泛型方法");
        return t;
    }
​
}

测试

package com.gather.MyGenericMethod;
​
public class TestDemo01 {
    //泛型方法
    public static void main(String[] args) {
        Demo01 demo01 = new Demo01();
        demo01.show(2);//传递什么类型的参数，T就是什么类型的
    }
}

泛型集合

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

• 特点：

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

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

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

Map集合

Map接口的特点：

1. 用于存储任意键值对（Key-Value）

2. 键：无序、无下标、不允许重复

3. 值：无序、无下标、允许重复

• Map

  • 实现类HashMap

  • 继承接口：SortedMap

    • 实现类：TreeMap

方法：

• V put（K key,V value）//将对象存入到集合中，关联键值。key重复则覆盖原值

• Object get（Object key）//根据键获取对应的值

• Set<K>//返回所有的key

• Collection<V> values()//返回包含所有的Collection集合

• Set<Map.Entry<K,V>>//键值匹配的Set集合。

package com.gather.Map;
​
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
​
/**
 * Map的使用
 * 特点：存储的键值对2键不能重复，值可以重复3无序
 * */
public class Demo01 {
    public static void main(String[] args) {
        //创建Map集合
        Map<String,String> map=new HashMap<>();
        //添加数据
        map.put("cn","中国");
        map.put("uk","英国");
        map.put("usa","美国");
        map.put("usa","meiguo");
        //会把前面的给替换掉
​
        System.out.println("元素个数"+map.size());
        System.out.println(map);
       /* map.remove("usa");
        System.out.println("元素个数"+map.size());*/
​
        //遍历
        System.out.println("====KeySet()=====");
        //Set<String> keyset=map.keySet();
        for (String key:
                map.keySet()) {
            System.out.println(key+map.get(key));
        }
        //3.2使用entrySet方法
        System.out.println("=======entrySet======");
        for (Map.Entry<String,String> entry:
             map.entrySet()) {
            System.out.println(entry.getKey()+entry.getValue());
        }
        //判断
        System.out.println(map.containsKey("cn"));
        System.out.println(map.containsValue("泰国"));
    }
}

HashMap【重点】

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

package com.gather.Map;
​
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
​
/**
 * Map的使用
 * 特点：存储的键值对2键不能重复，值可以重复3无序
 * */
public class Demo01 {
    public static void main(String[] args) {
        //创建Map集合
        Map<String,String> map=new HashMap<>();
        //添加数据
        map.put("cn","中国");
        map.put("uk","英国");
        map.put("usa","美国");
        map.put("usa","meiguo");
        //会把前面的给替换掉
​
        System.out.println("元素个数"+map.size());
        System.out.println(map);
       /* map.remove("usa");
        System.out.println("元素个数"+map.size());*/
​
        //遍历
        System.out.println("====KeySet()=====");
        //Set<String> keyset=map.keySet();
        for (String key:
                map.keySet()) {
            System.out.println(key+map.get(key));
        }
        //3.2使用entrySet方法
        System.out.println("=======entrySet======");
        for (Map.Entry<String,String> entry:
             map.entrySet()) {
            System.out.println(entry.getKey()+entry.getValue());
        }
        //判断
        System.out.println(map.containsKey("cn"));
        System.out.println(map.containsValue("泰国"));
    }
}

package com.gather.Map;
​
import java.util.HashMap;
import java.util.Map;
​
/*
* HashMap集合的使用
* 存储结构：哈希表
* */
public class Demo02 {
    public static void main(String[] args) {
        //创建集合
        HashMap<Studet,String> students=new HashMap<>();
        //添加元素
        Studet s1 = new Studet("孙悟空", 100);
        Studet s2 = new Studet("猪八戒", 101);
        Studet s3 = new Studet("沙和尚", 102);
​
        students.put(s1,"花果山");
        students.put(s2,"高老庄");
        students.put(s3,"流沙河");
        students.put(new Studet("沙和尚", 102),"流沙河");
        System.out.println("元素个数" + students.size());
        System.out.println(students);
        //2删除
        //students.remove(s1);
        //遍历
        //3.1keySet（）；
        for (Studet key :
                students.keySet()) {
            System.out.println(key+students.get(key));
        }
        System.out.println("=====================");
        //3.2entrySet（）；
        for (Map.Entry<Studet,String> entry:
             students.entrySet()) {
            System.out.println(entry.getKey() + entry.getValue());
        }
        //4判断
        System.out.println(students.containsKey("孙悟空"));
    }
}

源码总结：

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

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

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

4. jdk1.8当链表长度小于6时，调整为链表

5. jdk1.8以前，链表时头插入，jdk1.8以后时是尾插入

TreeMap

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

package com.gather.Map;
​
import java.util.Map;
import java.util.TreeMap;
​
//TreeMap
public class Demo03 {
    public static void main(String[] args) {
        TreeMap<Studet,String> treeMap=new TreeMap<>();
        Studet s1 = new Studet("孙悟空", 100);
        Studet s2 = new Studet("猪八戒", 101);
        Studet s3 = new Studet("沙和尚", 102);
​
        treeMap.put(s1,"花果山");
        treeMap.put(s2,"高老庄");
        treeMap.put(s3,"流沙河");
        System.out.println("元素个数" + treeMap.size());
        System.out.println(treeMap);
    //遍历
        for (Studet studet: treeMap.keySet()) {
            System.out.println(studet+treeMap.get(studet));
        }
​
        for (Map.Entry<Studet,String> entry:
             treeMap.entrySet()) {
            System.out.println(entry.getKey()+entry.getValue());
        }
        //判断
        System.out.println(treeMap.containsKey(s1));
    }
}

colletions工具类

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

package com.gather.Map;
​
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
​
public class Demo04 {
    public static void main(String[] args) {
        List<Integer> list=new ArrayList<>();
        list.add(200);
        list.add(2);
        list.add(20);
        list.add(2050);
        list.add(202);
        list.add(210);
        //sort排序
        System.out.println("排序之前"+list);
        Collections.sort(list);
        System.out.println("排序之后"+list);
        //binarySearch二分查找
        System.out.println(Collections.binarySearch(list,12));
        //copy复制
        List<Integer> dest=new ArrayList<>();
        for (int i = 0; i < list.size(); i++) {
            dest.add(0);
        };
        Collections.copy(dest,list);
        System.out.println(dest);
        //reverse反转
        Collections.reverse(list);
        System.out.println("反转之后"+list);
​
        //shuffle 打乱
        Collections.shuffle(list);
        System.out.println("打乱之后"+list);
        //补充：list转为数组
        Integer[] arr = list.toArray(new Integer[0]);
        System.out.println(arr.length);
        System.out.println(Arrays.toString(arr));
        //数组转为集合
        String[] names={"dd","ss","aa"};
        List<String> list2 = Arrays.asList(names);
        //集合是受限集合，不能添加和删除
        //基本类型集合转为集合时，需要修改为包装类
        System.out.println(list2);
    }
}