java集合学习笔记02

x33g5p2x  于2021-12-01 转载在 Java  
字(13.7k)|赞(0)|评价(0)|浏览(316)

关于Java Vector 类的讲解

Vector 类实现了一个动态数组。和 ArrayList 很相似,但是两者是不同的:

  • Vector 是同步访问的。

  • Vector 包含了许多传统的方法,这些方法不属于集合框架。

Vector 主要用在事先不知道数组的大小,或者只是需要一个可以改变大小的数组的情况。

Vector 类支持 4 种构造方法。

第一种构造方法创建一个默认的向量,默认大小为 10:Vector()

第二种构造方法创建指定大小的向量:Vector(int size)

第三种构造方法创建指定大小的向量,并且增量用 incr 指定。增量表示向量每次增加的元素数目:Vector(int size,int incr)

第四种构造方法创建一个包含集合 c 元素的向量:Vector(Collection c)

接下来回顾一下昨天的没有完成的ArrayList,今天重新整理了一下,昨天一开始不适合理解那个任务要求:

1:使用ArrayList

ArrayList追加元素耗时:5
ArrayList添加元素到任意位置耗时:1453
ArrayList之for 循环遍历;耗时:379
ArrayList之foreach耗时:796
ArrayList迭代器遍历耗时:782
ArrayList删除任意位置的元素耗时:1400
package 任务集合.ArrayLiat;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.Set;

/** * @author ${范涛之} * @Description * @create 2021-11-30 11:32 */
public class Test1 {

    public static void main(String[] args) {


        ArrayList<Integer> arrayList = new ArrayList<Integer>();
        Long start1 = System.currentTimeMillis();
        /** * 追加元素 */
        for (int i = 0; i <100000; i++) {
            arrayList.add(0);
        }
        Long end1 = System.currentTimeMillis();


        /** * 添加元素到任意位置 */
        Long start2 = System.currentTimeMillis();
        for (int i = 0; i <100000; i++) {
            arrayList.add(0,1);
        }
        Long end2 = System.currentTimeMillis();


        /** * for 循环遍历; */
        Long start3 = System.currentTimeMillis();
        for (int i = 0; i <100000; i++) {
            System.out.println(arrayList.get(i));
        }
        Long end3 = System.currentTimeMillis();



        /** * foreach循环遍历 */
        Long start4 = System.currentTimeMillis();
        for (int i:arrayList){
            System.out.println(i);
        }
        Long end4 = System.currentTimeMillis();

        /** * 使用迭代器遍历 */
        Long start5 = System.currentTimeMillis();
        Iterator iterator = arrayList.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        Long end5 = System.currentTimeMillis();


        /** * 删除任意位置的元素 */
        Long start6 = System.currentTimeMillis();
        for (int i = 0; i <100000; i++) {
            arrayList.remove(0);
        }
        Long end6 = System.currentTimeMillis();


        System.out.println("ArrayList追加元素耗时:"+(end1-start1));
        System.out.println("ArrayList添加元素到任意位置耗时:"+(end2-start2));
        System.out.println("ArrayList之for 循环遍历;耗时:"+(end3-start3));
        System.out.println("ArrayList之foreach耗时:"+(end4-start4));
        System.out.println("ArrayList迭代器遍历耗时:"+(end5-start5));
        System.out.println("ArrayList删除任意位置的元素耗时:"+(end6-start6));



    }
}

打印结果:

2:使用Vector

package 任务集合.Vector;

import java.util.Iterator;
import java.util.Vector;

/**
 * @author ${范涛之}
 * @Description
 * @create 2021-11-30 11:51
 */
public class Test1 {

