Java-集合

最新推荐文章于 2024-10-16 10:13:45 发布

yxy ^ _ ^

最新推荐文章于 2024-10-16 10:13:45 发布

阅读量2.4k

点赞数 4

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

本文链接：https://blog.csdn.net/weixin_43690923/article/details/121617231

版权

Java 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

集合：对象的容器，定义了对多个对象进行操作，类似与数组

和数组的区别：

数组长度固定，集合长度不固定
数组可存储基本类型和引用类型，集合只能存储引用类型

collection体系集合

collection接口：

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

方法：

add：添加
addAll：将一个集合的所有元素添加到此集合
clear：清空集合
contains：检查是否包含某对象
equals：比较次集合是否与指定对象相等
isEmpty：集合是否为空
remove：移除某个对象
size：返回集合中元素个数
toArray：将集合转换成数组

iterator：实现对元素的遍历

Collection collection = new ArrayList();
        //添加
        collection.add("英语");
        collection.add("123");
        collection.add("数学");
        //删除
        collection.remove("123");
        System.out.println(collection);
        //遍历
        Iterator it = collection.iterator();
        while (it.hasNext()){
            String s = (String) it.next();
            System.out.println(s);
        }

        System.out.println(collection.isEmpty());//判空
        System.out.println(collection.contains("123"));//是否包含123

List子接口

有序，有下标，元素可以重复

方法：

add：指定位置插入对象
addAll：将一个集合的元素添加到此集合的指定位置
get：获得指定位置元素
subList：返回指定集合段，含头不含尾
listIterator：迭代器和lterator区别：可以向前或者向后遍历，添加，删除，修改元素

 List list = new ArrayList();
        //添加
        list.add("123");
        list.add("456");
        list.add("789");
        //遍历
        //1.利用for循环
        for (int i = 0;i<list.size();i++){
            System.out.println(list.get(i));
        }
        //2.增强for循环
        for (Object o:list){
            System.out.println(o);
        }
        //3.Iterator迭代器
        Iterator iterator = list.iterator();
        while (iterator.hasNext()){
            String s = (String) iterator.next();
            System.out.println(s);
        }
        //4.ListLterator迭代器
        ListIterator listIterator = list.listIterator();
        while (listIterator.hasNext()){
            String s = (String) listIterator.next();
            System.out.println(s);
        }
        while (listIterator.hasPrevious()){
            String s = (String) listIterator.previous();
            System.out.println(s);
        }

ArrayList

数组结构实现，查询快，增删慢，若使用add方法后默认容量变为10，每次扩容大小为原来的1.5倍

方法：

add：：添加
remove：删除
listIterator：迭代器
cotains：判断
indexOf：查找

ArrayList arrayList = new ArrayList();
        //添加,当没有向集合中添加元素时初始容量为0，使用一次add后容量变为10，每次扩容大小为原来的1.5倍
        arrayList.add("123");
        arrayList.add("111");
        arrayList.add("000");
        //删除
        arrayList.remove("000");
        //遍历
        Iterator iterator = arrayList.iterator();
        while (iterator.hasNext()){
            String s = (String) iterator.next();
            System.out.println(s);
        }
        //遍历
        ListIterator listIterator = arrayList.listIterator();
        while (listIterator.hasNext()){
            String s = (String) listIterator.next();
            System.out.println(s);
        }

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

LinkList

链表结构实现，增删快，查询慢

方法：

add：：添加
remove：删除
listIterator：迭代器
cotains：判断
indexOf：查找，获取

泛型

把类型作为参数传递，常见形式有泛型类，泛型接口，泛型方法

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

好处：提高代码的重用性；防止类型转换异常，提高代码安全性

泛型类：语法：类名<T> T表示一种引用类型，如果编写多个可使用逗号隔开

注意：泛型只能是引用类型；不同泛型对象之间不能相互赋值

public class FanXing <T> {
    //定义变量
    T t;
    //泛型作为参数
    public void show(T t){
        System.out.println(t);
    }
    //泛型作为方法的返回值
    public T eat(){
        return  t;
    }
}

public class FanXinginterfaceImp implements FanXinginterface<String>{
    @Override
    public String server(String s) {
        return null;
    }
}

泛型接口：语法：接口名<T>

注意：不能泛型静态常量

public interface FanXinginterface<T> {
    T server(T t);
}

泛型方法：语法：<T>返回值类型


   //泛型方法
    public <T> T show(T t){
        return t;
    }

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

特点：

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

Set集合

无序，无下标，元素不可重复

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

 Set<String> set = new HashSet();
        //1.添加
        set.add("苹果");
        set.add("香蕉");
        set.add("葡萄");
        //2.删除
        set.remove("香蕉");
        //3.遍历
        //第一种：for增强
        for (String s:set){
            System.out.println(s);
        }
        //第二种：迭代器
        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            String s = (String)iterator.next();
            System.out.println(s);
        }

HashSet

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

基于HashSet实现元素不重复，当存入元素的哈希码相同时，会调用equals进行确认，如果结果为true，则拒绝后者存入

存储过程：

根本hashcode计算保存的位置，如果此位置为空，则直接保存，不空执行第二步（可重写hashcode和equals方法）
再执行equals方法，如果equals方法为true，则认为是重复，否则，形成链表

TreeSet

基于排列顺序实现元素不重复
实现了SortedSet接口，对集合进行自动排序
元素对象的类型必须实现Comparable接口，指定排序规则，
通过CompareTo方法确定是否为重复元素，compareto方法返回值为0，认为是重复元素

Comparator：实现定制比较

存储结构：红黑树

/创建集合，并指定比较规则
        TreeSet<String> treeSet = new TreeSet<>(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                int n1 = o1.length()-o2.length();
                int n2 = o1.compareTo(o2);
                return n1==0?n2:n1;
            }
         });

Map集合

用于存储任意键值对（Key-Value）
键：无序，无下标，不允许重复
值：无序，无下标，允许重复

方法：

put：将对象存到集合中，关联键值，key重复则覆盖原值
get：根据键值获取对应的值
Set<K>：返回所有的key
Collection<V> values（）：返回所有值的Collection集合
Set<Map.Entry<K，V>>：键值匹配的Set集合

Map<String,String> map = new HashMap<>();
        //添加元素
        map.put("1","中国");
        map.put("2","美国");
        map.put("3","英国");
        //删除，通过键值删除
        map.remove("2");
        //遍历
        //1.通过keyset
        Set<String> keyset = map.keySet();
        for (String key:keyset){
            System.out.println(key+map.get(key));
        }
        //2.使用entryset
        Set<Map.Entry<String,String>> entrySet = map.entrySet();
        for (Map.Entry<String,String> m:entrySet){
            System.out.println(m.getKey()+m.getValue());
        }
        //判断
        System.out.println(map.containsKey("3"));