JAVA集合框架

本文主要是介绍JAVA集合框架，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

概述

1.集合：对象的容器，定义了对多个对象进行操作的常用方法。可以实现数组的功能。
2.和数组的区别：
1>数据长度固定，集合长度不固定
2>数组可以存储基本类型和引用类型，集合只能存储引用类型

Collection体系集合
在这里插入图片描述

Collection父接口

特点：代表一组任意类型的对象，无需、无下标、不能重复。
方法：
在这里插入图片描述
学生类代码：

package Collections;

import java.util.Objects;

//学生类
public class Student {
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }

}

不含构造方法的代码测试：

package Collections;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

//collection接口的使用
/*1.添加元素
2.删除元素
3.遍历元素
4.判断*/
public class Demo01 {
    public static void main(String[] args) {
//        创建集合
        Collection collection=new ArrayList();
//        1.添加元素
        collection.add("苹果");
        collection.add("西瓜");
        collection.add("榴莲");
        System.out.println("元素个数"+collection.size());
        System.out.println(collection);
//        2.删除元素
        collection.remove("榴莲");
        System.out.println(collection);
//        collection.clear();//清空元素
//        3.遍历元素
//        3.1 使用增强for
        for (Object o : collection) {
            System.out.println(o);
        }
//        3.2使用迭代器，专门用来遍历集合的一种方式
//        hasNext();有没有下一个元素
//        next();获取下一个元素
//        remove()删除当前元素
        Iterator it=collection.iterator();
        while (it.hasNext()){
//            在迭代过程中不能使用collection其他方法
            String obj = (String)it.next();
            System.out.println(obj);
            //it.remove();//迭代器提供的方法
        }
        System.out.println(collection.size());
//        4.判断
        System.out.println(collection.contains("西瓜"));
        System.out.println(collection.isEmpty());
    }
}

含构造方法的代码测试：

package Collections;


import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

//collection接口的使用:保存学生的信息
public class Demo02 {
    public static void main(String[] args) {
//        新建Collection对象
        Collection collection = new ArrayList();
        Student s1 = new Student("uzi", 22);
        Student s2 = new Student("ming", 23);
        Student s3 = new Student("doinb", 25);
//        1.添加数据
        collection.add(s1);
        collection.add(s2);
        collection.add(s3);
        System.out.println("元素个数" + collection.size());
        System.out.println(collection.toString());
//        2.删除
        collection.remove(s3);
        System.out.println("删除之后" + collection.size());
//        collection.clear();//删除集合中的内存地址，并不能删除已经创建的对象
//        3.遍历
//        第一种
        for (Object o : collection) {
            Student s=(Student) o;//强制类型转换
            System.out.println(s.toString());
        }
//        第二种
        Iterator it=collection.iterator();
        while (it.hasNext()){
            Student s=(Student)it.next();//强制类型转换
            System.out.println(s.toString());
        }
//        4.判断
        System.out.println(collection.contains(s1));
        System.out.println(collection.isEmpty());
    }
}

List子接口

特点：有序、有下标、元素可以重复
方法：
在这里插入图片描述
代码测试：

package Collections;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

//List子接口的使用
//特点1.有序有下标 2.可以重复
public class Demo03 {
    public static void main(String[] args) {
//        创建集合对象
        List list=new ArrayList();
//        1.添加元素
        list.add("苹果");
        list.add("小米");
        list.add("华为");
        System.out.println("元素个数"+list.size());
        System.out.println(list.toString());
//        2.删除元素
        list.remove("苹果");//相当于list.remove(0);
        System.out.println("元素个数"+list.size());
        System.out.println(list.toString());
//        list.clear();//清空
//        3.遍历
//        第一种for
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
//        第二种增强for
        for (Object o : list) {
            System.out.println(o);
        }
//        第三种使用迭代器
        Iterator it=list.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
//        第四种列表迭代器，和Iterator区别，ListIterator可以向前向后遍历，也可以添加删除修稿元素
        ListIterator lit=list.listIterator();
        while (lit.hasNext()){
            System.out.println(lit.nextIndex()+":"+lit.next());
        }
        System.out.println("==========================");
        while (lit.hasPrevious()){
            System.out.println(lit.previousIndex()+":"+lit.previous());
        }
//        4.判断
        System.out.println(list.contains("苹果"));
        System.out.println(list.isEmpty());
//        5.获取位置
        System.out.println(list.indexOf("华为"));
    }
}

List数字数据测试：

package Collections;

import java.util.ArrayList;
import java.util.List;

public class Demo04 {
    public static void main(String[] args) {
        List list=new ArrayList();
//        添加数字数据,(自动装箱)
        list.add(10);
        list.add(20);
        list.add(30);
        list.add(40);
        list.add(50);
        System.out.println("元素个数"+list.size());
        System.out.println(list.toString());
//        2.删除操作
        list.remove(0);
//        list.remove(new Integer(20));//和上边相同，相当于拆箱
//        3.补充方法subList,返回子集合,含头不含尾
        List subList=list.subList(1,3);
        System.out.println(subList.toString());
    }
}

