第七章：集合容器

7.6.1容器和数组的区别

1，变量: 存储单个数据数组: 存储多个数据引用数据类型定长,长度一旦确定不可改变有序,有索引存储相同数据类型的数据 2，集合|容器: 存储多个数据容量可以多少进行动态的变动存储任意引用数据类型数据

public class Class01_Container {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        //添加元素
        list.add("你好");
        list.add(123456);
        list.add(null);
        list.add(true);
        list.add(3.14156);
        System.out.println(list);
        //查询数据个数
        System.out.println(list.size());
        list.add("你好");
        list.add(null);
        System.out.println(list);
        System.out.println(list.size());
        //获取索引位置的元素
        System.out.println(list.get(5));

7.6.2Collection接口

1， Collection 集合层次结构中的根接口。集合表示一组对象，称为其元素。

2，一些常见方法有：

添加 add

删除 remove

记数 size

包含 contains

清空 clear

是否空 isEmpty

public class Class01_Collection {
    public static void main(String[] args) {
        Collection col1 = new ArrayList();
        Collection col2 = new ArrayList();
        //添加元素
        col1.add(123);
        col1.add(456);
        col1.add("你是");
        col1.add(true);
        //在数据中添加元素
        System.out.println(col1.add(null));
        col2.add('A');
        col2.add('B');
        col2.add('C');
        System.out.println(col1);
        System.out.println(col2);

        //boolean addAll(Collection c)
        col1.addAll(col2);
        //System.out.println(col1);
        //System.out.println(col2);
        //boolean contains(Object o) 如果此collection包含指定的元素，则返回 true 。
        System.out.println(col1.contains(123));
        //boolean containsAll(Collection c) 如果此集合包含指定集合中的所有元素，则返回 true 。
        //System.out.println(col1.containsAll());
        //boolean isEmpty() 如果此集合不包含任何元素，则返回 true 。
        System.out.println(col2.isEmpty());
        //col2.clear();
        System.out.println(col2.isEmpty());
        //boolean remove(Object o) 从此集合中移除指定元素的单个实例（如果存在）（可选操作）。
        System.out.println(col1.remove("你是"));
        System.out.println(col1);
        //boolean removeAll(Collection c) 删除此集合的所有元素，这些元素也包含在指定的集合中（可选操作）。

        //boolean retainAll(Collection c) 仅保留此集合中包含在指定集合中的元素（可选操作）。
        col2.add('D');
        System.out.println(col1.retainAll(col2));
        System.out.println(col1);
        System.out.println(col2);
        //Object[] toArray() 返回包含此集合中所有元素的数组。
        System.out.println(Arrays.toString(col1.toArray()));
        //遍历方式
        //foreach
        for (Object obj:col2){
            System.out.println(obj);
        }
        //Iterator iterator() 返回此集合中元素的迭代器。
        //1)获取某一个集合的迭代器
        Iterator in = col1.iterator();
        //是否存在下一个元素
        while (in.hasNext()){
            //获取下一个元素
            System.out.println(in.next());
        }
    }
}

7.6.3List

1，List有序可重复的

2，List : 有序集合（也称为序列）。特点 : 有序,可重复 ,可以根据索引操作.. 新增功能 : 新增了一些根据索引操作的方法遍历方式 : for foreach iterator

public class Class01_List {
    public static void main(String[] args) {
        //创建一个list集合
        List list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(1);
        System.out.println(list);
        System.out.println(list.size());
        //void add(int index, E element) 将指定元素插入此列表中的指定位置（可选操作）。
        list.add(2,5);
        System.out.println(list);
        //E get(int index) 返回此列表中指定位置的元素。
        System.out.println(list.get(0));
        //int indexOf(Object o) 返回此列表中第一次出现的指定元素的索引，如果此列表不包含该元素，则返回-1。
        //int lastIndexOf(Object o) 返回此列表中指定元素最后一次出现的索引，如果此列表不包含该元素，则返回-1。
        System.out.println(list.indexOf(3));
        System.out.println(list.lastIndexOf(2));
        //static  List of(E... elements) 返回包含任意数量元素的不可修改列表。
        List list2 = List.of(1,3,5,7,9);
        System.out.println(list2);
        //E remove(int index) 删除此列表中指定位置的元素（可选操作）。
        //boolean remove(Object o) 从该列表中删除指定元素的第一个匹配项（如果存在）（可选操作）。
        System.out.println(list.remove(1));
        System.out.println(list);
        //E set(int index, E element) 用指定的元素替换此列表中指定位置的元素（可选操作）。
        System.out.println(list.set(0,2));
        System.out.println(list);
        //List subList(int fromIndex, int toIndex) 返回指定的 fromIndex （包含）和 toIndex （不包括）之间的此列表部分的视图。  结束索引不包含
        System.out.println(list.subList(2,4));
        System.out.println(list);
        //普通for循环遍历
        for (int i = 0;i s = list.iterator();
        //是否存在下一个元素
        while (s.hasNext()){
            //获取下一个元素
            System.out.println(s.next());
        }
    }
}

7.6.4手写ArrayList,自定义容器类

class MyContainer{
    //存储数据的结构
    private String[] elementData;
    //记录集合中数据的个数
    private int size;

