Java集合的Collection接口和List接口详解

目录
  • 1集合的概念
  • 2集合的父类Collection接口
    • 2.1常用方法
    • 2.2遍历
  • 3List接口
    • 3.1List接口常用方法
    • 3.2遍历
  • 4集合中元素的去重
  • 总结

1集合的概念

  • 把集合看做是一个容器,集合不是一个类,是一套集合框架,框架体系包含很多的集合类,java api提供了
  • 集合存储任意类型(基本包装类型,引用类型)
  • 集合对元素的增删查改操作起来非常方便的,专门提供很多方便操作的方法
  • 开发中经常集合来操作数据的,开发地位比较高的,考虑对数据的操作效率上的问题

2 集合的父类Collection接口

2.1常用方法

  • boolean add(E e) 添加某个元素
  • addAll(元素) 添加一个集合
  • remove(object) 删除一个元素
  • removeAll(collection) 删除一个集合
  • c.clear(); //移除所有
  • isEmpty() 判断是否为空
    public static void main(String[] args) {
        //创建集合
        Collection c = new ArrayList();
        //添加
        c.add("张三");
        c.add(10);
        c.add(false);
        c.add('a');
        System.out.println(c);
//        addAll(元素) 添加一个集合
        Collection c2 = new ArrayList();
        c2.add("hello");
        c2.add("world");
        c2.add("java");
        c.addAll(c2);
        System.out.println(c);
        //删除
        System.out.println("删除张三元素是否成功:" + c.remove("张三2"));
        System.out.println(c);
        c.removeAll(c2);
        System.out.println("移除c2集合:" + c);
        //清空和判断是否为空
//        c.clear(); //移除所有
//        System.out.println(c); //[]
        System.out.println(c.isEmpty()); //判断集合中的元素是否为空,为空返回true,否则false
        System.out.println(c.contains("张三222")); //是否包含某个指定的元素,是返回true,否则false
        System.out.println("获取集合中的元素个数:" + c.size()); //leng属性
    }

2.2遍历

  • 使用foreach 遍历
  • 使用迭代器遍历
  • 使用toArray()方法转成数组,再遍历.
  • 使用for遍历
    public static void main(String[] args) {
        Collection c = new ArrayList();
        c.add("张三");
        c.add("李四");
        c.add("王五");
        System.out.println(c);
        //foreach遍历方式
        System.out.println("-------------1");
        for(Object obj : c){
            System.out.println(obj);
        }
        //iterator方法,方式二
        System.out.println("-------------2");
        Iterator it = c.iterator();
        while(it.hasNext()){
            Object obj = it.next();
            System.out.println(obj);
        }
        System.out.println("-------------3");
        //方式三,toArray
        Object[] objs = c.toArray();
        for(Object o : objs){
            System.out.println(o);
        }
        System.out.println("-------------4");
        //方式四
        for(Iterator iterator  = c.iterator();iterator.hasNext();){
            Object obj = iterator.next();
            System.out.println(obj);
        }
        System.out.println("-------------5");
        for(Iterator iterator = c.iterator();iterator.hasNext(); System.out.println(iterator.next())){}

    }

3 List接口

List接口继承了Collection接口,所以Collection接口的方法List都可以使用.

3.1List接口常用方法

添加

  • boolean add(E e) 添加一个元素
  • void add(int index, E element) 添加某个元素到指定位置

boolean addAll(Collection<? extends E> c) 添加一个集合

  • boolean-addAll(int index, Collection<? extends E> c) 添加一个集合到指定位置

删除

  • E remove(int index) 删除指定位置的元素
  • boolean remove(Object o) 删除某个元素
  • boolean removeAll(Collection<?> c) 删除一个集合

修改

  • E set(int index, E element)

获取

  • E get(int index)
  • int size()
  • 其他
  • int indexOf(Object o)
  • int lastIndexOf(Object o)
  • List subList(int fromIndex, int toIndex)

3.2遍历

  • E get(int index) + int size()
  • ListIterator listIterator()
  • ListIterator listIterator(int index)

员工类:

