[17]-容器(集合)_Collection_List接口_ArrayList_LinkedList_Vector

最新推荐文章于 2021-10-18 16:22:56 发布

SIayer

最新推荐文章于 2021-10-18 16:22:56 发布

阅读量169

点赞数

分类专栏：我和java的故事从2020重新开始

本文链接：https://blog.csdn.net/SIayer/article/details/104881886

版权

我和java的故事从2020重新开始专栏收录该内容

39 篇文章 0 订阅

订阅专栏

为什么需要容器?

因为数组不满足需要

理由

因为数组的长度一旦创建,不可改变,所以数组有局限性,不能广泛的使用

要点:

集合只能存储对象(即引用数据类型)

接口框架

Java集合框架提供了一套性能优良、使用方便的接口和类，它们位于java.util包中

存放在集合中的数据，被称为元素(element)

在这里插入图片描述
为什么集合要分这么多接口呢:

因为底层的数据接口不同所以需要不同的接口来对应实现

(底层数据结构:有序,无序)

接口特点

Collection接口

存储一组不唯一，无序的对象

List接口:

存储一组不唯一,有序(索引顺序)的对象

Set接口:

存储一组唯一 ,无序的对象

List接口_ArrayList_用法(API)

List接口有序,不唯一(java.util)

ArrayList 底层数据结构是数组

优点:遍历数组比较快
缺点:删除和添加元素效率比较低

每次扩容0.5倍

(1)添加元素

list1.add("Hello");

(2)查看集合中元素的个数 size()

list1.size()

(3)查看集合是否为空

list1.isEmpty()

(4)将指定元素对象添加到当前集合中 addAll(Collection c)

List list1 = new ArrayList<>();
//(1)添加元素 add(Object obj)
       list1.add("Hello");
       list1.add(123);//自动装箱 Integer类型
  List list2 = new ArrayList<>();
        list2.add("hello");
        list2.add(456);
        list1.addAll(list2);
        System.out.println("重新查看list1中的元素个数:"+list1.size());
        System.out.println("查看list集合中的元素:"+list1);

(5)删除元素 (对象&索引两种方式从左到右第一个)

list1.remove("hello")

System.out.println("根据对象删除元素:"+list1.remove("hello"));
//删除123
 System.out.println("根据索引来删除:"+list1.remove(0));
//list1.remove(123) 会报错,原因是超出边界,因为编译器会认为是删除索引
list1.remove(new Integer(123));//此处为正确方式
 //删除 a 集合中所有 b集合里包含的内容 list1[hello,123,world] list2[hello,123]
 list1.remove(list2);//执行后 只剩下 list1[world]
//删除 两个集合中不同的元素
  list1.retainAll(list2);