    public MyContainer() {
    }

    
    public void add(String value) {
        //判断是否为第一次添加数据
        if(elementData==null || size==0){
            elementData = new String[1];
            elementData[0] = value;
            size++;
            return;
        }
        //不是第一次添加数据,原elementData指向数据对象,原数组中存在数据
        //记录原数组对象地址
        String[] temp = elementData;
        //创建新数组
        elementData = new String[size+1];
        //原数组中数据拷贝到新数组
        //i 作为原数组索引同时也能作为新数组水印
        for(int i=0;i=size){
            throw new IndexOutOfBoundsException(index+"索引越界啦!!!");
        }
        return elementData[index];
    }
    //根据索引修改数据
    //根据索引删除数据
    //返回数据的个数
    public int size(){
        return this.size;
    }
    @Override
    public String toString() {
        return Arrays.toString(elementData);
    }
}

7.6.5泛型

1，泛型 : jdk1.5新增参数化类型 : 数据的类型作为参数传递泛型通过一对<>配置泛型只能设置引用数据类型泛型可以提高稳定与可读性

public class Class01_Generic {
    public static void main(String[] args) {
        //泛型可以提高稳定与可读性
        ArrayList num = new ArrayList<>();
        num.add("ABC");
        num.add("BCD");
        num.add("CDE");
        //遍历增强for循环
        for (String str : num){
            System.out.println(str);
        }
        //Iterator迭代器遍历
        Iterator s1 = num.iterator();
        while (s1.hasNext()){
            System.out.println(s1.next());
        }
    }
}

7.6.6ArrayList

1, ArrayList : 有序,可重复,存在索引底层结构: 数组特点: 根据索引查询效率高,增删效率低应用场景:适合用在大量做查询,少量做增删的场景扩容: 默认的初始容量为10 , 每次扩容原容量的1.5倍int newCapacity = oldCapacity + (oldCapacity >> 1); 新增方法: void forEach(Consumer action)

2,遍历方式: 1)for 2)foreach 3)iterator 4)listIterator