package listdemo;
import java.util.Objects;
public class Employee {
    //员工属性, id name age salary
    private Integer id;
    private String name;
    private Integer age;
    private Double salary;
    public Employee() {
    }
    public Employee(Integer id, String name, Integer age, Double salary) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.salary = salary;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public Double getSalary() {
        return salary;
    }
    public void setSalary(Double salary) {
        this.salary = salary;
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Employee employee = (Employee) o;
        return Objects.equals(id, employee.id) &&
                Objects.equals(name, employee.name) &&
                Objects.equals(age, employee.age) &&
                Objects.equals(salary, employee.salary);
    }
    @Override
    public int hashCode() {
        return Objects.hash(id, name, age, salary);
    }
    @Override
    public String toString() {
        return "Employee{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", salary=" + salary +
                '}';
    }
}
public static void main(String[] args) {
        //创建一个list集合
        List list = new ArrayList();
        //添加的方法
        list.add("hello");
        list.add("java");
        list.add(1,"world"); //添加到指定的位置的元素,添加到第二个位置
        list.add("html");
        System.out.println(list);
        List list2 = new ArrayList();
        list2.add("test1");
        list2.add("test2");
        list2.add("test3");
//        list.addAll(list2); //添加一个集合
//        System.out.println(list);
        list.addAll(2,list2); //添加一个新集合到第一个老集合中指定的位置,下标为2
        System.out.println(list);
        //删除
        // *      boolean remove(Object o)
        System.out.println(list.remove("java"));
        System.out.println(list);
        // *      E remove(int index)
        Object obj = list.remove(1);
        System.out.println(obj); //world
        System.out.println(list);
        // *       boolean removeAll(Collection<?> c)
        list.removeAll(list2);
        System.out.println("删除新集合之后:" + list);
        //修改
        // *       E set(int index, E element)
        Object o = list.set(1, "编程语言");
        System.out.println(o);
        System.out.println("修改之后:" + list);
        // 其他
        // *       int indexOf(Object o) 从前面往后某个元素的位置
        // *       int lastIndexOf(Object o) 从后面往前面找某个元素的位置
        // *        List<E> subList(int fromIndex, int toIndex)
        List list3 = new ArrayList();
        list3.add("张三");
        list3.add("李四");
        list3.add("王五");
        list3.add("赵六");
        list3.add("小编");
        int i = list3.indexOf("李四2222");
        System.out.println("李四的位置:" + i);
        System.out.println("找王五的下标位置:" + list3.lastIndexOf("王五"));
        System.out.println(list3);
        List newsList = list3.subList(1, 4); //从老集合中截取1-3的位置的元素,并返回一个新的集合
        System.out.println(newsList); //1,2的位置的元素,3不包括,
    }

List的遍历

  • E get(int index) + int size()
  • ListIterator listIterator()
  • ListIterator listIterator(int index)
  • iterator();
  • toArray();
  • foreach
  • toString
  • for()
package listdemo;
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
/**
 *
 * 遍历
 *  *       E get(int index) + int size()
 *  *      ListIterator<E> listIterator()
 *  *      ListIterator<E> listIterator(int index)
 *          iterator();
 *          toArray();
 *          foreach
 *          toString
 *          for()
 *          for()
 *
 */
public class ListDemo02 {
    public static void main(String[] args) {
        //E get(int index) + int size()
        List list = new ArrayList();
        list.add("张三");
        list.add("李四");
        list.add("王五");
        ListIterator listIterator1 = list.listIterator(1);
        if (listIterator1.hasNext()){
            System.out.println("从第一个元素开始取出:" +listIterator1.next());
        }
        if (listIterator1.hasNext()){
            System.out.println("继续取下一个元素:" +listIterator1.next());
        }

        //size获取集合中元素的个数
        System.out.println(list.size());
        //get(索引)获取指定索引的元素
//        Object o = list.get(0);
//        System.out.println(o); //张三
//        o = list.get(1);
//        System.out.println(o); //李四
//        o = list.get(2);
//        System.out.println(o); //王五
        //以上出现重复,使用循环解决,结合size+get方法
        for (int i = 0; i < list.size(); i++) {
            Object o1 = list.get(i);
            System.out.println(o1);
        }
        List list2 = new ArrayList();
        list2.add("hello");
        list2.add("world");
        list2.add("java");
        ListIterator listIterator = list2.listIterator();//列表迭代器方法,返回迭代器对象
        //正向遍历
        while (listIterator.hasNext()) { //判断集合中是否有可取的下一个元素,如果有
            Object o = listIterator.next(); //取出第一个元素
            System.out.println(o);
        }
        System.out.println("------------------------");
        //逆序遍历,在使用hasPrevious(),previous(),先正序遍历才可以使用这个
        while(listIterator.hasPrevious()){
            Object obj = listIterator.previous();
            System.out.println(obj);
        }
    }
}

4 集合中元素的去重

package listdemo;
import java.util.ArrayList;
import java.util.List;
/**
 * 去除集合中重复的元素
 */
