Java容器：数组与集合的对比与实战-优快云博客

本文链接：https://blog.youkuaiyun.com/m0_46151790/article/details/128320824

数组和集合的对比

集合、数组都是对多个数据进行存储操作的结构，简称Java容器。

数组的特点

1.数组一旦初始化之后,数组的长度就不可变
2. 数组中提供的方法非常限，对于添加、删除、插入数据等操作，非常不便，同时效率不高。
3.获取数组中实际元素的个数的需求，数组没有现成的属性或方法可用
4.数组中的元素必须是有序的,可重复。但对于无序,不可重复的需求，不能满足。

集合的特点

解决了数组存储数据方面的弊端

Collection接口

在这里插入图片描述
java集合框架提供了一套性能优良,使用方便的接口和类,位于 java.util包下
Collection接口: 子接口List和子接口Set
Collection接口存储一组不唯一无序的对象

Collection接口的缺点

Collection 可重复造成空间的浪费无序造成查询效率的降低

Collection提供的方法

1.public boolean add(E e) :把给定的对象添加到当前集合中
2.public void clear():清空集合中所有的元素。
3. public boolean remove(E e) : 把给定的对象在当前集合中删除。
4.public boolean contains(Object obj) : 判断当前集合中是否包含给定的对象。
5. public boolean isEmpty() : 判断当前集合是否为空。
6.public int size() : 返回集合中元素的个数
7. public Object[] toArray() : 把集合中的元素，存储到数组中

Collections是一个集合框架的工具类,提供了一些集合操作的方法而collection是一个根接口

List子接口

特点:

1.List接口中存储的元素不唯是可以重复的,按线性存储方式存储集合中的每一个元素都带有一个索引值
2.但是List接口中的元素是有序的,即存入的顺序和取出的顺序一致。

List子接口有序可以重复

优点:

查询效率高可按索引进行查找

缺点:

容易造成数据冗余

List接口的实现类ArrayList

在这里插入图片描述

ArrayList实现类的特点

1.ArrayList的存储结构是数组
2.ArrayList遍历和随机访问元素的效率是比较高的查找快
3.但对数组的增加和删除效率慢

List接口提供的方法

 public class ArrayListTest {
    public static void main(String[] args) {
        //List接口的实现类:ArrayList
        //元素可以重复 但有序
        List arrayList=new ArrayList();
        //add():添加的个数 类型没有限制 因为没有泛型的限制
        //add方法 默认从下标0开始添加数据
        //add():添加的个数 类型没有限制
        //add方法 默认从下标0开始添加数据
        arrayList.add(1);//下标为0
        arrayList.add("abc");//下标为1
        //添加一个对象
        arrayList.add(new Student());
        //按下标向集合中添加元素
         //跟数组不同的是 数组会覆盖原数据 但是arrayList可以向后自动移动
           //原先下标为1的元素自动向后移动 形成连续的空间
            arrayList.add(1,"123");
         //get(索引值) 得到集合中对应索引的指定元素
        System.out.println(arrayList.get(1));//123
        //输出集合的大小
        System.out.println(arrayList.size());   
        //删除元素remove() 可以指定下标 删除整数一般用下标删除
        arrayList.remove(0);
        //下标为1的元素会自动往前做补充 保证空间的连续性
       System.out.println(arrayList.get(0));//123
        //remove()根据确定的值删除
        arrayList.remove("123");
        System.out.println(arrayList.get(0));//abc
        // arrayList.remove(new Student());是错误的　是两个不同的对象
        
        //正确做法
        Student student=new Student();
        arrayList.add(student);
        arrayList.remove(student);
       
       //集合的遍历
       //for循环 size()获取集合的大小
        for(int i=0;i<arrayList.size();i++){
            System.out.println(arrayList.get(i));
        }
        System.out.println("===============");
        // 增强for循环
        //没有泛型的限制 所以用Object 表示可以存储任意数据类型
        //for(数据类型 对象名:要遍历的集合名称)
        for (Object list:arrayList
             ) {
            System.out.println(list);
        }
    }
}

remove()方法把给定的对象在当前集合中删除。

List的另一个实现类LinkedList