public class Class01_ArrayList {
    public static void main(String[] args) {
        ArrayList list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(6);
        System.out.println(list);
        //增强for循环
        list.forEach(System.out::println);
        //普通for循环
        for (int i = 0;i str = list.iterator();
        while (str.hasNext()){
            System.out.println(str.next());
        }
    }
}

7.6.7linkedList

1,linkedList : list接口实现类: 有序,可重复

2, 底层结构: 双向链表特点 : 查询效率低,增删效率高应用场景 : 适合用在大量做增删少量做查询的位置新增功能 : 新增了一些操作链表头尾的方法遍历 : 与list相同

public class Class01_linkedList {
    public static void main(String[] args) {
        //创建接口对象
        linkedList list = new linkedList<>();
        //添加元素
        list.add("你好");
        list.add("高兴");
        list.add("开心");
        list.add("快乐");
        System.out.println(list);
        //查询头节点
        System.out.println(list.getFirst());
        //查询尾节点
        System.out.println(list.getLast());
        //删除数据节点
        System.out.println(list.removeFirst());
        System.out.println(list);
    }
}

7.6.8Set

1，Set : 无序,不可重复无序: 存放的顺序与内部真实存储对的顺序不一致新增内容 : static Set of(E... elements) 返回包含任意数量元素的不可修改集。遍历方式: foreach iterator

public class Class01_Set {
    public static void main(String[] args) {
        Set str = new HashSet<>();
        str.add("你好");
        str.add("13456");
        str.add("高兴");
        str.add(null);
        System.out.println(str);
        //static  Set of(E... elements) 返回包含任意数量元素的不可修改集。
        System.out.println(Set.of(1,2,3,4,5));
        //增强for循环遍历foreach
        for (String s : str) {
            System.out.println(s);
        }
        //迭代器遍历iterator
        Iterator s = str.iterator();
        while (s.hasNext()){
            System.out.println(s.next());
        }
    }
}

7.6.9TreeSet

TreeSet : 底层结构 : 红黑树(平衡二叉树) 特点 : 自动对数据做默认的升序排序应用场景: 想要实现去重,并且对数据需要默认排序情况遍历方式: 1)foreach 2)iterator

public class Class01_TreeSet {
    public static void main(String[] args) {
        TreeSet set = new TreeSet<>();
        set.add(3);
        set.add(2);
        set.add(1);
        set.add(4);
        set.add(6);
        set.add(5);
       
        System.out.println(set);
        //E ceiling(E e) 返回此set中大于或等于给定元素的 null元素，如果没有这样的元素，则 null 。
        System.out.println(set.ceiling(0));
        //E floor(E e) 返回此set中小于或等于给定元素的最大元素，如果没有这样的元素，则 null 。
        System.out.println(set.floor(7));
        //E first() 返回此集合中当前的第一个（最低）元素。
        //E last() 返回此集合中当前的最后一个（最高）元素。
        System.out.println(set.first());
        System.out.println(set.last());
        //E higher(E e) 返回此集合中的最小元素严格大于给定元素，如果没有这样的元素，则 null 。
        //E lower(E e) 返回此集合中的最大元素严格小于给定元素，如果没有这样的元素，则 null 。
        System.out.println(set.higher(2));
        System.out.println(set.lower(6));
        //E pollFirst() 检索并删除第一个（最低）元素，如果此组为空，则返回 null 。
        //E pollLast() 检索并删除最后一个（最高）元素，如果此集合为空，则返回 null 。
        System.out.println(set);
        System.out.println(set.pollFirst());
        System.out.println(set);
        //foreach遍历
        for (Integer num:set){
            System.out.println(num);
        }
        //iterator遍历
        Iterator s = set.iterator();
        while (s.hasNext()){
            System.out.println(s.next());
        }
    }
}

7.7内部比较器和外部比较器

比较器: 1.内部比较器|自然排序 : 实现Comparable接口,重写compareTo(T o)方法,方法体中制定比较规则 2.外部比较器|自定义排序实现Comparator接口,重写compare方法,方法体中制定比较规则
使用TreeSet存储Javabean数据,测试使用要求实现比较规则,有外部找外部,没有外部,默认找内部比较规则
注意: TreeSet去重,排序,都根据比较规则实现如果指定外部比较规则,使用外部比较规则,没有指定外部,使用内部比较规则,都不在,抛出类型转换异常ClassCastException

import java.util.*;