ArrayList【重点】

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

默认容量：DEFAULT_CAPACITY=10，如果没有向集合中添加任何元素时，容量为0，添加任意一个容量变为10，再添加元素时会每次扩容5个元素

代码测试：

package Collections;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;

//ArrayList 的使用
//数组结构实现，查询快，增删慢
public class Demo05 {
    public static void main(String[] args) {
//        创建集合：size 0  容量 0
        ArrayList arrayList=new ArrayList();
//        1.添加元素
        Student s1 = new Student("uzi", 22);
        Student s2 = new Student("ming", 25);
        Student s3 = new Student("rookie", 26);
        Student s4 = new Student("xiaohu", 22);
        arrayList.add(s1);
        arrayList.add(s2);
        arrayList.add(s3);
        arrayList.add(s4);
        System.out.println("元素个数"+arrayList.size());
        System.out.println(arrayList.toString());
//        2.删除元素
//        arrayList.remove(s1);
//        arrayList.remove(0);
        arrayList.remove(new Student("uzi", 22));//重写equals方法,和上边两个效果相同
        System.out.println(arrayList.toString());
//        3.遍历元素
//        1.迭代器
        Iterator it=arrayList.iterator();
        while (it.hasNext()){
            Student s=(Student) it.next();
            System.out.println(s);
        }
        System.out.println("==========================");
//        2.列表迭代器
        ListIterator lit=arrayList.listIterator();
        while (lit.hasNext()){
            Student s=(Student) lit.next();
            System.out.println(s.toString());
        }

//        4.判断
        System.out.println(arrayList.contains(new Student("xiaohu",22)));
    }
}

Vector

数组结构实现，查询快，增删慢,线程安全

迭代的关键字变成了枚，遍历使用枚举器

测试代码：

package Collections;

import java.util.Enumeration;
import java.util.Vector;

//vector集合的使用
//村树结构，数组
public class Demo06 {
    public static void main(String[] args) {
//    创建集合
        Vector vector=new Vector();
//        1.添加元素
        vector.add("草莓");
        vector.add("苹果");
        vector.add("桃子");
        vector.add("葡萄");
        System.out.println("元素个数"+vector.size());
//        2.删除
        vector.remove(0);
//        vector.clear();
//          3.遍历，使用枚举器
        Enumeration en=vector.elements();
        while (en.hasMoreElements()){
            String o= (String) en.nextElement();
            System.out.println(o);
        }
        //    4.判断
        System.out.println( vector.contains("桃子"));
        System.out.println(vector.isEmpty());
//            5.其他方法
        vector.firstElement();//第一个元素
        vector.lastElement();//最后一个元素
        vector.elementAt(0);//索引
    }
}

LinkedList

链表结构实现，增删快，查询慢
测试代码实现：

package Collections;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.ListIterator;

//LinkedList的使用
//存储结构，双向链表
public class Demo07 {
    public static void main(String[] args) {
//        1.创建集合
        LinkedList linkedList=new LinkedList();
//        2.添加元素
        Student s1 = new Student("uzi", 22);
        Student s2 = new Student("ming", 25);
        Student s3 = new Student("rookie", 26);
        Student s4 = new Student("xiaohu", 22);
        linkedList.add(s1);
        linkedList.add(s2);
        linkedList.add(s3);
        linkedList.add(s4);
        System.out.println("元素个数"+linkedList.size());
        System.out.println(linkedList.toString());
//        3.删除元素
        linkedList.remove(s2);
        System.out.println(linkedList.toString());
//        linkedList.clear();
//        4.遍历
//        4.1for
        for (int i = 0; i < linkedList.size(); i++) {
            System.out.println(linkedList.get(i));
        }
        System.out.println("=====================");
//        4.2加强for
        for (Object o : linkedList) {
            Student s=(Student)o;
            System.out.println(s);
        }
        System.out.println("=====================");
//        4.3迭代器
        Iterator it=linkedList.listIterator();
        while (it.hasNext()){
            Student s=(Student) it.next();
            System.out.println(s.toString());
        }
//        4.4功能强大的迭代器,列表迭代器
        ListIterator lit = linkedList.listIterator();
        while (lit.hasNext()){
            Student s=(Student) lit.next();
            System.out.println(s.toString());
        }
//        5.判断
        System.out.println(linkedList.isEmpty());
        System.out.println(linkedList.contains(s2));
//        6.获取
        System.out.println(linkedList.indexOf(s4));
    }
}

PS：

迭代器分为Iterator和ListIterator两种，一般来说ListIterator提供的方法更多，更好用。
枚举提供了遍历Vector和HashTable类型集合元素的功能。

这篇关于JAVA集合框架的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

Java教程

JAVA集合框架

概述

Collection父接口

List子接口

ArrayList【重点】

Vector

LinkedList

前端开发

后端开发

移动端开发

数据库

服务器运维

人工智能

区块链

游戏开发

网站运营

大数据/云计算

软件工程

软件/开发工具使用

资讯