public class ListDemo03 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(new Employee(101,"张三",20,2000.0));
        list.add(new Employee(102,"李四",30,3000.0));
        list.add(new Employee(103,"王五",20,2000.0));
        list.add(new Employee(103,"王五",20,2000.0));
        //创建一个新的集合
		List newList = new ArrayList();
        for(Object obj : list){
            if (!newList.contains(obj)){
                newList.add(obj);
            }
        }
        list = newList; //把新集合的数据赋值给到老集合
        //遍历老集合
       for(Object obj : list){
           System.out.println(obj);
        }
        //第二种去除重复的方式
        //冒泡,选择,比较equlas
        //根据选择排序的思想,从第一个元素依次和后面的每一个元素
        for (int i = 0; i < list.size(); i++) {
            for (int j = i+1; j < list.size(); j++) {
                //进行比较,如果第一个元素和第二个元素是相等
                //把第二个元素删除
                if (list.get(i).equals(list.get(j))){
                    list.remove(j);
                    j--;
                }
            }
        }
        for(Object obj : list){
            System.out.println(obj);
        }
    }
}

总结

本篇文章就到这里了,希望能够给你带来帮助,也希望您能够多多关注我们的更多内容!

(0)

相关推荐

  • java中List接口与实现类介绍

    目录 List接口介绍-ArrayList ArrayList源码结论 ArrayList源码分析 总结 List接口介绍-ArrayList 有序.可重复 线程不安全,因为没有synchronized修饰 ArrayList源码结论 ArrayList中维护了一个Object类型的数组elementData. transient Object[] elementData; // transient 表示该属性不会被序列化 当创建ArrayList对象时,如果使用的是无参构造器,则初始eleme

  • Java Collection 接口和常用方法综合详解

    目录 1. Collection 接口实现类的特点 2. Collection 接口常用方法 3. Collection接口遍历元素方式1- 使用Iterator(迭代器) 4. Collection 接口遍历对象方式2- for 循环增强 5. 练习 1. Collection 接口实现类的特点 public interface Collection<E> extends Iterable<E> 1)Collection实现子类可以存放多个元素,每个元素可以是Object 2)有

  • Java中的List接口实现类解析

    目录 Java的List接口实现类 实现类ArrayList 实现类LinkedList 实现类Vector List三个实现类 Java的List接口实现类 实现类ArrayList ArrayList类相当于一个容量可变的动态数组,当超过了他的大小时,类集自动增加,当对象被删除后,数组就可以缩小. import java.util.*; public class ListDemo { public static void main(String args[]){ Collection c1

  • 深入浅出讲解Java集合之Collection接口

    目录 一.集合框架的概述 二.集合框架(Java集合可分为Collection 和 Map 两种体系) 三.Collection接口中的方法的使用 四.集合元素的遍历操作 A. 使用(迭代器)Iterator接口 B. jdk5.0新增foreach循环,用于遍历集合.数组 五.Collection子接口之一:List接口 List接口方法 ArrayList的源码分析: JDK 7情况下: JDK 8中ArrayList的变化: LinkedList的源码分析: Vector的源码分析: 六.

  • Java List接口的集合使用详解

    目录 ArrayList集合 LinkedList类 LinkedList与ArrayList的区别: 总结 List接口继承collection接口,此接口可以对列表中的每个元素精确的控制,可以根据元素的索引来获取列表中的值,下面介绍常用的几种,ArrayList,LinkedList. ArrayList集合 ArrayList是一个动态修改的数组,它没有固定的大小,不需要自己分配空间,java本身已经初始化容量为10的大小,可以直接添加删除等一系列操作. ArrayList构造方法: Ar

  • Java源码解析之接口Collection

    一.图示 二.方法定义 我们先想一想,公司如果要我们自己去封装一些操作数组或者链表的工具类,我么需要封装哪些功能呢?不妨就是统计其 大小,增删改查.清空或者是查看否含有某条数据等等.而collection接口就是把这些通常操作提取出来,使其更全面.更通用,那现在我们就来看看其源码都有哪些方法. //返回集合的长度,如果长度大于Integer.MAX_VALUE,返回Integer.MAX_VALUE int size(); //如果集合元素总数为0,返回true boolean isEmpty(

  • Java集合框架之List ArrayList LinkedList使用详解刨析

    目录 1. List 1.1 List 的常见方法 1.2 代码示例 2. ArrayList 2.1 介绍 2.2 ArrayList 的构造方法 2.3 ArrayList 底层数组的大小 3. LinkedList 3.1 介绍 3.2 LinkedList 的构造方法 4. 练习题 5. 扑克牌小游戏 1. List 1.1 List 的常见方法 方法 描述 boolean add(E e) 尾插 e void add(int index, E element) 将 e 插入到 inde

  • Java集合框架之Stack Queue Deque使用详解刨析

    目录 1. Stack 1.1 介绍 1.2 常见方法 2. Queue 2.1 介绍 2.2 常见方法 3. Deque 3.1 介绍 3.2 常见方法 1. Stack 1.1 介绍 Stack 栈是 Vector 的一个子类,它实现了一个标准的后进先出的栈.它的底层是一个数组. 堆栈只定义了默认构造函数,用来创建一个空栈.堆栈除了包括由 Vector 定义的所有方法,也定义了自己的一些方法. 1.2 常见方法 方法 描述 E push(E item) 压栈 E pop() 出栈 E pee

  • Java集合框架源码分析之LinkedHashMap详解

    LinkedHashMap简介 LinkedHashMap是HashMap的子类,与HashMap有着同样的存储结构,但它加入了一个双向链表的头结点,将所有put到LinkedHashmap的节点一一串成了一个双向循环链表,因此它保留了节点插入的顺序,可以使节点的输出顺序与输入顺序相同. LinkedHashMap可以用来实现LRU算法(这会在下面的源码中进行分析). LinkedHashMap同样是非线程安全的,只在单线程环境下使用. LinkedHashMap源码剖析 LinkedHashM

  • Java集合中的fail-fast(快速失败)机制详解

    简介 我们知道Java中Collection接口下的很多集合都是线程不安全的, 比如 java.util.ArrayList不是线程安全的, 因此如果在使用迭代器的过程中有其他线程修改了list,那么将抛出ConcurrentModificationException,这就是所谓fail-fast策略. 这一策略在源码中的实现是通过 modCount 域,modCount 顾名思义就是修改次数,对ArrayList 内容的修改都将增加这个值,那么在迭代器初始化过程中会将这个值赋给迭代器的 exp

  • Java集合之Map接口与实现类详解

    目录 初识Map Map中常用方法 HashMap LinkedHashMap TreeMap HashMap和TreeMap的比较 Hashtable 集合中元素的遍历 iterator接口中的方法 Enumeration接口中的方法 初识Map Map接口没有从Collection接口继承,Map接口用于维护“键-值”对数据,这个“键-值”对就是Map中的元素,Map提供“键(Key)”到“值(value)”的映射,一个Map中键值必须是唯一的,不能有重复的键,因为Map中的“键-值”对元素

  • Java Map接口概述和常用方法详解

    目录 概述 Map常用子类 Map接口中的常用方法 Map集合遍历键找值方式 Entry键值对对象 Map集合遍历键值对方式 概述 现实生活中,我们常会看到这样的一种集合:IP地址与主机名,身份证号与个人,系统用户名与系统用户对象等,这种一一对应的关系,就叫做映射.Java提供了专门的集合类用来存放这种对象关系的对象,即java.util.Map接口. 我们通过查看Map接口描述,发现Map接口下的集合与Collection接口下的集合,它们存储数据的形式不同,如下图. Collection中的

  • Java接口和抽象类原理详解

    这篇文章主要介绍了Java接口和抽象类原理详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 对于面向对象编程来说,抽象是它的一大特征之一.在Java中,可以通过两种形式来体现OOP的抽象:接口和抽象类.这两者有太多相似的地方,又有太多不同的地方.很多人在初学的时候会以为它们可以随意互换使用,但是实际则不然.今天我们就一起来学习一下Java中的接口和抽象类.下面是本文的目录大纲: 一.抽象类 在了解抽象类之前,先来了解一下抽象方法.抽象方法是一

  • java面向对象设计原则之接口隔离原则示例详解

    目录 概念 实现 拓展 概念 小接口原则,即每个接口中不存在子类用不到却必须实现的方法,如果不然,就要将接口拆分.如下图所示定义了一个接口,包含了5个方法,实现类A用到了3个方法.实现类B用到了3个方法,类图如下: 类A没有方法4.方法5,却要实现它:类B没有方法2.方法3,但还是要实现这两个方法,不符合接口隔离原则.改造为将其拆分为三个接口,实现方式改为下图所示,符合接口隔离原则: 实现 面向对象机制中一个类可以实现多个接口,通过多重继承分离,通过接口多继承(实现)来实现客户的需求,代码更加清

随机推荐