java的复习 ->集合

最新推荐文章于 2024-07-07 20:37:02 发布
最新推荐文章于 2024-07-07 20:37:02 发布
阅读量159 收藏
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42787251/article/details/90034753
版权

List , Set, Map都是接口，前两个继承至collection接口，Map为独立接口
Set下有HashSet，LinkedHashSet，TreeSet
List下有ArrayList，Vector，LinkedList
Map下有Hashtable，LinkedHashMap，HashMap，TreeMap
collection接口下还有个Queue接口，有PriorityQueue类

注意:
Queue接口与List、Set同一级别，都是继承了collection接口。
看图你会发现,LinkedList既可以实现Queue接口,也可以实现List接口.只不过呢, LinkedList实现了Queue接口。Queue接口窄化了对LinkedList的方法的访问权限（即在方法中的参数类型如果是Queue时，就完全只能访问Queue接口所定义的方法 了，而不能直接访问 LinkedList的非Queue的方法），以使得只有恰当的方法才可以使用。

SortedSet是个接口，它里面的（只有TreeSet这一个实现可用）中的元素一定是有序的。

总结:
connection接口(注意首字母小写):
— List 有序,可重复

ArrayList
优点: 底层数据结构是数组，查询快，增删慢。
缺点: 线程不安全，效率高
Vector
优点: 底层数据结构是数组，查询快，增删慢。
缺点: 线程安全，效率低
LinkedList
优点: 底层数据结构是链表，查询慢，增删快。
缺点: 线程不安全，效率高
—Set 无序,唯一

HashSet
底层数据结构是哈希表。(无序,唯一)
如何来保证元素唯一性?
1.依赖两个方法：hashCode()和equals()

LinkedHashSet
底层数据结构是链表和哈希表。(FIFO插入有序,唯一)
1.由链表保证元素有序
2.由哈希表保证元素唯一

TreeSet
底层数据结构是红黑树。(唯一，有序)

  1. 如何保证元素排序的呢?
    自然排序
    比较器排序
    2.如何保证元素唯一性的呢?
    根据比较的返回值是否是0来决定

针对collection集合我们到底使用谁呢?(掌握)

唯一吗?

是：Set

排序吗?

是：TreeSet或LinkedHashSet
否：HashSet
如果你知道是Set，但是不知道是哪个Set，就用HashSet。

否：List

要安全吗?

是：Vector
否：ArrayList或者LinkedList

查询多：ArrayList
增删多：LinkedList
如果你知道是List，但是不知道是哪个List，就用ArrayList。

如果你知道是collection集合，但是不知道使用谁，就用ArrayList。
如果你知道用集合，就用ArrayList。

说完了collection,来简单说一下Map.

Map接口:
上图:

Map接口有三个比较重要的实现类，分别是HashMap、TreeMap和HashTable。

TreeMap是有序的，HashMap和HashTable是无序的。
Hashtable的方法是同步的，HashMap的方法不是同步的。这是两者最主要的区别。
这就意味着:

Hashtable是线程安全的，HashMap不是线程安全的。
HashMap效率较高，Hashtable效率较低。
如果对同步性或与遗留代码的兼容性没有任何要求，建议使用HashMap。 查看Hashtable的源代码就可以发现，除构造函数外，Hashtable的所有 public 方法声明中都有 synchronized关键字，而HashMap的源码中则没有。
Hashtable不允许null值，HashMap允许null值（key和value都允许）
父类不同：Hashtable的父类是Dictionary，HashMap的父类是AbstractMap
重点问题重点分析:
(一).TreeSet, LinkedHashSet and HashSet 的区别

  1. 介绍

TreeSet, LinkedHashSet and HashSet 在java中都是实现Set的数据结构
TreeSet的主要功能用于排序
LinkedHashSet的主要功能用于保证FIFO即有序的集合(先进先出)
HashSet只是通用的存储数据的集合
2. 相同点

Duplicates elements: 因为三者都实现Set interface，所以三者都不包含duplicate elements
Thread safety: 三者都不是线程安全的，如果要使用线程安全可以collections.synchronizedSet()
3. 不同点

Performance and Speed: HashSet插入数据最快，其次LinkHashSet，最慢的是TreeSet因为内部实现排序
Ordering: HashSet不保证有序，LinkHashSet保证FIFO即按插入顺序排序，TreeSet安装内部实现排序，也可以自定义排序规则
null:HashSet和LinkHashSet允许存在null数据，但是TreeSet中插入null数据时会报NullPointerException
4. 代码比较