LinkedList的存储结构是链表插入和删除元素的效率高
在这里插入图片描述
1.public void addFirst(E e) :将指定元素插入此列表的开头。
2.public void addLast(E e) :将指定元素添加到此列表的结尾。
3.public E getFirst() :返回此列表的第一个元素。
4.public E getLast() :返回此列表的最后一个元素。
5.public E removeFirst() :移除并返回此列表的第一个元素。
6.public E removeLast() :移除并返回此列表的最后一个元素。
7.public E pop() :从此列表所表示的堆栈处弹出一个元素。
8.public void push(E e) :将元素推入此列表所表示的堆栈。
9.public boolean isEmpty() ：如果列表不包含元素，则返回true。
除可以使用List提供的方法外由于存储结构是链表所以有一些新的方法:

public class LinkedListTest {
    public static void main(String[] args) {
        LinkedList linkedList=new LinkedList();
        linkedList.add("abcdef");
        //addFirst() 往链表头部添加数据(数据类型任意 没有泛型的限制)
        linkedList.addFirst("abc");
        //addLast() 往链表尾部添加数据
        linkedList.addLast("abcd");
        //在尾部再添加一个数据
        linkedList.add("abcdefgh");
        //遍历
        for (Object object:linkedList){
            System.out.println(object);//abc abcdef  abcd abcdefgh
        }
         //删除元素 remove
        //removeFirst() 删除链表头部数据
        linkedList.removeFirst();
        System.out.println("=================");
        for (Object object:linkedList){
            System.out.println(object);//abcdef  abcd abcdefgh
        }
        linkedList.removeLast();
        System.out.println("=================");
        for (Object object:linkedList){
            System.out.println(object);//abcdef  abcd
        }
    }
}

Set子接口

Set接口存储一组唯一的,无序的对象 (无序数据不可重复)
HashSet是Set接口的常用实现类
Set接口中存放对象的引用(也就是地址)

HashSet实现类

public class HashSetTest {
    public static void main(String[] args) {
        Set set=new HashSet();
        String s1=new String("java");
        String s2=s1;//s1和s2指向同一个地址 所以值相同 只是对象名不同
        String s3=new String("JAVA");
        set.add(s1);
        set.add(s2);//添加不进去
        set.add(s3);
        //因为Set接口无序 但是元素不可重复 所以s2没有添加进去
        System.out.println(set.size());//2
    }
}

public class HashSetTest {
    public static void main(String[] args) {
        Set set=new HashSet();
        String s1=new String("java");
        String s2=s1;//s1和s2指向同一个地址 所以值相同 只是对象名不同
        String s3=new String("java");
        set.add(s1);
        set.add(s2);//添加不进去
        set.add(s3);//添加不进去
        //因为Set接口无序 但是元素不可重复 所以s2,s3没有添加进去
        System.out.println(set.size());//1
    }
}

public class HashSetTest {
    public static void main(String[] args) {
        Set set=new HashSet();
        String s1=new String("java");
        String s2=s1;//s1和s2指向同一个地址 所以值相同 只是对象名不同
        String s3=new String("JAVA");
        set.add(s1);
        set.add(s2);//添加不进去
        set.add(s3);
        //因为Set接口无序 但是元素不可重复 所以s2没有添加进去
        System.out.println(set.size());//2
        //使用equals()方法判断该数据是否已经存在在set集和中
        boolean b=s1.equals(s2);
        System.out.println(b);//true
        //添加一个布尔型的值
        set.add(true);
        //添加一个整数值
        set.add(1);
        //添加一个对象
        Student student=new Student();
        set.add(student);
      **//因为Set接口无序 所以不能按照下标添加数据**
    
    //size() 表示set集和的大小 千万记住重复的值不算进size()中
         System.out.println(set.size());//5

      //remove()删除元素 不能根据下标删除 只能根据具体的值删除
        set.remove(student);
        
        //set集合的遍历 迭代器遍历 iterator() 返回值类型是一个迭代器
        System.out.println("===========");
       Iterator iterator= set.iterator();
       //hasNext() 表示查找set集合中有没有下一个数据 返回值为true或者false
       while(iterator.hasNext()){
           //没有泛型的限制 所以用Object
           Object object=iterator.next();//获取到set集合中的单个数据
           System.out.println(object);//输出的结果是无序的
       }
       //从set集合当中获取单个数据是没有get()方法的 不能根据下标找值 因为set集和无序

//从set当中查找指定的值 JAVA
        Iterator i=set.iterator();
        while(i.hasNext()){
            Object object=i.next();
            if(object.equals("JAVA")){  //sb 这用equals()比较 想啥呢
                System.out.println(object);
            }
        }
    }
}