public class Class01_Work {
    public static void main(String[] args) {
        TreeSet set = new TreeSet<>(new test());
        set.add(new Person("李亮",21,"男"));
        set.add(new Person("丁天赐",17,"男"));
        set.add(new Person("时应霞",22,"女"));
        set.add(new Person("范兆康",20,"男"));
        set.add(new Person("吴玉涛",23,"男"));
        System.out.println(set);
    }
}
//外部比较器
class test implements Comparator{

    @Override
    public int compare(Person o1, Person o2) {
        return o1.getAge()-o2.getAge();
    }
}
//定义人类
class Person implements Comparable{
    private String name;
    private int age;
    private String sex;

    public Person() {
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + ''' +
                ", age=" + age +
                ", sex='" + sex + ''' +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age && Objects.equals(name, person.name) && Objects.equals(sex, person.sex);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age, sex);
    }
    //内部比较器
    @Override
    public int compareTo(Person o) {
        return this.getAge()-o.getAge();
    }
    
}

7.7.1HashSet

底层结构: 哈希表(数组+链表+红黑树) 特点: 查询增删效率高,无序,去重应用场景: 适合用在去重,无序,增删查效率较高情况
存储Javabean类型数据实现去重: 需要Javabean类型重写hashcode与equals方法,需要根据对象的属性值进行计算|判断,不能根据对象地址
思考: 重写hashcode与equals以后两个对象hashcode相等,equals就一定相等? 不一定两个对象equals相等,hashcode一定相等? 一定
注意: javabean的定义规范: 重写hashcode与equals方法

public class Class01_HashSet {
    public static void main(String[] args) {
        HashSet set = new HashSet<>();
        set.add(new Person("丁天赐",17,"男"));
        set.add(new Person("时应霞",22,"女"));
        set.add(new Person("范兆康",20,"男"));
        set.add(new Person("吴玉涛",23,"男"));
        set.add(new Person("吴玉涛",23,"男"));
        set.add(new Person("楚凯凯",25,"男"));
        System.out.println(set);
        System.out.println("你好".hashCode());
        System.out.println(new Person().hashCode());
        System.out.println(new Person().hashCode());
        System.out.println(new Integer(1233).hashCode());
    }
}

7.7.2Map

Map 存储键值对类型数据键值对: K-V 映射关系 K : 键 -> 唯一的,不可重复,无序的 --> map中的所有key拿出来构成一个Set集合 V : 值 -> 可重复,无序的 --> map中的所有键值对的value拿出来构成一个Collection集合
一个key只能对应一个value,如果想要一个key对应多个value可以value定义为数组|集合如果key相同,value覆盖
遍历: 1.values() Collection values() 返回此映射中包含的值的Collection视图。 2.keySet() Set keySet() 返回此映射中包含的键的Set视图。 3.entrySet() Set> entrySet() 返回此映射中包含的映射的Set视图。

public class Class01_Map {
    public static void main(String[] args) {
        Map map = new HashMap<>();
        map.put(1,"老丁");
        map.put(2,"老李");
        map.put(3,"老范");
        map.put(4,"老吴");
        map.put(5,"老楚");
        map.put(5,"范兆康");
        // 如果key相同,value覆盖
        System.out.println(map);
        //boolean containsKey(Object key) 如果此映射包含指定键的映射，则返回 true 。
        //boolean containsValue(Object value) 如果此映射将一个或多个键映射到指定值，则返回 true 。
        System.out.println(map.containsValue("老范"));
        System.out.println(map.containsKey(1));
        //V get(Object key) 返回指定键映射到的值，如果此映射不包含键的映射，则返回 null 。
        System.out.println(map.get(5));
        //static  /Map of(K k1, V v1, K k2, V v2) 返回包含两个映射的不可修改的映射。
        System.out.println(Map.of(1,"hehe",2,"haha"));
        //V remove(Object key) 如果存在，则从该映射中移除键的映射（可选操作）。
        System.out.println(map.remove(5));
        System.out.println(map);
          //1.values() : 只能遍历value,不能遍历key
        //增强for循环，
        Collection values = map.values();
        for (String num : values){
            System.out.println(num);
        }
        //2.keySet(),获取Key和Values的值
        Set set = map.keySet();
        Iterator it = set.iterator();
        while (it.hasNext()){
            Integer i = it.next();
            System.out.println(i+"------>"+map.get(i));
        }
        //3.entrySet()
        Set> entry = map.entrySet();
        for (Map.Entry entry1 : entry){
            System.out.println(entry1.getKey()+"------>"+entry1.getValue());
        }
    }
}