public static void main(String args[]) {
HashSet hashSet = new HashSet<>();
LinkedHashSet linkedHashSet = new LinkedHashSet<>();
TreeSet treeSet = new TreeSet<>();

    for (String data : Arrays.asList("B", "E", "D", "C", "A")) {
        hashSet.add(data);
        linkedHashSet.add(data);
        treeSet.add(data);
    }

    //不保证有序
    System.out.println("Ordering in HashSet :" + hashSet);

    //FIFO保证安装插入顺序排序
    System.out.println("Order of element in LinkedHashSet :" + linkedHashSet);

    //内部实现排序
    System.out.println("Order of objects in TreeSet :" + treeSet);


}

运行结果:
Ordering in HashSet :[A, B, C, D, E] (无顺序)
Order of element in LinkedHashSet :[B, E, D, C, A] (FIFO插入有序)
Order of objects in TreeSet :[A, B, C, D, E] (排序)

(二).TreeSet的两种排序方式比较
1.排序的引入(以基本数据类型的排序为例)
由于TreeSet可以实现对元素按照某种规则进行排序，例如下面的例子

public class MyClass {

public static void main(String[] args) {
    // 创建集合对象
    // 自然顺序进行排序
    TreeSet<Integer> ts = new TreeSet<Integer>();

    // 创建元素并添加
    // 20,18,23,22,17,24,19,18,24
    ts.add(20);
    ts.add(18);
    ts.add(23);
    ts.add(22);
    ts.add(17);
    ts.add(24);
    ts.add(19);
    ts.add(18);
    ts.add(24);

    // 遍历
    for (Integer i : ts) {
        System.out.println(i);
    }
}

}

运行结果:
17
18
19
20
22
23
24

2.如果是引用数据类型呢,比如自定义对象,又该如何排序呢?
测试类:

public class MyClass {
public static void main(String[] args) {
TreeSet ts=new TreeSet();
//创建元素对象
Student s1=new Student(“zhangsan”,20);
Student s2=new Student(“lis”,22);
Student s3=new Student(“wangwu”,24);
Student s4=new Student(“chenliu”,26);
Student s5=new Student(“zhangsan”,22);
Student s6=new Student(“qianqi”,24);

    //将元素对象添加到集合对象中
    ts.add(s1);
    ts.add(s2);
    ts.add(s3);
    ts.add(s4);
    ts.add(s5);
    ts.add(s6);

    //遍历
    for(Student s:ts){
        System.out.println(s.getName()+"-----------"+s.getAge());
    }
}

}

Student.java:

public class Student {
private String name;
private int age;

public Student() {
    super();
    // TODO Auto-generated constructor stub
}

public Student(String name, int age) {
    super();
    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;
}

}

结果报错:

原因分析：
由于不知道该安照那一中排序方式排序，所以会报错。
解决方法：
1.自然排序
2.比较器排序

(1).自然排序
自然排序要进行一下操作：
1.Student类中实现 Comparable接口
2.重写Comparable接口中的Compareto方法