    public static void main(String[] args) {

        Vector<Integer> vector = new Vector<Integer>();

        /**
         * 追加元素
         */
        Long start1 = System.currentTimeMillis();
        for (int i = 0; i <100000; i++) {
            vector.add(0);
        }
        Long end1 = System.currentTimeMillis();

        /**
         * 添加元素到任意位置
         */
        Long start2 = System.currentTimeMillis();
        for (int i = 0; i <100000; i++) {
            vector.add(0,1);
        }
        Long end2 = System.currentTimeMillis();

        /**
         *  for 循环遍历;
         */
        Long start3 = System.currentTimeMillis();
        for (int i = 0; i <100000; i++) {
            System.out.println(vector.get(i));
        }
        Long end3 = System.currentTimeMillis();

        /**
         * foreach循环遍历
         */
        Long start4 = System.currentTimeMillis();
        for (int i:vector){
            System.out.println(i);
        }
        Long end4 = System.currentTimeMillis();


        /**
         * 使用迭代器遍历
         */
        Long start5 = System.currentTimeMillis();
        Iterator iterator = vector.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        Long end5 = System.currentTimeMillis();

        /**
         * 删除任意位置的元素
         */
        Long start6 = System.currentTimeMillis();
        for (int i = 0; i <100000; i++) {
            vector.remove(0);
        }
        Long end6 = System.currentTimeMillis();


        System.out.println("vector追加元素耗时:"+(end1-start1));
        System.out.println("vectort添加元素到任意位置耗时:"+(end2-start2));
        System.out.println("vector之for 循环遍历;耗时:"+(end3-start3));
        System.out.println("vector之foreach耗时:"+(end4-start4));
        System.out.println("vector迭代器遍历耗时:"+(end5-start5));
        System.out.println("vector删除任意位置的元素耗时:"+(end6-start6));

    }
}

运行结果:

LinkedList:

package 任务集合.LinkList;

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

/** * @author ${范涛之} * @Description * @create 2021-11-30 19:47 */
public class Test1 {
    public static void main(String[] args) {

        LinkedList<Integer> list = new LinkedList<Integer>();
        Long start1 = System.currentTimeMillis();
        /** * 追加元素 */
        for (int i = 0; i <100000; i++) {
            list.add(0);
        }
        Long end1 = System.currentTimeMillis();

        /** * 添加元素到任意位置 */
        Long start2 = System.currentTimeMillis();
        for (int i = 0; i <100000; i++) {
            list.add(0,1);
        }
        Long end2 = System.currentTimeMillis();

        /** * for 循环遍历; */
        Long start3 = System.currentTimeMillis();
        for (int i = 0; i <100000; i++) {
            System.out.println(list.get(i));
        }
        Long end3 = System.currentTimeMillis();

        /** * foreach循环遍历 */
        Long start4 = System.currentTimeMillis();
        for (int i:list){
            System.out.println(i);
        }
        Long end4 = System.currentTimeMillis();

        /** * 使用迭代器遍历 */
        Long start5 = System.currentTimeMillis();
        Iterator iterator = list.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        Long end5 = System.currentTimeMillis();

        /** * 删除任意位置的元素 */
        Long start6 = System.currentTimeMillis();
        for (int i = 0; i <100000; i++) {
            list.remove(0);
        }
        Long end6 = System.currentTimeMillis();

        System.out.println(" LinkedList追加元素耗时:"+(end1-start1));
        System.out.println(" LinkedList添加元素到任意位置耗时:"+(end2-start2));
        System.out.println(" LinkedList之for 循环遍历;耗时:"+(end3-start3));
        System.out.println(" LinkedList之foreach耗时:"+(end4-start4));
        System.out.println(" LinkedList迭代器遍历耗时:"+(end5-start5));
        System.out.println(" LinkedList删除任意位置的元素耗时:"+(end6-start6));



    }

}

运行结果:

三次打印结果统计:

ArrayList追加元素耗时:5
ArrayList添加元素到任意位置耗时:1453
ArrayList之for 循环遍历;耗时:379
ArrayList之foreach耗时:796
ArrayList迭代器遍历耗时:782
ArrayList删除任意位置的元素耗时:1400

vector追加元素耗时:5
vectort添加元素到任意位置耗时:1458
vector之for 循环遍历;耗时:394
vector之foreach耗时:812
vector迭代器遍历耗时:812
vector删除任意位置的元素耗时:1466

LinkedList追加元素耗时:5
LinkedList添加元素到任意位置耗时:2
LinkedList之for 循环遍历;耗时:9137
LinkedList之foreach耗时:818
LinkedList迭代器遍历耗时:786
LinkedList删除任意位置的元素耗时:3

通过比较我们可以发现:

LinkList的for 循环遍历耗时是特别长的!但是LinkList的删除任意元素位置超级快!

分割线·······················································································

关于HashSet和TreeSet类的讲解:

