java中的集合

最新推荐文章于 2023-06-13 16:55:10 发布

unique¢

最新推荐文章于 2023-06-13 16:55:10 发布

阅读量111

点赞数 1

分类专栏： javase 文章标签： java

本文链接：https://blog.csdn.net/m0_52598063/article/details/115035222

版权

javase 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

1）集合的继承结构图
1.1、Collection集合结构图
在这里插入图片描述
1.2、Map集合的继承结构图

2）关于Java.until.Collection接口中常用的方法
2.1、

Collection c=new ArrayList();  //创建一个集合对象。（Collection是接口，抽象的，无法实例化，用多态）
//(1)  boolean add(Object e) 向集合中添加元素
c.add("java");  
//(2)  int size()  获取集合中元素的个数
c.siae();  
//(3)  void clear() 清空集合
c.clear();  
//(4)  boolean contains(Object o) 判断当前集合中是否包含元素o，包含返回true，不包含返回false
c.contains(1);//自动装箱
//(5)  boolean remove(Object o) 删除集合中的某个元素。
c.remove(1);
//(6)  boolean isEmpty()  判断该集合中元素的个数是否为0
c.isEmpty();

注意：1、集合中不能直接存储基本数据类型，也不能存储Java对象，只能存储Java对象的内存地址
2、contains方法，底层调用了equals方法，因此调用contains方法时，要重写equals
3、remove方法底层也调用了equals方法

2.2、关于Collection中迭代器的使用

    public static void main(String[] args) {
        Collection c=new ArrayList();
        c.add(1);
        c.add("java");
        c.add(new Object());

        // 迭代器Iterator 在Map集合中不能用。在所有的Collection以及子类中使用。
        // 先获取集合对象的迭代器对象Iterator
        Iterator i=c.iterator();
//        以下两个方法是迭代器对象Iterator中的方法：
//        boolean hasNext()如果仍有元素可以迭代，则返回 true。
//        Object next() 返回迭代的下一个元素。
        while(i.hasNext()){
            Object o=i.next();
            System.out.println(o);
        }
    }

注意：在迭代集合元素的过程中，不能调用集合对象的remove方法，删除元素：
c.remove(o); 迭代过程中不能这样。
会出现：java.util.ConcurrentModificationException
由于集合中元素删除了，但是没有更新迭代器（迭代器不知集合发生了变化，导致迭代器的快照和原集合状态不同）导致异常

因此：在迭代元素的过程当中，一定要使用迭代器Iterator的remove方法，删除元素，
不要使用集合自带的remove方法删除元素。

3）List接口的特点及常用的方法
3.1、List集合存储元素特点：有序可重复
有序：List集合中的元素有下标
从零开始，以1递增
可重复：存储一个1，还可以再存储1
3.2、List接口特有的常用方法

void add(int index,Object element) //向指定下标插入元素，效率低

Object set(int index,Object element) //修改指定下标的元素

Object get(int index) //获取指定下标的值

int indexOf(Object o) //查找当前集合首次出o元素的下标

int lastIndexOf(Object o) //查找当前集合最后一次o元素的下标

Object remove(int index)  //删除指定下定的元素

3.3、ArrayList集合的一些特点
1、默认初始化容量10（底层先创建了一个长度为0的数组，当添加第一个元素的时候，初始化容量10。）
2、集合底层是一个Object[ ]数组。
3、构造方法：
new ArrayList();
new ArrayList(20); //初始化容量20
new ArrayList(Collection c);
4、ArrayList集合的扩容：
&esmp; 增长到原容量的1.5倍。
尽量减少扩容次数，提高效率
5、ArrayList集合不是线程安全的，可以通过Collections集合工具类的方法使它变成线程安全的

List<String> list=new ArrayList();
Collections.synchronizedList(list);

3.4、TreeSet集合的一些特性
1、TreeSet集合底层实际上是一个TreeMap，TreeMap集合底层是一个二叉树
2、放到TreeSet集合中的元素，等同于放到TreeMap集合Key部分
3、TreeSet集合中的元素：无序不可重复，但可以按照元素大小顺序自动排序
4、放在TreeSet集合或者TreeMap集合Key部分的元素实现排序有两种方式
第一种：放在集合中的元素实现java.lang.Comparable接口，并且实现compareTo方法
第二种：在构造TreeSet或者TreeMap集合时给他传一个比较器对象
5、Comparable和Comparator怎么选择呢？
当比较规则不会发生改变的时候，或者说当比较规则只有1个的时候，建议实现Comparable接口。
如果比较规则有多个，并且需要多个比较规则之间频繁切换，建议使用Comparator接口。

Comparator接口的设计符合OCP原则。

如何在一个类中实现compareTo方法

class User implements Comparable<User>{
    int age;
    String name;
    public User(){

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


    @Override
    public int compareTo(User o) {
        if(this.age==o.age){//当年龄相同时，按名字升序排
            return this.name.compareTo(o.name);
        }
        return this.age-o.age;//从小到大排序
    }
}

第二种方法：给TreeSet集合传一个比较器对象

public class test {
    public static void main(String[] args) {
        //传一个比较器
        TreeSet<Hero> set=new TreeSet<>(new HeroComparator());
        
        TreeSet<Hero> hero=new TreeSet<>(new Comparator<Hero>() {
            @Override  //第一种方式：采用匿名内部类来创建一个比较器对象
            public int compare(Hero o1, Hero o2) {
                return o1.age-o2.age;
            }
        });
    }
}

class Hero{
    int age;
    public Hero(int age){
        this.age=age;
    }
    