compareTo(T o) 比较此对象与指定对象的顺序。
public class Student implements Comparable{
private String name;
private int age;

public Student() {
    super();
    // TODO Auto-generated constructor stub
}

public Student(String name, int age) {
    super();
    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 int compareTo(Student s) {
    //return -1; //-1表示放在红黑树的左边,即逆序输出
    //return 1;  //1表示放在红黑树的右边，即顺序输出
    //return o;  //表示元素相同，仅存放第一个元素
    //主要条件 姓名的长度,如果姓名长度小的就放在左子树，否则放在右子树
    int num=this.name.length()-s.name.length();
    //姓名的长度相同，不代表内容相同,如果按字典顺序此 String 对象位于参数字符串之前，则比较结果为一个负整数。
    //如果按字典顺序此 String 对象位于参数字符串之后，则比较结果为一个正整数。
    //如果这两个字符串相等，则结果为 0
    int num1=num==0?this.name.compareTo(s.name):num;
    //姓名的长度和内容相同，不代表年龄相同，所以还要判断年龄
    int num2=num1==0?this.age-s.age:num1;
    return num2;
}

}

运行结果:

lis-----------22
qianqi-----------24
wangwu-----------24
chenliu-----------26
zhangsan-----------20
zhangsan-----------22

(2).比较器排序
比较器排序步骤：
1.单独创建一个比较类，这里以MyComparator为例，并且要让其继承Comparator接口
2.重写Comparator接口中的Compare方法

compare(T o1,T o2) 比较用来排序的两个参数。
3.在主类中使用下面的 构造方法

TreeSet(Comparator<? superE> comparator)
构造一个新的空 TreeSet，它根据指定比较器进行排序。
1
测试类:

public class MyClass {

public static void main(String[] args) {
    //创建集合对象
    //TreeSet(Comparator<? super E> comparator) 构造一个新的空 TreeSet，它根据指定比较器进行排序。
    TreeSet<Student> ts=new TreeSet<Student>(new MyComparator());

    //创建元素对象
    Student s1=new Student("zhangsan",20);
    Student s2=new Student("lis",22);
    Student s3=new Student("wangwu",24);
    Student s4=new Student("chenliu",26);
    Student s5=new Student("zhangsan",22);
    Student s6=new Student("qianqi",24);

    //将元素对象添加到集合对象中
    ts.add(s1);
    ts.add(s2);
    ts.add(s3);
    ts.add(s4);
    ts.add(s5);
    ts.add(s6);

    //遍历
    for(Student s:ts){
        System.out.println(s.getName()+"-----------"+s.getAge());
    }
}

}

Student.java:

public class Student {
private String name;
private int age;

public Student() {
    super();
    // TODO Auto-generated constructor stub
}

public Student(String name, int age) {
    super();
    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;
}

}

MyComparator类：

public class MyComparator implements Comparator {

@Override
public int compare(Student s1,Student s2) {
    // 姓名长度
    int num = s1.getName().length() - s2.getName().length();
    // 姓名内容
    int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
    // 年龄
    int num3 = num2 == 0 ? s1.getAge() - s2.getAge() : num2;
    return num3;
}

}

运行结果:

lis-----------22
qianqi-----------24
wangwu-----------24
chenliu-----------26
zhangsan-----------20
zhangsan-----------22

(三). 性能测试
对象类:

class Dog implements Comparable {
int size;
public Dog(int s) {
size = s;
}
public String toString() {
return size + “”;
}
@Override
public int compareTo(Dog o) {
//数值大小比较
return size - o.size;
}
}

主类:

public class MyClass {

public static void main(String[] args) {

    Random r = new Random();
    HashSet<Dog> hashSet = new HashSet<Dog>();
    TreeSet<Dog> treeSet = new TreeSet<Dog>();
    LinkedHashSet<Dog> linkedSet = new LinkedHashSet<Dog>();

    // start time
    long startTime = System.nanoTime();
    for (int i = 0; i < 1000; i++) {
        int x = r.nextInt(1000 - 10) + 10;
        hashSet.add(new Dog(x));
    }

    // end time
    long endTime = System.nanoTime();
    long duration = endTime - startTime;
    System.out.println("HashSet: " + duration);

    // start time
    startTime = System.nanoTime();
    for (int i = 0; i < 1000; i++) {
        int x = r.nextInt(1000 - 10) + 10;
        treeSet.add(new Dog(x));
    }
    // end time
    endTime = System.nanoTime();
    duration = endTime - startTime;
    System.out.println("TreeSet: " + duration);

    // start time
    startTime = System.nanoTime();
    for (int i = 0; i < 1000; i++) {
        int x = r.nextInt(1000 - 10) + 10;
        linkedSet.add(new Dog(x));
    }

    // end time
    endTime = System.nanoTime();
    duration = endTime - startTime;
    System.out.println("LinkedHashSet: " + duration);
}

}

运行结果:

HashSet: 1544313
TreeSet: 2066049
LinkedHashSet: 629826
虽然测试不够准确,但能反映得出，TreeSet要慢得多,因为它是有序的。

独家记忆！
关注
Java-Interview-超全集合github上评分最高的jiva面试题
08-15
通过学习和复习这些知识点，并结合"Java-Interview-超全集合github上评分最高的jiva面试题"中的题目进行实战演练，可以有效地提升Java开发者在面试中的竞争力，为成功获得理想职位打下坚实基础。在面试准备过程中，...
Java期末复习-类集框架
08-06
Java 类集框架是Java编程语言中用于存储和操作对象集合的核心组件。它提供了一系列接口和类，方便开发者处理各种数据结构，如列表、队列、集合、映射等。类集框架的最大父接口是`Collection`，而`Map`接口则是处理...
Java集合中List,Set以及Map等集合体系详解(史上最全)
热门推荐
君羊
06-12 33万+
概述: List Set Map都是接口，前两个继承至Collection接口，Map为独立接口 Set下有HashSet，LinkedHashSet，TreeSet List下有ArrayList，Vector，LinkedList Map下有Hashtable，LinkedHashMap，HashMap，TreeMap 还有Collection接口下还有个Queue接口，有Priority...
Java基础之List和Set以及Map的区别和联系
weixin_46610759的博客
09-16 195
Java基础之List和Set以及Map的区别和联系 List按对象进入的顺序保存对象，不做排序或编辑操作。Set对每个对象只接受一次，并使用自己内部的排序方法(通常，你只关心某个元素是否属于Set,而不关心它的顺序–否则应该使用List)。Map同样对每个元素保存一份，但这是基于"键"的，Map也有内置的排序，因而不关心元素添加的顺序。如果添加元素的顺序对你很重要，应该使用 LinkedHashSet或者LinkedHashMap. List的功能方法 实际上有两种List: 一种是基本的ArrayLis
JAVA集合体系
H3542561135的博客
08-10 176
集合知识
Java 中的集合体系
Withered Wood
04-12 831
目录1. 什么是集合？2. 为什么要使用集合？3. 3个接口介绍3.1 `List` 接口包括以下实现3.2 `Set` 接口包括以下实现3.3 `Map` 接口包括以下实现4. 如何选择集合？5. 比较和区别一些接口或类6. Collections 工具类有哪些常用方法？6.1 排序6.2 查找，替换 1. 什么是集合？ 集合类是 Java 数据结构的实现。它允许以各种方式将元素分组，并定义了各种使这些元素更容易操作的方法。集合类是可以往里面保存多个对象的类，存放的是对象，不同的集合类有不同的功能和特点，
01大数据面试复习----Java基础---集合类、多线程、JVM.zip
09-30
在准备大数据面试的过程中，Java基础是必不可少的一部分，尤其聚焦于集合类、多线程和JVM这三大核心领域。下面将分别对这三个方面进行深入探讨。 **一、Java集合类** Java集合框架是处理对象组的重要工具，它包括...
Java集合-复习
孤舟行客
03-19 1047
划重点（面试常问的HashMap原理）： HashMap是一个“链表散列”的数据结构，即数组和链表的结合体； HashMap的底层是一个数组结构，数组中每一项是一个链表； HashMap初始化的时候，会初始化一个数组，Map的内部类Entry就是数组中的元素，每个Entry就是一个Key-value对，并且持有一个指向下一个元素（Entry）的引用，这就构成了链表； 常用的集合类实现类...
Java集合（复习）
YZG ' BLOG
11-18 578
集合、数组都是对多个数据进行存储操作的结构，简称Java容器。说明: 此时的存储，主要是指能存层面的存储，不涉及到持久化的存储（.txt,.jpg,.avi,数据库中）数组在存储多个数据方面的特点一旦初始化以后，它的长度就确定了。数组一旦定义好，它的数据类型也就确定了。我们就只能操作指定类型的数据了。比如：String[] arr;int[] str;数组在存储多个数据方面的特点一旦初始化以后，其长度就不可修改。
Java集合体系
Hello World!
07-29 4728
集合与数组的区别（1）长度区别集合长度可变，数组长度不可变（2）内容区别集合可存储不同类型元素，数组存储只可单一类型元素（3）元素区别集合只能存储引用类型元素，数组可存储引用类型，也可存储基本类型Java集合类可以用于存储数量不等的多个对象，还可用于保存具有映射关系的关联数组。在这里主要讲一些我们平常很常用的一些接口和一些实现类。Java集合可分为Collection和Map两种体系Collection接口单列数据，定义了存取一组对象的方法的集合Map接口。.........
Java基础复习-Java JavaSE 必练基础案例（CSDN@追光者♂）
07-24
3. **集合框架**：ArrayList、LinkedList、HashSet、HashMap等容器是Java程序中常用的数据结构。理解它们的工作原理以及如何选择合适的容器，可以提高代码的效率和可维护性。 4. **IO流**：Java的输入/输出系统基于...
集合复习（java)
最新发布
qq_50249256的博客
07-07 990
学习笔记，方便复习
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值