Set 集合类似于一个罐子,程序可以依次把多个对象“丢进”Set 集合,而 Set 集合通常不能记住元素的添加顺序。也就是说 Set 集合中的对象不按特定的方式排序,只是简单地把对象加入集合。Set 集合中不能包含重复的对象,并且最多只允许包含一个 null 元素。

Set 实现了 Collection 接口,它主要有两个常用的实现类:HashSet 类和 TreeSet类。

HashSet 类:HashSet 是 Set 接口的典型实现,大多数时候使用 Set 集合时就是使用这个实现类。HashSet 是按照 Hash 算法来存储集合中的元素。因此具有很好的存取和查找性能。

HashSet 具有以下特点:

  • 不能保证元素的排列顺序,顺序可能与添加顺序不同,顺序也有可能发生变化。

  • HashSet 不是同步的,如果多个线程同时访问或修改一个 HashSet,则必须通过代码来保证其同步。

  • 集合元素值可以是 null。

HashSet hs = new HashSet();    // 调用无参的构造函数创建HashSet对象
HashSet<String> hss = new HashSet<String>();    // 创建泛型的 HashSet 集合对象

编写一个 Java 程序,使用 HashSet 创建一个 Set 集合,并向该集合中添加 4 套教程。具体实现代码如下:

public static void main(String[] args) {
    HashSet<String> courseSet = new HashSet<String>(); // 创建一个空的 Set 集合
    String course1 = new String("Java入门教程");
    String course2 = new String("Python基础教程");
    String course3 = new String("C语言学习教程");
    String course4 = new String("Golang入门教程");
    courseSet.add(course1); // 将 course1 存储到 Set 集合中
    courseSet.add(course2); // 将 course2 存储到 Set 集合中
    courseSet.add(course3); // 将 course3 存储到 Set 集合中
    courseSet.add(course4); // 将 course4 存储到 Set 集合中
    System.out.println("C语言中文网教程有:");
    Iterator<String> it = courseSet.iterator();
    while (it.hasNext()) {
        System.out.println("《" + (String) it.next() + "》"); // 输出 Set 集合中的元素
    }
    System.out.println("有" + courseSet.size() + "套精彩教程!");

如上述代码,首先使用 HashSet 类的构造方法创建了一个 Set 集合,接着创建了 4 个 String 类型的对象,并将这些对象存储到 Set 集合中。使用 HashSet 类中的 iterator() 方法获取一个 Iterator 对象,并调用其 hasNext() 方法遍历集合元素,再将使用 next() 方法读取的元素强制转换为 String 类型。最后调用 HashSet 类中的 size() 方法获取集合元素个数。

TreeSet 类:

TreeSet 类同时实现了 Set 接口和 SortedSet 接口。SortedSet 接口是 Set 接口的子接口,可以实现对集合进行自然排序,因此使用 TreeSet 类实现的 Set 接口默认情况下是自然排序的,这里的自然排序指的是升序排序。

TreeSet 只能对实现了 Comparable 接口的类对象进行排序,因为 Comparable 接口中有一个 compareTo(Object o) 方法用于比较两个对象的大小。例如 a.compareTo(b),如果 a 和 b 相等,则该方法返回 0;如果 a 大于 b,则该方法返回大于 0 的值;如果 a 小于 b,则该方法返回小于 0 的值。

表 1 列举了 JDK 类库中实现 Comparable 接口的类,以及这些类对象的比较方式。

TreeSet 类除了实现 Collection 接口的所有方法之外,还提供了如表 2 所示的方法。:

注意:表面上看起来这些方法很多,其实很简单。因为 TreeSet 中的元素是有序的,所以增加了访问第一个、前一个、后一个、最后一个元素的方法,并提供了 3 个从 TreeSet 中截取子 TreeSet 的方法。

本次有 5 名学生参加考试,当老师录入每名学生的成绩后,程序将按照从低到高的排列顺序显示学生成绩。此外,老师可以查询本次考试是否有满分的学生存在,不及格的成绩有哪些,90 分以上成绩的学生有几名:

public class Test08 {
    public static void main(String[] args) {
        TreeSet<Double> scores = new TreeSet<Double>(); // 创建 TreeSet 集合
        Scanner input = new Scanner(System.in);
        System.out.println("------------学生成绩管理系统-------------");
        for (int i = 0; i < 5; i++) {
            System.out.println("第" + (i + 1) + "个学生成绩:");
            double score = input.nextDouble();
            // 将学生成绩转换为Double类型,添加到TreeSet集合中
            scores.add(Double.valueOf(score));
        }
        Iterator<Double> it = scores.iterator(); // 创建 Iterator 对象
        System.out.println("学生成绩从低到高的排序为:");
        while (it.hasNext()) {
            System.out.print(it.next() + "\t");
        }
        System.out.println("\n请输入要查询的成绩:");
        double searchScore = input.nextDouble();
        if (scores.contains(searchScore)) {
            System.out.println("成绩为: " + searchScore + " 的学生存在!");
        } else {
            System.out.println("成绩为: " + searchScore + " 的学生不存在!");
        }
        // 查询不及格的学生成绩
        SortedSet<Double> score1 = scores.headSet(60.0);
        System.out.println("\n不及格的成绩有:");
        for (int i = 0; i < score1.toArray().length; i++) {
            System.out.print(score1.toArray()[i] + "\t");
        }
        // 查询90分以上的学生成绩
        SortedSet<Double> score2 = scores.tailSet(90.0);
        System.out.println("\n90 分以上的成绩有:");
        for (int i = 0; i < score2.toArray().length; i++) {
            System.out.print(score2.toArray()[i] + "\t");
        }
    }
}

如上述代码,首先创建一个 TreeSet 集合对象 scores,并向该集合中添加 5 个 Double 对象。接着使用 while 循环遍历 scores 集合对象,输出该对象中的元素,然后调用 TreeSet 类中的 contains() 方法获取该集合中是否存在指定的元素。最后分别调用 TreeSet 类中的 headSet() 方法和 tailSet() 方法获取不及格的成绩和 90 分以上的成绩。

------------学生成绩管理系统-------------
第1个学生成绩:
53
第2个学生成绩:
48
第3个学生成绩:
85
第4个学生成绩:
98
第5个学生成绩:
68
学生成绩从低到高的排序为:
48.0    53.0    68.0    85.0    98.0   
请输入要查询的成绩:
90
成绩为: 90.0 的学生不存在!

不及格的成绩有:
48.0    53.0   
90 分以上的成绩有:
98.0

自我小总结:总之就是你在录入信息的时候子系统就自动按照升序排列,然后合理根据需求调用对应的方法即可!上面的两个表便说明了一切!

开始任务:

hashset:

package 任务集合.HashSet;

import java.util.HashSet;
import java.util.Iterator;

/** * @author ${范涛之} * @Description * @create 2021-11-30 19:55 */
public class Test1 {

    public static void main(String[] args) {

        HashSet<Integer> hashSet = new HashSet<Integer>();

        /** * 追加元素 */
        Long start1 = System.currentTimeMillis();
        for (int i = 0; i <100000; i++) {
            hashSet.add(i);
        }
        Long end1 = System.currentTimeMillis();

        /** * foreach循环遍历 */
        Long start4 = System.currentTimeMillis();
        for (int i:hashSet){
            System.out.println(i);
        }
        Long end4 = System.currentTimeMillis();

        /** * 使用迭代器遍历 */
        Long start5 = System.currentTimeMillis();
        Iterator iterator = hashSet.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        Long end5 = System.currentTimeMillis();

        /** * 删除任意位置的元素 */
        Long start6 = System.currentTimeMillis();
        for (int i = 0; i <100000; i++) {
            hashSet.remove(0);
        }
        Long end6 = System.currentTimeMillis();

        System.out.println(" HashSet追加元素耗时:"+(end1-start1));
        System.out.println(" HashSet之foreach耗时:"+(end4-start4));
        System.out.println(" HashSet迭代器遍历耗时:"+(end5-start5));
        System.out.println(" HashSet删除任意位置的元素耗时:"+(end6-start6));



    }

}

运行结果:

HashSet追加元素耗时:10
 HashSet之foreach耗时:444
 HashSet迭代器遍历耗时:511
 HashSet删除任意位置的元素耗时:4

treeset:

package 任务集合.TreeSet;

import java.util.Iterator;
import java.util.TreeSet;

/** * @author ${范涛之} * @Description * @create 2021-11-30 20:13 */
public class Test1 {
    public static void main(String[] args) {

        TreeSet<Integer> treeSet = new TreeSet<Integer>();

        /** * 追加元素 */
        Long start1 = System.currentTimeMillis();
        for (int i = 0; i <100000; i++) {
            treeSet.add(i);
        }
        Long end1 = System.currentTimeMillis();

        /** * foreach循环遍历 */
        Long start4 = System.currentTimeMillis();
        for (int i:treeSet){
            System.out.println(i);
        }
        Long end4 = System.currentTimeMillis();

        /** * 使用迭代器遍历 */
        Long start5 = System.currentTimeMillis();
        Iterator iterator = treeSet.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        Long end5 = System.currentTimeMillis();

        /** * 删除任意位置的元素 */
        Long start6 = System.currentTimeMillis();
        for (int i = 0; i <100000; i++) {
            treeSet.remove(0);
        }
        Long end6 = System.currentTimeMillis();

        System.out.println(" HashSet追加元素耗时:"+(end1-start1));
        System.out.println(" HashSet之foreach耗时:"+(end4-start4));
        System.out.println(" HashSet迭代器遍历耗时:"+(end5-start5));
        System.out.println(" HashSet删除任意位置的元素耗时:"+(end6-start6));

    }
}

运行结果:

TreeSet追加元素耗时:22
TreeSet之foreach耗时:462
TreeSet迭代器遍历耗时:536
TreeSet删除任意位置的元素耗时:7

结果比较:

HashSet追加元素耗时:10
 HashSet之foreach耗时:465
 HashSet迭代器遍历耗时:517
 HashSet删除任意位置的元素耗时:3


TreeSet追加元素耗时:22
TreeSet之foreach耗时:462
TreeSet迭代器遍历耗时:536
TreeSet删除任意位置的元素耗时:7

Map:

Java中有四种常见的Map实现,HashMap,TreeMap,HashTable和LinkedHashMap,我们可以使用一句话来描述各个Map,如下:

  • HashMap:基于散列表实现,是无序的;

  • TreeMap:基于红黑树实现,按Key排序;

  • LinkedHashMap:保存了插入顺序;

  • Hashtable:是同步的,与HashMap类似;

package 任务集合.Map;

import java.util.HashMap;
import java.util.Iterator;

/** * @author ${范涛之} * @Description * @create 2021-11-30 20:18 */
public class HashMapTest {

    public static void main(String[] args) {

        HashMap<Integer, Integer> hashMap = new HashMap<>();
        /** * 添加键值对i与i的平方 */
        Long start1 = System.currentTimeMillis();
        for (int i =0;i<100000;i++){
            hashMap.put(i,i*i);
        }
        Long end1 = System.currentTimeMillis();

        /** * 替换键值对i与i的平方 */
        Long start2 = System.currentTimeMillis();
        for (int i =0;i<100000;i++){
            hashMap.put(i,-i);
        }
        Long end2 = System.currentTimeMillis();

        /** * entrySet进行遍历; */
        Long start3 = System.currentTimeMillis();
        System.out.println(hashMap.entrySet());
        Long end3 = System.currentTimeMillis();

        /** * keySet进行遍历; */
        Long start4 = System.currentTimeMillis();
        System.out.println(hashMap.keySet());
        Long end4 = System.currentTimeMillis();


        /** * values进行遍历; */
        Long start5 = System.currentTimeMillis();
        System.out.println(hashMap.values());
        Long end5 = System.currentTimeMillis();

        /** * 迭代器进行遍历; */
        Long start6 = System.currentTimeMillis();
        Iterator iterator = hashMap.entrySet().iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        Long end6 = System.currentTimeMillis();

        //删除十万对键值对
        Long start7 = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
            hashMap.remove(i);
        }
        Long end7 = System.currentTimeMillis();

        
        System.out.println(" HashMap添加键值对耗时:"+(end1-start1));
        System.out.println(" HashMap替换键值对耗时:"+(end2-start2));
        System.out.println(" HashSet通过entrySet进行遍历耗时:"+(end3-start3));
        System.out.println(" HashSet通过keySet进行遍历耗时:"+(end4-start4));
        System.out.println(" HashSet通过 values进行遍历耗时:"+(end5-start5));
        System.out.println(" HashSet通过迭代器进行遍历耗时:"+(end6-start6));
        System.out.println(" HashSet删除十万对键值对耗时:"+(end7-start7));



    }
}

输出结果:

其他三种方法类似,只需要修改名字即可!

相关文章

微信公众号

最新文章

更多

目录