7.7.3HashMap

HashMap : 基于哈希表的Map接口的实现。此实现提供了所有可选的映射操作，并允许null值和null键。底层: 哈希表(数组+链表+红黑树) 特点: 查询,增删效率高,无序的,根据key去重线程不安全
容量Capacity | 初始容量（16) DEFAULT_INITIAL_CAPACITY : 哈希表数组结构第一次默认大小加载因子loadFactor|默认加载因子DEFAULT_LOAD_FACTOR : 0.75 大小: 集合中数据的个数扩容临界值threshold|阀值 : size = Capacity*loadFactor 实现扩容扩容机制 : newCap = oldCap << 1,每次扩容原容量的2倍
去重 : HashMap中键值对的key为javabean的时候,要求key的类型重写hashcode与equals方法
注意: map的去重根据key实现,HashMap的哈希表中计算位桶的索引,判断是否重复都是根据key,与value无关,只有存储数据构建新节点的时候或者key相同value覆盖的时候才有value有关

public class Class01_HashMap {
    public static void main(String[] args) {
        //创建对象，键值对
        HashMap map = new HashMap<>();
        //添加数据
        map.put(new Teacher("丁天赐",17,"语文"),"语文");
        map.put(new Teacher("李亮",21,"数学"),"数学");
        map.put(new Teacher("范兆康",22,"英语"),"英语");
        map.put(new Teacher("吴玉涛",23,"物理"),"物理");
        map.put(new Teacher("楚凯凯",52,"化学"),"化学");
        map.put(new Teacher("时应霞",22,"政治"),"政治");
        map.put(new Teacher("罗宇航",18,"Java"),"Java");
        map.put(new Teacher("罗宇航",18,"Java"),"Java+大数据");
        //打印数据
        System.out.println(map);
        Set set = map.keySet();
        Iterator it = set.iterator();
        while (it.hasNext()){
            Teacher i = it.next();
            System.out.println(i+"----->"+map.get(i));
        }
        };
    }
//定义教师类
class Teacher {
    private String name;
    private int age;
    private String subject;

    public Teacher() {
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    public String getSubject() {
        return subject;
    }

    public void setSubject(String subject) {
        this.subject = subject;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Teacher teacher = (Teacher) o;
        return age == teacher.age && Objects.equals(name, teacher.name) && Objects.equals(subject, teacher.subject);
    }

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

    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + ''' +
                ", age=" + age +
                ", subject='" + subject + ''' +
                '}';
    }
}

7.7.4Hashtableh和HashMap的区别

Hashtable : 底层结构: 哈希表
HashMap与Hashtable之间的区别: 1.继承体系不同 2.存储键值对中对null值的要求不同 HashMap中null值可以作为键值对 Hashtable中null值不能作为键值对 3.同步情况不同 HashMap线程不安全,不同步 Hashtable线程安全的哈希表 4.初始容量,扩容机制不同 HashMap初始容量16 扩容: 每次扩容原容量的2倍 Hashtable初始容量11 扩容: 每次扩容原容量的2倍+1 int newCapacity = (oldCapacity << 1) + 1; 5.计算key的hash值,与位桶索引的方式不同 HashMap : int hash = (h = key.hashCode()) ^ (h >>> 16); int index = (n - 1) & hash; Hashtable : int hash = key.hashCode(); int index = (hash & 0x7FFFFFFF) % tab.length;
HashMap线程不安全问题： 1.可以使用Hashtable 2.Collections工具类中 synchronizedMap(Map m) 3.juc高级并发编程包 ConcurrentHashMap --> 推荐

