ICode9
精准搜索请尝试： 精确搜索
首页
编程语言>
数据库
系统相关
互联网
其他分享
Python
Java
JavaScript
android
PHP
首页 > 编程语言> 文章详细

JAVA集合框架

2021-11-22 15:00:32  阅读：147  来源： 互联网

标签：JAVA 框架 list System collection println Student 集合 out


概述

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,框架,list,System,collection,println,Student,集合,out
来源： https://blog.csdn.net/qq_42076902/article/details/121471077

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

关于我们 | 联系我们 | 留言反馈

专注分享技术，共同学习，共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有