(6)判断指定元素在集合中是否存在(返回boolean类型结果 true/false

  System.out.println("hello在集合中是否存在:"+list1.contains("hello"));
//判断集合1是否包含集合2全部元素(返回boolean类型结果 true/false
    System.out.println("判断集合1是否包含集合2全部元素"+list1.containsAll(list2));

(7)清空集合内所有元素对象

list1.clear();

(8)获取指定索引位置上的元素对象

 list1.get(1);

(9)将指定索引位置上的元素对象设置成新对象

  list1.set(1,"java");

(10)在指定的位置上添加

list1.add(1,"html");

(11)查找元素在集合中的位置 (左到右第一个元素对象) 没有为-1

list1.indexOf("java");

(12)遍历集合中所有的内容

12.1 使用加强for循环去遍历集合中的元素

 System.out.println("使用加强for循环去遍历集合中的元素");
   for (Object obj : list1) {
   System.out.println(obj);
    }

12.2 使用普通for循环遍历

 System.out.println("使用普通for循环遍历");
      for (int i = 0; i < list1.size(); i++) {
        System.out.println(list1.get(i));//get 根据索引去获取对象
     }

12.3.1 使用迭代器遍历(正向遍历)

 Iterator ite = list1.iterator(); //正向遍历
    while (ite.hasNext()){//判断集合中是否有元素对象
        Object obj = ite.next();//自动进行了向上类型转换
        System.out.println(obj);
  }

12.3.2 使用迭代器遍历(逆向遍历)

System.out.println("使用listIterator()逆向遍历");
ListIterator listIterator = list1.listIterator();
 System.out.println("正向遍历");//原理:先看看集合中的元素有那些再进行逆向遍历
 System.out.println("在集合开头,后面还有元素吗"+listIterator.hasNext());
 System.out.println("在集合开头,前面还有元素吗"+listIterator.hasPrevious());
    while (listIterator.hasNext()){
           System.out.println(listIterator.next());
     }
  System.out.println("到达集合末尾,后面还有元素吗"+listIterator.hasNext());
  System.out.println("到达集合末尾,前面还有元素吗"+listIterator.hasPrevious());
  System.out.println("逆向遍历集合中的元素");
     while (listIterator.hasPrevious()){
         System.out.println(listIterator.previous());
    }

package com.lin.list;

import java.util.*;

public class TestArrayList {
    public static void main(String[] args) {
        //创建集合对象  接口 new 实现类
        List list1 = new ArrayList<>();

        //(1)添加元素 add(Object obj)
        list1.add("Hello");
        list1.add(123);//自动装箱 Integer类型
        list1.add(new Scanner(System.in));

        //(2)查看集合中元素的个数 size()
        System.out.println(list1.size());

        //(3)查看集合是否为空
        System.out.println("查看集合是否为空:"+list1.isEmpty());

        //(4)将指定元素对象添加到当前集合中 addAll(Collection c)
        List list2 = new ArrayList();
        list2.add("hello");
        list2.add(456);
        list1.addAll(list2);
        System.out.println("重新查看list1中的元素个数:"+list1.size());
        System.out.println("查看list集合中的元素:"+list1);

        //(5)删除元素 (对象&索引两种方式 从左到右第一个)
        System.out.println("根据对象删除元素:"+list1.remove("hello"));
        //删除123
        System.out.println("根据索引来删除:"+list1.remove(0));
        //list1.remove(123) 会报错,原因是超出边界,因为编译器会认为是删除索引
        list1.remove(new Integer(123));//此处为正确方式
        //删除 a 集合中所有 b集合里包含的内容 list1[hello,123,world] list2[hello,123]
        list1.remove(list2);//执行后 只剩下 list1[world]
        //删除 两个集合中不同的元素
        list1.retainAll(list2);

        //(6)判断 指定元素在集合中是否存在(返回boolean类型结果 true/false
        System.out.println("hello在集合中是否存在:"+list1.contains("hello"));
        //判断集合1是否包含集合2全部元素(返回boolean类型结果 true/false
        System.out.println("判断集合1是否包含集合2全部元素"+list1.containsAll(list2));

        //(7)清空集合内所有元素对象
        list1.clear();

        //(8)获取指定索引位置上的元素对象
        System.out.println("获取索引位置为1的对象"+list1.get(1));

        //(9)将指定索引位置上的元素对象设置成新对象
        list1.set(1,"java");

        //(10)在指定的位置上添加
        list1.add(1,"html");

        //(11)查找元素在集合中的位置 (左到右第一个元素对象) 没有为-1
        list1.indexOf("java");

        //(12)遍历集合中所有的内容

        //12.1 使用加强for循环去遍历集合中的元素
        System.out.println("使用加强for循环去遍历集合中的元素");
        for (Object obj : list1) {
            System.out.println(obj);
        }
        //12.2 使用普通for循环遍历
        System.out.println("使用普通for循环遍历");
        for (int i = 0; i < list1.size(); i++) {
            System.out.println(list1.get(i));//get 根据索引去获取对象
        }

        //12.3 使用迭代器遍历
        Iterator ite = list1.iterator(); //正向遍历
        while (ite.hasNext()){//判断集合中是否有元素对象
            Object obj = ite.next();//自动进行了向上类型转换
            System.out.println(obj);
        }
        System.out.println("使用listIterator()逆向遍历");
        ListIterator listIterator = list1.listIterator();
        System.out.println("正向遍历");//原理:先看看集合中的元素有那些再进行逆向遍历
        System.out.println("在集合开头,后面还有元素吗"+listIterator.hasNext());
        System.out.println("在集合开头,前面还有元素吗"+listIterator.hasPrevious());
        while (listIterator.hasNext()){
            System.out.println(listIterator.next());
        }
        System.out.println("到达集合末尾,后面还有元素吗"+listIterator.hasNext());
        System.out.println("到达集合末尾,前面还有元素吗"+listIterator.hasPrevious());
        System.out.println("逆向遍历集合中的元素");
        while (listIterator.hasPrevious()){
            System.out.println(listIterator.previous());
        }

    }
}

在这里插入图片描述

List接口LinkList用法(API)

List接口有序,不唯一(java.util)
LinkedList 底层数据结构是链表
优点:删除和添加元素的效率比较高
缺点:数据结构复杂分为单向链表和双向链表
在这里插入图片描述
LinkedList -API 与ArrayList 相同,就多了一下的方法

LinkedList list = new LinkedList();
        //添加
        list.add("hello");//添加元素
        list.addFirst("java");//在集合元素头部添加元素
        list.addLast("world");//在集合元素尾部添加元素

        //删除
       /* list.removeFirst();//删除头元素
        list.removeLast();//删除尾元素*/

        //遍历与ArrayList一致
        for (Object o : list) {
            System.out.println(o);
        }

在这里插入图片描述

List接口_Vector_用法(API)

List接口有序,不唯一(java.util)
API用法与ArrayList相同
底层数据结构与ArrayList相同都是 Object 类型的数组
Vector 与 ArrayList 的区别 :

(1)

Vector 的 add()方法是同步方法

ArrayList 的 add() 方法是非同步方法

(2)

Vector 扩容每次扩充 1 倍 ,

ArrayList 每次扩充 0.5 倍

(3)

Vector 是在调用构造方法时，直接初始化容量为 10，

ArrayList 是在第一次调用添加方法时，初始化容量为 10

(4)

Vector 的版本是 JDK1.0,

ArrayList，JDK1.2 版

(5)

Vector 是线程同步的，安全性高，效率低，

ArrayList 是线程非同步的，安全性低，效率高

public static void main(String[] args) {
    //创建了集合对象
    Vector vector=new Vector();
    System.out.println(vector.capacity()+"\t集合中元素的个数:"+vector.size());
    //ArrayList al=new ArrayList();
    //al.add("hello");
    //添加
    vector.add("hello");
    vector.add(0, "world");
    vector.addElement("java"); //添加元素
    
    System.out.println(vector.capacity()+"\t集合中元素的个数:"+vector.size());
    System.out.println("集合中元素的个数:"+vector.size());
    System.out.println(vector);
    //删除
    //vector.remove(1);
    //vector.remove("java");
    //vector.clear();
    //vector.removeElement("java");
    //获取元素的方法
    System.out.println(vector.get(1));
    
    System.out.println(vector);
    System.out.println("加强for循环");
    for(Object obj:vector){
      System.out.println(obj);
    }
    System.out.println("使用迭代器遍历集合:");
    for(Iterator ite=vector.iterator();ite.hasNext();){
      System.out.println(ite.next());
    }
    
    Iterator ite=vector.iterator(); 
    while(ite.hasNext()){
      System.out.println(ite.next());
    }
  }
}

在这里插入图片描述

SIayer

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
[17]-容器(集合)_Collection_List接口_ArrayList_LinkedList_Vector

为什么需要容器?因为数组不满足需要理由因为数组的长度一旦创建,不可改变,所以数组有局限性,不能广泛的使用要点:集合只能存储对象(即引用数据类型)接口框架Java集合框架提供了一套性能优良、使用方便的接口和类，它们位于java.util包中存放在集合中的数据，被称为元素(element)为什么集合要分这么多接口呢:因为底层的数据接口不同所以需要不同的接口来对应实现(底层数据结...
复制链接

扫一扫