7.7.5TreeMap

TreeMap : 底层结构 : 红黑树特点: 自动做升序排序,无序的,去重的
注意: 无论是排序,还是去重都是根据兼职对的key计算排序去重问题: 都是根据键值对的key实现,要求key的类型实现内部比较器,或者定义TreeMap指定使用外部比价器
TreeSet底层就是由TreeMap维护的,就是TreeMap键值对的key

public class Class01_TreeMap{
    public static void main(String[] args) {
        TreeMap map = new TreeMap<>(new Comparator() {
            @Override
            public int compare(School o1, School o2) {
                return o1.getId()-o2.getId();
            }
        });
        //Lambda表达式
        map = new TreeMap((o1, o2) -> {
            return ((School)o1).getId()-((School)o2).getId();
        });
        map.put(new School(20,1105),"1105");
        map.put(new School(26,1103),"1103");
        map.put(new School(15,1102),"1102");
        map.put(new School(40,1106),"1106");
        map.put(new School(10,1101),"1101");
        //输出数据
        System.out.println(map);
        //迭代器遍历
        Set set = map.keySet();
        Iterator num = set.iterator();
        while (num.hasNext()){
            School i = num.next();
            System.out.println(i+"----->"+map.get(i));
        }
    }
        }
        //定义班级对象
class School implements Comparable{
    private int People;
    private int id;

    public School() {
    }

    public School(int people, int id) {
        People = people;
        this.id = id;
    }

    public int getPeople() {
        return People;
    }

    public void setPeople(int people) {
        People = people;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        School school = (School) o;
        return People == school.People && Objects.equals(id, school.id);
    }

    @Override
    public int hashCode() {
        return Objects.hash(People, id);
    }

    @Override
    public String toString() {
        return "School{" +
                "People=" + People +
                ", id='" + id + ''' +
                '}';
    }

    @Override
    public int compareTo(School o) {
        return this.getId() - o.getId();
    }

7.7.6Properties

Properties : Properties类表示一组持久的属性。 Properties可以保存到流中或从流中加载。属性列表中的每个键及其对应的值都是一个字符串。 Properties常用做配置文件使用
定义使用步骤: 1.src下新建文件 xx.properties 2.创建Properties类型的对象 3.调用load(InputStream|Reader) 4.根据key获取value getProperty(key)

public class Class01_Properties {
    public static void main(String[] args) throws IOException {
        //创建对象
        Properties pro = new Properties();
       
        //输出
        //System.out.println(pro);
        //从流中加载数据
        pro.load(Thread.currentThread().getContextClassLoader().getResourceAsStream("map01/db.Properties"));
        System.out.println(pro.getProperty("name"));
        System.out.println(pro.getProperty("age"));
    }

}

7.7.7Collections

Collections 此类仅包含对集合进行操作或返回集合的静态方法。静态工厂类似Arrays 常见的简答题: 问Collection与Collections的区别

public class Class01_Collections {
    public static void main(String[] args) {
         
        //创建一个List对象
        List list = new ArrayList<>();
        list.add(1);
        list.add(5);
        list.add(4);
        list.add(2);
        list.add(3);
        System.out.println(list);
        //自然排序
        Collections.sort(list);
        System.out.println(list);
        //随机排序
        
        //逆序排列
        Collections.reverse(list);
        System.out.println(list);
        //二分搜索法
        System.out.println(Collections.binarySearch(list,3));
        //填充
        Collections.fill(list,4);
        System.out.println(list);
    }
}

第七章：集合容器

Linux相关栏目本月热门文章