    public String toString(){
        return "Hero["+"age="+this.age+"]";
    }
}

//第二种方式：单独编写一个比较器
class HeroComparator implements Comparator<Hero>{

    @Override
    public int compare(Hero o1, Hero o2) {
        return o1.age-o2.age;
    }
}

4)**java.until.Map接口的特性及常用的方法** 4.1、Map和Collection没有继承关系 4.2、Map集合以key和value的方式存储数据：键值对

key和value都是引用数据类型
key和value都是存储对象的内存地址
key起到主导的地位，value是key的一个附属品
4.3、Map接口中常用的方法

V put(K key,V value);  //向Map集合中添加键值对

V get(Object key); //通过key获取value

void clear(); //清空Map集合

boolean containsKey(Object key); //判断Map中是否包含某个key

boolean containsValue(Object value); //判断Map中是否包含某个value

boolean isEmpty(); //判断 Map集合中元素个数是否为零

V remove(Object key); //通过key删除键值对

int size(); //获取Map集合中键值对的个数

Collection<V> values();  //获取Map集合中所有的value，饭hi一个Collection

x keySet(); //获取Map集合中所有的key（所有的key是一个Set集合）

Set<Map.Entry<K,V>> entrySet(); //将Map集合转换成Set集合

4.4、Map集合的遍历

public static void main(String[] args) {
        Map<Integer,String> map=new HashMap<>();
        map.put(1,"zhangsan");
        map.put(2,"lisi");
        map.put(3,"wangwu");
        map.put(3,"zhaoliu");
         第一种方式：获取所有的key，通过遍历key，来遍历value
        Set<Integer> set=map.keySet();
        // 遍历key，通过key获取value
        Iterator<Integer> i=set.iterator();
        while(i.hasNext()){
            Integer a=i.next();
            String s=map.get(a);
            System.out.println("key="+a+",vlaue="+s);
        }
        System.out.println();
        for(Integer d:set){
            System.out.println("ket="+d+",value="+map.get(d));
        }
        System.out.println();

        // 第二种方式：Set<Map.Entry<K,V>> entrySet()
        // 以上这个方法是把Map集合直接全部转换成Set集合。
        // Set集合中元素的类型是：Map.Entry
        Set<Map.Entry<Integer, String>> entries = map.entrySet();
        for(Map.Entry<Integer,String> r:entries){
            Integer j=r.getKey();
            String k=r.getValue();
            System.out.println("key="+j+",value="+k);
        }
    }

注意：Map.Entry类型，Entry是Map中一个静态内部类

5）HashMap集合中一些特性
5.1、HashMap集合底层是哈希表/散列表的数据结构
5.2、哈希表是一个数组和单向链表的结合体。
5.3、HashMap集合底层的源代码

public class HashMap{
            // HashMap底层实际上就是一个数组。（一维数组）
            Node<K,V>[] table;
            // 静态的内部类HashMap.Node
            static class Node<K,V> {
                final int hash; // 哈希值（哈希值是key的hashCode()方法的执行结果。hash值通过哈希函数/算法，可以转换存储成数组的下标。）
                final K key; // 存储到Map集合中的那个key
                V value; // 存储到Map集合中的那个value
                Node<K,V> next; // 下一个节点的内存地址。
            }
        }
       // 哈希表/散列表：一维数组，这个数组中每一个元素是一个单向链表。（数组和链表的结合体。）

5.4、HashMap集合的key部分特点：
无序不可重复
无序：因为不一定挂到那个单向链表上
不可重复：equals方法保证HashMap集合的Key不可重复。如果key重复了，value会覆盖
注意：
a、放在HashMap集合key部分的元素其实就是放到HashSet集合中了。
所以HashSet集合中的元素也需要同时重写hashCode()+equals()方法。
b、如果一个类的equals方法重写了，那么hashCode（）方法必须重写。
并且equals方法返回是true，hashCode（）方法返回的值必须一样。
eg：equals方法返回true表示两个对象相同，在同一个单向链表上比较。
那么对于同一个单向链表上的节点来说，他们的哈希值都是相同的。
所以hashCode()方法的返回值也应该相同。

5.5、向Map集合中存，以及从Map集合中取，都是先调用key的hashCode方法，然后再调用equals方法！
equals方法有可能调用，也有可能不调用。
拿put(k,v)举例，什么时候equals不会调用？
k.hashCode()方法返回哈希值，
哈希值经过哈希算法转换成数组下标。
数组下标位置上如果是null，equals不需要执行。
拿get(k)举例，什么时候equals不会调用？
k.hashCode()方法返回哈希值，
哈希值经过哈希算法转换成数组下标。
数组下标位置上如果是null，equals不需要执行。

5.6、HashMap集合的key和value都可以为null

6）关于Properties集合

Properties是一个Map集合，继承Hashtable，Properties的key和value都是String类型。
Properties被称为属性类对象。
Properties是线程安全的。
掌握Properties的两个方法，一个存，一个取

public static void main(String[] args) {
        // 创建一个Properties对象
        Properties pro=new Properties();
        //存数据
        pro.setProperty("java","sun");
        // 通过key获取value
        String s = pro.getProperty("java");
    }